@astrale-os/sdk 0.5.0-beta.99 → 0.6.0-beta.0

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

@@ -1,5 +1,6 @@
 import ts from 'typescript';
-import { objectProperty, propertyChain, resolveImportedSymbol, resolveProjectImport, unwrap, visit, } from '../../adapters/typescript/index.js';
+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',
@@ -24,7 +25,11 @@ export const providerRules = [
                         if (providerExecutionInvoke(file, node)) {
                             const reference = node.arguments[0];
                             const admitted = reference === undefined ? undefined : callableReference(unwrap(reference));
-                            const referenceExpression = admitted?.expression;
+                            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;
@@ -96,7 +101,7 @@ export const providerRules = [
                     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 receiver is opaque.`));
+                        evidence.push(ambiguity(file, node, `Provider call ${chain?.join('.')} resembles a local Domain operation but its instance is opaque.`));
                     }
                 });
             }
@@ -113,7 +118,9 @@ function remoteCallable(file, invoke) {
     if (!admitted.resolved) {
         return ambiguity(file, argument, 'Remote Domain Function requirement cannot be proven from an opaque reference.');
     }
-    const expression = admitted.expression;
+    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.');
     }
@@ -123,20 +130,20 @@ function remoteCallable(file, invoke) {
         constructor.module !== '@astrale-os/sdk/client/session') {
         return ambiguity(file, expression, 'Remote Domain Function requirement cannot be proven from a non-SDK reference.');
     }
-    const receiver = expression.arguments[0];
+    const domain = expression.arguments[0];
     const callable = expression.arguments[1];
-    const receiverChain = receiver && propertyChain(receiver);
+    const domainChain = domain && propertyChain(domain);
     const callableChain = callable && propertyChain(callable);
-    if (receiverChain?.length !== 1 ||
+    if (domainChain?.length !== 1 ||
         callableChain === undefined ||
-        callableChain[0] !== receiverChain[0] ||
+        callableChain[0] !== domainChain[0] ||
         !callableSelector(callableChain.slice(1))) {
-        return ambiguity(file, expression, 'Remote Domain Function requirement cannot be proven from an opaque receiver or selector.');
+        return ambiguity(file, expression, 'Remote Domain Function requirement cannot be proven from an opaque Domain or selector.');
     }
-    const receiverName = receiverChain[0];
-    const module = bindingTypeModule(file, receiverName, expression);
+    const domainName = domainChain[0];
+    const module = bindingTypeModule(file, domainName, expression);
     if (module === undefined || !externalFacade(module)) {
-        return ambiguity(file, receiver, 'Remote Domain receiver type cannot be mapped to one public package facade.');
+        return ambiguity(file, domain, 'Remote Domain type cannot be mapped to one public package facade.');
     }
     return {
         file,
@@ -160,116 +167,6 @@ function bindingTypeModule(file, name, node) {
     }
     return undefined;
 }
-function applicationFunctionRequirements(project) {
-    const applicationPath = project.policy.rootFiles.find(({ id }) => id === 'application')?.sourcePath;
-    const file = applicationPath && project.filesByPath.get(applicationPath);
-    if (!file)
-        return { keys: new Set(), indeterminate: true };
-    const applications = [];
-    visit(file.source, (node) => {
-        if (!ts.isCallExpression(node))
-            return;
-        const symbol = resolveImportedSymbol(file, node.expression);
-        if (symbol.kind === 'resolved' &&
-            symbol.name === 'defineApplication' &&
-            (symbol.module === '@astrale-os/sdk' || symbol.module === '@astrale-os/sdk/application')) {
-            applications.push(node);
-        }
-    });
-    if (applications.length !== 1)
-        return { keys: new Set(), indeterminate: true };
-    const input = applications[0].arguments[0];
-    if (!input || !ts.isObjectLiteralExpression(unwrap(input))) {
-        return { keys: new Set(), indeterminate: true };
-    }
-    const requirementsProperty = objectProperty(unwrap(input), 'requirements');
-    if (requirementsProperty === undefined)
-        return { keys: new Set(), indeterminate: false };
-    if (!ts.isPropertyAssignment(requirementsProperty)) {
-        return { keys: new Set(), indeterminate: true };
-    }
-    const requirementsCall = unwrap(requirementsProperty.initializer);
-    if (!ts.isCallExpression(requirementsCall))
-        return { keys: new Set(), indeterminate: true };
-    const requirementsSymbol = resolveImportedSymbol(file, requirementsCall.expression);
-    if (requirementsSymbol.kind !== 'resolved' ||
-        requirementsSymbol.name !== 'requirements' ||
-        (requirementsSymbol.module !== '@astrale-os/sdk' &&
-            requirementsSymbol.module !== '@astrale-os/sdk/application')) {
-        return { keys: new Set(), indeterminate: true };
-    }
-    const definition = requirementsCall.arguments[0];
-    if (definition === undefined)
-        return { keys: new Set(), indeterminate: false };
-    if (!ts.isObjectLiteralExpression(unwrap(definition))) {
-        return { keys: new Set(), indeterminate: true };
-    }
-    const functions = objectProperty(unwrap(definition), 'functions');
-    if (functions === undefined)
-        return { keys: new Set(), indeterminate: false };
-    if (!ts.isPropertyAssignment(functions))
-        return { keys: new Set(), indeterminate: true };
-    const values = unwrap(functions.initializer);
-    if (!ts.isArrayLiteralExpression(values))
-        return { keys: new Set(), indeterminate: true };
-    const keys = new Set();
-    let indeterminate = false;
-    for (const element of values.elements) {
-        if (ts.isSpreadElement(element)) {
-            indeterminate = true;
-            continue;
-        }
-        const target = requiredCallable(file, element);
-        if (target === undefined)
-            indeterminate = true;
-        else
-            keys.add(remoteCallableKey(target));
-    }
-    return { keys, indeterminate };
-}
-function requiredCallable(file, input) {
-    const admitted = callableReference(unwrap(input));
-    if (!admitted.resolved)
-        return undefined;
-    let current = admitted.expression;
-    const selector = [];
-    while (ts.isPropertyAccessExpression(unwrap(current))) {
-        const property = unwrap(current);
-        selector.unshift(property.name.text);
-        current = unwrap(property.expression);
-    }
-    if (!callableSelector(selector) || !ts.isCallExpression(current))
-        return undefined;
-    const resolve = unwrap(current.expression);
-    if (!ts.isPropertyAccessExpression(resolve) || resolve.name.text !== 'resolve')
-        return undefined;
-    const schemaSymbol = resolveImportedSymbol(file, resolve.expression);
-    if (schemaSymbol.kind !== 'resolved' ||
-        schemaSymbol.name !== 'schema' ||
-        schemaSymbol.module !== '@astrale-os/sdk/schema') {
-        return undefined;
-    }
-    const schemaValue = current.arguments[0];
-    if (!schemaValue)
-        return undefined;
-    const facade = resolveImportedSymbol(file, schemaValue);
-    if (facade.kind !== 'resolved' || !externalFacade(facade.module))
-        return undefined;
-    return { module: facade.module, selector: Object.freeze(selector) };
-}
-function callableSelector(selector) {
-    return ((selector.length === 2 && selector[0] === 'functions') ||
-        (selector.length === 4 && selector[0] === 'classes' && selector[2] === 'methods'));
-}
-function externalFacade(module) {
-    return (!module.startsWith('.') &&
-        !module.startsWith('#') &&
-        !module.startsWith('@astrale-os/sdk') &&
-        !module.startsWith('@astrale-os/kernel-'));
-}
-function remoteCallableKey(input) {
-    return `${input.module}\0${input.selector.join('\0')}`;
-}
 function providerExecutionInvoke(file, call) {
     const expression = unwrap(call.expression);
     const invoked = ts.isIdentifier(expression) && lexicalConstInitializer(expression) !== undefined
@@ -295,48 +192,6 @@ function providerExecutionInvoke(file, call) {
             (ts.isIdentifier(element.propertyName) && element.propertyName.text === 'invoke'));
     });
 }
-function callableReference(expression) {
-    if (!ts.isIdentifier(expression))
-        return { expression, resolved: true };
-    const initializer = lexicalConstInitializer(expression);
-    return initializer === undefined
-        ? { expression, resolved: false }
-        : { expression: unwrap(initializer), resolved: true };
-}
-/** Resolve only one immutable lexical alias; the linter does not emulate program execution. */
-function lexicalConstInitializer(identifier) {
-    let child = identifier;
-    let current = identifier.parent;
-    while (current) {
-        if (ts.isFunctionLike(current)) {
-            if (current.parameters.some(({ name }) => bindingContains(name, identifier.text))) {
-                return undefined;
-            }
-        }
-        if (ts.isBlock(current) || ts.isSourceFile(current) || ts.isModuleBlock(current)) {
-            const index = current.statements.findIndex((statement) => statement.pos <= child.pos && statement.end >= child.end);
-            const before = index < 0 ? current.statements : current.statements.slice(0, index);
-            for (const statement of [...before].reverse()) {
-                if (!ts.isVariableStatement(statement))
-                    continue;
-                const declaration = statement.declarationList.declarations.find(({ name }) => ts.isIdentifier(name) && name.text === identifier.text);
-                if (!declaration)
-                    continue;
-                return (statement.declarationList.flags & ts.NodeFlags.Const) !== 0
-                    ? declaration.initializer
-                    : undefined;
-            }
-        }
-        child = current;
-        current = current.parent;
-    }
-    return undefined;
-}
-function bindingContains(binding, name) {
-    if (ts.isIdentifier(binding))
-        return binding.text === name;
-    return binding.elements.some((element) => !ts.isOmittedExpression(element) && bindingContains(element.name, name));
-}
 function providerOperation(file, node) {
     let current = node.parent;
     while (current && !providerFunction(current))