@bleedingdev/modern-js-create 3.5.0-ultramodern.4 → 3.5.0-ultramodern.41

package/dist/esm-node/ultramodern-workspace/tooling-command-catalog.js

@@ -0,0 +1,101 @@
+import "node:module";
+const defineToolingCommand = (command)=>({
+        ...command,
+        wrapperPath: `scripts/${command.wrapperName}.mts`
+    });
+const generatedToolingCommands = [
+    defineToolingCommand({
+        id: 'validate',
+        command: 'validate',
+        wrapperName: 'validate-ultramodern-workspace',
+        contractKey: 'validate',
+        rootScript: 'contract:check'
+    }),
+    defineToolingCommand({
+        id: 'typecheck',
+        command: 'typecheck',
+        wrapperName: 'ultramodern-typecheck',
+        contractKey: 'typecheck',
+        rootScript: 'typecheck',
+        templatePath: "templates/workspace-scripts/ultramodern-typecheck.mjs",
+        cwd: 'invocation'
+    }),
+    defineToolingCommand({
+        id: 'mfTypes',
+        command: 'mf-types',
+        wrapperName: 'assert-mf-types',
+        contractKey: 'mfTypes',
+        rootScript: 'mf:types'
+    }),
+    defineToolingCommand({
+        id: 'publicSurface',
+        command: 'public-surface',
+        wrapperName: 'generate-public-surface-assets',
+        contractKey: 'publicSurface',
+        templatePath: "templates/workspace-scripts/generate-public-surface-assets.mjs"
+    }),
+    defineToolingCommand({
+        id: 'backendFederationGenerate',
+        command: 'backend-federation-generate',
+        wrapperName: 'generate-node-backend-federation',
+        contractKey: 'backendFederationGenerate',
+        rootScript: 'node:backend-federation:generate',
+        templatePath: "templates/workspace-scripts/generate-node-backend-federation.mjs"
+    }),
+    defineToolingCommand({
+        id: 'backendFederationProof',
+        command: 'backend-federation-proof',
+        wrapperName: 'proof-node-backend-federation',
+        contractKey: 'backendFederationProof',
+        rootScript: 'node:proof',
+        templatePath: "templates/workspace-scripts/proof-node-backend-federation.mjs"
+    }),
+    defineToolingCommand({
+        id: 'cloudflareProof',
+        command: 'cloudflare-proof',
+        wrapperName: 'proof-cloudflare-version',
+        contractKey: 'cloudflareProof',
+        rootScript: 'cloudflare:proof',
+        templatePath: "templates/workspace-scripts/proof-cloudflare-version.mjs"
+    }),
+    defineToolingCommand({
+        id: 'cloudflareOutputVerify',
+        command: 'cloudflare-output-verify',
+        wrapperName: 'verify-cloudflare-output',
+        contractKey: 'cloudflareOutputVerify',
+        rootScript: 'cloudflare-output:verify'
+    }),
+    defineToolingCommand({
+        id: 'performanceReadiness',
+        command: 'performance-readiness',
+        wrapperName: 'ultramodern-performance-readiness',
+        contractKey: 'performanceReadiness',
+        rootScript: 'performance:readiness',
+        templatePath: "templates/workspace-scripts/ultramodern-performance-readiness.mjs"
+    }),
+    defineToolingCommand({
+        id: 'migrateStrictEffect',
+        command: 'migrate-strict-effect',
+        wrapperName: 'migrate-strict-effect',
+        contractKey: 'migrateStrictEffect',
+        rootScript: 'migrate:strict-effect'
+    }),
+    defineToolingCommand({
+        id: 'routesGenerate',
+        command: 'routes-generate',
+        wrapperName: 'generate-tanstack-routes',
+        contractKey: 'routesGenerate'
+    })
+];
+const toolingCommandById = Object.fromEntries(generatedToolingCommands.map((command)=>[
+        command.id,
+        command
+    ]));
+const GENERATED_TOOLING_COMMANDS = toolingCommandById;
+const generatedToolingCommandList = ()=>generatedToolingCommands.map((command)=>command.command);
+const createToolingWrapperContract = ()=>Object.fromEntries(generatedToolingCommands.map((command)=>[
+            command.contractKey,
+            command.wrapperPath
+        ]));
+const createGeneratedToolingWrapperMap = createToolingWrapperContract;
+export { GENERATED_TOOLING_COMMANDS, createGeneratedToolingWrapperMap, generatedToolingCommandList, generatedToolingCommands };

package/dist/esm-node/ultramodern-workspace/tsconfigs.js

