@bleedingdev/modern-js-code-tools 3.9.0-ultramodern.16 → 3.9.0-ultramodern.18

package/dist/esm-node/module-graph.js

@@ -0,0 +1,261 @@
+import "node:module";
+import node_fs from "node:fs";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { exports as external_resolve_exports_exports } from "resolve.exports";
+import { SourceSyntaxError, parseSource, traverseSource } from "./source-analysis.js";
+import * as __rspack_external__babel_types_6e8337dd from "@babel/types";
+const MAX_MODULES = 256;
+const MAX_LOOKUPS = 512;
+function parseConsumer(filePath) {
+    if (node_fs.statSync(filePath).size > 1000000) throw new Error(`${filePath}: consumer source exceeds 1 MB analysis budget`);
+    const file = parseSource(node_fs.readFileSync(filePath, 'utf8'), filePath);
+    traverseSource(file, {
+        AssignmentExpression (p) {
+            throw new SourceSyntaxError(`contract bindings must be immutable at ${p.node.start}`);
+        },
+        UpdateExpression (p) {
+            throw new SourceSyntaxError(`contract bindings must be immutable at ${p.node.start}`);
+        },
+        TSModuleDeclaration () {
+            throw new SourceSyntaxError('contract bindings must not be merged with namespaces');
+        }
+    });
+    return file;
+}
+const propertyName = (node)=>{
+    if (void 0 !== node && (__rspack_external__babel_types_6e8337dd.isIdentifier(node) || __rspack_external__babel_types_6e8337dd.isStringLiteral(node) || __rspack_external__babel_types_6e8337dd.isNumericLiteral(node))) return __rspack_external__babel_types_6e8337dd.isIdentifier(node) ? node.name : String(node.value);
+};
+const localConst = (sourceFile, name)=>{
+    for (const item of sourceFile.program.body){
+        const statement = __rspack_external__babel_types_6e8337dd.isExportNamedDeclaration(item) ? item.declaration : item;
+        if (!__rspack_external__babel_types_6e8337dd.isVariableDeclaration(statement) || 'const' !== statement.kind) continue;
+        const matches = statement.declarations.filter((declaration)=>__rspack_external__babel_types_6e8337dd.isIdentifier(declaration.id, {
+                name
+            }));
+        if (1 === matches.length) return matches[0];
+    }
+};
+const exportedConst = (sourceFile, name)=>{
+    for (const statement of sourceFile.program.body)if (__rspack_external__babel_types_6e8337dd.isExportNamedDeclaration(statement) && 'type' !== statement.exportKind) {
+        if (__rspack_external__babel_types_6e8337dd.isVariableDeclaration(statement.declaration) && 'const' === statement.declaration.kind) {
+            const declaration = statement.declaration.declarations.find((value)=>__rspack_external__babel_types_6e8337dd.isIdentifier(value.id, {
+                    name
+                }));
+            if (declaration) return declaration;
+        }
+        if (!statement.source && statement.specifiers.some((value)=>__rspack_external__babel_types_6e8337dd.isExportSpecifier(value) && 'type' !== value.exportKind && __rspack_external__babel_types_6e8337dd.isIdentifier(value.local, {
+                name
+            }) && __rspack_external__babel_types_6e8337dd.isIdentifier(value.exported, {
+                name
+            }))) return localConst(sourceFile, name);
+    }
+};
+const inside = (file, boundary)=>file === boundary || file.startsWith(`${boundary}${node_path.sep}`);
+const containingWorkspace = (file)=>{
+    for(let directory = node_path.dirname(file);; directory = node_path.dirname(directory)){
+        if (node_fs.existsSync(node_path.join(directory, 'pnpm-workspace.yaml'))) return node_fs.realpathSync(directory);
+        if (directory === node_path.dirname(directory)) return;
+    }
+};
+const sourceBoundary = (file, workspace)=>{
+    for(let directory = node_path.dirname(file);; directory = node_path.dirname(directory)){
+        if (node_fs.existsSync(node_path.join(directory, 'package.json')) && directory !== workspace) return node_fs.realpathSync(directory);
+        if (directory === workspace || directory === node_path.dirname(directory)) return node_fs.realpathSync(node_path.dirname(file));
+    }
+};
+const sourceFileAt = (target, boundary)=>{
+    const stem = target.replace(/\.(?:[cm]?[jt]sx?)$/u, '');
+    for (const candidate of [
+        `${stem}.ts`,
+        `${stem}.tsx`,
+        `${stem}.mts`,
+        `${stem}.cts`,
+        target,
+        node_path.join(target, 'index.ts'),
+        node_path.join(target, 'index.tsx')
+    ])try {
+        const real = node_fs.realpathSync(candidate);
+        if (inside(real, boundary) && node_fs.statSync(real).isFile()) return real;
+    } catch  {}
+};
+const packageEntry = (specifier)=>{
+    if (specifier.startsWith('.') || specifier.startsWith('/') || specifier.startsWith('#')) return;
+    const parts = specifier.split('/');
+    const count = specifier.startsWith('@') ? 2 : 1;
+    if (parts.length < count || parts.slice(0, count).some((part)=>!part)) return;
+    return {
+        name: parts.slice(0, count).join('/'),
+        exportKey: parts.length === count ? '.' : `./${parts.slice(count).join('/')}`
+    };
+};
+const resolveModulePath = (module, specifier, workspace)=>{
+    if (/^\.\.?\//u.test(specifier)) {
+        const file = sourceFileAt(node_path.resolve(node_path.dirname(module.path), specifier), module.boundary);
+        return void 0 === file ? void 0 : {
+            kind: 'module',
+            path: file,
+            boundary: module.boundary
+        };
+    }
+    const entry = packageEntry(specifier);
+    if (!entry) return;
+    if (!workspace) return {
+        kind: 'external'
+    };
+    const paths = createRequire(module.path).resolve.paths(entry.name) ?? [];
+    for (const lookup of paths){
+        const directory = node_path.join(lookup, entry.name);
+        const manifest = node_path.join(directory, 'package.json');
+        if (!node_fs.existsSync(manifest)) continue;
+        const boundary = node_fs.realpathSync(directory);
+        if (!inside(boundary, workspace) || boundary.split(node_path.sep).includes('node_modules')) break;
+        const pkg = JSON.parse(node_fs.readFileSync(manifest, 'utf8'));
+        if (pkg.name !== entry.name || void 0 === pkg.exports) return;
+        let target;
+        try {
+            const targets = external_resolve_exports_exports(pkg, entry.exportKey, {
+                conditions: [
+                    'modern:source'
+                ]
+            });
+            target = Array.isArray(targets) ? targets[0] : void 0;
+        } catch  {
+            return;
+        }
+        if (!target || !target.startsWith('./')) return;
+        const file = sourceFileAt(node_path.resolve(boundary, target), boundary);
+        return void 0 === file ? void 0 : {
+            kind: 'module',
+            path: file,
+            boundary
+        };
+    }
+    return {
+        kind: 'external'
+    };
+};
+const importedBinding = (module, name)=>{
+    for (const statement of module.file.program.body)if (__rspack_external__babel_types_6e8337dd.isImportDeclaration(statement) && 'type' !== statement.importKind) {
+        for (const specifier of statement.specifiers)if (__rspack_external__babel_types_6e8337dd.isIdentifier(specifier.local, {
+            name
+        })) {
+            if (__rspack_external__babel_types_6e8337dd.isImportSpecifier(specifier) && 'type' !== specifier.importKind) return {
+                imported: propertyName(specifier.imported) ?? name,
+                specifier: statement.source.value
+            };
+            if (__rspack_external__babel_types_6e8337dd.isImportDefaultSpecifier(specifier)) return {
+                imported: 'default',
+                specifier: statement.source.value
+            };
+        }
+    }
+};
+const reexportedBinding = (module, name)=>{
+    for (const statement of module.file.program.body){
+        if (!__rspack_external__babel_types_6e8337dd.isExportNamedDeclaration(statement) || 'type' === statement.exportKind) continue;
+        const specifier = statement.specifiers.find((value)=>__rspack_external__babel_types_6e8337dd.isExportSpecifier(value) && 'type' !== value.exportKind && propertyName(value.exported) === name);
+        if (void 0 !== specifier && __rspack_external__babel_types_6e8337dd.isExportSpecifier(specifier)) return {
+            local: __rspack_external__babel_types_6e8337dd.isIdentifier(specifier.local) ? specifier.local.name : specifier.local.value,
+            ...statement.source ? {
+                specifier: statement.source.value
+            } : {}
+        };
+    }
+};
+const defaultExport = (module)=>{
+    for (const statement of module.file.program.body){
+        if (!__rspack_external__babel_types_6e8337dd.isExportDefaultDeclaration(statement)) continue;
+        const declaration = statement.declaration;
+        if (__rspack_external__babel_types_6e8337dd.isIdentifier(declaration)) return declaration.name;
+        return __rspack_external__babel_types_6e8337dd.isExpression(declaration) ? declaration : void 0;
+    }
+};
+function createModuleGraph(filePath) {
+    const realPath = node_fs.realpathSync(filePath);
+    const workspace = containingWorkspace(realPath);
+    const root = {
+        file: parseConsumer(realPath),
+        path: realPath,
+        boundary: sourceBoundary(realPath, workspace)
+    };
+    const modules = new Map([
+        [
+            root.path,
+            root
+        ]
+    ]);
+    const readModule = (modulePath, boundary)=>{
+        if (modules.has(modulePath)) return modules.get(modulePath);
+        if (modules.size >= MAX_MODULES) return;
+        let module;
+        try {
+            module = {
+                file: parseConsumer(modulePath),
+                path: modulePath,
+                boundary
+            };
+        } catch  {
+            module = void 0;
+        }
+        modules.set(modulePath, module);
+        return module;
+    };
+    const resolveBinding = (module, name, scope, chain, seen)=>{
+        const key = `${scope}:${module.path}#${name}`;
+        if (seen.has(key) || seen.size >= MAX_LOOKUPS) return;
+        seen.add(key);
+        const last = chain.at(-1);
+        const hops = last?.path === module.path && last.name === name ? chain : [
+            ...chain,
+            {
+                path: module.path,
+                name
+            }
+        ];
+        const declaration = 'export' === scope ? exportedConst(module.file, name) : localConst(module.file, name);
+        if (declaration?.init) return {
+            kind: 'declaration',
+            expression: declaration.init,
+            module,
+            chain: hops
+        };
+        const throughModule = (specifier, imported, allowExternal)=>{
+            const target = resolveModulePath(module, specifier, workspace);
+            if (target?.kind === 'external') return allowExternal ? {
+                kind: 'external',
+                specifier,
+                name: imported,
+                chain: hops
+            } : void 0;
+            const next = target && readModule(target.path, target.boundary);
+            return void 0 === next ? void 0 : resolveBinding(next, imported, 'export', hops, seen);
+        };
+        if ('local' === scope) {
+            const imported = importedBinding(module, name);
+            return void 0 === imported ? void 0 : throughModule(imported.specifier, imported.imported, true);
+        }
+        if ('default' === name) {
+            const exported = defaultExport(module);
+            if ('string' == typeof exported) return resolveBinding(module, exported, 'local', hops, seen);
+            return void 0 === exported ? void 0 : {
+                kind: 'declaration',
+                expression: exported,
+                module,
+                chain: hops
+            };
+        }
+        const reexported = reexportedBinding(module, name);
+        if (void 0 !== reexported) return void 0 === reexported.specifier ? resolveBinding(module, reexported.local, 'local', hops, seen) : throughModule(reexported.specifier, reexported.local, true);
+        for (const statement of module.file.program.body){
+            if (!__rspack_external__babel_types_6e8337dd.isExportAllDeclaration(statement) || 'type' === statement.exportKind) continue;
+            const resolved = throughModule(statement.source.value, name, false);
+            if (void 0 !== resolved) return resolved;
+        }
+    };
+    return {
+        root,
+        resolve: (module, name, scope)=>resolveBinding(module, name, scope, [], new Set())
+    };
+}
+export { createModuleGraph, exportedConst, localConst, parseConsumer, propertyName };

