@astrale-os/kernel-dsl 0.1.5 → 0.2.0-beta.10

package/dist/v1/bundle/codec.js

@@ -0,0 +1,168 @@
+import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, json, } from '@astrale-os/kernel-dsl/value';
+import { dependencyLimits } from '../addressing/domain-dependency.js';
+import { compareUnicode } from '../addressing/ordering.js';
+import { acceptDomainSchema } from '../schema/admission/accept.js';
+import { canonicalDomainSchemaAfterValidation } from '../schema/canonical/revision.js';
+import { revisionOfDomainSchema } from '../schema/canonical/revision.js';
+import { MemoryDomainSchemaLookup } from '../schema/dependency/lookup.js';
+import { SchemaError } from '../schema/diagnostic.js';
+import { BundleError, diagnostic } from './diagnostic.js';
+import { asDomainSchemaBundle, } from './model.js';
+import { parseDomainSchemaBundleStructure } from './structure.js';
+function escapeToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+export function acceptDomainSchemaBundle(input) {
+    let admitted;
+    try {
+        admitted = acceptJsonValue(input);
+    }
+    catch (error) {
+        if (error instanceof JsonBoundaryError) {
+            throw new BundleError([diagnostic('DV_JSON_VALUE', error.pointer, error.message)]);
+        }
+        throw error;
+    }
+    return acceptBundleValue(admitted);
+}
+export function decodeDomainSchemaBundle(input) {
+    try {
+        return acceptBundleValue(json.decode(input));
+    }
+    catch (error) {
+        if (error instanceof json.DecodeError) {
+            throw new BundleError([diagnostic('DV_JSON_VALUE', '', error.message)]);
+        }
+        throw error;
+    }
+}
+export function serializeDomainSchemaBundle(bundle) {
+    return json.serialize(bundle);
+}
+export function encodeDomainSchemaBundle(bundle) {
+    return json.encode(bundle);
+}
+function acceptBundleValue(input) {
+    const structure = parseDomainSchemaBundleStructure(input);
+    const root = candidate(structure.root, '/root');
+    const closure = structure.closure.map((schema, index) => candidate(schema, `/closure/${index}`));
+    const diagnostics = [];
+    const candidates = new Map();
+    if (closure.length + 1 > dependencyLimits.closure) {
+        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/closure', `A dependency closure may contain at most ${dependencyLimits.closure} Domains.`));
+    }
+    for (const entry of [root, ...closure]) {
+        if (Object.keys(entry.schema.dependencies).length > dependencyLimits.direct) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', `${entry.pointer}/dependencies`, `A Domain may declare at most ${dependencyLimits.direct} direct dependency aliases.`));
+        }
+    }
+    for (const entry of closure) {
+        if (entry.key === root.key) {
+            diagnostics.push(diagnostic('BUNDLE_ROOT_DUPLICATED', entry.pointer, 'The root schema must not also appear in the bundle closure.'));
+            continue;
+        }
+        const previous = candidates.get(entry.key);
+        if (previous !== undefined) {
+            diagnostics.push(diagnostic('BUNDLE_SCHEMA_DUPLICATED', entry.pointer, `Schema ${entry.schema.origin}@${entry.revision} duplicates ${previous.pointer}.`));
+            continue;
+        }
+        candidates.set(entry.key, entry);
+    }
+    const reachable = new Set();
+    collectReachable(root, root, candidates, reachable, new Set(), new Map(), diagnostics, 0);
+    for (const entry of candidates.values()) {
+        if (!reachable.has(entry.key)) {
+            diagnostics.push(diagnostic('BUNDLE_CLOSURE_EXTRA', entry.pointer, `Schema ${entry.schema.origin}@${entry.revision} is not reachable from the root.`));
+        }
+    }
+    if (diagnostics.length > 0)
+        throw new BundleError(diagnostics);
+    const accepted = new Map();
+    const acceptCandidate = (entry) => {
+        const existing = accepted.get(entry.key);
+        if (existing !== undefined)
+            return existing.schema;
+        for (const dependency of Object.values(entry.schema.dependencies)) {
+            const nested = candidates.get(keyOf(dependency.origin, dependency.revision));
+            if (nested !== undefined)
+                acceptCandidate(nested);
+        }
+        try {
+            const schema = acceptDomainSchema(entry.schema, new MemoryDomainSchemaLookup([...accepted.values()]));
+            const revision = revisionOfDomainSchema(schema);
+            if (revision !== entry.revision) {
+                throw new BundleError([
+                    diagnostic('BUNDLE_SCHEMA_REVISION', '', `Accepted schema revision ${revision} differs from indexed revision ${entry.revision}.`),
+                ]);
+            }
+            accepted.set(entry.key, { schema, revision });
+            return schema;
+        }
+        catch (error) {
+            if (!(error instanceof SchemaError))
+                throw error;
+            throw new BundleError(error.diagnostics.map((item) => diagnostic(item.code, `${entry.pointer}${item.pointer}`, item.message, item.ref)));
+        }
+    };
+    for (const entry of candidates.values()) {
+        if (reachable.has(entry.key))
+            acceptCandidate(entry);
+    }
+    const rootSchema = acceptCandidate(root);
+    const acceptedClosure = [...reachable]
+        .map((key) => accepted.get(key)?.schema)
+        .filter((schema) => schema !== undefined)
+        .sort(compareSchemas);
+    return asDomainSchemaBundle(rootSchema, acceptedClosure);
+}
+function candidate(schema, pointer) {
+    const canonical = canonicalDomainSchemaAfterValidation(schema);
+    return {
+        schema,
+        revision: canonical.revision,
+        key: keyOf(schema.origin, canonical.revision),
+        pointer,
+    };
+}
+function collectReachable(current, root, candidates, reachable, active, revisions, diagnostics, depth) {
+    if (active.has(current.key)) {
+        diagnostics.push(diagnostic('BUNDLE_CLOSURE_CYCLE', current.pointer, `Bundle dependency cycle reaches ${current.schema.origin}@${current.revision}.`));
+        return;
+    }
+    active.add(current.key);
+    if (depth > dependencyLimits.depth) {
+        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', current.pointer, `Dependency depth ${depth} exceeds the maximum ${dependencyLimits.depth}.`));
+        active.delete(current.key);
+        return;
+    }
+    for (const [alias, dependency] of Object.entries(current.schema.dependencies)) {
+        const pointer = `${current.pointer}/dependencies/${escapeToken(alias)}`;
+        const dependencyKey = keyOf(dependency.origin, dependency.revision);
+        if (dependencyKey === root.key) {
+            diagnostics.push(diagnostic('BUNDLE_CLOSURE_CYCLE', pointer, 'Bundle dependency closure returns to its root.'));
+            continue;
+        }
+        const previous = revisions.get(dependency.origin);
+        if (previous !== undefined && previous !== dependency.revision) {
+            diagnostics.push(diagnostic('BUNDLE_REVISION_COHERENCE', pointer, `Bundle requires ${dependency.origin} at both ${previous} and ${dependency.revision}.`));
+        }
+        else {
+            revisions.set(dependency.origin, dependency.revision);
+        }
+        const nested = candidates.get(dependencyKey);
+        if (nested === undefined) {
+            diagnostics.push(diagnostic('BUNDLE_CLOSURE_MISSING', pointer, `Bundle has no exact ${dependency.origin}@${dependency.revision}.`));
+            continue;
+        }
+        reachable.add(nested.key);
+        collectReachable(nested, root, candidates, reachable, active, revisions, diagnostics, depth + 1);
+    }
+    active.delete(current.key);
+}
+function compareSchemas(left, right) {
+    return (compareUnicode(left.origin, right.origin) ||
+        compareUnicode(revisionOfDomainSchema(left), revisionOfDomainSchema(right)));
+}
+function keyOf(origin, revision) {
+    return `${origin}\u0000${revision}`;
+}

