@loutrejs/loutre 0.5.0 → 0.7.0

package/dist/graph/compiler.js

@@ -1,228 +0,0 @@
-import { asModuleInstance, normalizeProvider, tokenName, } from '../core/index.js';
-import { compileApplication as compileBaseApplication, } from './graph.js';
-export function compileApplication(input) {
-    const base = compileBaseApplication(input);
-    const modules = collectModules(input.modules);
-    const moduleIds = new Map(modules.map((module, index) => [module, `module:${index + 1}`]));
-    const implementationModules = collectImplementationModules(modules, moduleIds);
-    const implementationNames = new Map(base.graph.implementations.map((implementation) => [
-        implementation.id,
-        implementation.name,
-    ]));
-    const graphModules = new Map(base.graph.modules.map((module) => [module.id, module]));
-    const executionModules = new Map();
-    for (const execution of base.graph.executions) {
-        if (execution.kind !== 'protocol')
-            continue;
-        const implementationName = implementationNames.get(execution.implementation);
-        const module = implementationName
-            ? implementationModules.get(implementationName)
-            : undefined;
-        if (!module)
-            continue;
-        executionModules.set(`${execution.contract}:${execution.procedure}:${execution.protocol}`, module);
-    }
-    const providerModules = collectProviderModules(modules, moduleIds);
-    const nodes = base.graph.nodes.map((node) => {
-        const module = node.module ??
-            providerModules.get(node.label) ??
-            moduleForImplementation(node, implementationModules) ??
-            moduleForLifecycle(node) ??
-            moduleForLayer(node, executionModules);
-        if (!module)
-            return node;
-        const owner = graphModules.get(module);
-        if (!owner)
-            return node;
-        return {
-            ...node,
-            module,
-            visibility: owner.exports.includes(node.label) ? 'exported' : 'private',
-        };
-    });
-    const diagnostics = [
-        ...base.diagnostics,
-        ...validateModuleExports(base.graph.modules),
-        ...validateModuleVisibility(base.graph, nodes),
-    ];
-    const graph = {
-        ...base.graph,
-        nodes,
-        diagnostics,
-    };
-    return { graph, diagnostics };
-}
-export const buildApplicationGraph = compileApplication;
-function collectModules(roots) {
-    const modules = [];
-    const seen = new Set();
-    const visit = (candidate) => {
-        const module = asModuleInstance(candidate);
-        if (seen.has(module))
-            return;
-        seen.add(module);
-        for (const imported of module.definition.imports ?? [])
-            visit(imported);
-        modules.push(module);
-    };
-    for (const root of roots)
-        visit(root);
-    return modules;
-}
-function collectProviderModules(modules, moduleIds) {
-    const result = new Map();
-    const ambiguous = new Set();
-    for (const module of modules) {
-        const moduleId = moduleIds.get(module);
-        if (!moduleId)
-            continue;
-        for (const declaration of module.definition.providers ?? []) {
-            const provider = normalizeProvider(declaration);
-            const labels = [
-                tokenName(provider.provide),
-                ...(provider.kind === 'class' ? [provider.useClass.name] : []),
-                ...(provider.kind === 'conditional'
-                    ? Reflect.ownKeys(provider.mapping).flatMap((key) => {
-                        const candidate = provider.mapping[key];
-                        return candidate ? [candidate.name] : [];
-                    })
-                    : []),
-            ];
-            for (const label of labels) {
-                const current = result.get(label);
-                if (current && current !== moduleId)
-                    ambiguous.add(label);
-                else
-                    result.set(label, moduleId);
-            }
-        }
-    }
-    for (const label of ambiguous)
-        result.delete(label);
-    return result;
-}
-function collectImplementationModules(modules, moduleIds) {
-    const result = new Map();
-    const ambiguous = new Set();
-    for (const module of modules) {
-        const moduleId = moduleIds.get(module);
-        if (!moduleId)
-            continue;
-        for (const implementation of module.definition.implementations ?? []) {
-            const current = result.get(implementation.name);
-            if (current && current !== moduleId)
-                ambiguous.add(implementation.name);
-            else
-                result.set(implementation.name, moduleId);
-        }
-    }
-    for (const name of ambiguous)
-        result.delete(name);
-    return result;
-}
-function moduleForImplementation(node, modules) {
-    return node.kind === 'implementation' ? modules.get(node.label) : undefined;
-}
-function moduleForLifecycle(node) {
-    if (node.kind !== 'framework' || !node.id.startsWith('lifecycle:module:')) {
-        return undefined;
-    }
-    const match = /^lifecycle:(module:\d+):/.exec(node.id);
-    return match?.[1];
-}
-function moduleForLayer(node, executionModules) {
-    if (node.kind !== 'layer')
-        return undefined;
-    const match = /^layer:(contract:\d+)\/([^/]+)\/([^/]+)\//.exec(node.id);
-    if (!match)
-        return undefined;
-    const [, contract, procedure, protocol] = match;
-    return executionModules.get(`${contract}:${procedure}:${protocol}`);
-}
-function validateModuleExports(modules) {
-    const byId = new Map(modules.map((module) => [module.id, module]));
-    return modules.flatMap((module) => module.exports.flatMap((token) => declaresToken(module, token) ||
-        canResolveExport(module, token, byId, new Set())
-        ? []
-        : [
-            {
-                code: 'LUTRE_MODULE_EXPORT_UNRESOLVED',
-                message: `${describeModule(module)} exports ${token}, but the token is neither declared nor re-exported from an imported Module.`,
-                path: `${module.id}.exports.${token}`,
-            },
-        ]));
-}
-function declaresToken(module, token) {
-    return module.providers.includes(token) || module.environment.includes(token);
-}
-function canResolveExport(source, token, modules, visited) {
-    if (visited.has(source.id))
-        return false;
-    visited.add(source.id);
-    for (const importedId of source.imports) {
-        const imported = modules.get(importedId);
-        if (!imported || !imported.exports.includes(token))
-            continue;
-        if (declaresToken(imported, token))
-            return true;
-        if (canResolveExport(imported, token, modules, new Set(visited)))
-            return true;
-    }
-    return false;
-}
-function validateModuleVisibility(graph, nodes) {
-    const modules = new Map(graph.modules.map((module) => [module.id, module]));
-    const nodesById = new Map(nodes.map((node) => [node.id, node]));
-    const seen = new Set();
-    const diagnostics = [];
-    for (const edge of graph.edges) {
-        const consumer = nodesById.get(edge.from);
-        const dependency = nodesById.get(edge.to);
-        if (!consumer?.module ||
-            !dependency?.module ||
-            consumer.module === dependency.module ||
-            !modules.has(consumer.module) ||
-            !modules.has(dependency.module)) {
-            continue;
-        }
-        const key = `${consumer.id}->${dependency.id}`;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        if (isTokenVisibleFrom(consumer.module, dependency.module, dependency.label, modules)) {
-            continue;
-        }
-        diagnostics.push({
-            code: 'LUTRE_MODULE_VISIBILITY',
-            message: `${consumer.label} in ${describeModuleId(consumer.module, modules)} depends on private ${dependency.label} from ${describeModuleId(dependency.module, modules)}. Export the dependency and import its Module explicitly.`,
-            path: consumer.id,
-        });
-    }
-    return diagnostics;
-}
-function isTokenVisibleFrom(sourceId, targetId, token, modules, visited = new Set()) {
-    if (visited.has(sourceId))
-        return false;
-    visited.add(sourceId);
-    const source = modules.get(sourceId);
-    if (!source)
-        return false;
-    for (const importedId of source.imports) {
-        const imported = modules.get(importedId);
-        if (!imported || !imported.exports.includes(token))
-            continue;
-        if (importedId === targetId)
-            return true;
-        if (isTokenVisibleFrom(importedId, targetId, token, modules, new Set(visited))) {
-            return true;
-        }
-    }
-    return false;
-}
-function describeModule(module) {
-    return module.name ?? module.description ?? module.id;
-}
-function describeModuleId(id, modules) {
-    const module = modules.get(id);
-    return module ? describeModule(module) : id;
-}