@@ -0,0 +1,137 @@
+import "node:module";
+import node_path from "node:path";
+import { appHasApi, resolveRemoteRefs, sharedPackages, verticalApiApps } from "./descriptors.js";
+import { effectDiagnostics } from "./effect-diagnostics.js";
+import { relativeRootFor } from "./naming.js";
+function createTsConfigBase() {
+    return {
+        compilerOptions: {
+            target: 'ESNext',
+            lib: [
+                'ESNext',
+                'DOM',
+                'DOM.Iterable'
+            ],
+            module: 'preserve',
+            moduleResolution: 'Bundler',
+            moduleDetection: 'force',
+            jsx: 'preserve',
+            isolatedModules: true,
+            verbatimModuleSyntax: true,
+            strict: true,
+            noEmit: true,
+            allowImportingTsExtensions: true,
+            allowJs: true,
+            esModuleInterop: true,
+            noUncheckedIndexedAccess: true,
+            exactOptionalPropertyTypes: true,
+            noImplicitOverride: true,
+            noFallthroughCasesInSwitch: true,
+            noPropertyAccessFromIndexSignature: true,
+            noImplicitReturns: true,
+            resolveJsonModule: true,
+            plugins: [
+                {
+                    name: '@effect/language-service',
+                    diagnostics: true,
+                    includeSuggestionsInTsc: true,
+                    ignoreEffectSuggestionsInTscExitCode: false,
+                    ignoreEffectWarningsInTscExitCode: false,
+                    ignoreEffectErrorsInTscExitCode: false,
+                    skipDisabledOptimization: true,
+                    diagnosticSeverity: Object.fromEntries(effectDiagnostics.map((name)=>[
+                            name,
+                            'error'
+                        ]))
+                }
+            ]
+        }
+    };
+}
+function createTsBuildInfoFile(packageDir) {
+    const cacheKey = packageDir.replace(/[^a-zA-Z0-9._-]+/gu, '__');
+    return `${relativeRootFor(packageDir)}/node_modules/.cache/tsgo/${cacheKey}.tsbuildinfo`;
+}
+function createTsDeclarationOutDir(packageDir) {
+    const cacheKey = packageDir.replace(/[^a-zA-Z0-9._-]+/gu, '__');
+    return `${relativeRootFor(packageDir)}/node_modules/.cache/tsgo/declarations/${cacheKey}`;
+}
+function createReferences(packageDir, references) {
+    return [
+        ...new Set(references)
+    ].filter((reference)=>reference !== packageDir).map((reference)=>({
+            path: node_path.relative(packageDir, reference).split(node_path.sep).join('/')
+        }));
+}
+function createPackageTsConfig(packageDir, options = {}) {
+    const resolvedOptions = 'boolean' == typeof options ? {
+        includeApi: options
+    } : options;
+    const include = resolvedOptions.include ?? [
+        'src',
+        'locales/**/*.json',
+        'package.json',
+        'shared'
+    ];
+    if (resolvedOptions.includeApi) include.push('api');
+    const references = createReferences(packageDir, resolvedOptions.references ?? []);
+    const tsconfig = {
+        extends: `${relativeRootFor(packageDir)}/tsconfig.base.json`,
+        compilerOptions: {
+            composite: true,
+            declaration: true,
+            declarationMap: false,
+            emitDeclarationOnly: true,
+            incremental: true,
+            noEmit: false,
+            outDir: createTsDeclarationOutDir(packageDir),
+            tsBuildInfoFile: createTsBuildInfoFile(packageDir)
+        },
+        include
+    };
+    if (references.length > 0) tsconfig.references = references;
+    return tsconfig;
+}
+function createAppTsConfig(app, remotes = []) {
+    const references = [
+        ...sharedPackages.map((sharedPackage)=>sharedPackage.directory),
+        ...'shell' === app.kind ? verticalApiApps(remotes).map((remote)=>remote.directory) : resolveRemoteRefs(app, remotes).map((remote)=>remote.directory)
+    ];
+    return createPackageTsConfig(app.directory, {
+        includeApi: appHasApi(app),
+        references
+    });
+}
+function createAppMfTypesTsConfig(app) {
+    const exposedFiles = Object.entries(app.exposes ?? {}).sort(([left], [right])=>'./Route' === left ? -1 : './Route' === right ? 1 : 0).map(([, exposePath])=>exposePath.replace(/^\.\//u, ''));
+    return {
+        extends: `${relativeRootFor(app.directory)}/tsconfig.base.json`,
+        include: [
+            ...new Set([
+                ...exposedFiles,
+                'src/modern-app-env.d.ts'
+            ])
+        ]
+    };
+}
+function createSharedPackageTsConfig(packageDir) {
+    return createPackageTsConfig(packageDir, {
+        include: [
+            'src'
+        ]
+    });
+}
+function createRootTsConfig(apps = []) {
+    return {
+        files: [],
+        references: [
+            ...sharedPackages.map((sharedPackage)=>({
+                    path: sharedPackage.directory
+                })),
+            ...apps.map((app)=>({
+                    path: app.directory
+                }))
+        ]
+    };
+}
+export { createAppMfTypesTsConfig, createAppTsConfig, createPackageTsConfig, createRootTsConfig, createSharedPackageTsConfig, createTsConfigBase };

package/dist/esm-node/ultramodern-workspace/versions.js

@@ -1,42 +1,41 @@
 import "node:module";
-const TANSTACK_ROUTER_VERSION = '1.170.16';
-const TANSTACK_ROUTER_CORE_VERSION = '1.171.13';
-const MODULE_FEDERATION_VERSION = '2.6.0';
+const TANSTACK_ROUTER_VERSION = '1.170.17';
+const TANSTACK_ROUTER_CORE_VERSION = '1.171.14';
+const MODULE_FEDERATION_VERSION = '2.7.0';
 const ZEPHYR_RSPACK_PLUGIN_VERSION = '1.1.1';
 const ZEPHYR_AGENT_VERSION = '1.1.1';
-const WRANGLER_VERSION = '4.102.0';
+const WRANGLER_VERSION = '4.109.0';
 const CLOUDFLARE_COMPATIBILITY_DATE = '2026-06-02';
-const TAILWIND_VERSION = '4.3.1';
-const TAILWIND_POSTCSS_VERSION = '4.3.1';
-const POSTCSS_VERSION = '8.5.15';
-const EFFECT_VERSION = '4.0.0-beta.91';
-const EFFECT_VITEST_VERSION = '4.0.0-beta.91';
-const EFFECT_TSGO_VERSION = '0.14.6';
-const TYPESCRIPT_STABLE_VERSION = '6.0.3';
-const TYPESCRIPT_NATIVE_PREVIEW_VERSION = '7.0.0-dev.20260628.1';
+const TAILWIND_VERSION = '4.3.2';
+const RSBUILD_PLUGIN_TAILWINDCSS_VERSION = '2.0.3';
+const EFFECT_VERSION = '4.0.0-beta.94';
+const EFFECT_VITEST_VERSION = '4.0.0-beta.94';
+const EFFECT_TSGO_VERSION = '0.16.3';
+const DRIZZLE_ORM_VERSION = '1.0.0-rc.4';
+const TYPESCRIPT_STABLE_VERSION = '7.0.2';
 const TYPESCRIPT_VERSION = TYPESCRIPT_STABLE_VERSION;
-const OXLINT_VERSION = '1.71.0';
-const OXFMT_VERSION = '0.56.0';
-const ULTRACITE_VERSION = '7.8.3';
-const LEFTHOOK_VERSION = '^2.1.9';
-const I18NEXT_VERSION = '26.3.1';
+const TYPESCRIPT_COMPILER_API_VERSION = '6.0.2';
+const OXLINT_VERSION = '1.73.0';
+const OXFMT_VERSION = '0.58.0';
+const ULTRACITE_VERSION = '7.9.3';
+const LEFTHOOK_VERSION = '^2.1.10';
+const I18NEXT_VERSION = '26.3.6';
 const NODE_FETCH_VERSION = '^3.3.2';
 const REACT_VERSION = '^19.2.7';
 const REACT_DOM_VERSION = '^19.2.7';
-const REACT_ROUTER_VERSION = '7.18.0';
+const REACT_ROUTER_VERSION = '7.18.1';
 const TYPES_REACT_VERSION = '^19.2.17';
 const TYPES_REACT_DOM_VERSION = '^19.2.3';
-const NODE_VERSION = '26.3.0';
-const PNPM_VERSION = '11.9.0';
-const RSTACK_AGENT_SKILLS_COMMIT = '61c948b42512e223bad44b83af4080eba48b2677';
-const MODULE_FEDERATION_AGENT_SKILLS_COMMIT = '07bb5b6c43ad457609e00c081b72d4c42508ec76';
+const NODE_VERSION = '26.5.0';
+const PNPM_VERSION = '11.10.0';
 const ultramodernWorkspaceVersions = {
     tanstackRouter: TANSTACK_ROUTER_VERSION,
     tanstackRouterCore: TANSTACK_ROUTER_CORE_VERSION,
     moduleFederation: MODULE_FEDERATION_VERSION,
     effect: EFFECT_VERSION,
     effectVitest: EFFECT_VITEST_VERSION,
+    drizzleOrm: DRIZZLE_ORM_VERSION,
     tailwind: TAILWIND_VERSION,
-    tailwindPostcss: TAILWIND_POSTCSS_VERSION
+    rsbuildPluginTailwindcss: RSBUILD_PLUGIN_TAILWINDCSS_VERSION
 };
-export { CLOUDFLARE_COMPATIBILITY_DATE, EFFECT_TSGO_VERSION, EFFECT_VERSION, EFFECT_VITEST_VERSION, I18NEXT_VERSION, LEFTHOOK_VERSION, MODULE_FEDERATION_AGENT_SKILLS_COMMIT, MODULE_FEDERATION_VERSION, NODE_FETCH_VERSION, NODE_VERSION, OXFMT_VERSION, OXLINT_VERSION, PNPM_VERSION, POSTCSS_VERSION, REACT_DOM_VERSION, REACT_ROUTER_VERSION, REACT_VERSION, RSTACK_AGENT_SKILLS_COMMIT, TAILWIND_POSTCSS_VERSION, TAILWIND_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_NATIVE_PREVIEW_VERSION, TYPESCRIPT_STABLE_VERSION, TYPESCRIPT_VERSION, TYPES_REACT_DOM_VERSION, TYPES_REACT_VERSION, ULTRACITE_VERSION, WRANGLER_VERSION, ZEPHYR_AGENT_VERSION, ZEPHYR_RSPACK_PLUGIN_VERSION, ultramodernWorkspaceVersions };
+export { CLOUDFLARE_COMPATIBILITY_DATE, DRIZZLE_ORM_VERSION, EFFECT_TSGO_VERSION, EFFECT_VERSION, EFFECT_VITEST_VERSION, I18NEXT_VERSION, LEFTHOOK_VERSION, MODULE_FEDERATION_VERSION, NODE_FETCH_VERSION, NODE_VERSION, OXFMT_VERSION, OXLINT_VERSION, PNPM_VERSION, REACT_DOM_VERSION, REACT_ROUTER_VERSION, REACT_VERSION, RSBUILD_PLUGIN_TAILWINDCSS_VERSION, TAILWIND_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_COMPILER_API_VERSION, TYPESCRIPT_STABLE_VERSION, TYPESCRIPT_VERSION, TYPES_REACT_DOM_VERSION, TYPES_REACT_VERSION, ULTRACITE_VERSION, WRANGLER_VERSION, ZEPHYR_AGENT_VERSION, ZEPHYR_RSPACK_PLUGIN_VERSION, ultramodernWorkspaceVersions };

package/dist/esm-node/ultramodern-workspace/workspace-script-plan.js

@@ -0,0 +1,117 @@
+import "node:module";
+import { appHasApi } from "./descriptors.js";
+import { relativeRootFor } from "./naming.js";
+import { createPublicSurfaceGenerationCommand } from "./public-surface.js";
+import { GENERATED_TOOLING_COMMANDS } from "./tooling-command-catalog.js";
+const toolingWrapperPath = (key)=>GENERATED_TOOLING_COMMANDS[key].wrapperPath;
+const rootToolingScriptName = (key)=>{
+    const rootScript = GENERATED_TOOLING_COMMANDS[key].rootScript;
+    if (!rootScript) throw new Error(`Generated tooling command ${key} does not define a root package script.`);
+    return rootScript;
+};
+const rootToolingWrapperCommand = (key)=>`node ./${toolingWrapperPath(key)}`;
+const relativeToolingWrapperPath = (packageDir, key)=>`${relativeRootFor(packageDir)}/${toolingWrapperPath(key)}`;
+const packageToolingWrapperCommand = (packageDir, key)=>`node ${relativeToolingWrapperPath(packageDir, key)}`;
+const workspaceRootPackageScriptNames = {
+    build: 'build',
+    cloudflareBuild: 'cloudflare:build',
+    cloudflareDeploy: 'cloudflare:deploy',
+    cloudflareProof: rootToolingScriptName('cloudflareProof'),
+    cloudflareOutputVerify: rootToolingScriptName('cloudflareOutputVerify'),
+    backendFederationGenerate: rootToolingScriptName('backendFederationGenerate'),
+    nodeProof: rootToolingScriptName('backendFederationProof'),
+    mfTypes: rootToolingScriptName('mfTypes'),
+    performanceReadiness: rootToolingScriptName('performanceReadiness'),
+    migrateStrictEffect: rootToolingScriptName('migrateStrictEffect'),
+    zeropsMaterialize: 'zerops:materialize',
+    contractCheck: rootToolingScriptName('validate'),
+    typecheck: 'typecheck',
+    check: 'check'
+};
+const shellOnlyOmittedRootScriptPlanKeys = new Set([
+    'backendFederationGenerate',
+    'nodeProof',
+    'zeropsMaterialize'
+]);
+const workspaceAppPackageScriptNames = {
+    dev: 'dev',
+    build: 'build',
+    cloudflareBuild: 'cloudflare:build',
+    cloudflareDeploy: 'cloudflare:deploy',
+    cloudflarePreview: 'cloudflare:preview',
+    cloudflareProof: 'cloudflare:proof',
+    serve: 'serve',
+    typecheck: 'typecheck'
+};
+const createStrictTsgoTypecheckCommand = (packageDir)=>`${packageToolingWrapperCommand(packageDir, 'typecheck')} --project tsconfig.json`;
+function createWorkspaceAppScriptPlan(app) {
+    const backendFederationBuildCommand = appHasApi(app) ? `${packageToolingWrapperCommand(app.directory, 'backendFederationGenerate')} --app ${app.id}` : void 0;
+    const backendFederationCloudflareBuildCommand = backendFederationBuildCommand ? `${backendFederationBuildCommand} --target dist-cloudflare` : void 0;
+    const buildSteps = [
+        'ULTRAMODERN_ZEPHYR=false modern build',
+        backendFederationBuildCommand,
+        createPublicSurfaceGenerationCommand(app, 'dist'),
+        app.exposes ? packageToolingWrapperCommand(app.directory, 'mfTypes') : void 0
+    ].filter((step)=>Boolean(step));
+    const cloudflareBuildSteps = [
+        'ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern build',
+        backendFederationCloudflareBuildCommand,
+        'ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern deploy --skip-build',
+        createPublicSurfaceGenerationCommand(app, 'cloudflare'),
+        `${packageToolingWrapperCommand(app.directory, 'cloudflareOutputVerify')} --app ${app.id}`
+    ].filter((step)=>Boolean(step));
+    return {
+        dev: 'modern dev',
+        build: buildSteps.join(' && '),
+        cloudflareBuild: cloudflareBuildSteps.join(' && '),
+        cloudflareDeploy: 'ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS=true pnpm run cloudflare:build && wrangler deploy --config .output/wrangler.json',
+        cloudflarePreview: 'pnpm run cloudflare:build && wrangler dev --config .output/wrangler.json',
+        cloudflareProof: `${packageToolingWrapperCommand(app.directory, 'cloudflareProof')} --app ${app.id}`,
+        serve: 'modern serve',
+        typecheck: createStrictTsgoTypecheckCommand(app.directory)
+    };
+}
+function createWorkspaceAppPackageScripts(app) {
+    const plan = createWorkspaceAppScriptPlan(app);
+    return Object.fromEntries(Object.entries(workspaceAppPackageScriptNames).map(([planKey, packageScriptName])=>[
+            packageScriptName,
+            plan[planKey]
+        ]));
+}
+function createWorkspaceRootScriptPlan(remotes = [], options = {}) {
+    const hasRemotes = remotes.length > 0;
+    const mfTypesScript = rootToolingScriptName('mfTypes');
+    const performanceReadinessScript = rootToolingScriptName('performanceReadiness');
+    const cloudflareOutputVerifyScript = rootToolingScriptName('cloudflareOutputVerify');
+    const backendFederationGenerateScript = rootToolingScriptName('backendFederationGenerate');
+    const nodeProofScript = rootToolingScriptName('backendFederationProof');
+    const bridgeCheck = options.bridgeCheck ?? '';
+    const remoteBuildPrefix = hasRemotes ? 'ULTRAMODERN_ZEPHYR=false pnpm -r --filter "./verticals/*" run build && ' : '';
+    const remoteCloudflareBuildPrefix = hasRemotes ? 'pnpm -r --filter "./verticals/*" run cloudflare:build && ' : '';
+    const remoteCloudflareDeployPrefix = hasRemotes ? 'pnpm -r --filter "./verticals/*" run cloudflare:deploy && ' : '';
+    return {
+        build: `${remoteBuildPrefix}ULTRAMODERN_ZEPHYR=false pnpm --filter "./apps/shell-super-app" run build && pnpm ${mfTypesScript} && pnpm ${performanceReadinessScript}`,
+        cloudflareBuild: `${remoteCloudflareBuildPrefix}pnpm --filter "./apps/shell-super-app" run cloudflare:build && pnpm ${mfTypesScript} && pnpm ${cloudflareOutputVerifyScript}`,
+        cloudflareDeploy: `${remoteCloudflareDeployPrefix}pnpm --filter "./apps/shell-super-app" run cloudflare:deploy`,
+        cloudflareProof: `${rootToolingWrapperCommand('cloudflareProof')} --out .codex/reports/cloudflare-version-proof/public-url-proof.json`,
+        cloudflareOutputVerify: rootToolingWrapperCommand('cloudflareOutputVerify'),
+        backendFederationGenerate: rootToolingWrapperCommand('backendFederationGenerate'),
+        nodeProof: `pnpm ${backendFederationGenerateScript} && ${rootToolingWrapperCommand('backendFederationProof')}`,
+        mfTypes: rootToolingWrapperCommand('mfTypes'),
+        performanceReadiness: rootToolingWrapperCommand('performanceReadiness'),
+        migrateStrictEffect: rootToolingWrapperCommand('migrateStrictEffect'),
+        zeropsMaterialize: "node ./scripts/materialize-zerops-runtime.mjs",
+        contractCheck: rootToolingWrapperCommand('validate'),
+        typecheck: options.typecheck ?? `${rootToolingWrapperCommand('typecheck')} --project tsconfig.json`,
+        check: `pnpm format:check && pnpm lint && pnpm typecheck && pnpm skills:check && pnpm i18n:boundaries && pnpm api:check && pnpm contract:check${hasRemotes ? ` && pnpm ${nodeProofScript}` : ''} && pnpm performance:readiness${bridgeCheck}`
+    };
+}
+function createWorkspaceRootPackageScripts(remotes = [], options = {}) {
+    const plan = createWorkspaceRootScriptPlan(remotes, options);
+    const shellOnly = 0 === remotes.length;
+    return Object.fromEntries(Object.entries(workspaceRootPackageScriptNames).filter(([planKey])=>!(shellOnly && shellOnlyOmittedRootScriptPlanKeys.has(planKey))).map(([planKey, packageScriptName])=>[
+            packageScriptName,
+            plan[planKey]
+        ]));
+}
+export { createStrictTsgoTypecheckCommand, createWorkspaceAppPackageScripts, createWorkspaceRootPackageScripts, createWorkspaceRootScriptPlan };

package/dist/esm-node/ultramodern-workspace/workspace-scripts.js

@@ -1,18 +1,13 @@
 import "node:module";
 import node_fs from "node:fs";
 import node_path from "node:path";
-import { verticalApiGroupName } from "./api.js";
-import { remoteComponentOutputPath } from "./demo-components.js";
-import { appHasApi, appI18nNamespace, remoteDependencyAlias, shellApp } from "./descriptors.js";
-import { readFileTemplate, renderFileTemplate, writeFileReplacing } from "./fs-io.js";
-import { packageName, tailwindPrefixForApp } from "./naming.js";
-import { createCloudflareSecurityContract } from "./policy.js";
-import { publicSurfaceManagedSourceAssetPaths } from "./public-surface.js";
-import { createLocalisedUrlsMap, createRouteMetaFilePath, createRouteOwnedI18nPaths, createRoutePageFilePath } from "./routes.js";
-import { CLOUDFLARE_COMPATIBILITY_DATE, NODE_VERSION, PNPM_VERSION } from "./versions.js";
+import { readFileTemplate as external_fs_io_js_readFileTemplate, renderFileTemplate, workspaceTemplateDir, writeFileReplacing } from "./fs-io.js";
+import { GENERATED_TOOLING_COMMANDS, generatedToolingCommands } from "./tooling-command-catalog.js";
+import { createWorkspaceValidationContract } from "./workspace-validation-contract.js";
+const singleQuoted = (value)=>`'${value.replace(/'/gu, "\\'")}'`;
 function createToolWrapperScript(command, extraArgs = []) {
-    const commandJson = JSON.stringify(command);
-    const extraArgsJson = JSON.stringify(extraArgs);
+    const commandLiteral = singleQuoted(command);
+    const extraArgsLiteral = `[${extraArgs.map(singleQuoted).join(', ')}]`;
     return `#!/usr/bin/env node
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
@@ -23,7 +18,7 @@ const forwardedArgs = process.argv.slice(2);
 const workspaceRoot =
   process.env.ULTRAMODERN_WORKSPACE_ROOT ??
   path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const ultramodernArgs = ['ultramodern', ${commandJson}, ...${extraArgsJson}, ...forwardedArgs];
+const ultramodernArgs = ['ultramodern', ${commandLiteral}, ...${extraArgsLiteral}, ...forwardedArgs];
 const result = createBin
   ? spawnSync(process.execPath, [createBin, ...ultramodernArgs], {
       env: { ...process.env, ULTRAMODERN_WORKSPACE_ROOT: workspaceRoot },
@@ -43,6 +38,13 @@ if (result.error) {
 process.exit(result.status ?? 1);
 `;
 }
+function writeGeneratedToolWrapperScript(targetDir, key) {
+    const command = GENERATED_TOOLING_COMMANDS[key];
+    writeWorkspaceOwnedMtsScript(targetDir, command.wrapperName, createToolWrapperScript(command.command));
+}
+function writeGeneratedToolWrapperScripts(targetDir, options = {}) {
+    for (const command of generatedToolingCommands)if (!(options.shellOnly && BACKEND_FEDERATION_WRAPPER_IDS.has(command.id))) writeGeneratedToolWrapperScript(targetDir, command.id);
+}
 function createSkillsToolWrapperScript() {
     return `#!/usr/bin/env node
 import { spawnSync } from 'node:child_process';
@@ -97,75 +99,96 @@ function migrateCopiedWorkspaceScriptToMts(targetDir, name) {
     node_fs.renameSync(legacyPath, migratedPath);
 }
 function createWorkspaceValidationScript(scope, enableTailwind, remotes = []) {
-    const verticals = remotes.filter(appHasApi).map((remote)=>({
-            id: remote.id,
-            domain: remote.domain,
-            stem: remote.api.stem,
-            group: verticalApiGroupName(remote),
-            path: remote.directory,
-            port: remote.port,
-            mfName: remote.mfName,
-            apiPrefix: remote.api.prefix,
-            tailwindPrefix: tailwindPrefixForApp(remote),
-            zephyrAlias: remoteDependencyAlias(remote),
-            packageName: packageName(scope, remote.packageSuffix),
-            exposes: Object.keys(remote.exposes ?? {}),
-            componentPaths: Object.keys(remote.exposes ?? {}).map((expose)=>remoteComponentOutputPath(remote, expose)).filter((componentPath)=>Boolean(componentPath)),
-            namespace: appI18nNamespace(remote),
-            routePagePaths: createRouteOwnedI18nPaths(remote).filter((route)=>'/' !== route.canonicalPath).map((route)=>createRoutePageFilePath(remote, route.canonicalPath)),
-            routeMetaPaths: createRouteOwnedI18nPaths(remote).map((route)=>createRouteMetaFilePath(remote, route.canonicalPath)),
-            localisedUrls: createLocalisedUrlsMap(remote),
-            verticalRefs: remote.verticalRefs ?? []
-        }));
-    const shellRouteMetaPaths = createRouteOwnedI18nPaths(shellApp).map((route)=>createRouteMetaFilePath(shellApp, route.canonicalPath));
-    const shellNamespace = appI18nNamespace(shellApp);
-    const oldRemotePaths = [
-        'apps/remotes'
-    ];
-    const expectedBuildScript = remotes.length > 0 ? 'ULTRAMODERN_ZEPHYR=false pnpm -r --filter "./verticals/*" run build && ULTRAMODERN_ZEPHYR=false pnpm --filter "./apps/shell-super-app" run build && pnpm mf:types && pnpm performance:readiness' : 'ULTRAMODERN_ZEPHYR=false pnpm --filter "./apps/shell-super-app" run build && pnpm mf:types && pnpm performance:readiness';
-    const expectedCloudflareBuildScript = remotes.length > 0 ? 'pnpm -r --filter "./verticals/*" run cloudflare:build && pnpm --filter "./apps/shell-super-app" run cloudflare:build && pnpm mf:types' : 'pnpm --filter "./apps/shell-super-app" run cloudflare:build && pnpm mf:types';
-    const expectedCloudflareDeployScript = remotes.length > 0 ? 'pnpm -r --filter "./verticals/*" run cloudflare:deploy && pnpm --filter "./apps/shell-super-app" run cloudflare:deploy' : 'pnpm --filter "./apps/shell-super-app" run cloudflare:deploy';
-    const expectedCloudflareSecurity = createCloudflareSecurityContract();
+    const contract = createWorkspaceValidationContract(scope, enableTailwind, remotes);
     return renderFileTemplate("workspace-scripts/validate-ultramodern-workspace.mjs", {
-        packageScope: scope,
-        nodeVersion: NODE_VERSION,
-        pnpmVersion: PNPM_VERSION,
-        tailwindEnabledJson: JSON.stringify(enableTailwind),
-        fullStackVerticalsJson: JSON.stringify(verticals, null, 2),
-        shellNamespaceJson: JSON.stringify(shellNamespace),
-        oldRemotePathsJson: JSON.stringify(oldRemotePaths, null, 2),
-        expectedBuildScriptJson: JSON.stringify(expectedBuildScript),
-        expectedCloudflareBuildScriptJson: JSON.stringify(expectedCloudflareBuildScript),
-        expectedCloudflareDeployScriptJson: JSON.stringify(expectedCloudflareDeployScript),
-        expectedCloudflareSecurityJson: JSON.stringify(expectedCloudflareSecurity, null, 2),
-        publicSurfaceManagedSourceAssetPathsJson: JSON.stringify([
-            ...publicSurfaceManagedSourceAssetPaths
-        ], null, 2),
-        shellRouteMetaPathsJson: JSON.stringify(shellRouteMetaPaths, null, 2),
-        cloudflareCompatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+        packageScope: contract.packageScope,
+        nodeVersion: contract.versions.node,
+        tailwindEnabledJson: JSON.stringify(contract.tailwindEnabled),
+        fullStackVerticalsJson: JSON.stringify(contract.fullStackVerticals, null, 2),
+        shellNamespaceJson: JSON.stringify(contract.shellNamespace),
+        oldRemotePathsJson: JSON.stringify(contract.oldRemotePaths),
+        expectedBuildScriptJson: JSON.stringify(contract.scripts.build),
+        expectedCloudflareBuildScriptJson: JSON.stringify(contract.scripts.cloudflareBuild),
+        expectedCloudflareDeployScriptJson: JSON.stringify(contract.scripts.cloudflareDeploy),
+        expectedCloudflareSecurityJson: JSON.stringify(contract.cloudflareSecurity, null, 2),
+        workspaceValidationContractJson: JSON.stringify(contract, null, 2),
+        publicSurfaceManagedSourceAssetPathsJson: JSON.stringify(contract.publicSurfaceManagedSourceAssetPaths, null, 2),
+        shellRouteMetaPathsJson: JSON.stringify(contract.shellRouteMetaPaths, null, 2),
+        effectVersion: contract.versions.effect,
+        moduleFederationVersion: contract.versions.moduleFederation,
+        cloudflareCompatibilityDate: contract.versions.cloudflareCompatibilityDate
     });
 }
 function createWorkspaceI18nBoundaryValidationScript() {
-    return readFileTemplate("workspace-scripts/check-ultramodern-i18n-boundaries.mts");
+    return external_fs_io_js_readFileTemplate("workspace-scripts/check-ultramodern-i18n-boundaries.mts");
 }
 function createWorkspaceApiBoundaryValidationScript() {
-    return readFileTemplate("workspace-scripts/check-ultramodern-api-boundaries.mts");
+    return external_fs_io_js_readFileTemplate("workspace-scripts/check-ultramodern-api-boundaries.mts");
 }
 function createPerformanceReadinessConfigScript() {
-    return readFileTemplate("workspace-scripts/ultramodern-performance-readiness.config.mjs");
+    return external_fs_io_js_readFileTemplate("workspace-scripts/ultramodern-performance-readiness.config.mjs");
 }
-function writeGeneratedWorkspaceScripts(targetDir, _scope, _enableTailwind, _remotes = []) {
-    writeWorkspaceOwnedMtsScript(targetDir, 'assert-mf-types', createToolWrapperScript('mf-types'));
-    writeWorkspaceOwnedMtsScript(targetDir, 'validate-ultramodern-workspace', createToolWrapperScript('validate'));
+function createZeropsRuntimeMaterializationScript() {
+    return external_fs_io_js_readFileTemplate("workspace-scripts/materialize-zerops-runtime.mjs");
+}
+function writeGeneratedWorkspaceScripts(targetDir, _scope, _enableTailwind, remotes = []) {
+    const shellOnly = 0 === remotes.length;
     writeWorkspaceOwnedMtsScript(targetDir, 'check-ultramodern-i18n-boundaries', createWorkspaceI18nBoundaryValidationScript());
     writeWorkspaceOwnedMtsScript(targetDir, 'check-ultramodern-api-boundaries', createWorkspaceApiBoundaryValidationScript());
-    writeWorkspaceOwnedMtsScript(targetDir, 'generate-public-surface-assets', createToolWrapperScript('public-surface'));
-    writeWorkspaceOwnedMtsScript(targetDir, 'proof-cloudflare-version', createToolWrapperScript('cloudflare-proof'));
+    if (!shellOnly) writeFileReplacing(targetDir, "scripts/materialize-zerops-runtime.mjs", createZeropsRuntimeMaterializationScript());
     writeFileReplacing(targetDir, "scripts/ultramodern-performance-readiness.config.mjs", createPerformanceReadinessConfigScript());
-    writeWorkspaceOwnedMtsScript(targetDir, 'ultramodern-performance-readiness', createToolWrapperScript('performance-readiness'));
-    writeWorkspaceOwnedMtsScript(targetDir, 'migrate-strict-effect', createToolWrapperScript('migrate-strict-effect'));
-    writeWorkspaceOwnedMtsScript(targetDir, 'ultramodern-typecheck', createToolWrapperScript('typecheck'));
+    writeGeneratedToolWrapperScripts(targetDir, {
+        shellOnly
+    });
     writeWorkspaceOwnedMtsScript(targetDir, 'bootstrap-agent-skills', createSkillsToolWrapperScript());
     migrateCopiedWorkspaceScriptToMts(targetDir, 'setup-agent-reference-repos');
 }
-export { createPerformanceReadinessConfigScript, createWorkspaceApiBoundaryValidationScript, createWorkspaceI18nBoundaryValidationScript, createWorkspaceValidationScript, writeGeneratedWorkspaceScripts };
+function createAgentReferenceReposSetupScript() {
+    return node_fs.readFileSync(node_path.join(workspaceTemplateDir, "scripts/setup-agent-reference-repos.mjs"), 'utf-8');
+}
+const BACKEND_FEDERATION_WRAPPER_IDS = new Set([
+    'backendFederationGenerate',
+    'backendFederationProof'
+]);
+function migratedWorkspaceScriptArtifacts(options) {
+    const artifacts = [
+        {
+            relativePath: "scripts/check-ultramodern-i18n-boundaries.mts",
+            content: createWorkspaceI18nBoundaryValidationScript(),
+            legacyPath: "scripts/check-ultramodern-i18n-boundaries.mjs"
+        },
+        {
+            relativePath: "scripts/check-ultramodern-api-boundaries.mts",
+            content: createWorkspaceApiBoundaryValidationScript(),
+            legacyPath: "scripts/check-ultramodern-api-boundaries.mjs"
+        },
+        {
+            relativePath: "scripts/ultramodern-performance-readiness.config.mjs",
+            content: createPerformanceReadinessConfigScript()
+        },
+        {
+            relativePath: "scripts/bootstrap-agent-skills.mts",
+            content: createSkillsToolWrapperScript(),
+            legacyPath: "scripts/bootstrap-agent-skills.mjs"
+        },
+        {
+            relativePath: "scripts/setup-agent-reference-repos.mts",
+            content: createAgentReferenceReposSetupScript(),
+            legacyPath: "scripts/setup-agent-reference-repos.mjs"
+        }
+    ];
+    for (const command of generatedToolingCommands)if (!(options.shellOnly && BACKEND_FEDERATION_WRAPPER_IDS.has(command.id))) artifacts.push({
+        relativePath: command.wrapperPath,
+        content: createToolWrapperScript(command.command),
+        legacyPath: command.wrapperPath.replace(/\.mts$/u, '.mjs')
+    });
+    return artifacts;
+}
+const migratedWorkspaceScriptBasenames = [
+    'check-ultramodern-i18n-boundaries',
+    'check-ultramodern-api-boundaries',
+    'bootstrap-agent-skills',
+    'setup-agent-reference-repos',
+    ...generatedToolingCommands.map((command)=>command.wrapperName)
+];
+export { createWorkspaceValidationScript, createZeropsRuntimeMaterializationScript, migratedWorkspaceScriptArtifacts, migratedWorkspaceScriptBasenames, writeGeneratedWorkspaceScripts };