package/dist/v1/bundle/create.d.ts

@@ -0,0 +1,3 @@
+import type { DomainSchema } from '../schema/model/schema.js';
+import type { DomainSchemaBundle } from './model.js';
+export declare function createDomainSchemaBundle<const Root extends DomainSchema>(root: Root): DomainSchemaBundle<Root>;

package/dist/v1/bundle/create.js

@@ -0,0 +1,5 @@
+import { requireDomainClosure } from '../schema/resolution/closure.js';
+import { asDomainSchemaBundle } from './model.js';
+export function createDomainSchemaBundle(root) {
+    return asDomainSchemaBundle(root, requireDomainClosure(root).map(({ schema }) => schema));
+}

package/dist/v1/bundle/diagnostic.d.ts

@@ -0,0 +1,10 @@
+import type { SchemaDiagnostic, SchemaDiagnosticCode } from '../schema/diagnostic.js';
+export type BundleDiagnosticCode = SchemaDiagnosticCode | 'BUNDLE_CLOSURE_CYCLE' | 'BUNDLE_CLOSURE_EXTRA' | 'BUNDLE_CLOSURE_MISSING' | 'BUNDLE_REVISION_COHERENCE' | 'BUNDLE_ROOT_DUPLICATED' | 'BUNDLE_SCHEMA_DUPLICATED' | 'BUNDLE_SCHEMA_REVISION' | 'BUNDLE_STRUCTURE' | 'UNSUPPORTED_BUNDLE_FORMAT' | 'UNSUPPORTED_BUNDLE_VERSION';
+export type BundleDiagnostic<Code extends BundleDiagnosticCode = BundleDiagnosticCode> = Omit<SchemaDiagnostic, 'code'> & {
+    readonly code: Code;
+};
+export declare function diagnostic<const Code extends BundleDiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): BundleDiagnostic<Code>;
+export declare class BundleError extends Error {
+    readonly diagnostics: readonly BundleDiagnostic[];
+    constructor(diagnostics: readonly BundleDiagnostic[]);
+}