package/dist/types/cli/microvertical-api-check.d.ts

@@ -1 +1 @@
-export declare function runMicroVerticalApiCheckCli(args?: string[], filesOnly?: boolean): number;
+export declare function runMicroVerticalApiCheckCli(args?: string[], filesOnly?: boolean): Promise<number>;

package/dist/types/cli/workspace-source-check.d.ts

@@ -17,4 +17,4 @@ export type WorkspaceSourceCheckOptions = {
     readonly pluralCategories?: Readonly<Record<string, readonly string[]>>;
 };
 export declare const runWorkspaceSourceCheck: ({ cwd, sourceRoots, locales, pluralCategories, }?: WorkspaceSourceCheckOptions) => number;
-export declare const main: () => void;
+export declare const runWorkspaceSourceCheckCli: (args?: readonly string[]) => number;

package/dist/types/microvertical-api-boundary.d.ts

@@ -1,5 +1,8 @@
+import { type ModuleGraph } from './module-graph.js';
 export type { MicroVerticalApiBaselineExpectation, MicroVerticalTopologyEntry, } from './microvertical-api-baseline.js';
 export { configuredMicroVerticalApiStem, microVerticalApiBaselineViolation, } from './microvertical-api-baseline.js';
+export type { ModuleGraph, ModuleGraphHop, ResolvedBinding, SourceModule, } from './module-graph.js';
+export { createModuleGraph } from './module-graph.js';
 export interface MicroVerticalConfiguredApp {
     readonly path: string;
     readonly id?: string;
@@ -15,11 +18,22 @@ export interface MicroVerticalConfiguredApp {
         readonly additionalPaths?: Readonly<Record<string, string>>;
     };
 }
