@astrale-os/kernel-dsl 0.2.0-beta.37 → 0.2.0-beta.39

package/dist/v1/schema/compatibility/meaning.js

@@ -1,234 +0,0 @@
-import { json } from '@astrale-os/kernel-dsl/value';
-import { Key } from '../../addressing/index.js';
-import { compareUnicode } from '../../addressing/ordering.js';
-import { isValueObject as isJsonObject } from '../../language/value/model/object.js';
-import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from '../../language/value/syntax/keywords.js';
-import { digestDomainSchemaBytes } from '../canonical/domain.digest.js';
-import { deepFreeze } from '../canonical/freeze.js';
-import { effectiveDefinition, effectiveMethod } from './context.js';
-import { keyForDefinitionRef } from './coordinate.js';
-import { ANNOTATION_KEYWORDS } from './fields.js';
-/**
- * The meaning of one coordinate is a portable value built from the fields `fields.ts` classifies
- * as counting at the coordinate's usage level; `__tests__/fields.test.ts` proves the two agree.
- * Comparison works on these values, so every difference can name its exact path.
- */
-export function meaningForCoordinate(context, coordinate, requirement) {
-    const owner = context.schemas.get(Key.origin(coordinate.key));
-    if (owner === undefined)
-        return undefined;
-    if (coordinate.kind === 'class')
-        return classMeaning(context, coordinate, requirement)?.meaning;
-    if (coordinate.kind === 'member')
-        return memberMeaning(owner, coordinate.ref);
-    const analysis = effectiveDefinition(context, owner, coordinate.owner);
-    if (analysis === undefined)
-        return undefined;
-    if (coordinate.kind === 'property') {
-        const field = analysis.properties.get(coordinate.key);
-        return field === undefined ? undefined : propertyMeaning(field);
-    }
-    const method = effectiveMethod(analysis, coordinate.key);
-    return method === undefined ? undefined : methodMeaning(method);
-}
-/**
- * A reference needs the Class to exist with its kind, abstractness and orientation; inheritance
- * additionally takes on the source ancestors, class policies, data contract and, for an Edge, the
- * endpoint and constraint contracts. A target projected onto a source requirement keeps only the
- * ancestors the source named, so a superset satisfies it while a removal changes it.
- */
-export function classMeaning(context, coordinate, onto) {
-    const owner = context.schemas.get(coordinate.ref.origin);
-    const declaration = owner?.classes[coordinate.ref.name];
-    const analysis = owner === undefined ? undefined : effectiveDefinition(context, owner, coordinate.ref);
-    if (owner === undefined || declaration === undefined || analysis === undefined)
-        return undefined;
-    const ancestors = ancestorKeys(context, coordinate.ref);
-    const requirement = Object.freeze({
-        ancestors,
-        properties: new Set(analysis.properties.keys()),
-    });
-    const meaning = {
-        coordinate: 'class',
-        level: coordinate.level,
-        kind: declaration.kind,
-        abstract: declaration.abstract,
-        ...(declaration.kind === 'edge' ? { orientation: declaration.orientation } : {}),
-        ...(coordinate.level === 'inherit'
-            ? {
-                extends: onto === undefined
-                    ? ancestors
-                    : onto.ancestors.filter((ancestor) => ancestors.includes(ancestor)),
-                policies: Object.fromEntries(Object.entries(declaration.policies)
-                    .filter(([, ref]) => ref !== undefined)
-                    .map(([role, ref]) => [role, keyForDefinitionRef(ref)])),
-                ...(declaration.kind === 'node'
-                    ? {
-                        data: analysis.data === undefined
-                            ? null
-                            : {
-                                owner: keyForDefinitionRef(analysis.data.owner),
-                                declaration: analysis.data.declaration,
-                            },
-                    }
-                    : { endpoints: declaration.endpoints, constraints: declaration.constraints }),
-            }
-            : {}),
-    };
-    return { meaning: deepFreeze(meaning), requirement };
-}
-export function memberMeaning(owner, ref) {
-    const meaning = memberMeaningOf(owner, ref);
-    return meaning === undefined ? undefined : deepFreeze(meaning);
-}
-function memberMeaningOf(owner, ref) {
-    if (ref.origin !== owner.origin)
-        return undefined;
-    switch (ref.kind) {
-        case 'function': {
-            const declaration = owner.functions[ref.name];
-            return declaration === undefined
-                ? undefined
-                : { coordinate: 'function', ...callableContract(declaration) };
-        }
-        case 'policy': {
-            const declaration = owner.policies[ref.name];
-            return declaration === undefined
-                ? undefined
-                : { coordinate: 'policy', expression: declaration.expression };
-        }
-        case 'view': {
-            const declaration = owner.views[ref.name];
-            return declaration === undefined
-                ? undefined
-                : { coordinate: 'view', target: declaration.target };
-        }
-        case 'core': {
-            const node = owner.core.nodes[ref.name];
-            return node === undefined
-                ? undefined
-                : {
-                    coordinate: 'core',
-                    class: node.class,
-                    properties: node.properties,
-                    edges: incidentCoreEdges(owner, ref.name).map((edge) => ({
-                        class: edge.class,
-                        source: edge.source,
-                        target: edge.target,
-                        properties: edge.properties,
-                    })),
-                };
-        }
-    }
-}
-export function propertyMeaning(field) {
-    return deepFreeze({
-        coordinate: 'property',
-        owner: keyForDefinitionRef(field.owner),
-        name: field.name,
-        schema: semanticValueSchema(field.schema),
-        required: field.required,
-        ...(field.auto === undefined ? {} : { auto: field.auto }),
-        ...(field.state === undefined ? {} : { state: field.state }),
-    });
-}
-export function methodMeaning(method) {
-    return deepFreeze({
-        coordinate: 'method',
-        owner: keyForDefinitionRef(method.owner),
-        name: method.name,
-        ...callableContract(method.declaration),
-    });
-}
-/**
- * Fingerprint the contract a caller compiles against, independently of its Domain revision: the
- * exact key, the owner, dispatch and abstractness of a Method, and the semantic input and output
- * contracts; authorization is excluded (DM-CALLABLE-FINGERPRINT). A static consumer pins this
- * instead of a Domain revision, so a dependency release that leaves the callable contract untouched
- * keeps every bound invocation valid.
- */
-export function callableFingerprint(callable) {
-    // This digest input travels in every bound invocation and is recomputed by the Kernel; its
-    // shape is frozen, `kind` included, so a Kernel upgrade never invalidates an unchanged pin.
-    return fingerprintMeaning('owner' in callable
-        ? {
-            kind: 'method',
-            key: callable.key,
-            owner: callable.owner.key,
-            ...callableContract(callable),
-        }
-        : { kind: 'function', key: callable.key, ...callableContract(callable) });
-}
-/** The `always` fields of CALLABLE_FIELDS: dispatch shape and the semantic input and output. */
-function callableContract(declaration) {
-    return {
-        ...('static' in declaration
-            ? { static: declaration.static, abstract: declaration.abstract }
-            : {}),
-        input: semanticValueSchema(declaration.input),
-        output: semanticOutput(declaration.output),
-    };
-}
-function semanticOutput(output) {
-    switch (output.mode) {
-        case 'value':
-            return { mode: 'value', schema: semanticValueSchema(output.schema) };
-        case 'stream':
-            return { mode: 'stream', item: semanticValueSchema(output.item) };
-        case 'binary':
-            return { mode: 'binary' };
-    }
-}
-/** Drop annotation keywords wherever a schema keyword nests a schema; never inside data. */
-export function semanticValueSchema(value) {
-    if (typeof value === 'boolean')
-        return value;
-    const semantic = {};
-    for (const [keyword, entry] of Object.entries(value)) {
-        if (ANNOTATION_KEYWORDS.includes(keyword))
-            continue;
-        if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(entry)) {
-            semantic[keyword] = semanticValueSchema(entry);
-        }
-        else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(entry)) {
-            semantic[keyword] = entry.map((item) => isJsonSchema(item) ? semanticValueSchema(item) : item);
-        }
-        else if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(entry)) {
-            semantic[keyword] = Object.fromEntries(Object.entries(entry).map(([name, item]) => [
-                name,
-                isJsonSchema(item) ? semanticValueSchema(item) : item,
-            ]));
-        }
-        else {
-            semantic[keyword] = entry;
-        }
-    }
-    return semantic;
-}
-export function fingerprintMeaning(value) {
-    return digestDomainSchemaBytes(json.encode(value));
-}
-function ancestorKeys(context, ref) {
-    const seen = new Set();
-    const visit = (current) => {
-        const declaration = context.schemas.get(current.origin)?.classes[current.name];
-        if (declaration === undefined)
-            return;
-        for (const parent of declaration.extends) {
-            const key = keyForDefinitionRef(parent);
-            if (seen.has(key))
-                continue;
-            seen.add(key);
-            visit(parent);
-        }
-    };
-    visit(ref);
-    return [...seen].sort(compareUnicode);
-}
-function incidentCoreEdges(owner, name) {
-    return owner.core.edges.filter((edge) => (edge.source.kind === 'core' && edge.source.name === name) ||
-        (edge.target.kind === 'core' && edge.target.name === name));
-}
-function isJsonSchema(value) {
-    return typeof value === 'boolean' || isJsonObject(value);
-}