@withgateway/sdk 0.9.1 → 0.9.3
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.
- package/dist/agents/index.d.mts +12 -4
- package/dist/agents/index.d.ts +12 -4
- package/dist/agents/index.js +30 -0
- package/dist/agents/index.js.map +1 -1
- package/dist/agents/index.mjs +30 -0
- package/dist/agents/index.mjs.map +1 -1
- package/dist/cli.js +2291 -945
- package/dist/cli.js.map +1 -1
- package/dist/cli.mjs +2290 -944
- package/dist/cli.mjs.map +1 -1
- package/dist/files/index.js.map +1 -1
- package/dist/files/index.mjs.map +1 -1
- package/dist/index.js +325 -184
- package/dist/index.js.map +1 -1
- package/dist/index.mjs +324 -183
- package/dist/index.mjs.map +1 -1
- package/dist/traces/index.js.map +1 -1
- package/dist/traces/index.mjs.map +1 -1
- package/dist/tracing/index.js +1 -1
- package/dist/tracing/index.js.map +1 -1
- package/dist/tracing/index.mjs +1 -1
- package/dist/tracing/index.mjs.map +1 -1
- package/dist/worlds/index.d.mts +3 -1
- package/dist/worlds/index.d.ts +3 -1
- package/dist/worlds/index.js +178 -67
- package/dist/worlds/index.js.map +1 -1
- package/dist/worlds/index.mjs +177 -66
- package/dist/worlds/index.mjs.map +1 -1
- package/package.json +1 -1
- package/runtime/gatewaysdk/environment/bundle_manifest.py +297 -9
- package/runtime/gatewaysdk/environment/factory_documents.py +670 -0
- package/runtime/gatewaysdk/environment/factory_rules.py +973 -0
- package/runtime/gatewaysdk/environment/factory_shapes.py +253 -0
- package/runtime/gatewaysdk/environment/factory_spine.py +1155 -0
- package/runtime/gatewaysdk/environment/factory_spine_shapes.py +480 -0
- package/runtime/gatewaysdk/environment/schema/admission.py +61 -59
- package/runtime/gatewaysdk/environment/schema/cast.py +133 -67
- package/runtime/gatewaysdk/environment/schema/compiler.py +16 -17
- package/runtime/gatewaysdk/environment/schema/handler_errors.py +58 -4
- package/runtime/gatewaysdk/environment/schema/host.py +21 -2
- package/runtime/gatewaysdk/environment/schema/host_control.py +3 -1
- package/runtime/gatewaysdk/environment/schema/host_loops.py +27 -4
- package/runtime/gatewaysdk/environment/schema/host_metrics.py +69 -0
- package/runtime/gatewaysdk/environment/schema/host_requests.py +21 -0
- package/runtime/gatewaysdk/environment/schema/host_session.py +7 -0
- package/runtime/gatewaysdk/environment/schema/host_versions.py +4 -0
- package/runtime/gatewaysdk/environment/schema/host_workers.py +172 -50
- package/runtime/gatewaysdk/environment/schema/ingest.py +12 -3
- package/runtime/gatewaysdk/environment/schema/mapping.py +1 -1
- package/runtime/gatewaysdk/environment/schema/measured_tests.py +187 -0
- package/runtime/gatewaysdk/environment/schema/platform.py +57 -3
- package/runtime/gatewaysdk/environment/schema/platform_query.py +4 -3
- package/runtime/gatewaysdk/environment/schema/platform_templates.py +105 -17
- package/runtime/gatewaysdk/environment/schema/process_memory.py +76 -0
- package/runtime/gatewaysdk/environment/schema/redaction.py +13 -0
- package/runtime/gatewaysdk/environment/schema/runtime.py +14 -0
- package/runtime/gatewaysdk/environment/schema/scaffold.py +21 -4
- package/runtime/gatewaysdk/environment/schema/shape_catalog.py +493 -0
- package/runtime/gatewaysdk/environment/schema/shape_declarations.py +219 -0
- package/runtime/gatewaysdk/environment/schema/skill.py +1 -0
- package/runtime/gatewaysdk/environment/schema/skills/connector-schema-authoring/SKILL.md +1 -0
- package/runtime/gatewaysdk/environment/schema/skills/factory-orchestrator/SKILL.md +147 -0
- package/runtime/gatewaysdk/environment/schema/skills/world-data-ingestion/ROWS.md +5 -1
- package/runtime/gatewaysdk/environment/schema/skills/world-data-ingestion/SKILL.md +4 -4
- package/runtime/gatewaysdk/environment/schema/skills/worlds-getting-started/SKILL.md +2 -2
- package/runtime/gatewaysdk/environment/schema/skills/worlds-getting-started/references/cli-mcp-map.md +1 -0
- package/runtime/gatewaysdk/environment/schema/skills/worlds-getting-started/references/shape-catalog.md +59 -0
- package/runtime/gatewaysdk/environment/schema/validation.py +14 -0
- package/runtime/gatewaysdk/environment/schema/worker.py +7 -4
- package/runtime/gatewaysdk/environment/schema/worker_key.py +38 -0
- package/runtime/gatewaysdk/environment/schema/worker_peaks.py +38 -0
- package/runtime/gatewaysdk/environment/schema/worker_watch.py +50 -0
- package/runtime/gatewaysdk/environment/schema/workers.py +237 -68
- package/runtime/gatewaysdk/environment/schema/world_host.py +56 -62
- package/runtime/gatewaysdk/environment/schema/world_tests.py +3 -1
- package/skills/connector-schema-authoring/SKILL.md +1 -0
- package/skills/connector-schema-authoring/connector-worlds.md +1 -0
- package/skills/connector-schema-authoring/world-schema.md +7 -0
- package/skills/factory-orchestrator/SKILL.md +147 -0
- package/skills/world-data-ingestion/ROWS.md +5 -1
- package/skills/world-data-ingestion/SKILL.md +4 -4
- package/skills/worlds-getting-started/SKILL.md +2 -2
- package/skills/worlds-getting-started/references/cli-mcp-map.md +1 -0
- package/skills/worlds-getting-started/references/shape-catalog.md +59 -0
package/package.json
CHANGED
|
@@ -10,16 +10,29 @@ from typing import Any
|
|
|
10
10
|
from ._toml import tomllib
|
|
11
11
|
|
|
12
12
|
BUNDLE_MANIFEST = "gateway-bundle.toml"
|
|
13
|
-
MIN_BUNDLE_MEMBERS =
|
|
13
|
+
MIN_BUNDLE_MEMBERS = 1
|
|
14
14
|
MAX_BUNDLE_MEMBERS = 48
|
|
15
15
|
BUNDLE_NOT_A_WORLD = (
|
|
16
16
|
"A world bundle is not itself a world, its members are: drop gateway-env.toml from the bundle, or push it "
|
|
17
17
|
"as its own world."
|
|
18
18
|
)
|
|
19
19
|
BUNDLE_PUSH_ACTIONS = ("tests",)
|
|
20
|
-
BUNDLE_RESERVED_TABLES = ("
|
|
20
|
+
BUNDLE_RESERVED_TABLES = ("integrations",)
|
|
21
|
+
LINK_TRANSFORMS = (
|
|
22
|
+
"lower",
|
|
23
|
+
"upper",
|
|
24
|
+
"trim",
|
|
25
|
+
"collapse_ws",
|
|
26
|
+
"nfkc",
|
|
27
|
+
"digits",
|
|
28
|
+
"email_local_part",
|
|
29
|
+
"email_domain",
|
|
30
|
+
"sha1",
|
|
31
|
+
"sha256",
|
|
32
|
+
)
|
|
33
|
+
STRIP_PREFIX = "strip_prefix:"
|
|
21
34
|
|
|
22
|
-
_TABLES = ("bundle", "members", "actions", *BUNDLE_RESERVED_TABLES)
|
|
35
|
+
_TABLES = ("bundle", "members", "actions", "identities", "references", *BUNDLE_RESERVED_TABLES)
|
|
23
36
|
_BUNDLE_KEYS = ("name", "test_state")
|
|
24
37
|
_MEMBER_ALIAS = re.compile(r"^[a-z][a-z0-9_]{0,31}$")
|
|
25
38
|
_RESERVED_ALIASES = ("constructor", "prototype")
|
|
@@ -28,16 +41,40 @@ _MEMBER_REF = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$")
|
|
|
28
41
|
_WORLD_SLUG = re.compile(r"^(?!(?:migrate|runtime|templates)$)[a-z0-9][a-z0-9\-_]*$")
|
|
29
42
|
_MAX_SLUG_LENGTH = 128
|
|
30
43
|
_MAX_TEST_STATE_LENGTH = 120
|
|
44
|
+
_ENTITY = re.compile(r"[A-Za-z][A-Za-z0-9_]{0,63}")
|
|
45
|
+
_FIELD_NAME = re.compile(r"[A-Za-z_][A-Za-z0-9_-]*")
|
|
46
|
+
_FIELD_POINTER = re.compile(r"(?:/(?:[^/~]|~[01])+)+")
|
|
47
|
+
_IDENTITY_KEYS = ("created_in", "in", "key", "name")
|
|
48
|
+
_IDENTITY_MEMBER_KEYS = ("carry", "entity", "field", "transform")
|
|
49
|
+
_REFERENCE_KEYS = ("from", "to")
|
|
50
|
+
_REFERENCE_END_KEYS = ("entity", "field", "world")
|
|
51
|
+
_TRANSFORM_RULE = f"{', '.join(LINK_TRANSFORMS)} or strip_prefix:<prefix>"
|
|
31
52
|
|
|
32
53
|
|
|
33
54
|
def _utf16_length(value: str) -> int:
|
|
34
|
-
return len(value.encode("utf-16-le")) // 2
|
|
55
|
+
return len(value.encode("utf-16-le", "surrogatepass")) // 2
|
|
35
56
|
|
|
36
57
|
|
|
37
58
|
def _world_slug(value: str) -> bool:
|
|
38
59
|
return len(value) <= _MAX_SLUG_LENGTH and _WORLD_SLUG.fullmatch(value) is not None
|
|
39
60
|
|
|
40
61
|
|
|
62
|
+
def is_link_transform(name: str) -> bool:
|
|
63
|
+
return name in LINK_TRANSFORMS or (name.startswith(STRIP_PREFIX) and len(name) > len(STRIP_PREFIX))
|
|
64
|
+
|
|
65
|
+
|
|
66
|
+
def _transform_names(value: Any) -> list[Any] | None:
|
|
67
|
+
if value is None:
|
|
68
|
+
return []
|
|
69
|
+
if isinstance(value, str):
|
|
70
|
+
return [value]
|
|
71
|
+
return value if isinstance(value, list) else None
|
|
72
|
+
|
|
73
|
+
|
|
74
|
+
def _is_field(value: Any) -> bool:
|
|
75
|
+
return isinstance(value, str) and bool(_FIELD_NAME.fullmatch(value) or _FIELD_POINTER.fullmatch(value))
|
|
76
|
+
|
|
77
|
+
|
|
41
78
|
@dataclass(frozen=True)
|
|
42
79
|
class BundleMember:
|
|
43
80
|
alias: str
|
|
@@ -48,6 +85,59 @@ class BundleMember:
|
|
|
48
85
|
return {"alias": self.alias, "slug": self.slug, "ref": self.ref}
|
|
49
86
|
|
|
50
87
|
|
|
88
|
+
@dataclass(frozen=True)
|
|
89
|
+
class BundleIdentityMember:
|
|
90
|
+
alias: str
|
|
91
|
+
entity: str
|
|
92
|
+
field: str
|
|
93
|
+
transform: tuple[str, ...] = ()
|
|
94
|
+
carry: tuple[tuple[str, str], ...] = ()
|
|
95
|
+
|
|
96
|
+
def to_json(self) -> dict[str, Any]:
|
|
97
|
+
return {
|
|
98
|
+
"alias": self.alias,
|
|
99
|
+
"entity": self.entity,
|
|
100
|
+
"field": self.field,
|
|
101
|
+
"transform": list(self.transform),
|
|
102
|
+
"carry": dict(self.carry),
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
|
|
106
|
+
@dataclass(frozen=True)
|
|
107
|
+
class BundleIdentity:
|
|
108
|
+
name: str
|
|
109
|
+
key: str
|
|
110
|
+
created_in: str | None
|
|
111
|
+
members: tuple[BundleIdentityMember, ...]
|
|
112
|
+
|
|
113
|
+
def to_json(self) -> dict[str, Any]:
|
|
114
|
+
return {
|
|
115
|
+
"name": self.name,
|
|
116
|
+
"key": self.key,
|
|
117
|
+
"createdIn": self.created_in,
|
|
118
|
+
"in": [member.to_json() for member in self.members],
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
|
|
122
|
+
@dataclass(frozen=True)
|
|
123
|
+
class BundleReferenceEnd:
|
|
124
|
+
world: str
|
|
125
|
+
entity: str
|
|
126
|
+
field: str
|
|
127
|
+
|
|
128
|
+
def to_json(self) -> dict[str, str]:
|
|
129
|
+
return {"world": self.world, "entity": self.entity, "field": self.field}
|
|
130
|
+
|
|
131
|
+
|
|
132
|
+
@dataclass(frozen=True)
|
|
133
|
+
class BundleReference:
|
|
134
|
+
source: BundleReferenceEnd
|
|
135
|
+
target: BundleReferenceEnd
|
|
136
|
+
|
|
137
|
+
def to_json(self) -> dict[str, Any]:
|
|
138
|
+
return {"from": self.source.to_json(), "to": self.target.to_json()}
|
|
139
|
+
|
|
140
|
+
|
|
51
141
|
@dataclass(frozen=True)
|
|
52
142
|
class BundleManifest:
|
|
53
143
|
name: str
|
|
@@ -55,6 +145,8 @@ class BundleManifest:
|
|
|
55
145
|
members: tuple[BundleMember, ...]
|
|
56
146
|
on_push: tuple[str, ...] = ()
|
|
57
147
|
reserved: tuple[str, ...] = field(default_factory=tuple)
|
|
148
|
+
identities: tuple[BundleIdentity, ...] = ()
|
|
149
|
+
references: tuple[BundleReference, ...] = ()
|
|
58
150
|
|
|
59
151
|
@classmethod
|
|
60
152
|
def read(cls, text: str) -> BundleManifest | list[str]:
|
|
@@ -90,6 +182,8 @@ class BundleManifest:
|
|
|
90
182
|
"testState": self.test_state,
|
|
91
183
|
"members": [member.to_json() for member in sorted(self.members, key=lambda m: m.alias)],
|
|
92
184
|
"onPush": list(self.on_push),
|
|
185
|
+
"identities": [identity.to_json() for identity in self.identities],
|
|
186
|
+
"references": [reference.to_json() for reference in self.references],
|
|
93
187
|
"reserved": list(self.reserved),
|
|
94
188
|
}
|
|
95
189
|
|
|
@@ -105,6 +199,10 @@ class _Reader:
|
|
|
105
199
|
bundle = self._bundle()
|
|
106
200
|
self._member_tables()
|
|
107
201
|
on_push = self._actions()
|
|
202
|
+
members = self.root.get("members")
|
|
203
|
+
relationships = _RelationshipReader(self.issues, set(members) if isinstance(members, dict) else set())
|
|
204
|
+
relationships.read_identities(self.root.get("identities"))
|
|
205
|
+
relationships.read_references(self.root.get("references"))
|
|
108
206
|
if self.issues or bundle is None:
|
|
109
207
|
return self.issues
|
|
110
208
|
return BundleManifest(
|
|
@@ -113,6 +211,8 @@ class _Reader:
|
|
|
113
211
|
members=tuple(self.members),
|
|
114
212
|
on_push=tuple(on_push),
|
|
115
213
|
reserved=tuple(sorted(t for t in BUNDLE_RESERVED_TABLES if t in self.root)),
|
|
214
|
+
identities=tuple(relationships.identities),
|
|
215
|
+
references=tuple(relationships.references),
|
|
116
216
|
)
|
|
117
217
|
|
|
118
218
|
def _unknown_tables(self) -> None:
|
|
@@ -155,13 +255,11 @@ class _Reader:
|
|
|
155
255
|
return
|
|
156
256
|
count = len(members)
|
|
157
257
|
if count < MIN_BUNDLE_MEMBERS:
|
|
158
|
-
|
|
258
|
+
self.issues.append(f"gateway-bundle.toml names {count} members; a bundle names at least one member.")
|
|
259
|
+
if count > MAX_BUNDLE_MEMBERS:
|
|
159
260
|
self.issues.append(
|
|
160
|
-
f"gateway-bundle.toml names {count}
|
|
161
|
-
"(one world is a world, not a bundle)."
|
|
261
|
+
f"gateway-bundle.toml names {count} members; a bundle holds at most {MAX_BUNDLE_MEMBERS}."
|
|
162
262
|
)
|
|
163
|
-
if count > MAX_BUNDLE_MEMBERS:
|
|
164
|
-
self.issues.append(f"gateway-bundle.toml names {count} members; a bundle holds at most {MAX_BUNDLE_MEMBERS}.")
|
|
165
263
|
pinned_by: dict[str, str] = {}
|
|
166
264
|
for alias in sorted(members):
|
|
167
265
|
self._member(alias, members[alias], pinned_by)
|
|
@@ -232,12 +330,202 @@ class _Reader:
|
|
|
232
330
|
return list(on_push)
|
|
233
331
|
|
|
234
332
|
|
|
333
|
+
class _RelationshipReader:
|
|
334
|
+
def __init__(self, issues: list[str], members: set[str]) -> None:
|
|
335
|
+
self.issues = issues
|
|
336
|
+
self.members = members
|
|
337
|
+
self.identities: list[BundleIdentity] = []
|
|
338
|
+
self.references: list[BundleReference] = []
|
|
339
|
+
self._named: set[str] = set()
|
|
340
|
+
self._declared: dict[tuple[str, ...], int] = {}
|
|
341
|
+
|
|
342
|
+
def read_identities(self, value: Any) -> None:
|
|
343
|
+
if value is None:
|
|
344
|
+
return
|
|
345
|
+
if not isinstance(value, list):
|
|
346
|
+
self.issues.append("`identities` must be an array of tables, one [[identities]] per identity.")
|
|
347
|
+
return
|
|
348
|
+
for position, entry in enumerate(value, start=1):
|
|
349
|
+
self._identity(entry, position)
|
|
350
|
+
|
|
351
|
+
def read_references(self, value: Any) -> None:
|
|
352
|
+
if value is None:
|
|
353
|
+
return
|
|
354
|
+
if not isinstance(value, list):
|
|
355
|
+
self.issues.append("`references` must be an array of tables, one [[references]] per reference.")
|
|
356
|
+
return
|
|
357
|
+
for position, entry in enumerate(value, start=1):
|
|
358
|
+
self._reference(entry, position)
|
|
359
|
+
|
|
360
|
+
def _identity(self, entry: Any, position: int) -> None:
|
|
361
|
+
if not isinstance(entry, dict):
|
|
362
|
+
self.issues.append(f"identity #{position} must be a table with a name, a key and in.<alias> tables.")
|
|
363
|
+
return
|
|
364
|
+
before = len(self.issues)
|
|
365
|
+
name = entry.get("name")
|
|
366
|
+
named = isinstance(name, str) and _MEMBER_ALIAS.fullmatch(name) is not None
|
|
367
|
+
at = f"identity `{name}`" if named else f"identity #{position}"
|
|
368
|
+
self._unknown_keys(entry, _IDENTITY_KEYS, at, "name, key, created_in and in")
|
|
369
|
+
if not named:
|
|
370
|
+
self.issues.append(
|
|
371
|
+
f"{at} name must be lowercase letters, digits or '_', start with a letter and be at most 32 characters."
|
|
372
|
+
)
|
|
373
|
+
if named and name in self._named:
|
|
374
|
+
self.issues.append(f"{at} is declared twice; an identity's name is unique in the bundle.")
|
|
375
|
+
if named:
|
|
376
|
+
self._named.add(str(name))
|
|
377
|
+
key = entry.get("key")
|
|
378
|
+
if not isinstance(key, str) or not _FIELD_NAME.fullmatch(key):
|
|
379
|
+
self.issues.append(
|
|
380
|
+
f"{at} key must be a field name: letters, digits, '_' or '-', starting with a letter or '_'."
|
|
381
|
+
)
|
|
382
|
+
spans = self._spans(entry.get("in"), at)
|
|
383
|
+
self._carried_once(spans, at)
|
|
384
|
+
created_in = self._created_in(entry.get("created_in"), spans, at)
|
|
385
|
+
if len(self.issues) > before:
|
|
386
|
+
return
|
|
387
|
+
self.identities.append(BundleIdentity(str(name), str(key), created_in, tuple(spans)))
|
|
388
|
+
|
|
389
|
+
def _spans(self, value: Any, at: str) -> list[BundleIdentityMember]:
|
|
390
|
+
if not isinstance(value, dict) or not value:
|
|
391
|
+
self.issues.append(
|
|
392
|
+
f'{at} needs in.<alias> = {{ entity = "...", field = "..." }}, one per member world it spans.'
|
|
393
|
+
)
|
|
394
|
+
return []
|
|
395
|
+
return [self._span(alias, value[alias], f"{at} in.{alias}") for alias in sorted(value)]
|
|
396
|
+
|
|
397
|
+
def _span(self, alias: str, value: Any, where: str) -> BundleIdentityMember:
|
|
398
|
+
self._member(alias, where)
|
|
399
|
+
if not isinstance(value, dict):
|
|
400
|
+
self.issues.append(f'{where} must be a table: {{ entity = "...", field = "..." }}.')
|
|
401
|
+
return BundleIdentityMember(alias, "", "")
|
|
402
|
+
self._unknown_keys(value, _IDENTITY_MEMBER_KEYS, where, "entity, field, transform and carry")
|
|
403
|
+
entity, field_ = self._endpoint(value, where)
|
|
404
|
+
transform = tuple(self._transform(value.get("transform"), where))
|
|
405
|
+
return BundleIdentityMember(alias, entity, field_, transform, self._carry(value.get("carry"), field_, where))
|
|
406
|
+
|
|
407
|
+
def _carry(self, value: Any, key_field: Any, where: str) -> tuple[tuple[str, str], ...]:
|
|
408
|
+
if value is None:
|
|
409
|
+
return ()
|
|
410
|
+
if not isinstance(value, dict):
|
|
411
|
+
self.issues.append(
|
|
412
|
+
f'{where}.carry must be a table: {{ <name> = "<field>" }}, the fields this span carries to its '
|
|
413
|
+
"counterparts."
|
|
414
|
+
)
|
|
415
|
+
return ()
|
|
416
|
+
carried: list[tuple[str, str]] = []
|
|
417
|
+
held: set[Any] = set()
|
|
418
|
+
for name in sorted(value):
|
|
419
|
+
target = value[name]
|
|
420
|
+
if not _FIELD_NAME.fullmatch(name):
|
|
421
|
+
self.issues.append(
|
|
422
|
+
f"{where}.carry name `{name}` must be a field name: letters, digits, '_' or '-', starting with a "
|
|
423
|
+
"letter or '_'."
|
|
424
|
+
)
|
|
425
|
+
if not _is_field(target):
|
|
426
|
+
self.issues.append(
|
|
427
|
+
f"{where}.carry.{name} must be a field name or a JSON pointer such as /profile/name."
|
|
428
|
+
)
|
|
429
|
+
continue
|
|
430
|
+
if target == key_field:
|
|
431
|
+
self.issues.append(f"{where}.carry.{name} names the span's own field; the key is carried already.")
|
|
432
|
+
if target in held:
|
|
433
|
+
self.issues.append(f"{where}.carry names `{target}` twice; a field carries one value.")
|
|
434
|
+
held.add(target)
|
|
435
|
+
carried.append((name, target))
|
|
436
|
+
return tuple(carried)
|
|
437
|
+
|
|
438
|
+
def _carried_once(self, spans: list[BundleIdentityMember], at: str) -> None:
|
|
439
|
+
aliases: dict[str, list[str]] = {}
|
|
440
|
+
for span in spans:
|
|
441
|
+
for name, _ in span.carry:
|
|
442
|
+
aliases.setdefault(name, []).append(span.alias)
|
|
443
|
+
for name in sorted(aliases):
|
|
444
|
+
if len(aliases[name]) == 1:
|
|
445
|
+
self.issues.append(
|
|
446
|
+
f"{at} carries `{name}` only in.{aliases[name][0]}; name it in another span too, or drop it."
|
|
447
|
+
)
|
|
448
|
+
|
|
449
|
+
def _created_in(self, value: Any, spans: list[BundleIdentityMember], at: str) -> str | None:
|
|
450
|
+
if value is None:
|
|
451
|
+
return None
|
|
452
|
+
if isinstance(value, str) and any(span.alias == value for span in spans):
|
|
453
|
+
return value
|
|
454
|
+
self.issues.append(f"{at} created_in must name one of the identity's members (in.<alias>).")
|
|
455
|
+
return None
|
|
456
|
+
|
|
457
|
+
def _reference(self, entry: Any, position: int) -> None:
|
|
458
|
+
at = f"reference #{position}"
|
|
459
|
+
if not isinstance(entry, dict):
|
|
460
|
+
self.issues.append(f"{at} must be a table with from and to.")
|
|
461
|
+
return
|
|
462
|
+
before = len(self.issues)
|
|
463
|
+
self._unknown_keys(entry, _REFERENCE_KEYS, at, "from and to")
|
|
464
|
+
source = self._end(entry.get("from"), f"{at} from")
|
|
465
|
+
target = self._end(entry.get("to"), f"{at} to")
|
|
466
|
+
if len(self.issues) > before:
|
|
467
|
+
return
|
|
468
|
+
signature = (source.world, source.entity, source.field, target.world, target.entity, target.field)
|
|
469
|
+
first = self._declared.get(signature)
|
|
470
|
+
if first is not None:
|
|
471
|
+
self.issues.append(f"{at} repeats reference #{first}; a reference is declared once.")
|
|
472
|
+
return
|
|
473
|
+
self._declared[signature] = position
|
|
474
|
+
self.references.append(BundleReference(source, target))
|
|
475
|
+
|
|
476
|
+
def _end(self, value: Any, where: str) -> BundleReferenceEnd:
|
|
477
|
+
if not isinstance(value, dict):
|
|
478
|
+
self.issues.append(f'{where} must be a table: {{ world = "<alias>", entity = "...", field = "..." }}.')
|
|
479
|
+
return BundleReferenceEnd("", "", "")
|
|
480
|
+
self._unknown_keys(value, _REFERENCE_END_KEYS, where, "world, entity and field")
|
|
481
|
+
self._member(value.get("world"), f"{where}.world")
|
|
482
|
+
entity, field_ = self._endpoint(value, where)
|
|
483
|
+
return BundleReferenceEnd(str(value.get("world")), entity, field_)
|
|
484
|
+
|
|
485
|
+
def _member(self, alias: Any, where: str) -> None:
|
|
486
|
+
if isinstance(alias, str) and alias in self.members:
|
|
487
|
+
return
|
|
488
|
+
self.issues.append(f"{where} must name a member of this bundle.")
|
|
489
|
+
|
|
490
|
+
def _endpoint(self, table: dict[str, Any], where: str) -> tuple[Any, Any]:
|
|
491
|
+
entity = table.get("entity")
|
|
492
|
+
field_ = table.get("field")
|
|
493
|
+
if not isinstance(entity, str) or not _ENTITY.fullmatch(entity):
|
|
494
|
+
self.issues.append(
|
|
495
|
+
f"{where}.entity must be an entity name: letters, digits or '_', a letter first, at most 64 characters."
|
|
496
|
+
)
|
|
497
|
+
if not _is_field(field_):
|
|
498
|
+
self.issues.append(f"{where}.field must be a field name or a JSON pointer such as /owner/email.")
|
|
499
|
+
return entity, field_
|
|
500
|
+
|
|
501
|
+
def _transform(self, value: Any, where: str) -> list[str]:
|
|
502
|
+
names = _transform_names(value)
|
|
503
|
+
if names is None or not all(isinstance(name, str) for name in names):
|
|
504
|
+
self.issues.append(f"{where}.transform must be a transform name or a list of them.")
|
|
505
|
+
return []
|
|
506
|
+
for name in names:
|
|
507
|
+
if not is_link_transform(name):
|
|
508
|
+
self.issues.append(f"{where}.transform `{name}` is not one of {_TRANSFORM_RULE}.")
|
|
509
|
+
return names
|
|
510
|
+
|
|
511
|
+
def _unknown_keys(self, table: dict[str, Any], allowed: tuple[str, ...], at: str, takes: str) -> None:
|
|
512
|
+
for key in sorted(table):
|
|
513
|
+
if key not in allowed:
|
|
514
|
+
self.issues.append(f"{at} has no key `{key}`; it takes {takes}.")
|
|
515
|
+
|
|
516
|
+
|
|
235
517
|
__all__ = [
|
|
236
518
|
"BUNDLE_MANIFEST",
|
|
237
519
|
"BUNDLE_PUSH_ACTIONS",
|
|
238
520
|
"BUNDLE_RESERVED_TABLES",
|
|
521
|
+
"LINK_TRANSFORMS",
|
|
239
522
|
"MAX_BUNDLE_MEMBERS",
|
|
240
523
|
"MIN_BUNDLE_MEMBERS",
|
|
524
|
+
"BundleIdentity",
|
|
525
|
+
"BundleIdentityMember",
|
|
241
526
|
"BundleManifest",
|
|
242
527
|
"BundleMember",
|
|
528
|
+
"BundleReference",
|
|
529
|
+
"BundleReferenceEnd",
|
|
530
|
+
"is_link_transform",
|
|
243
531
|
]
|