package/dist/graph/graph.d.ts

@@ -1,18 +0,0 @@
-import { type ArgsClass, type ContractBinding, type ModuleInstance, type ModuleTemplate, type TaskDescriptor, type TriggerDescriptor } from '../core/index.js';
-import type { ApplicationGraphIR, CompilationResult, Diagnostic } from './ir.js';
-export declare class StaticValidationError extends Error {
-    readonly diagnostics: readonly Diagnostic[];
-    readonly graph?: ApplicationGraphIR | undefined;
-    constructor(diagnostics: readonly Diagnostic[], graph?: ApplicationGraphIR | undefined);
-}
-export interface ApplicationCompilationInput {
-    readonly contract?: ContractBinding;
-    readonly modules: readonly (ModuleInstance | ModuleTemplate<void>)[];
-    readonly arguments?: ArgsClass | undefined;
-    readonly tasks?: readonly TaskDescriptor<any, any>[];
-    readonly triggers?: readonly TriggerDescriptor[];
-}
-export declare function compileApplication(input: ApplicationCompilationInput): CompilationResult;
-export declare const buildApplicationGraph: typeof compileApplication;
-export declare function validateGraph(graph: ApplicationGraphIR): readonly Diagnostic[];
-export declare function assertValidCompilation(result: CompilationResult): ApplicationGraphIR;