+export interface MicroVerticalApiContractRuleContext {
+    /** Workspace-relative app directory. */
+    readonly appPath: string;
+    readonly protocol: 'rest' | 'rpc';
+    /** Graph rooted at the app's shared contract (`graph.root`). */
+    readonly graph: ModuleGraph;
+}
+/** A consumer-owned contract rule; each returned message is a violation. */
+export type MicroVerticalApiContractRule = (context: MicroVerticalApiContractRuleContext) => readonly string[];
 export interface MicroVerticalApiCheckOptions {
     readonly workspaceRoot: string;
     readonly configuredApps?: readonly MicroVerticalConfiguredApp[];
     /** Explicit expected installed owner, useful for isolated/non-hoisted installations. */
     readonly baselinePackageDirectory?: string;
+    /** Rules run once per API app against its shared contract's module graph. */
+    readonly contractRules?: readonly MicroVerticalApiContractRule[];
 }
 export interface MicroVerticalApiCheckResult {
     readonly diagnostics: readonly string[];

package/dist/types/module-graph.d.ts

@@ -0,0 +1,52 @@
+import * as t from '@babel/types';
+/** A parsed consumer module and the package directory it may traverse privately. */
+export interface SourceModule {
+    readonly file: t.File;
+    /** Real absolute path. */
+    readonly path: string;
+    /** Real package directory; relative imports may not leave it. */
+    readonly boundary: string;
+}
+/** One `name` looked up in the module at `path`, in traversal order. */
+export interface ModuleGraphHop {
+    readonly path: string;
+    readonly name: string;
+}
+/**
+ * Where a binding ends up. `declaration` is a workspace `const` initializer;
+ * `external` is a named import or re-export from a package outside the
+ * workspace source graph. `chain` starts at the requesting module and ends at
+ * the declaring module (or the last workspace module before the package).
+ */
+export type ResolvedBinding = {
+    readonly kind: 'declaration';
+    readonly expression: t.Expression;
+    readonly module: SourceModule;
+    readonly chain: readonly ModuleGraphHop[];
+} | {
+    readonly kind: 'external';
+    readonly specifier: string;
+    readonly name: string;
+    readonly chain: readonly ModuleGraphHop[];
+};
+export interface ModuleGraph {
+    readonly root: SourceModule;
+    /**
+     * Follow a local binding (`scope: 'local'`) or an export (`'export'`) of
+     * `module` through relative imports, re-exports and public workspace
+     * package exports. Unresolvable, cyclic or over-budget bindings return
+     * undefined so callers fail closed.
+     */
+    resolve(module: SourceModule, name: string, scope: 'export' | 'local'): ResolvedBinding | undefined;
+}
+/** Resolution follows `const` bindings, so a module that mutates them is unreadable. */
+export declare function parseConsumer(filePath: string): t.File;
+export declare const propertyName: (node: t.Node | undefined) => string | undefined;
+export declare const localConst: (sourceFile: t.File, name: string) => t.VariableDeclarator | undefined;
+export declare const exportedConst: (sourceFile: t.File, name: string) => t.VariableDeclarator | undefined;
+/**
+ * The module graph rooted at `filePath`. Each module is parsed once per graph;
+ * an unreadable module stays unresolved instead of assumed valid. Throws
+ * `SourceSyntaxError` when the root itself is not a readable consumer module.
+ */
+export declare function createModuleGraph(filePath: string): ModuleGraph;

package/package.json

@@ -23,7 +23,7 @@
   "engines": {
     "node": ">=20"
   },
-  "version": "3.9.0-ultramodern.16",
+  "version": "3.9.0-ultramodern.18",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/esm-node/index.js",
   "typesVersions": {
@@ -91,11 +91,12 @@
   "modern:source": "./src/index.ts",
   "bin": {
     "modern-api-check": "bin/modern-api-check.mjs",
-    "modern-api-check-files": "bin/modern-api-check-files.mjs"
+    "modern-api-check-files": "bin/modern-api-check-files.mjs",
+    "modern-i18n-check": "bin/modern-i18n-check.mjs"
   },
   "scripts": {
     "build": "rm -rf dist && rslib build -c rslib.config.mts",
     "dev": "rslib build -c rslib.config.mts -w",
-    "test": "rstest --passWithNoTests"
+    "test": "rstest"
   }
 }