package/dist/v1/bundle/diagnostic.js

@@ -0,0 +1,17 @@
+import { compareUnicode } from '../addressing/ordering.js';
+export function diagnostic(code, pointer, message, ref) {
+    return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
+}
+export class BundleError extends Error {
+    diagnostics;
+    constructor(diagnostics) {
+        const ordered = [...diagnostics].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
+            compareUnicode(left.code, right.code) ||
+            compareUnicode(left.message, right.message));
+        super(ordered
+            .map(({ code, pointer, message }) => `${pointer || '/'} [${code}] ${message}`)
+            .join('\n'));
+        this.name = 'BundleError';
+        this.diagnostics = Object.freeze(ordered);
+    }
+}

package/dist/v1/bundle/index.d.ts

@@ -0,0 +1,18 @@
+/** Create and transport one accepted schema with its exact dependency closure. */
+import type { DomainSchema } from '../schema/model/schema.js';
+import type { DOMAIN_BUNDLE_FORMAT, DOMAIN_BUNDLE_VERSION } from './model.js';
+/** Stable public name for the canonical exact dependency-closure envelope. */
+export interface Bundle<Root extends DomainSchema = DomainSchema> {
+    readonly format: typeof DOMAIN_BUNDLE_FORMAT;
+    readonly version: typeof DOMAIN_BUNDLE_VERSION;
+    readonly root: Root;
+    readonly closure: readonly DomainSchema[];
+}
+export declare function create<const Root extends DomainSchema>(root: Root): Bundle<Root>;
+export declare function accept(input: unknown): Bundle;
+export declare function decode(input: string | Uint8Array): Bundle;
+export declare function encode(bundle: Bundle): Uint8Array;
+export declare function serialize(bundle: Bundle): string;
+export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
+export { BundleError as Error } from './diagnostic.js';
+export type { BundleDiagnostic as Diagnostic, BundleDiagnosticCode as DiagnosticCode, } from './diagnostic.js';

