hooktrace 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,202 @@
1
+ # frozen_string_literal: true
2
+
3
+ require "json"
4
+ require_relative "field"
5
+ require_relative "validator"
6
+
7
+ module Hooktrace
8
+ class Contract
9
+ attr_reader :name, :fields
10
+
11
+ def self.define(name, &block)
12
+ builder = Builder.new
13
+ builder.instance_eval(&block) if block
14
+
15
+ new(name: name, fields: builder.fields)
16
+ end
17
+
18
+ def self.override(existing_contract, &block)
19
+ builder = Builder.new(base_fields: existing_contract.fields, allow_override: true)
20
+ builder.instance_eval(&block) if block
21
+
22
+ new(name: existing_contract.name, fields: builder.fields)
23
+ end
24
+
25
+ def self.from_h(hash)
26
+ data = hash.transform_keys(&:to_s)
27
+ fields = (data["fields"] || []).map { |f| parse_field_hash(f) }
28
+ new(name: data.fetch("name", "anonymous"), fields: fields)
29
+ end
30
+
31
+ def self.from_json(json_str)
32
+ from_h(JSON.parse(json_str))
33
+ end
34
+
35
+ def self.parse_field_hash(hash)
36
+ data = hash.transform_keys(&:to_s)
37
+ Field.new(
38
+ name: data["name"],
39
+ type: data["type"]&.to_sym,
40
+ required: data.fetch("required", true),
41
+ nullable: data.fetch("nullable", false),
42
+ fields: (data["fields"] || []).map { |f| parse_field_hash(f) },
43
+ item_type: data["item_type"]&.to_sym,
44
+ item_fields: (data["item_fields"] || []).map { |f| parse_field_hash(f) }
45
+ )
46
+ end
47
+ private_class_method :parse_field_hash
48
+
49
+ def initialize(name:, fields:)
50
+ @name = name.to_s.freeze
51
+ @fields = fields.freeze
52
+ freeze
53
+ end
54
+
55
+ def validate(payload, strict: false, max_errors: Validator::DEFAULT_MAX_ERRORS)
56
+ Validator.new(self, strict: strict, max_errors: max_errors).validate(payload)
57
+ end
58
+
59
+ def to_h
60
+ {
61
+ name: name,
62
+ fields: fields.map { |f| field_to_h(f) }
63
+ }
64
+ end
65
+
66
+ def to_json(*args)
67
+ JSON.generate(to_h, *args)
68
+ end
69
+
70
+ private
71
+
72
+ def field_to_h(field)
73
+ h = {
74
+ name: field.name,
75
+ type: field.type,
76
+ required: field.required?,
77
+ nullable: field.nullable?
78
+ }
79
+ h[:item_type] = field.item_type if field.item_type
80
+ h[:item_fields] = field.item_fields.map { |f| field_to_h(f) } if field.item_fields.any?
81
+ h[:fields] = field.fields.map { |f| field_to_h(f) } if field.fields.any?
82
+ h
83
+ end
84
+
85
+ class Builder
86
+ attr_reader :fields
87
+
88
+ def initialize(base_fields: [], allow_override: false)
89
+ @fields = base_fields.dup
90
+ @allow_override = allow_override
91
+ @seen_names = {}
92
+ end
93
+
94
+ def required(name, type: nil, nullable: nil)
95
+ add_field(name: name, type: type, required: true, nullable: nullable)
96
+ end
97
+
98
+ def optional(name, type: nil, nullable: nil)
99
+ add_field(name: name, type: type, required: false, nullable: nullable)
100
+ end
101
+
102
+ def remove(name)
103
+ target = name.to_s
104
+ @fields.reject! { |f| f.name == target }
105
+ @seen_names.delete(target)
106
+ end
107
+
108
+ def object(name, required: nil, nullable: nil, &block)
109
+ existing = prepare_field_target(name)
110
+ child_builder = Builder.new(
111
+ base_fields: existing&.fields || [],
112
+ allow_override: @allow_override
113
+ )
114
+ child_builder.instance_eval(&block) if block
115
+
116
+ field = Field.new(
117
+ name: name,
118
+ type: :object,
119
+ required: resolve_flag(required, existing, :required?, true),
120
+ nullable: resolve_flag(nullable, existing, :nullable?, false),
121
+ fields: child_builder.fields
122
+ )
123
+ upsert_field(field)
124
+ end
125
+
126
+ def array(name, item_type: nil, required: nil, nullable: nil, &block)
127
+ existing = prepare_field_target(name)
128
+ item_fields = build_array_item_fields(existing, &block)
129
+ resolved_item_type = item_type&.to_sym || existing&.item_type
130
+
131
+ field = Field.new(
132
+ name: name,
133
+ type: :array,
134
+ required: resolve_flag(required, existing, :required?, true),
135
+ nullable: resolve_flag(nullable, existing, :nullable?, false),
136
+ item_type: resolved_item_type,
137
+ item_fields: item_fields
138
+ )
139
+ upsert_field(field)
140
+ end
141
+
142
+ private
143
+
144
+ def build_array_item_fields(existing, &block)
145
+ return existing&.item_fields || [] unless block
146
+
147
+ child_builder = Builder.new(
148
+ base_fields: existing&.item_fields || [],
149
+ allow_override: @allow_override
150
+ )
151
+ child_builder.instance_eval(&block)
152
+ child_builder.fields
153
+ end
154
+
155
+ def add_field(name:, type:, required:, nullable:)
156
+ existing = prepare_field_target(name)
157
+ resolved_type = type&.to_sym || existing&.type
158
+ raise ArgumentError, "Field type is required for '#{name}'" unless resolved_type
159
+
160
+ field = Field.new(
161
+ name: name,
162
+ type: resolved_type,
163
+ required: required,
164
+ nullable: resolve_flag(nullable, existing, :nullable?, false)
165
+ )
166
+ upsert_field(field)
167
+ end
168
+
169
+ def resolve_flag(explicit, existing, attr, default)
170
+ return explicit unless explicit.nil?
171
+
172
+ existing ? existing.public_send(attr) : default
173
+ end
174
+
175
+ def prepare_field_target(name)
176
+ check_duplicate!(name) unless @allow_override
177
+ find_field(name)
178
+ end
179
+
180
+ def upsert_field(field)
181
+ idx = @fields.index { |f| f.name == field.name }
182
+ if idx
183
+ @fields[idx] = field
184
+ else
185
+ @fields << field
186
+ end
187
+ @seen_names[field.name] = true
188
+ field
189
+ end
190
+
191
+ def find_field(name)
192
+ key = name.to_s
193
+ @fields.find { |f| f.name == key }
194
+ end
195
+
196
+ def check_duplicate!(name)
197
+ key = name.to_s
198
+ raise ArgumentError, "Duplicate field definition: '#{name}'" if @seen_names.key?(key)
199
+ end
200
+ end
201
+ end
202
+ end