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

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

@@ -0,0 +1,3 @@
+import type { SourceProject } from '../../adapters/typescript/index.js';
+import type { RuleImplementation } from '../../evaluation/index.js';
+export declare const sourceRuleImplementations: readonly RuleImplementation<SourceProject>[];

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

@@ -0,0 +1,3 @@
+import { sourceImplementation } from './verifier.js';
+import { sourceRuleVerifiers } from './verifiers.js';
+export const sourceRuleImplementations = Object.freeze(sourceRuleVerifiers.map(sourceImplementation));

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

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

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

@@ -0,0 +1,40 @@
+import { resolveProjectImport } from '../../adapters/typescript/index.js';
+import { isForeignDomain, production, violation } from './shared.js';
+export const integrationRules = [
+    {
+        id: 'INT-PURE',
+        ruleRevision: '6eddaa070e097a15d194b09ebfeb8d21251c6682879e54a200efb91007742555',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'integrations')) {
+                for (const sourceImport of file.imports) {
+                    const target = resolveProjectImport(project, file, sourceImport.specifier);
+                    const allowedSchemaType = target?.layer === 'schema' && sourceImport.typeOnly;
+                    const allowedSibling = target?.layer === 'integrations';
+                    const allowedKernelType = sourceImport.typeOnly && sourceImport.specifier.startsWith('@astrale-os/kernel-');
+                    const forbiddenBoundary = executionBoundaryImport(sourceImport.specifier) ||
+                        isForeignDomain(sourceImport.specifier) ||
+                        concreteProviderImport(sourceImport.specifier) ||
+                        sourceImport.specifier.startsWith('@astrale-os/adapter-') ||
+                        (sourceImport.specifier.startsWith('@astrale-os/sdk') &&
+                            sourceImport.specifier !== '@astrale-os/sdk/integration') ||
+                        sourceImport.specifier.startsWith('@astrale-os/kernel-client');
+                    const allowedPortableType = sourceImport.typeOnly && !forbiddenBoundary;
+                    if (allowedSchemaType || allowedSibling || allowedKernelType || allowedPortableType) {
+                        continue;
+                    }
+                    if (target || forbiddenBoundary) {
+                        evidence.push(violation(file, sourceImport.node, `Integration imports boundary or concrete dependency ${sourceImport.specifier}.`));
+                    }
+                }
+            }
+            return evidence;
+        },
+    },
+];
+function concreteProviderImport(specifier) {
+    return /^(?:(?:stripe|twilio|openai)(?:$|\/)|@aws-sdk\/|@azure\/|@google-cloud\/)/.test(specifier);
+}
+function executionBoundaryImport(specifier) {
+    return /^(?:node:)?(?:child_process|cluster|dgram|dns(?:\/promises)?|fs(?:\/promises)?|http2?|https|net|process|readline(?:\/promises)?|repl|sqlite|timers(?:\/promises)?|tls|worker_threads)$/.test(specifier);
+}

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

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

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

@@ -0,0 +1,113 @@
+import ts from 'typescript';
+import { importedSymbol, propertyChain, resolveProjectImport, unwrap, visit, } from '../../adapters/typescript/index.js';
+import { ambiguity, definitionOriginAmbiguity, definitionObjects, forbiddenIoImport, production, propertyExpression, violation, } from './shared.js';
+const FORBIDDEN_LAYERS = new Set([
+    'integrations',
+    'functions',
+    'providers',
+    'mutations',
+    'queries',
+    'scripts',
+    'ui',
+    'views',
+]);
+export const migrationRules = [
+    {
+        id: 'MIG-EXACT-REVS',
+        ruleRevision: '2353d23e19e0afa948b8c8c15b906a2e1427622cea441001d7e28c6fea81c860',
+        evaluate(project) {
+            const evidence = [];
+            const origins = schemaOrigins(project);
+            for (const file of production(project, 'migrations')) {
+                for (const definition of definitionObjects(file, 'defineMigration')) {
+                    const uncertain = definitionOriginAmbiguity(file, definition, 'Migration definition');
+                    if (uncertain) {
+                        evidence.push(uncertain);
+                        continue;
+                    }
+                    const { call, object } = definition;
+                    if (!object) {
+                        evidence.push(ambiguity(file, call, 'Migration descriptor is not a static object literal.'));
+                        continue;
+                    }
+                    const from = propertyExpression(object, 'from');
+                    const to = propertyExpression(object, 'to');
+                    if (!from || !to) {
+                        evidence.push(violation(file, object, 'Migration must declare exactly one from and one to revision.'));
+                        continue;
+                    }
+                    const fromSchema = revisionSchema(file, from);
+                    const toSchema = revisionSchema(file, to);
+                    if (!fromSchema || !toSchema) {
+                        evidence.push(ambiguity(file, !fromSchema ? from : to, 'Migration revision is not one static schema.revision binding.'));
+                        continue;
+                    }
+                    if (fromSchema === toSchema) {
+                        evidence.push(violation(file, to, `Migration source and target are both ${toSchema}.`));
+                        continue;
+                    }
+                    const fromOrigin = origins.get(fromSchema);
+                    const toOrigin = origins.get(toSchema);
+                    if (!fromOrigin || !toOrigin) {
+                        evidence.push(ambiguity(file, object, `Cannot establish origins for ${fromSchema} and ${toSchema}.`));
+                    }
+                    else if (fromOrigin !== toOrigin) {
+                        evidence.push(violation(file, object, `Migration crosses Domain origins ${fromOrigin} and ${toOrigin}.`));
+                    }
+                }
+            }
+            return evidence;
+        },
+    },
+    {
+        id: 'MIG-DEDICATED-CTX',
+        ruleRevision: 'be6389211e5ac1c0a2805a45dbc394aace48167f462947edc1db47cb4d34bf1e',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'migrations')) {
+                for (const sourceImport of file.imports) {
+                    const target = resolveProjectImport(project, file, sourceImport.specifier);
+                    const layer = target?.layer ?? sourceImport.specifier.match(/^#([^/]+)\//)?.[1];
+                    if ((layer && FORBIDDEN_LAYERS.has(layer)) ||
+                        forbiddenIoImport(sourceImport.specifier) ||
+                        sourceImport.specifier.startsWith('@astrale-os/adapter-')) {
+                        evidence.push(violation(file, sourceImport.node, `Migration imports forbidden boundary ${sourceImport.specifier}.`));
+                    }
+                }
+            }
+            return evidence;
+        },
+    },
+];
+function revisionSchema(file, expression) {
+    const target = unwrap(expression);
+    if (!ts.isCallExpression(target) || target.arguments.length !== 1)
+        return undefined;
+    const chain = propertyChain(target.expression);
+    if (chain?.at(-1) !== 'revision')
+        return undefined;
+    const schema = unwrap(target.arguments[0]);
+    if (!ts.isIdentifier(schema))
+        return undefined;
+    const symbol = importedSymbol(file, schema);
+    return symbol?.name ?? schema.text;
+}
+function schemaOrigins(project) {
+    const result = new Map();
+    for (const file of production(project, 'schema')) {
+        visit(file.source, (node) => {
+            if (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name) || !node.initializer)
+                return;
+            const value = unwrap(node.initializer);
+            if (!ts.isCallExpression(value))
+                return;
+            const symbol = importedSymbol(file, value.expression);
+            if (symbol?.name !== 'defineSchema')
+                return;
+            const origin = value.arguments[0];
+            if (origin && ts.isStringLiteral(unwrap(origin)))
+                result.set(node.name.text, unwrap(origin).text);
+        });
+    }
+    return result;
+}

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

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