package/dist/v1/bundle/index.js

@@ -0,0 +1,20 @@
+/** Create and transport one accepted schema with its exact dependency closure. */
+import { acceptDomainSchemaBundle, decodeDomainSchemaBundle, encodeDomainSchemaBundle, serializeDomainSchemaBundle, } from './codec.js';
+import { createDomainSchemaBundle } from './create.js';
+export function create(root) {
+    return createDomainSchemaBundle(root);
+}
+export function accept(input) {
+    return acceptDomainSchemaBundle(input);
+}
+export function decode(input) {
+    return decodeDomainSchemaBundle(input);
+}
+export function encode(bundle) {
+    return encodeDomainSchemaBundle(bundle);
+}
+export function serialize(bundle) {
+    return serializeDomainSchemaBundle(bundle);
+}
+export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
+export { BundleError as Error } from './diagnostic.js';

package/dist/v1/bundle/model.d.ts

@@ -0,0 +1,16 @@
+import type { DomainSchema } from '../schema/model/schema.js';
+export declare const DOMAIN_BUNDLE_FORMAT: 'astrale.dsl.bundle';
+export declare const DOMAIN_BUNDLE_VERSION: 'v1';
+declare const DOMAIN_SCHEMA_BUNDLE_BRAND: unique symbol;
+/** Canonical portable envelope for one root schema and its exact transitive closure. */
+export interface DomainSchemaBundleValue<Root extends DomainSchema = DomainSchema> {
+    readonly format: typeof DOMAIN_BUNDLE_FORMAT;
+    readonly version: typeof DOMAIN_BUNDLE_VERSION;
+    readonly root: Root;
+    readonly closure: readonly DomainSchema[];
+}
+export type DomainSchemaBundle<Root extends DomainSchema = DomainSchema> = DomainSchemaBundleValue<Root> & {
+    readonly [DOMAIN_SCHEMA_BUNDLE_BRAND]: true;
+};
+export declare function asDomainSchemaBundle<Root extends DomainSchema>(root: Root, closure: readonly DomainSchema[]): DomainSchemaBundle<Root>;
+export {};

package/dist/v1/bundle/model.js

@@ -0,0 +1,11 @@
+import { deepFreeze } from '../schema/canonical/freeze.js';
+export const DOMAIN_BUNDLE_FORMAT = 'astrale.dsl.bundle';
+export const DOMAIN_BUNDLE_VERSION = 'v1';
+export function asDomainSchemaBundle(root, closure) {
+    return deepFreeze({
+        format: DOMAIN_BUNDLE_FORMAT,
+        version: DOMAIN_BUNDLE_VERSION,
+        root,
+        closure: [...closure],
+    });
+}

package/dist/v1/bundle/structure.d.ts

@@ -0,0 +1,7 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { DomainSchemaIR } from '../schema/model/schema.js';
+export interface DomainSchemaBundleStructure {
+    readonly root: DomainSchemaIR;
+    readonly closure: readonly DomainSchemaIR[];
+}
+export declare function parseDomainSchemaBundleStructure(input: JsonValue): DomainSchemaBundleStructure;

package/dist/v1/bundle/structure.js

