@bleedingdev/modern-js-code-tools 3.9.0-ultramodern.3 → 3.9.0-ultramodern.5

package/dist/cjs/microvertical-api-owner.cjs

@@ -0,0 +1,217 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    baselinePackage: ()=>baselinePackage,
+    baselinePublicIdentityIsExact: ()=>baselinePublicIdentityIsExact,
+    resolveBaselinePackageDirectory: ()=>resolveBaselinePackageDirectory
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const parser_namespaceObject = require("@babel/parser");
+const types_namespaceObject = require("@babel/types");
+const baselinePackage = '@modern-js/bff-effect/microvertical-api';
+const ownerName = '@modern-js/bff-effect';
+const within = (root, file)=>file.startsWith(`${root}${external_node_path_default().sep}`);
+function resolveBaselinePackageDirectory(fromFile) {
+    const lookup = (0, external_node_module_namespaceObject.createRequire)(fromFile).resolve.paths(baselinePackage);
+    for (const directory of lookup ?? []){
+        const candidate = external_node_path_default().join(directory, ownerName);
+        if (!external_node_fs_default().existsSync(candidate)) continue;
+        const root = external_node_fs_default().realpathSync(candidate);
+        const manifest = JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().join(root, 'package.json'), 'utf8'));
+        if (![
+            ownerName,
+            '@bleedingdev/modern-js-bff-effect'
+        ].includes(manifest.name)) throw new Error(`${fromFile}: ${baselinePackage} resolved to unrelated package ${String(manifest.name)}`);
+        const target = importTarget(manifest.exports?.['./microvertical-api']);
+        if (!target?.startsWith('./')) throw new Error(`${fromFile}: ${baselinePackage} has no public Node import export`);
+        external_node_fs_default().statSync(external_node_path_default().resolve(root, target));
+        return root;
+    }
+    throw new Error(`${fromFile}: cannot resolve installed ${baselinePackage}`);
+}
+function importTarget(value) {
+    if ('string' == typeof value) return value;
+    if (!value || 'object' != typeof value || Array.isArray(value)) return;
+    for (const [condition, target] of Object.entries(value))if ([
+        'node',
+        'import',
+        'default'
+    ].includes(condition)) {
+        const resolved = importTarget(target);
+        if (resolved) return resolved;
+    }
+}
+function baselinePublicIdentityIsExact(fromFile, expectation) {
+    const owner = external_node_fs_default().realpathSync(expectation.baselinePackageDirectory);
+    const manifest = JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().join(owner, 'package.json'), 'utf8'));
+    if (expectation.baselinePackage !== baselinePackage || ![
+        ownerName,
+        '@bleedingdev/modern-js-bff-effect'
+    ].includes(manifest.name)) return false;
+    let resolvedOwner;
+    try {
+        resolvedOwner = resolveBaselinePackageDirectory(fromFile);
+    } catch (error) {
+        if (error instanceof Error && error.message.includes('resolved to unrelated package')) return false;
+        throw error;
+    }
+    if (resolvedOwner !== owner) return false;
+    const target = importTarget(manifest.exports?.['./microvertical-api']);
+    if (!target?.startsWith('./')) return false;
+    const modules = new Map();
+    const load = (filename)=>{
+        const real = external_node_fs_default().realpathSync(filename);
+        if (!within(owner, real)) return;
+        let file = modules.get(real);
+        if (!file) {
+            if (modules.size >= 64 || external_node_fs_default().statSync(real).size > 1000000) throw new Error(`${real}: public export analysis budget exceeded`);
+            file = (0, parser_namespaceObject.parse)(external_node_fs_default().readFileSync(real, 'utf8'), {
+                sourceType: 'module',
+                sourceFilename: real,
+                plugins: [
+                    "typescript"
+                ]
+            });
+            modules.set(real, file);
+        }
+        return {
+            file,
+            real
+        };
+    };
+    const follow = (from, specifier)=>{
+        if (!specifier.startsWith('.')) return;
+        const candidate = external_node_path_default().resolve(external_node_path_default().dirname(from), specifier);
+        if (!within(owner, candidate)) return;
+        return [
+            candidate,
+            `${candidate}.ts`,
+            `${candidate}.js`,
+            external_node_path_default().join(candidate, 'index.ts'),
+            external_node_path_default().join(candidate, 'index.js')
+        ].find((file)=>external_node_fs_default().existsSync(file) && external_node_fs_default().statSync(file).isFile());
+    };
+    const exportedOwner = (filename, name, seen = new Set())=>{
+        const loaded = load(filename);
+        if (!loaded) return;
+        const { file, real } = loaded;
+        const key = `${real}:${name}`;
+        if (seen.has(key)) return;
+        seen = new Set([
+            ...seen,
+            key
+        ]);
+        const explicit = [];
+        const stars = [];
+        for (const statement of file.program.body){
+            if (types_namespaceObject.isExportAllDeclaration(statement) && 'type' !== statement.exportKind) {
+                const next = follow(real, statement.source.value);
+                if (!next) return;
+                stars.push(next);
+            }
+            if (!types_namespaceObject.isExportNamedDeclaration(statement) || 'type' === statement.exportKind) continue;
+            const declaration = statement.declaration;
+            if (types_namespaceObject.isVariableDeclaration(declaration) && declaration.declarations.some((value)=>types_namespaceObject.isIdentifier(value.id, {
+                    name
+                }))) explicit.push(real);
+            if ((types_namespaceObject.isFunctionDeclaration(declaration) || types_namespaceObject.isClassDeclaration(declaration)) && types_namespaceObject.isIdentifier(declaration.id, {
+                name
+            })) explicit.push(real);
+            for (const value of statement.specifiers)if (types_namespaceObject.isExportSpecifier(value) && 'type' !== value.exportKind && types_namespaceObject.isIdentifier(value.exported, {
+                name
+            })) {
+                if (!types_namespaceObject.isIdentifier(value.local, {
+                    name
+                })) {
+                    explicit.push(void 0);
+                    continue;
+                }
+                if (statement.source) {
+                    const next = follow(real, statement.source.value);
+                    explicit.push(next ? exportedOwner(next, name, seen) : void 0);
+                } else {
+                    const local = file.program.body.find((item)=>types_namespaceObject.isVariableDeclaration(item) && item.declarations.some((value)=>types_namespaceObject.isIdentifier(value.id, {
+                                name
+                            })) || (types_namespaceObject.isFunctionDeclaration(item) || types_namespaceObject.isClassDeclaration(item)) && types_namespaceObject.isIdentifier(item.id, {
+                            name
+                        }));
+                    if (local) {
+                        explicit.push(real);
+                        continue;
+                    }
+                    const imported = file.program.body.find((item)=>types_namespaceObject.isImportDeclaration(item) && 'type' !== item.importKind && item.specifiers.some((value)=>types_namespaceObject.isImportSpecifier(value) && 'type' !== value.importKind && types_namespaceObject.isIdentifier(value.local, {
+                                name
+                            }) && types_namespaceObject.isIdentifier(value.imported, {
+                                name
+                            })));
+                    const next = types_namespaceObject.isImportDeclaration(imported) ? follow(real, imported.source.value) : void 0;
+                    explicit.push(next ? exportedOwner(next, name, seen) : void 0);
+                }
+            }
+        }
+        if (explicit.length) return 1 === explicit.length ? explicit[0] : void 0;
+        const owners = stars.map((next)=>exportedOwner(next, name, seen));
+        const unique = new Set(owners.filter((value)=>void 0 !== value));
+        return 1 === unique.size ? [
+            ...unique
+        ][0] : void 0;
+    };
+    const entry = external_node_path_default().resolve(owner, target);
+    const owners = [
+        'MicroVerticalBuildMarkerSchema',
+        'MicroVerticalReadinessSchema',
+        'createMicroVerticalOperationContext'
+    ].map((name)=>exportedOwner(entry, name));
+    return void 0 !== owners[0] && owners.every((value)=>value === owners[0]);
+}
+exports.baselinePackage = __webpack_exports__.baselinePackage;
+exports.baselinePublicIdentityIsExact = __webpack_exports__.baselinePublicIdentityIsExact;
+exports.resolveBaselinePackageDirectory = __webpack_exports__.resolveBaselinePackageDirectory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "baselinePackage",
+    "baselinePublicIdentityIsExact",
+    "resolveBaselinePackageDirectory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/oxlint-plugin/rules/strict-effect-api-boundaries.cjs

