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

package/dist/v1/schema/validation/domain.structure.js

@@ -0,0 +1,427 @@
+import { z } from 'zod';
+import { PropertyKey as SemanticPropertyKey } from '../../addressing/index.js';
+import { CORE_SLUG_PATTERN, DEPENDENCY_ALIAS_PATTERN, DOMAIN_ORIGIN_PATTERN, DOMAIN_REVISION_PATTERN, MEMBER_NAME_PATTERN, } from '../../addressing/patterns.js';
+import { MEDIA_TYPE_PATTERN } from '../../language/class/model/data.js';
+import * as metadata from '../../language/definition/metadata.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { DOMAIN_FORMAT, DOMAIN_VERSION } from '../model/format.js';
+const originSchema = z.string().min(3).max(253).regex(DOMAIN_ORIGIN_PATTERN);
+const memberNameSchema = z.string().regex(MEMBER_NAME_PATTERN);
+const dependencyAliasSchema = z
+    .string()
+    .regex(DEPENDENCY_ALIAS_PATTERN)
+    .refine((value) => value !== '__proto__' && value !== 'prototype' && value !== 'constructor', 'Expected a non-reserved dependency alias.');
+const propertyKeySchema = z
+    .string()
+    .refine(SemanticPropertyKey.is, 'Expected a canonical PropertyKey.');
+const coreSlugSchema = z.string().min(1).max(100).regex(CORE_SLUG_PATTERN);
+const revisionSchema = z.string().regex(DOMAIN_REVISION_PATTERN);
+const descriptionSchema = z
+    .string()
+    .min(metadata.description.minLength)
+    .max(metadata.description.maxLength);
+const iconSchema = z.string().min(metadata.icon.minLength).max(metadata.icon.maxLength);
+const jsonValueSchema = z.lazy(() => z.union([
+    z.null(),
+    z.boolean(),
+    z.number(),
+    z.string(),
+    z.array(jsonValueSchema),
+    z.record(z.string(), jsonValueSchema),
+]));
+const jsonObjectSchema = z.record(z.string(), jsonValueSchema);
+const jsonSchemaSchema = z.union([z.boolean(), jsonObjectSchema]);
+const dataDeclarationSchema = z.strictObject({
+    mediaType: z.string().regex(MEDIA_TYPE_PATTERN),
+});
+const propertyDefinitionSchema = z.strictObject({
+    schema: jsonSchemaSchema,
+    required: z.boolean(),
+    visibility: z.enum(['public', 'private']),
+    auto: z
+        .strictObject({
+        on: uniqueArray(z.enum(['create', 'update'])).min(1),
+        set: z.literal('instant'),
+    })
+        .optional(),
+    description: descriptionSchema.optional(),
+});
+const propertyRecordSchema = z.record(memberNameSchema, propertyDefinitionSchema);
+const domainDependencySchema = z.strictObject({
+    origin: originSchema,
+    revision: revisionSchema,
+});
+const classRefSchema = absoluteRefSchema('class');
+const functionRefSchema = absoluteRefSchema('function');
+const policyRefSchema = absoluteRefSchema('policy');
+const viewRefSchema = absoluteRefSchema('view');
+const coreRefSchema = z.strictObject({
+    origin: originSchema,
+    kind: z.literal('core'),
+    name: coreSlugSchema,
+});
+const domainRefSchema = z.strictObject({ kind: z.literal('domain') });
+const coreEndpointRefSchema = z.discriminatedUnion('kind', [coreRefSchema, domainRefSchema]);
+const policyObjectRefSchema = z.discriminatedUnion('kind', [
+    classRefSchema,
+    functionRefSchema,
+    policyRefSchema,
+    viewRefSchema,
+    coreRefSchema,
+]);
+const edgeEndpointBaseShape = {
+    role: memberNameSchema,
+    accepts: uniqueArray(classRefSchema).min(1),
+};
+const edgeCountSchema = z.enum(['0..*', '1..*', '0..1', '1']);
+const directedEdgeEndpointsSchema = z.strictObject({
+    source: z.strictObject({ ...edgeEndpointBaseShape, outgoing: edgeCountSchema }),
+    target: z.strictObject({ ...edgeEndpointBaseShape, incoming: edgeCountSchema }),
+});
+const incidentEndpointSchema = z.strictObject({
+    ...edgeEndpointBaseShape,
+    incident: edgeCountSchema,
+});
+const undirectedEdgeEndpointsSchema = z.tuple([incidentEndpointSchema, incidentEndpointSchema]);
+const edgeConstraintsSchema = z.strictObject({
+    noSelf: z.literal(true).optional(),
+    acyclic: z.literal(true).optional(),
+});
+const policyPatternSubjectSchema = z.strictObject({ kind: z.literal('subject') });
+const policyPatternObjectSchema = z.strictObject({ kind: z.literal('object') });
+const policyPatternSourceSchema = z.strictObject({ kind: z.literal('source') });
+const policyPatternTargetSchema = z.strictObject({ kind: z.literal('target') });
+const policyPatternVariableSchema = z.strictObject({
+    kind: z.literal('variable'),
+    id: z.number().int().min(0),
+});
+const policyPatternNodeSchema = z.discriminatedUnion('kind', [
+    policyPatternSubjectSchema,
+    policyPatternObjectSchema,
+    policyPatternSourceSchema,
+    policyPatternTargetSchema,
+    policyPatternVariableSchema,
+]);
+const policyVariableSchema = z.strictObject({
+    variable: policyPatternVariableSchema,
+    class: classRefSchema,
+});
+const policyRepeatSchema = z.strictObject({
+    min: z.number().int().min(0).max(3),
+    max: z.number().int().min(0).max(3),
+});
+const policyPatternExpressionSchema = z.lazy(() => z.union([
+    z.strictObject({
+        source: policyPatternNodeSchema,
+        class: classRefSchema,
+        target: policyPatternNodeSchema,
+        repeat: policyRepeatSchema.optional(),
+    }),
+    z.strictObject({
+        exists: z.strictObject({
+            nodes: z.array(policyVariableSchema).min(1).max(4),
+            where: policyPatternExpressionSchema,
+        }),
+    }),
+    z.strictObject({
+        allOf: z.array(policyPatternExpressionSchema).min(1),
+    }),
+    z.strictObject({
+        anyOf: z.array(policyPatternExpressionSchema).min(1),
+    }),
+]));
+const policyCheckObjectSchema = z.discriminatedUnion('kind', [
+    z.strictObject({ kind: z.literal('self') }),
+    z.strictObject({
+        kind: z.literal('input'),
+        field: memberNameSchema,
+    }),
+    z.strictObject({
+        kind: z.literal('ref'),
+        ref: policyObjectRefSchema,
+    }),
+]);
+const policyCheckExpressionSchema = z.lazy(() => z.union([
+    z.strictObject({
+        check: policyRefSchema,
+        object: policyCheckObjectSchema,
+    }),
+    z.strictObject({
+        allOf: z.array(policyCheckExpressionSchema).min(1),
+    }),
+    z.strictObject({
+        anyOf: z.array(policyCheckExpressionSchema).min(1),
+    }),
+]));
+const callableOutputSchema = z.discriminatedUnion('mode', [
+    z.strictObject({
+        mode: z.literal('value'),
+        schema: jsonSchemaSchema,
+    }),
+    z.strictObject({
+        mode: z.literal('stream'),
+        item: jsonSchemaSchema,
+    }),
+    z.strictObject({
+        mode: z.literal('binary'),
+    }),
+]);
+const callableShape = {
+    description: descriptionSchema.optional(),
+    input: jsonSchemaSchema,
+    output: callableOutputSchema,
+    auth: z.enum(['anonymous', 'authenticated', 'authorized']),
+    policy: policyCheckExpressionSchema.optional(),
+};
+const methodDeclarationSchema = z
+    .strictObject({
+    ...callableShape,
+    static: z.boolean(),
+    inheritance: z.enum(['abstract', 'default', 'sealed']),
+})
+    .superRefine((method, context) => {
+    if (method.inheritance === 'abstract' && method.policy !== undefined) {
+        context.addIssue({
+            code: 'custom',
+            path: ['policy'],
+            message: 'An abstract method cannot declare a policy.',
+            params: { structureCode: 'STRUCTURE_ABSTRACT_POLICY' },
+        });
+    }
+    if (method.auth !== 'authorized' && method.policy !== undefined) {
+        context.addIssue({
+            code: 'custom',
+            path: ['policy'],
+            message: 'Only an authorized method may declare a policy.',
+            params: { structureCode: 'STRUCTURE_CALLABLE_POLICY_AUTH' },
+        });
+    }
+});
+const methodRecordSchema = z.record(memberNameSchema, methodDeclarationSchema);
+const nodeClassPoliciesSchema = z.strictObject({
+    read: policyRefSchema.optional(),
+    traverse: policyRefSchema.optional(),
+});
+const edgeClassPoliciesSchema = z.strictObject({
+    traverse: policyRefSchema.optional(),
+});
+const nodeClassSchema = z.strictObject({
+    ref: classRefSchema,
+    kind: z.literal('node'),
+    abstract: z.boolean(),
+    description: descriptionSchema.optional(),
+    extends: uniqueArray(classRefSchema),
+    properties: propertyRecordSchema,
+    methods: methodRecordSchema,
+    data: dataDeclarationSchema.optional(),
+    icon: iconSchema.optional(),
+    policies: nodeClassPoliciesSchema,
+});
+const edgeClassShape = {
+    ref: classRefSchema,
+    kind: z.literal('edge'),
+    abstract: z.boolean(),
+    description: descriptionSchema.optional(),
+    extends: uniqueArray(classRefSchema),
+    properties: propertyRecordSchema,
+    constraints: edgeConstraintsSchema,
+};
+const edgeClassSchema = z
+    .strictObject({
+    ...edgeClassShape,
+    orientation: z.enum(['directed', 'undirected']),
+    endpoints: z.union([directedEdgeEndpointsSchema, undirectedEdgeEndpointsSchema]),
+    policies: edgeClassPoliciesSchema,
+})
+    .superRefine(validateEdgeOrientationShape);
+const classDeclarationSchema = z.discriminatedUnion('kind', [nodeClassSchema, edgeClassSchema]);
+function validateEdgeOrientationShape(value, context) {
+    if ((value.orientation === 'undirected') === Array.isArray(value.endpoints))
+        return;
+    context.addIssue({
+        code: 'custom',
+        path: ['endpoints'],
+        message: `${value.orientation} Edge endpoints have the wrong structural shape.`,
+        params: { structureCode: 'STRUCTURE_EDGE_ORIENTATION' },
+    });
+}
+const functionDefinitionSchema = z
+    .strictObject({ ref: functionRefSchema, ...callableShape })
+    .superRefine((callable, context) => {
+    if (callable.auth !== 'authorized' && callable.policy !== undefined) {
+        context.addIssue({
+            code: 'custom',
+            path: ['policy'],
+            message: 'Only an authorized function may declare a policy.',
+            params: { structureCode: 'STRUCTURE_CALLABLE_POLICY_AUTH' },
+        });
+    }
+});
+const policyExpressionSchema = z.union([
+    z.strictObject({
+        match: policyPatternExpressionSchema,
+    }),
+    z.strictObject({
+        allOf: z.array(policyRefSchema).min(1),
+    }),
+    z.strictObject({
+        anyOf: z.array(policyRefSchema).min(1),
+    }),
+]);
+const policyDefinitionSchema = z.strictObject({
+    ref: policyRefSchema,
+    expression: policyExpressionSchema,
+    description: descriptionSchema.optional(),
+});
+const viewTargetSchema = z.discriminatedUnion('kind', [
+    z.strictObject({ kind: z.literal('domain') }),
+    z.strictObject({
+        kind: z.literal('definition'),
+        definitions: uniqueArray(classRefSchema).min(1),
+    }),
+]);
+const viewDefinitionSchema = z.strictObject({
+    ref: viewRefSchema,
+    description: descriptionSchema.optional(),
+    target: viewTargetSchema,
+});
+const coreNodeSchema = z.strictObject({
+    ref: coreRefSchema,
+    class: classRefSchema,
+    properties: z.record(propertyKeySchema, jsonValueSchema),
+});
+const coreEdgeSchema = z.strictObject({
+    class: classRefSchema,
+    source: coreEndpointRefSchema,
+    target: coreEndpointRefSchema,
+    properties: z.record(propertyKeySchema, jsonValueSchema),
+});
+const coreSchema = z.strictObject({
+    nodes: z.record(coreSlugSchema, coreNodeSchema),
+    edges: z.array(coreEdgeSchema),
+});
+const structuralSchema = z.strictObject({
+    format: z.literal(DOMAIN_FORMAT),
+    version: z.literal(DOMAIN_VERSION),
+    origin: originSchema,
+    dependencies: z.record(dependencyAliasSchema, domainDependencySchema),
+    classes: z.record(memberNameSchema, classDeclarationSchema),
+    functions: z.record(memberNameSchema, functionDefinitionSchema),
+    policies: z.record(memberNameSchema, policyDefinitionSchema),
+    views: z.record(memberNameSchema, viewDefinitionSchema),
+    core: coreSchema,
+});
+export const domainSchemaStructuralSchema = structuralSchema;
+export function parseDomainSchemaStructure(input) {
+    const result = domainSchemaStructuralSchema.safeParse(input);
+    if (result.success)
+        return result.data;
+    throw new SchemaError(result.error.issues.flatMap((issue) => diagnosticsForIssue(issue, input)));
+}
+function absoluteRefSchema(kind) {
+    return z.strictObject({
+        origin: originSchema,
+        kind: z.literal(kind),
+        name: memberNameSchema,
+    });
+}
+function uniqueArray(element) {
+    return z.array(element).superRefine((values, context) => {
+        const firstIndexByValue = new Map();
+        values.forEach((value, index) => {
+            const key = canonicalJson(value);
+            const firstIndex = firstIndexByValue.get(key);
+            if (firstIndex === undefined) {
+                firstIndexByValue.set(key, index);
+                return;
+            }
+            context.addIssue({
+                code: 'custom',
+                path: [index],
+                message: `Array item duplicates item ${firstIndex}.`,
+                params: { structureCode: 'STRUCTURE_DUPLICATE_ITEM' },
+            });
+        });
+    });
+}
+function canonicalJson(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    return `{${Object.entries(value)
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+        .map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`)
+        .join(',')}}`;
+}
+function diagnosticsForIssue(issue, input) {
+    if (issue.code === 'unrecognized_keys') {
+        return issue.keys.map((key) => diagnostic('STRUCTURE_UNKNOWN_FIELD', pointer([...issue.path, key]), `Unknown field ${JSON.stringify(key)}.`));
+    }
+    const customCode = issue.code === 'custom' ? customStructureCode(issue.params?.structureCode) : undefined;
+    return [
+        diagnostic(customCode ?? structureCode(issue, input), pointer(issue.path), structureMessage(issue, input)),
+    ];
+}
+function customStructureCode(input) {
+    switch (input) {
+        case 'STRUCTURE_ABSTRACT_POLICY':
+        case 'STRUCTURE_CALLABLE_POLICY_AUTH':
+        case 'STRUCTURE_DUPLICATE_ITEM':
+        case 'STRUCTURE_EDGE_ORIENTATION':
+            return input;
+        default:
+            return undefined;
+    }
+}
+function structureCode(issue, input) {
+    switch (issue.code) {
+        case 'invalid_type':
+            return valueAtPath(input, issue.path) === undefined ? 'STRUCTURE_REQUIRED' : 'STRUCTURE_TYPE';
+        case 'invalid_value':
+            return 'STRUCTURE_VALUE';
+        case 'invalid_format':
+            return 'STRUCTURE_FORMAT';
+        case 'invalid_union':
+            return 'STRUCTURE_UNION';
+        case 'invalid_key':
+            return 'STRUCTURE_KEY';
+        case 'too_small':
+            return 'STRUCTURE_MINIMUM';
+        case 'too_big':
+            return 'STRUCTURE_MAXIMUM';
+        case 'not_multiple_of':
+            return 'STRUCTURE_MULTIPLE';
+        default:
+            return 'STRUCTURE_INVALID';
+    }
+}
+function structureMessage(issue, input) {
+    if (issue.code === 'invalid_type' && valueAtPath(input, issue.path) === undefined) {
+        return 'Required value is missing.';
+    }
+    if (issue.code === 'invalid_union') {
+        return 'Value does not match any allowed structural variant.';
+    }
+    if (issue.code === 'invalid_key') {
+        return 'Record member name is invalid.';
+    }
+    return issue.message;
+}
+function valueAtPath(input, path) {
+    let value = input;
+    for (const segment of path) {
+        if (typeof value !== 'object' || value === null)
+            return undefined;
+        value = Reflect.get(value, segment);
+    }
+    return value;
+}
+function pointer(path) {
+    if (path.length === 0)
+        return '';
+    return `/${path.map((segment) => escapePointerSegment(String(segment))).join('/')}`;
+}
+function escapePointerSegment(segment) {
+    return segment.replaceAll('~', '~0').replaceAll('/', '~1');
+}

package/dist/v1/schema/validation/policy/budgets.d.ts

@@ -0,0 +1,4 @@
+import type { PolicyValidationContext } from './context.js';
+import { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks } from '../../../language/policy/analysis/budgets.js';
+export { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks, };
+export declare function validatePolicyBudgets(context: PolicyValidationContext): void;

package/dist/v1/schema/validation/policy/budgets.js

@@ -0,0 +1,102 @@
+import { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks, } from '../../../language/policy/analysis/budgets.js';
+import { escapePointer } from './context.js';
+export { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks, };
+export function validatePolicyBudgets(context) {
+    for (const name of Object.keys(context.environment.candidate.policies)) {
+        const measure = measurePolicy(context, name, new Set());
+        if (measure === undefined)
+            continue;
+        const pointer = `/policies/${escapePointer(name)}`;
+        if (measure.depth > MAX_PATTERN_DEPTH) {
+            context.add('PL_BUDGET', pointer, `Expanded Pattern depth ${measure.depth} exceeds ${MAX_PATTERN_DEPTH}.`);
+        }
+        if (measure.edgeCounts.length > MAX_BRANCHES) {
+            context.add('PL_BUDGET', pointer, `Expanded Pattern has more than ${MAX_BRANCHES} normalized branches.`);
+        }
+        const edgeMaximum = Math.max(0, ...measure.edgeCounts);
+        if (edgeMaximum > MAX_EDGES) {
+            context.add('PL_BUDGET', pointer, `A normalized branch contains ${edgeMaximum} Edge predicates; the maximum is ${MAX_EDGES}.`);
+        }
+        if (measure.domains.size > MAX_DOMAINS) {
+            context.add('PL_BUDGET', pointer, `Expanded Pattern references ${measure.domains.size} Domains; the maximum is ${MAX_DOMAINS}.`);
+        }
+    }
+}
+function measurePolicy(context, name, visiting) {
+    if (visiting.has(name))
+        return undefined;
+    const declaration = context.normalized.get(name);
+    if (declaration === undefined)
+        return undefined;
+    const nested = new Set(visiting);
+    nested.add(name);
+    if ('match' in declaration) {
+        return measurePattern(declaration.match, context.environment.candidate.origin);
+    }
+    const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
+    const children = refs.flatMap((ref) => {
+        if (!context.isLocalPolicy(ref))
+            return [];
+        const value = measurePolicy(context, ref.name, nested);
+        return value === undefined ? [] : [value];
+    });
+    if (children.length !== refs.length || children.length === 0)
+        return undefined;
+    return combineMeasures('allOf' in declaration ? 'allOf' : 'anyOf', children);
+}
+function measurePattern(pattern, ownOrigin) {
+    if (isEdge(pattern)) {
+        return {
+            depth: 1,
+            edgeCounts: [1],
+            domains: new Set([ownOrigin, pattern.class.origin]),
+        };
+    }
+    if ('exists' in pattern) {
+        const child = measurePattern(pattern.exists.where, ownOrigin);
+        return {
+            depth: child.depth + 1,
+            edgeCounts: child.edgeCounts,
+            domains: new Set([
+                ...child.domains,
+                ...pattern.exists.nodes.map((node) => node.class.origin),
+            ]),
+        };
+    }
+    const { key, values } = patternOperands(pattern);
+    return combineMeasures(key, values.map((child) => measurePattern(child, ownOrigin)));
+}
+function combineMeasures(key, children) {
+    const depth = 1 + Math.max(0, ...children.map((child) => child.depth));
+    const domains = new Set(children.flatMap((child) => [...child.domains]));
+    if (key === 'anyOf') {
+        return {
+            depth,
+            edgeCounts: children.flatMap((child) => child.edgeCounts).slice(0, BRANCH_OVERFLOW),
+            domains,
+        };
+    }
+    let edgeCounts = [0];
+    for (const child of children) {
+        const next = [];
+        for (const left of edgeCounts) {
+            for (const right of child.edgeCounts) {
+                next.push(left + right);
+                if (next.length >= BRANCH_OVERFLOW)
+                    break;
+            }
+            if (next.length >= BRANCH_OVERFLOW)
+                break;
+        }
+        edgeCounts = next;
+    }
+    return { depth, edgeCounts, domains };
+}
+function patternOperands(value) {
+    return 'allOf' in value
+        ? { key: 'allOf', values: value.allOf }
+        : { key: 'anyOf', values: value.anyOf };
+}
+function isEdge(value) {
+    return 'source' in value;
+}

package/dist/v1/schema/validation/policy/context.d.ts

@@ -0,0 +1,28 @@
+import type { ClassDefinition } from '../../../language/class/model/class.js';
+import type { PolicyExpression } from '../../../language/policy/model/policy.js';
+import type { DefinitionAnalysisResult } from '../../analysis/class.js';
+import type { SchemaDiagnostic, SchemaDiagnosticCode } from '../../diagnostic.js';
+import type { DomainResolutionContext } from '../../resolution/context.js';
+import type { IndexedClassDefinition } from '../../resolution/definition.index.js';
+import { type ClassRef, type PolicyRef } from '../../../addressing/index.js';
+export declare class PolicyValidationContext {
+    #private;
+    readonly environment: DomainResolutionContext;
+    readonly analysis: DefinitionAnalysisResult;
+    readonly diagnostics: SchemaDiagnostic[];
+    readonly normalized: Map<string, PolicyExpression>;
+    readonly allNodeClasses: readonly ClassRef[];
+    readonly concreteNodeClasses: readonly ClassRef[];
+    constructor(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult);
+    resolveNodeClass(ref: ClassRef, pointer: string): IndexedClassDefinition | undefined;
+    resolveEdge(ref: ClassRef, pointer: string): IndexedClassDefinition | undefined;
+    resolvePolicy(ref: PolicyRef, pointer: string): boolean;
+    isLocalPolicy(ref: PolicyRef): boolean;
+    edgeDeclaration(ref: ClassRef): Extract<ClassDefinition, {
+        readonly kind: 'edge';
+    }> | undefined;
+    /** Return true when candidate is the required Class or a same-kind descendant. */
+    classExtends(candidate: ClassRef, required: ClassRef): boolean;
+    add(code: SchemaDiagnosticCode, pointer: string, message: string, ref?: string): void;
+}
+export declare function escapePointer(value: string): string;

package/dist/v1/schema/validation/policy/context.js

@@ -0,0 +1,89 @@
+import { Key } from '../../../addressing/index.js';
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { diagnostic } from '../../diagnostic.js';
+const formatDefinitionRef = Key.of;
+export class PolicyValidationContext {
+    environment;
+    analysis;
+    diagnostics = [];
+    normalized = new Map();
+    allNodeClasses;
+    concreteNodeClasses;
+    #invalidPolicyRefs = new Set();
+    constructor(environment, analysis) {
+        this.environment = environment;
+        this.analysis = analysis;
+        const nodeClasses = [...environment.definitions.values()].filter((value) => value.ref.kind === 'class' && value.kind === 'node');
+        this.allNodeClasses = nodeClasses.map((value) => value.ref);
+        this.concreteNodeClasses = nodeClasses
+            .filter((value) => !value.declaration.abstract)
+            .map((value) => value.ref);
+    }
+    resolveNodeClass(ref, pointer) {
+        const resolved = this.environment.resolve(ref);
+        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'node') {
+            this.add('PL_REF', pointer, `${formatDefinitionRef(ref)} does not resolve to an owning/direct-dependency Node Class.`, formatDefinitionRef(ref));
+            return undefined;
+        }
+        return resolved;
+    }
+    resolveEdge(ref, pointer) {
+        const resolved = this.environment.resolve(ref);
+        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'edge') {
+            this.add('PL_REF', pointer, `${formatDefinitionRef(ref)} does not resolve to an owning/direct-dependency Edge Class.`, formatDefinitionRef(ref));
+            return undefined;
+        }
+        return resolved;
+    }
+    resolvePolicy(ref, pointer) {
+        const key = `${pointer}\u0000${definitionRefIndex(ref)}`;
+        if (this.#invalidPolicyRefs.has(key))
+            return false;
+        const declaration = this.environment.resolvePolicy(ref);
+        if (ref.origin !== this.environment.candidate.origin ||
+            ref.kind !== 'policy' ||
+            declaration === undefined) {
+            this.#invalidPolicyRefs.add(key);
+            this.add('PL_REF', pointer, `${formatDefinitionRef(ref)} is not an exact local named Policy ref.`, formatDefinitionRef(ref));
+            return false;
+        }
+        return true;
+    }
+    isLocalPolicy(ref) {
+        return (ref.origin === this.environment.candidate.origin &&
+            ref.kind === 'policy' &&
+            this.environment.candidate.policies[ref.name] !== undefined);
+    }
+    edgeDeclaration(ref) {
+        const resolved = this.environment.resolve(ref);
+        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'edge') {
+            return undefined;
+        }
+        return resolved.declaration;
+    }
+    /** Return true when candidate is the required Class or a same-kind descendant. */
+    classExtends(candidate, required) {
+        if (definitionRefIndex(candidate) === definitionRefIndex(required))
+            return true;
+        const visited = new Set();
+        const visit = (ref) => {
+            const key = definitionRefIndex(ref);
+            if (key === definitionRefIndex(required))
+                return true;
+            if (visited.has(key))
+                return false;
+            visited.add(key);
+            const resolved = this.environment.resolveAny(ref);
+            if (resolved === undefined || resolved.ref.kind !== 'class')
+                return false;
+            return resolved.declaration.extends.some(visit);
+        };
+        return visit(candidate);
+    }
+    add(code, pointer, message, ref) {
+        this.diagnostics.push(diagnostic(code, pointer, message, ref));
+    }
+}
+export function escapePointer(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}

package/dist/v1/schema/validation/policy/references.d.ts

@@ -0,0 +1,2 @@
+import type { PolicyValidationContext } from './context.js';
+export declare function validatePolicyReferences(context: PolicyValidationContext): void;