@astrale-os/sdk 0.5.0-beta.13 → 0.5.0-beta.130

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

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

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

@@ -0,0 +1,230 @@
+import ts from 'typescript';
+import { propertyChain, resolveImportedSymbol, resolveProjectImport, unwrap, visit, } from '../../adapters/typescript/index.js';
+import { applicationFunctionRequirements, callableReference, callableSelector, externalFacade, lexicalConstInitializer, remoteCallableKey, } from './callable-requirements.js';
+import { ambiguity, production, violation } from './shared.js';
+const LOCAL_DOMAIN_LAYERS = new Set([
+    'functions',
+    'mutations',
+    'queries',
+    'rules',
+    'schema',
+    'states',
+    'ui',
+    'views',
+]);
+const GRAPH_OPERATIONS = new Set(['mutate', 'query', 'invoke', 'defineAction', 'defineWorkflow']);
+export const providerRules = [
+    {
+        id: 'PRV-XDOM-TYPED',
+        ruleRevision: 'a520d2276cd10135dc189bb248875406c8286c1a74d4cc39f8ec4d5a96510a49',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'providers')) {
+                visit(file.source, (node) => {
+                    if (ts.isCallExpression(node)) {
+                        if (providerExecutionInvoke(file, node)) {
+                            const reference = node.arguments[0];
+                            const admitted = reference === undefined ? undefined : callableReference(unwrap(reference));
+                            const referenceExpression = admitted &&
+                                ts.isCallExpression(admitted.expression) &&
+                                ts.isCallExpression(admitted.expression.expression)
+                                ? admitted.expression.expression
+                                : admitted?.expression;
+                            const symbol = referenceExpression && ts.isCallExpression(referenceExpression)
+                                ? resolveImportedSymbol(file, referenceExpression.expression)
+                                : undefined;
+                            if (symbol?.kind !== 'resolved' ||
+                                symbol.name !== 'reference' ||
+                                symbol.module !== '@astrale-os/sdk/client/session') {
+                                evidence.push(admitted?.resolved === false
+                                    ? ambiguity(file, reference ?? node, 'Remote Domain callable reference cannot be proven from an opaque local value.')
+                                    : violation(file, node, 'Remote Domain invocation does not construct one typed public callable reference.'));
+                            }
+                        }
+                    }
+                    if (ts.isAsExpression(node) &&
+                        node.type.kind === ts.SyntaxKind.NeverKeyword &&
+                        enclosingInvoke(file, node)) {
+                        evidence.push(violation(file, node, 'Remote Domain invocation fabricates a never cast instead of using the typed public facade.'));
+                    }
+                });
+            }
+            return evidence;
+        },
+    },
+    {
+        id: 'PRV-XDOM-REQ',
+        ruleRevision: '065816fda57910e917670ed657cf45b1ad3bfdc8fba6362f48123221725e20a0',
+        evaluate(project) {
+            const targets = [];
+            const evidence = [];
+            for (const file of production(project, 'providers')) {
+                visit(file.source, (node) => {
+                    if (!ts.isCallExpression(node) || !providerExecutionInvoke(file, node))
+                        return;
+                    const target = remoteCallable(file, node);
+                    if ('kind' in target)
+                        evidence.push(target);
+                    else
+                        targets.push(target);
+                });
+            }
+            if (targets.length === 0)
+                return evidence;
+            const declared = applicationFunctionRequirements(project);
+            for (const target of targets) {
+                if (declared.keys.has(remoteCallableKey(target)))
+                    continue;
+                const selector = target.selector.join('.');
+                evidence.push(declared.indeterminate
+                    ? ambiguity(target.file, target.node, `Application Function requirements are opaque for ${target.module} ${selector}.`)
+                    : violation(target.file, target.node, `Remote Domain callable ${target.module} ${selector} lacks one exact Application Function requirement.`));
+            }
+            return evidence;
+        },
+    },
+    {
+        id: 'PRV-NO-DOMAIN',
+        ruleRevision: '5905f9e8fdd2130de52b41e2bbd920ada1ad9c04a71a04e79c98b1333c318e1b',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'providers')) {
+                for (const sourceImport of file.imports) {
+                    const target = resolveProjectImport(project, file, sourceImport.specifier);
+                    if (target?.layer && LOCAL_DOMAIN_LAYERS.has(target.layer)) {
+                        evidence.push(violation(file, sourceImport.node, `Provider imports local Domain layer ${target.layer}.`));
+                    }
+                }
+                visit(file.source, (node) => {
+                    if (!ts.isCallExpression(node))
+                        return;
+                    const chain = propertyChain(node.expression);
+                    const name = chain?.at(-1);
+                    if (name && GRAPH_OPERATIONS.has(name) && !providerExecutionInvoke(file, node)) {
+                        evidence.push(ambiguity(file, node, `Provider call ${chain?.join('.')} resembles a local Domain operation but its instance is opaque.`));
+                    }
+                });
+            }
+            return evidence;
+        },
+    },
+];
+function remoteCallable(file, invoke) {
+    const argument = invoke.arguments[0];
+    if (argument === undefined) {
+        return ambiguity(file, invoke, 'Remote Domain invocation has no statically visible reference.');
+    }
+    const admitted = callableReference(unwrap(argument));
+    if (!admitted.resolved) {
+        return ambiguity(file, argument, 'Remote Domain Function requirement cannot be proven from an opaque reference.');
+    }
+    const expression = ts.isCallExpression(admitted.expression) && ts.isCallExpression(admitted.expression.expression)
+        ? admitted.expression.expression
+        : admitted.expression;
+    if (!ts.isCallExpression(expression)) {
+        return ambiguity(file, expression, 'Remote Domain Function requirement cannot be proven from a computed reference.');
+    }
+    const constructor = resolveImportedSymbol(file, expression.expression);
+    if (constructor.kind !== 'resolved' ||
+        constructor.name !== 'reference' ||
+        constructor.module !== '@astrale-os/sdk/client/session') {
+        return ambiguity(file, expression, 'Remote Domain Function requirement cannot be proven from a non-SDK reference.');
+    }
+    const domain = expression.arguments[0];
+    const callable = expression.arguments[1];
+    const domainChain = domain && propertyChain(domain);
+    const callableChain = callable && propertyChain(callable);
+    if (domainChain?.length !== 1 ||
+        callableChain === undefined ||
+        callableChain[0] !== domainChain[0] ||
+        !callableSelector(callableChain.slice(1))) {
+        return ambiguity(file, expression, 'Remote Domain Function requirement cannot be proven from an opaque Domain or selector.');
+    }
+    const domainName = domainChain[0];
+    const module = bindingTypeModule(file, domainName, expression);
+    if (module === undefined || !externalFacade(module)) {
+        return ambiguity(file, domain, 'Remote Domain type cannot be mapped to one public package facade.');
+    }
+    return {
+        file,
+        node: invoke,
+        module,
+        selector: Object.freeze(callableChain.slice(1)),
+    };
+}
+function bindingTypeModule(file, name, node) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isFunctionLike(current)) {
+            const parameter = current.parameters.find((candidate) => ts.isIdentifier(candidate.name) && candidate.name.text === name);
+            const type = parameter?.type;
+            if (type && ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName)) {
+                const resolution = resolveImportedSymbol(file, type.typeName);
+                return resolution.kind === 'resolved' ? resolution.module : undefined;
+            }
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function providerExecutionInvoke(file, call) {
+    const expression = unwrap(call.expression);
+    const invoked = ts.isIdentifier(expression) && lexicalConstInitializer(expression) !== undefined
+        ? unwrap(lexicalConstInitializer(expression))
+        : expression;
+    const operation = providerOperation(file, call);
+    if (!operation)
+        return false;
+    const execution = operation.parameters[1]?.name;
+    if (!execution)
+        return false;
+    if (ts.isPropertyAccessExpression(invoked) && invoked.name.text === 'invoke') {
+        return (ts.isIdentifier(execution) &&
+            ts.isIdentifier(invoked.expression) &&
+            invoked.expression.text === execution.text);
+    }
+    if (!ts.isIdentifier(invoked) || !ts.isObjectBindingPattern(execution))
+        return false;
+    return execution.elements.some((element) => {
+        if (!ts.isIdentifier(element.name) || element.name.text !== invoked.text)
+            return false;
+        return (element.propertyName === undefined ||
+            (ts.isIdentifier(element.propertyName) && element.propertyName.text === 'invoke'));
+    });
+}
+function providerOperation(file, node) {
+    let current = node.parent;
+    while (current && !providerFunction(current))
+        current = current.parent;
+    if (!current || !providerFunction(current))
+        return undefined;
+    const property = ts.isMethodDeclaration(current) ? current : current.parent;
+    const object = ts.isMethodDeclaration(property)
+        ? property.parent
+        : ts.isPropertyAssignment(property)
+            ? property.parent
+            : undefined;
+    if (!object || !ts.isObjectLiteralExpression(object))
+        return undefined;
+    const call = object.parent;
+    if (!ts.isCallExpression(call) || call.arguments[1] !== object)
+        return undefined;
+    const symbol = resolveImportedSymbol(file, call.expression);
+    return symbol.kind === 'resolved' &&
+        symbol.name === 'defineProvider' &&
+        symbol.module === '@astrale-os/sdk/integration'
+        ? current
+        : undefined;
+}
+function providerFunction(node) {
+    return ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isMethodDeclaration(node);
+}
+function enclosingInvoke(file, node) {
+    let current = node.parent;
+    while (current && !ts.isStatement(current)) {
+        if (ts.isCallExpression(current) && providerExecutionInvoke(file, current))
+            return true;
+        current = current.parent;
+    }
+    return false;
+}

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

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