@@ -50,7 +50,7 @@ const createStrictEffectApiBoundariesRule = ()=>({
                         node,
                         message: 'Generated UltraModern workspaces use direct api/index.ts, shared/api.ts and src/api/* paths; api/effect, api/lambda, shared/effect and src/effect are forbidden.'
                     });
-                    (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /@modern-js\/plugin-bff\/hono-server/u, 'UltraModern API workspaces must not import Hono server helpers; use @modern-js/plugin-bff/effect-edge and HttpApi.');
+                    (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /@modern-js\/plugin-bff\/(?:server|hono-server)(?![\w-])/u, 'UltraModern API workspaces must not import Hono server helpers; use @modern-js/bff-effect/effect-edge and HttpApi.');
                     (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /\bruntimeFramework\s*(?::|=)\s*['"]hono['"]/u, 'UltraModern API apps must use bff.runtimeFramework: "effect".');
                     (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /(?:from|import)\s*['"][^'"]*(?:api\/effect|shared\/effect)[^'"]*['"]|shared-effect-api/u, 'Import API code from direct api/index.ts, shared/api.ts or src/api/* paths, not api/effect, shared/effect or shared Effect API packages.');
                     (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /\bstrictEffectApproach\s*(?::|=)\s*false\b/u, 'UltraModern API apps must keep strictEffectApproach enabled.');

package/dist/cjs/strict-effect-runtime.cjs

@@ -48,7 +48,8 @@ const parser_namespaceObject = require("@babel/parser");
 const traverse_namespaceObject = require("@babel/traverse");
 var traverse_default = /*#__PURE__*/ __webpack_require__.n(traverse_namespaceObject);
 const types_namespaceObject = require("@babel/types");
-const edge = '@modern-js/plugin-bff/effect-edge';
+const edge = '@modern-js/bff-effect/effect-edge';
+const nodeRuntime = '@modern-js/bff-effect/effect';
 const sharedRuntime = /^@[^/]+\/shared-contracts\/server\/effect-bff-runtime$/u;
 const failure = 'Generated API entries must export defineEffectBff(...) or the server-only shared Effect BFF assembly helper with an explicitly composed handler Layer and an unshadowed executable root; entries must implement handlers through HttpApiBuilder.group.';
 const invalidSources = new WeakSet();
@@ -164,23 +165,38 @@ function strictEffectRuntimeTopologyViolation(source, resolveImport) {
         const imported = (node)=>{
             const value = binding(node);
             const decl = value?.path.node;
-            if (!decl || !types_namespaceObject.isImportSpecifier(decl) || 'type' === decl.importKind) return;
+            if (!decl || !types_namespaceObject.isImportSpecifier(decl) && !types_namespaceObject.isImportNamespaceSpecifier(decl) || types_namespaceObject.isImportSpecifier(decl) && 'type' === decl.importKind) return;
             const statement = value.path.parent;
             if (!types_namespaceObject.isImportDeclaration(statement) || 'type' === statement.importKind) return;
             return {
-                name: types_namespaceObject.isIdentifier(decl.imported) ? decl.imported.name : decl.imported.value,
+                namespace: types_namespaceObject.isImportNamespaceSpecifier(decl),
+                name: types_namespaceObject.isImportNamespaceSpecifier(decl) ? '*' : types_namespaceObject.isIdentifier(decl.imported) ? decl.imported.name : decl.imported.value,
                 specifier: statement.source.value
             };
         };
-        const native = (node, name, sources = [
-            edge
-        ])=>{
+        const namespaceSources = {
+            HttpApi: [
+                edge,
+                'effect/unstable/httpapi'
+            ],
+            HttpApiBuilder: [
+                edge,
+                'effect/unstable/httpapi'
+            ],
+            HttpRouter: [
+                edge,
+                'effect/unstable/http'
+            ]
+        };
+        const native = (node, name, sources)=>{
             const value = imported(node);
-            return value?.name === name && sources.includes(value.specifier);
+            if (!value) return false;
+            const importedNameMatches = value.namespace ? value.specifier === `effect/${name}` : value.name === name && value.specifier !== `effect/${name}`;
+            return importedNameMatches && (sources ?? namespaceSources[name] ?? [
+                edge
+            ]).includes(value.specifier);
         };
-        const method = (node, namespace, member, sources = [
-            edge
-        ])=>{
+        const method = (node, namespace, member, sources)=>{
             node = unwrap(node);
             return types_namespaceObject.isMemberExpression(node) && !node.computed && types_namespaceObject.isIdentifier(node.property, {
                 name: member
@@ -258,8 +274,15 @@ function strictEffectRuntimeTopologyViolation(source, resolveImport) {
         };
         const layerSources = [
             edge,
-            'effect'
+            'effect',
+            'effect/Layer'
         ];
+        const returned = (body)=>{
+            if (!types_namespaceObject.isBlockStatement(body)) return body;
+            const statements = body.body;
+            const last = statements.at(-1);
+            return statements.slice(0, -1).every((statement)=>types_namespaceObject.isVariableDeclaration(statement)) && types_namespaceObject.isReturnStatement(last) ? last.argument : void 0;
+        };
         const pipe = (node, check)=>types_namespaceObject.isMemberExpression(node.callee) && !node.callee.computed && types_namespaceObject.isIdentifier(node.callee.property, {
                 name: 'pipe'
             }) && check(node.callee.object) && node.arguments.every((argument)=>method(argument, 'Layer', 'orDie', layerSources) || types_namespaceObject.isCallExpression(argument) && method(argument.callee, 'Layer', 'provide', layerSources) && argument.arguments.length > 0);
@@ -268,7 +291,7 @@ function strictEffectRuntimeTopologyViolation(source, resolveImport) {
             if (!types_namespaceObject.isArrowFunctionExpression(node) && !types_namespaceObject.isFunctionExpression(node)) return false;
             const parameter = node.params[0];
             if (!types_namespaceObject.isIdentifier(parameter)) return false;
-            const body = types_namespaceObject.isBlockStatement(node.body) ? 1 === node.body.body.length && types_namespaceObject.isReturnStatement(node.body.body[0]) ? node.body.body[0].argument : void 0 : node.body;
+            const body = returned(node.body);
             const chain = (value, count = 0)=>{
                 value = unwrap(value);
                 if (types_namespaceObject.isIdentifier(value)) return count > 0 && declaration(value) === parameter;
@@ -324,7 +347,7 @@ function strictEffectRuntimeTopologyViolation(source, resolveImport) {
             const groupInit = groupValue && initialized(groupValue);
             if (!groupInit || !types_namespaceObject.isCallExpression(groupInit) || !method(groupInit.callee, 'RpcGroup', 'make', [
                 'effect/unstable/rpc',
-                '@modern-js/plugin-bff/effect-client'
+                '@modern-js/bff-effect/effect-client'
             ])) return false;
             const layerInit = initialized(layer) ?? unwrap(layer);
             if (!types_namespaceObject.isCallExpression(layerInit) || !types_namespaceObject.isMemberExpression(layerInit.callee) || layerInit.callee.computed || !types_namespaceObject.isIdentifier(layerInit.callee.property, {
@@ -344,7 +367,10 @@ function strictEffectRuntimeTopologyViolation(source, resolveImport) {
                 if (init) return runtime(init);
                 if (!types_namespaceObject.isCallExpression(node)) return false;
                 const value = imported(node.callee);
-                if (value?.name === 'defineEffectBff' && value.specifier === edge || value?.name === 'assembleEffectBffRuntime' && sharedRuntime.test(value.specifier)) {
+                if (value?.name === 'defineEffectBff' && [
+                    edge,
+                    nodeRuntime
+                ].includes(value.specifier) || value?.name === 'assembleEffectBffRuntime' && sharedRuntime.test(value.specifier)) {
                     if (1 !== node.arguments.length) return false;
                     const values = properties(node.arguments[0]);
                     if (!values) return false;
@@ -360,11 +386,9 @@ function strictEffectRuntimeTopologyViolation(source, resolveImport) {
                 }
                 const decl = declaration(node.callee);
                 const factory = decl && types_namespaceObject.isFunctionDeclaration(decl) ? decl : initialized(node.callee);
-                if (!factory || !types_namespaceObject.isFunctionDeclaration(factory) && !types_namespaceObject.isArrowFunctionExpression(factory) && !types_namespaceObject.isFunctionExpression(factory) || factory.params.length || node.arguments.length || !factory.body) return false;
-                if (!types_namespaceObject.isBlockStatement(factory.body)) return runtime(factory.body);
-                const statements = factory.body.body;
-                const last = statements.at(-1);
-                return statements.slice(0, -1).every((statement)=>types_namespaceObject.isVariableDeclaration(statement)) && !!last && types_namespaceObject.isReturnStatement(last) && !!last.argument && runtime(last.argument);
+                if (!factory || !types_namespaceObject.isFunctionDeclaration(factory) && !types_namespaceObject.isArrowFunctionExpression(factory) && !types_namespaceObject.isFunctionExpression(factory) || !factory.body) return false;
+                const result = returned(factory.body);
+                return !!result && runtime(result);
             });
         const root = entry.file.program.body.find((statement)=>types_namespaceObject.isExportDefaultDeclaration(statement));
         return root && runtime(root.declaration) ? void 0 : failure;

package/dist/esm/cli/microvertical-api-check.js

@@ -0,0 +1,33 @@
+import { checkMicroVerticalApiBoundaries, checkMicroVerticalApiConsumerFiles } from "../microvertical-api-boundary.js";
+function runMicroVerticalApiCheckCli(args = process.argv.slice(2), filesOnly = false) {
+    let workspaceRoot = process.env.ULTRAMODERN_WORKSPACE_ROOT ?? process.cwd();
+    let baselinePackageDirectory;
+    for(let index = 0; index < args.length; index += 1){
+        const argument = args[index];
+        if ('--help' === argument || '-h' === argument) {
+            console.log(`${filesOnly ? 'modern-api-check-files' : 'modern-api-check'} [--workspace-root <path>] [--baseline-package-directory <path>]\n${filesOnly ? 'Checks consumer files, contracts, package exports and owner identity. Does not analyze runtime topology; run the strict Effect source phase separately.' : 'Checks consumer files, contracts, package exports, owner identity and runtime topology once per API entry.'}\nWorkspace defaults to ULTRAMODERN_WORKSPACE_ROOT then cwd. Exit codes: 0 valid, 1 consumer violation, 2 tool/configuration failure.`);
+            return 0;
+        }
+        if (![
+            '--workspace-root',
+            '--baseline-package-directory'
+        ].includes(argument ?? '') || !args[index + 1] || args[index + 1]?.startsWith('--')) {
+            console.error(`Invalid argument: ${argument ?? ''}. Use --help.`);
+            return 2;
+        }
+        const value = args[++index];
+        if ('--workspace-root' === argument) workspaceRoot = value;
+        else baselinePackageDirectory = value;
+    }
+    const result = (filesOnly ? checkMicroVerticalApiConsumerFiles : checkMicroVerticalApiBoundaries)({
+        workspaceRoot,
+        baselinePackageDirectory
+    });
+    for (const diagnostic of result.diagnostics)console.error(`API violation: ${diagnostic}`);
+    for (const error of result.toolErrors)console.error(`API tool error: ${error}`);
+    if (result.toolErrors.length) return 2;
+    if (result.diagnostics.length) return 1;
+    console.log(`UltraModern API ${filesOnly ? 'consumer files' : 'boundary'} check passed.`);
+    return 0;
+}
+export { runMicroVerticalApiCheckCli };