@@ -0,0 +1,71 @@
+import { SchemaError } from '../schema/diagnostic.js';
+import { routeDomainSchema } from '../schema/validation/domain.route.js';
+import { BundleError, diagnostic } from './diagnostic.js';
+import { DOMAIN_BUNDLE_FORMAT, DOMAIN_BUNDLE_VERSION } from './model.js';
+export function parseDomainSchemaBundleStructure(input) {
+    if (!isObject(input)) {
+        throw new BundleError([
+            diagnostic('BUNDLE_STRUCTURE', '', 'DomainSchemaBundle must be an object.'),
+        ]);
+    }
+    const diagnostics = [];
+    const expected = new Set(['format', 'version', 'root', 'closure']);
+    for (const key of Object.keys(input)) {
+        if (!expected.has(key)) {
+            diagnostics.push(diagnostic('BUNDLE_STRUCTURE', `/${escapeToken(key)}`, `Unknown bundle field ${key}.`));
+        }
+    }
+    for (const key of expected) {
+        if (!(key in input)) {
+            diagnostics.push(diagnostic('BUNDLE_STRUCTURE', `/${key}`, `Missing bundle field ${key}.`));
+        }
+    }
+    if (input.format !== DOMAIN_BUNDLE_FORMAT) {
+        diagnostics.push(diagnostic('UNSUPPORTED_BUNDLE_FORMAT', '/format', `Unsupported DomainSchemaBundle format ${describe(input.format)}.`));
+    }
+    if (input.version !== DOMAIN_BUNDLE_VERSION) {
+        diagnostics.push(diagnostic('UNSUPPORTED_BUNDLE_VERSION', '/version', `Unsupported DomainSchemaBundle version ${describe(input.version)}.`));
+    }
+    const root = routeAt(input.root, '/root', diagnostics);
+    const closure = [];
+    if (!Array.isArray(input.closure)) {
+        diagnostics.push(diagnostic('BUNDLE_STRUCTURE', '/closure', 'DomainSchemaBundle closure must be an array.'));
+    }
+    else {
+        for (const [index, value] of input.closure.entries()) {
+            const schema = routeAt(value, `/closure/${index}`, diagnostics);
+            if (schema !== undefined)
+                closure.push(schema);
+        }
+    }
+    if (diagnostics.length > 0)
+        throw new BundleError(diagnostics);
+    if (root === undefined) {
+        throw new BundleError([
+            diagnostic('BUNDLE_STRUCTURE', '/root', 'DomainSchemaBundle root is missing.'),
+        ]);
+    }
+    return Object.freeze({ root, closure: Object.freeze(closure) });
+}
+function routeAt(value, pointer, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    try {
+        return routeDomainSchema(value);
+    }
+    catch (error) {
+        if (!(error instanceof SchemaError))
+            throw error;
+        diagnostics.push(...error.diagnostics.map((entry) => diagnostic(entry.code, `${pointer}${entry.pointer}`, entry.message, entry.ref)));
+        return undefined;
+    }
+}
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function describe(value) {
+    return value === undefined ? '(missing)' : JSON.stringify(value);
+}
+function escapeToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}

package/dist/v1/bundle/transport.d.ts

@@ -0,0 +1,8 @@
+import type { Bundle } from './index.js';
+export type { Bundle } from './index.js';
+export declare const accept: (input: unknown) => Bundle;
+export declare const decode: (input: string | Uint8Array) => Bundle;
+export declare const encode: (bundle: Bundle) => Uint8Array;
+export declare const serialize: (bundle: Bundle) => string;
+export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
+export { BundleError as Error } from './diagnostic.js';

package/dist/v1/bundle/transport.js

@@ -0,0 +1,7 @@
+import { acceptDomainSchemaBundle, decodeDomainSchemaBundle, encodeDomainSchemaBundle, serializeDomainSchemaBundle, } from './codec.js';
+export const accept = (input) => acceptDomainSchemaBundle(input);
+export const decode = (input) => decodeDomainSchemaBundle(input);
+export const encode = (bundle) => encodeDomainSchemaBundle(bundle);
+export const serialize = (bundle) => serializeDomainSchemaBundle(bundle);
+export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
+export { BundleError as Error } from './diagnostic.js';

package/dist/v1/compiled/admission/accept.d.ts

@@ -0,0 +1,3 @@
+import type { CompiledSchema } from '../model/schema.js';
+/** Admit one detached compiled closure before indices and declarations become executable. */
+export declare function acceptCompiledSchema(input: unknown): CompiledSchema;