@astrale-os/kernel-dsl 1.0.0-beta.12 → 1.0.0-beta.14

package/dist/v1/schema/validation/domain.json-schema.js

@@ -0,0 +1,183 @@
+import { toJSONSchema } from 'zod';
+import { VALUE_RULES } from '../../language/validation/rule.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
+import { RULES } from '../rule.js';
+import { domainSchemaStructure, documentJsonSchema, structureRules, } from './domain.structure.js';
+import { jsonValueJsonSchema, jsonValueRules } from './json.json-schema.js';
+import { valueSchemaJsonSchema, valueSchemaRules, } from './value.json-schema.js';
+/** The checks the published document names, each with its stage and the positions it constrains. */
+const namedRules = { ...structureRules, ...jsonValueRules, ...valueSchemaRules };
+/**
+ * The JSON Schema of an authored Domain schema document, rendered from the structure the Kernel
+ * enforces. Zod derives what it reads; `documentJsonSchema` states each refinement it cannot read,
+ * or names the rule JSON Schema cannot state. A refinement neither stated nor named fails the
+ * rendering, so that no check of the structure is dropped silently. Every value schema is in the
+ * published dialect and states the profile rules JSON Schema can state; the others are named.
+ */
+export function domainSchemaJsonSchema() {
+    assertChecksStated(domainSchemaStructure);
+    const { $schema, $defs = {}, ...root } = toJSONSchema(domainSchemaStructure, {
+        metadata: documentJsonSchema,
+        io: 'input',
+        // Every opaque part is stated or named, as `assertChecksStated` proved.
+        unrepresentable: 'any',
+        override: ({ zodSchema, jsonSchema: rendered }) => {
+            // Zod states the items of a tuple but not its length.
+            const def = zodSchema._zod.def;
+            if (def.type !== 'tuple')
+                return;
+            if (def.rest !== null || def.items.some((item) => item._zod.optin === 'optional')) {
+                throw new Error('A tuple of the structure has a fixed length.');
+            }
+            rendered.minItems = def.items.length;
+            rendered.maxItems = def.items.length;
+        },
+    });
+    const unnamed = Object.keys($defs).filter((name) => name.startsWith('__schema'));
+    if (unnamed.length > 0) {
+        throw new Error(`Every shared part of the structure is named: ${unnamed.join(', ')} is not.`);
+    }
+    const json = jsonValueJsonSchema();
+    const values = valueSchemaJsonSchema();
+    const valueSchema = $defs['value-schema'];
+    const nodeProperty = $defs['node-property-definition'];
+    if (root.allOf !== undefined ||
+        valueSchema === undefined ||
+        nodeProperty === undefined ||
+        valueSchema.allOf !== undefined ||
+        nodeProperty.allOf !== undefined ||
+        [...Object.keys(json.definitions), ...Object.keys(values.definitions)].some((name) => name in $defs)) {
+        throw new Error('Portable JSON extends the root, and the value language the value-schema and Node Property definitions.');
+    }
+    const definitions = Object.fromEntries(Object.entries({
+        ...$defs,
+        'value-schema': { ...valueSchema, allOf: [...values.root] },
+        'node-property-definition': { ...nodeProperty, allOf: [values.nodeProperty] },
+        ...json.definitions,
+        ...values.definitions,
+    }).sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0)));
+    const document = { ...root, allOf: [json.root] };
+    const positions = rulePositions({ ...document, $defs: definitions });
+    return {
+        $schema,
+        $id: 'https://schemas.astrale.ai/dsl/v1/domain-schema',
+        title: 'V1 DomainSchema',
+        $comment: 'Generated from the structure the Kernel enforces; value schemas are in the dialect https://schemas.astrale.ai/dsl/v1/value-schema. Each check JSON Schema cannot state is named under x-astrale-rules, with its stage and the positions it constrains.',
+        'x-astrale-rules': Object.fromEntries(Object.keys(namedRules).sort().map((name) => {
+            const { statement, ...rule } = namedRules[name];
+            const named = { ...rule, stage: stageOf(rule), statement };
+            return [name, { ...named, positions: positions.get(name) ?? [] }];
+        })),
+        ...document,
+        $defs: definitions,
+    };
+}
+/**
+ * What a named rule reads, in the stages of `schema.RULES`: its code's, or for a value code the
+ * value rule's own, which reads the document alone unless it reads the context.
+ */
+function stageOf(rule) {
+    if (rule.valueCode === undefined)
+        return RULES[rule.code].stage;
+    return VALUE_RULES[rule.valueCode].stage === 'context' ? 'context' : 'rule';
+}
+/**
+ * Every refinement and custom part of the structure carries its statement in `documentJsonSchema`:
+ * the keywords that state it, or its named rule. Only parts zod renders take part.
+ */
+export function assertChecksStated(schema, visited = new Set()) {
+    if (visited.has(schema))
+        return;
+    visited.add(schema);
+    const part = schema;
+    const def = part._zod.def;
+    for (const check of def.checks ?? []) {
+        if (check._zod.def.check === 'custom' && !isStated(schema, check)) {
+            throw new Error('A refinement of the structure is neither stated nor named.');
+        }
+    }
+    switch (def.type) {
+        case 'boolean':
+        case 'enum':
+        case 'literal':
+        case 'null':
+        case 'number':
+        case 'string':
+            return;
+        case 'custom':
+            if (statementOf(schema) === undefined) {
+                throw new Error('A custom part of the structure is neither stated nor named.');
+            }
+            return;
+        case 'array':
+            return assertChecksStated(def.element, visited);
+        case 'lazy':
+            return assertChecksStated(part._zod.innerType, visited);
+        case 'object':
+            for (const field of Object.values(def.shape))
+                assertChecksStated(field, visited);
+            return;
+        case 'optional':
+            return assertChecksStated(def.innerType, visited);
+        case 'record':
+            assertChecksStated(def.keyType, visited);
+            return assertChecksStated(def.valueType, visited);
+        case 'tuple':
+            for (const item of def.items)
+                assertChecksStated(item, visited);
+            return;
+        case 'union':
+            for (const option of def.options)
+                assertChecksStated(option, visited);
+            return;
+        default:
+            throw new Error(`The structure has a ${def.type} part, which this rendering does not read.`);
+    }
+}
+/** A check is stated where it was added, or on a refinement of that schema. */
+function isStated(schema, check) {
+    for (let current = schema; current !== undefined;) {
+        if (statementOf(current) !== undefined)
+            return true;
+        const parent = current._zod.parent;
+        if (parent?._zod.def.checks?.includes(check) !== true)
+            return false;
+        current = parent;
+    }
+    return false;
+}
+/** The keywords or rule registered on this very schema, which `get` would inherit from a parent. */
+function statementOf(schema) {
+    const { id: _id, description: _description, ...statement } = documentJsonSchema._map.get(schema) ?? {};
+    return Object.keys(statement).length > 0 ? statement : undefined;
+}
+/**
+ * Where each rule applies, as JSON Pointers into the document. The marker a named check leaves is
+ * removed; every `maxLength` counts UTF-16 code units, the length the structure measures.
+ */
+function rulePositions(document) {
+    const positions = new Map();
+    const note = (rule, pointer) => positions.set(rule, [...(positions.get(rule) ?? []), `#${pointer}`]);
+    const visit = (value, pointer) => {
+        if (Array.isArray(value)) {
+            value.forEach((item, index) => visit(item, `${pointer}/${index}`));
+            return;
+        }
+        if (value === null || typeof value !== 'object')
+            return;
+        const schema = value;
+        const rules = schema['x-astrale-rule'];
+        if (rules !== undefined) {
+            for (const rule of [rules].flat())
+                note(rule, pointer);
+            delete schema['x-astrale-rule'];
+        }
+        if (typeof schema.maxLength === 'number')
+            note('length-in-utf16-code-units', pointer);
+        for (const [key, entry] of Object.entries(schema)) {
+            visit(entry, `${pointer}/${escapePointerToken(key)}`);
+        }
+    };
+    visit(document, '');
+    return positions;
+}