harn-modules 0.7.29

Cross-file module graph and import resolution utilities for Harn
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

// std/schema — ergonomic schema builders and typed-value helpers
//
// Import with: import "std/schema"

pub fn schema_any() {
  return {type: "any"}
}

pub fn schema_string() {
  return {type: "string"}
}

pub fn schema_int() {
  return {type: "int"}
}

pub fn schema_float() {
  return {type: "float"}
}

pub fn schema_bool() {
  return {type: "bool"}
}

pub fn schema_nil() {
  return {type: "nil"}
}

pub fn schema_literal(value) {
  return {const: value}
}

pub fn schema_enum(values) {
  return {enum: values}
}

pub fn schema_list(item_schema = nil, options = nil) {
  var out = {type: "list"}
  if item_schema != nil {
    out = out + {items: item_schema}
  }
  if options != nil {
    out = schema_extend(out, options)
  }
  return out
}

pub fn schema_array(item_schema = nil, options = nil) {
  return schema_list(item_schema, options)
}

pub fn schema_dict(value_schema = nil, options = nil) {
  var out = {type: "dict"}
  if value_schema != nil {
    out = out + {additional_properties: value_schema}
  }
  if options != nil {
    out = schema_extend(out, options)
  }
  return out
}

pub fn schema_field(schema, required = true) {
  return schema_extend(schema, {required: required})
}

pub fn schema_object(fields, options = nil) {
  var properties = {}
  var required = []

  for entry in fields {
    let raw_schema = entry.value
    let is_required = raw_schema.required == nil || raw_schema.required
    let field_schema = schema_omit(raw_schema, ["required"])
    properties = properties + {[entry.key]: field_schema}
    if is_required {
      required = required + [entry.key]
    }
  }

  var out = {type: "dict", properties: properties}
  if len(required) > 0 {
    out = out + {required: required}
  }
  if options != nil {
    out = schema_extend(out, options)
  }
  return out
}

pub fn schema_union(branches) {
  return {union: branches}
}

pub fn schema_all_of(branches) {
  return {all_of: branches}
}

pub fn schema_nullable(schema) {
  return schema_extend(schema, {nullable: true})
}

pub fn schema_default(schema, value) {
  return schema_extend(schema, {default: value, required: false})
}

pub fn schema_pick_keys(schema, keys) {
  return schema_pick(schema, keys)
}

pub fn schema_omit_keys(schema, keys) {
  return schema_omit(schema, keys)
}

pub fn schema_partial_deep(schema) {
  return schema_partial(schema)
}

pub fn schema_json(schema) {
  return schema_to_json_schema(schema)
}

pub fn schema_openapi(schema) {
  return schema_to_openapi_schema(schema)
}

pub fn from_json_schema(schema) {
  return schema_from_json_schema(schema)
}

pub fn from_openapi_schema(schema) {
  return schema_from_openapi_schema(schema)
}

pub fn get_typed_result(value, schema, apply_defaults = false) {
  if apply_defaults {
    return schema_parse(value, schema)
  }
  return schema_check(value, schema)
}

pub fn get_typed_value(value, schema, apply_defaults = false) {
  let result = get_typed_result(value, schema, apply_defaults)
  if is_ok(result) {
    return unwrap(result)
  }
  throw_error(unwrap_err(result).message)
}

pub fn is_type(value, schema) {
  return schema_is(value, schema)
}