@astrale-os/sdk 0.5.0-beta.2 → 0.5.0-beta.21

package/dist/tooling/linter/implementations/source/actions.js

@@ -0,0 +1,184 @@
+import ts from 'typescript';
+import { importedSymbol, resolveProjectImport, unwrap, visit, } from '../../adapters/typescript/index.js';
+import { ambiguity, production, violation } from './shared.js';
+export const actionRules = [
+    {
+        id: 'ACT-ONE-IMPL',
+        ruleRevision: '3c5e7f05c95826ea9ba14cdb6c1ed30dd190f3774bfbad3a2dfa607aada4a044',
+        evaluate(project) {
+            const evidence = [];
+            const registered = new Map();
+            const compositionPaths = new Set(project.policy.rootFiles
+                .filter(({ role }) => role === 'composition')
+                .map(({ sourcePath }) => sourcePath));
+            const roots = production(project).filter(({ path }) => compositionPaths.has(path));
+            for (const file of roots) {
+                visit(file.source, (node) => {
+                    if (!ts.isCallExpression(node) || !isDefineRuntimeCall(file, node))
+                        return;
+                    const input = node.arguments[0] && unwrap(node.arguments[0]);
+                    if (!input || !ts.isObjectLiteralExpression(input)) {
+                        evidence.push(ambiguity(file, node, 'defineRuntime input is not a static object literal.'));
+                        return;
+                    }
+                    const actions = input.properties.find((property) => (ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) &&
+                        (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) &&
+                        property.name.text === 'actions');
+                    if (!actions)
+                        return;
+                    const registry = ts.isPropertyAssignment(actions)
+                        ? unwrap(actions.initializer)
+                        : ts.isShorthandPropertyAssignment(actions)
+                            ? resolveLocalInitializer(file.source, actions.name.text)
+                            : undefined;
+                    if (!registry) {
+                        evidence.push(ambiguity(file, actions, 'defineRuntime actions binding cannot be resolved locally.'));
+                        return;
+                    }
+                    const objectValues = inspectObjectValuesRegistry(project, file, registry);
+                    if (objectValues.kind === 'valid')
+                        return;
+                    if (objectValues.kind === 'invalid') {
+                        evidence.push(objectValues.ambiguous
+                            ? ambiguity(file, registry, objectValues.message)
+                            : violation(file, registry, objectValues.message));
+                        return;
+                    }
+                    if (!ts.isArrayLiteralExpression(registry)) {
+                        evidence.push(ambiguity(file, registry, 'defineRuntime actions is not a static array literal.'));
+                        return;
+                    }
+                    visitActionLeaves(registry, (expression) => {
+                        const value = unwrap(expression);
+                        if (!ts.isIdentifier(value)) {
+                            evidence.push(violation(file, value, 'Action must be one imported Actions binding.'));
+                            return;
+                        }
+                        const symbol = importedSymbol(file, value);
+                        const sourceImport = symbol && file.imports.find(({ specifier }) => specifier === symbol.module);
+                        const target = sourceImport && resolveProjectImport(project, file, sourceImport.specifier);
+                        if (target?.layer === 'actions' && !target.submodule) {
+                            evidence.push(ambiguity(file, value, `Action ${value.text} reaches the Actions layer facade but its ultimate semantic submodule owner is unresolved.`));
+                            return;
+                        }
+                        if (!target || target.layer !== 'actions' || !target.submodule) {
+                            evidence.push(violation(file, value, `Action ${value.text} is not owned by one Actions submodule.`));
+                            return;
+                        }
+                        const key = `${target.path}\0${symbol.name}`;
+                        if (registered.has(key)) {
+                            evidence.push(violation(file, value, `Action ${value.text} is registered more than once from ${target.path}.`));
+                        }
+                        else {
+                            registered.set(key, value);
+                        }
+                    });
+                });
+            }
+            return evidence;
+        },
+    },
+];
+function isDefineRuntimeCall(file, node) {
+    const factory = unwrap(node.expression);
+    return (ts.isCallExpression(factory) &&
+        importedSymbol(file, factory.expression)?.name === 'defineRuntime');
+}
+function inspectObjectValuesRegistry(project, file, expression) {
+    if (!ts.isCallExpression(expression) ||
+        !ts.isPropertyAccessExpression(unwrap(expression.expression)) ||
+        unwrap(expression.expression).getText() !== 'Object.values' ||
+        expression.arguments.length !== 1) {
+        return { kind: 'not-object-values' };
+    }
+    const binding = unwrap(expression.arguments[0]);
+    if (!ts.isIdentifier(binding)) {
+        return {
+            kind: 'invalid',
+            message: 'Object.values Actions registry must use one imported Actions facade.',
+            ambiguous: false,
+        };
+    }
+    const symbol = importedSymbol(file, binding);
+    const namespaceModule = file.source.statements.find((statement) => ts.isImportDeclaration(statement) &&
+        statement.importClause?.namedBindings !== undefined &&
+        ts.isNamespaceImport(statement.importClause.namedBindings) &&
+        statement.importClause.namedBindings.name.text === binding.text)?.moduleSpecifier;
+    const module = symbol?.module ??
+        (namespaceModule && ts.isStringLiteral(namespaceModule) ? namespaceModule.text : undefined);
+    const sourceImport = module === undefined ? undefined : file.imports.find(({ specifier }) => specifier === module);
+    const target = sourceImport && resolveProjectImport(project, file, sourceImport.specifier);
+    if (target?.layer !== 'actions' || target.submodule) {
+        return {
+            kind: 'invalid',
+            message: 'Object.values Actions registry must resolve to the Actions layer facade.',
+            ambiguous: target === undefined,
+        };
+    }
+    let exported = 0;
+    for (const statement of target.source.statements) {
+        if (ts.isExportDeclaration(statement)) {
+            if (statement.moduleSpecifier === undefined ||
+                !ts.isStringLiteral(statement.moduleSpecifier) ||
+                statement.exportClause === undefined ||
+                !ts.isNamedExports(statement.exportClause)) {
+                return {
+                    kind: 'invalid',
+                    message: 'Actions facade must use explicit named re-exports from semantic submodules.',
+                    ambiguous: false,
+                };
+            }
+            const owner = resolveProjectImport(project, target, statement.moduleSpecifier.text);
+            if (owner === undefined) {
+                return {
+                    kind: 'invalid',
+                    message: 'Actions facade re-export owner cannot be resolved.',
+                    ambiguous: true,
+                };
+            }
+            if (owner.layer !== 'actions' || !owner.submodule) {
+                return {
+                    kind: 'invalid',
+                    message: 'Actions facade re-exports a value without one semantic Actions submodule owner.',
+                    ambiguous: false,
+                };
+            }
+            exported += statement.exportClause.elements.length;
+            continue;
+        }
+        const modifiers = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : undefined;
+        if (ts.isExportAssignment(statement) ||
+            modifiers?.some(({ kind }) => kind === ts.SyntaxKind.ExportKeyword)) {
+            return {
+                kind: 'invalid',
+                message: 'Actions facade exports a root-owned value without a semantic submodule owner.',
+                ambiguous: false,
+            };
+        }
+    }
+    return exported > 0
+        ? { kind: 'valid' }
+        : {
+            kind: 'invalid',
+            message: 'Actions facade exports no statically owned Action bindings.',
+            ambiguous: false,
+        };
+}
+function visitActionLeaves(array, callback) {
+    for (const element of array.elements) {
+        callback(ts.isSpreadElement(element) ? element.expression : element);
+    }
+}
+function resolveLocalInitializer(source, name) {
+    let result;
+    visit(source, (node) => {
+        if (!result &&
+            ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.name.text === name &&
+            node.initializer) {
+            result = unwrap(node.initializer);
+        }
+    });
+    return result;
+}

package/dist/tooling/linter/implementations/source/global.d.ts

@@ -0,0 +1,2 @@
+import type { SourceRuleVerifier } from './verifier.js';
+export declare const globalRules: readonly SourceRuleVerifier[];