@bleedingdev/modern-js-ultramodern-create 3.8.3-ultramodern.2

package/dist/esm-node/ultramodern-workspace/bridge-config/validation.js

@@ -0,0 +1,28 @@
+import "node:module";
+import { defaultReactSingletons } from "./defaults.js";
+function validateParentPackageCoverage(workspacePackages, dependencies) {
+    const declaredPackages = new Set();
+    for (const [index, entry] of workspacePackages.entries()){
+        const label = `bridge.workspacePackages[${index}]`;
+        const packageNames = entry.packageNames ?? [];
+        if (0 === packageNames.length && (entry.testAliases ?? []).length > 0) throw new Error(`${label}.packageNames must declare the parent package names covered by "${entry.pattern}" before testAliases can be checked.`);
+        for (const packageName of packageNames)declaredPackages.add(packageName);
+        for (const alias of entry.testAliases ?? []){
+            if (!packageNames.some((packageName)=>aliasMatchesPackage(alias.alias, packageName))) throw new Error(`${label}.testAliases entry "${alias.alias}" must match one of ${label}.packageNames.`);
+            if (pointsAtBuildOutput(alias.target)) throw new Error(`${label}.testAliases target "${alias.target}" must point at source files, not dist output.`);
+        }
+    }
+    const missingDependencies = dependencies.filter((dependency)=>!declaredPackages.has(dependency));
+    if (declaredPackages.size > 0 && missingDependencies.length > 0) throw new Error(`Bridge mode dependencies must be declared by bridge.workspacePackages[].packageNames: ${missingDependencies.join(', ')}.`);
+}
+function aliasMatchesPackage(alias, packageName) {
+    return alias === packageName || alias.startsWith(`${packageName}/`);
+}
+function pointsAtBuildOutput(target) {
+    return target.split(/[\\/]/u).includes('dist');
+}
+function validateReactSingletons(reactSingletons) {
+    const missing = defaultReactSingletons.filter((packageName)=>!reactSingletons.includes(packageName));
+    if (missing.length > 0) throw new Error(`Bridge mode React singleton/dedupe declarations must include ${defaultReactSingletons.join(' and ')}. Missing: ${missing.join(', ')}.`);
+}
+export { validateParentPackageCoverage, validateReactSingletons };

package/dist/esm-node/ultramodern-workspace/bridge-config/workspace-packages.js

@@ -0,0 +1,68 @@
+import "node:module";
+import { ultramodernBridgeCliFlags } from "./schema.js";
+import { readRepeatedOptionValues, requireNonEmptyValue, splitAssignment, uniqueNonEmptyValues } from "./shared.js";
+function readWorkspacePackages(args) {
+    const drafts = new Map();
+    const getDraft = (pattern)=>{
+        const normalizedPattern = requireNonEmptyValue(pattern, ultramodernBridgeCliFlags.workspacePackage);
+        const existing = drafts.get(normalizedPattern);
+        if (existing) return existing;
+        const draft = {
+            pattern: normalizedPattern,
+            packageNames: [],
+            testAliases: []
+        };
+        drafts.set(normalizedPattern, draft);
+        return draft;
+    };
+    for (const pattern of readRepeatedOptionValues(args, ultramodernBridgeCliFlags.workspacePackage))getDraft(pattern);
+    for (const value of readRepeatedOptionValues(args, ultramodernBridgeCliFlags.workspacePackageName)){
+        const { left: pattern, right: packageNames } = splitAssignment(value, ultramodernBridgeCliFlags.workspacePackageName, '<pattern>=<package-name>[,<package-name>]');
+        getDraft(pattern).packageNames.push(...packageNames.split(',').map((packageName)=>packageName.trim()).filter(Boolean));
+    }
+    for (const value of readRepeatedOptionValues(args, ultramodernBridgeCliFlags.testAlias)){
+        const separator = value.indexOf(':');
+        if (-1 === separator) throw new Error(`${ultramodernBridgeCliFlags.testAlias} must use <pattern>:<alias>=<target>.`);
+        const pattern = value.slice(0, separator);
+        const aliasDefinition = value.slice(separator + 1);
+        const { left: alias, right: target } = splitAssignment(aliasDefinition, ultramodernBridgeCliFlags.testAlias, '<pattern>:<alias>=<target>');
+        getDraft(pattern).testAliases.push({
+            alias: requireNonEmptyValue(alias, `${ultramodernBridgeCliFlags.testAlias} alias`),
+            target: requireNonEmptyValue(target, `${ultramodernBridgeCliFlags.testAlias} target`)
+        });
+    }
+    return normalizeWorkspacePackages([
+        ...drafts.values()
+    ]);
+}
+function normalizeWorkspacePackages(workspacePackages) {
+    return workspacePackages.map((entry, index)=>{
+        const label = `bridge.workspacePackages[${index}]`;
+        const packageNames = entry.packageNames && entry.packageNames.length > 0 ? uniqueNonEmptyValues(entry.packageNames, `${label}.packageNames`) : void 0;
+        const testAliases = entry.testAliases && entry.testAliases.length > 0 ? normalizeTestAliases(entry.testAliases, label) : void 0;
+        return {
+            pattern: requireNonEmptyValue(entry.pattern, `${label}.pattern`),
+            ...packageNames ? {
+                packageNames
+            } : {},
+            ...testAliases ? {
+                testAliases
+            } : {}
+        };
+    });
+}
+function normalizeTestAliases(testAliases, parentLabel) {
+    const aliases = new Map();
+    for (const [index, alias] of testAliases.entries()){
+        const label = `${parentLabel}.testAliases[${index}]`;
+        const normalizedAlias = requireNonEmptyValue(alias.alias, `${label}.alias`);
+        aliases.set(normalizedAlias, {
+            alias: normalizedAlias,
+            target: requireNonEmptyValue(alias.target, `${label}.target`)
+        });
+    }
+    return [
+        ...aliases.values()
+    ];
+}
+export { normalizeWorkspacePackages, readWorkspacePackages };

package/dist/esm-node/ultramodern-workspace/bridge-config.js

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "./bridge-config/index.js";

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

@@ -0,0 +1,97 @@
+import "node:module";
+import node_path from "node:path";
+import { addUltramodernVertical, generateUltramodernWorkspace, planUltramodernVertical } from "./public-api.js";
+async function ultramodernCodeSmithAdapter(context, runtime) {
+    const config = context.config ?? {};
+    const mode = resolveMode(config);
+    const basePath = node_path.resolve(runtime?.outputPath ?? context.materials?.default?.basePath ?? process.cwd());
+    const modernVersion = config.modernVersion ?? 'latest';
+    const packageSource = resolvePackageSource(config);
+    const enableTailwind = config.enableTailwind ?? config.tailwind;
+    if (config.dryRun && 'vertical' !== mode) throw new Error('UltraModern CodeSmith dry-run is supported only in vertical mode.');
+    const name = await resolveName(context, config, mode);
+    const result = 'workspace' === mode ? generateUltramodernWorkspace({
+        targetDir: resolveTargetDir(basePath, config.targetDir, name),
+        packageName: name,
+        modernVersion,
+        enableTailwind,
+        bridge: config.bridge,
+        overlays: config.overlays,
+        packageSource
+    }) : runVerticalMode({
+        workspaceRoot: resolveWorkspaceRoot(basePath, config.workspaceRoot),
+        name,
+        modernVersion,
+        enableTailwind,
+        overlays: config.overlays,
+        packageSource,
+        ...config.preset ? {
+            preset: config.preset
+        } : {},
+        ...config.apiProtocol ? {
+            apiProtocol: config.apiProtocol
+        } : {},
+        ...config.horizontalRemote ? {
+            horizontalRemote: true
+        } : {}
+    }, Boolean(config.dryRun));
+    context.data ??= {};
+    context.data.ultramodernResult = result;
+    if (config.logResult) {
+        const logger = context.logger ?? runtime?.logger;
+        logger?.info?.(JSON.stringify(result, null, 2));
+    }
+    return result;
+}
+function resolveMode(config) {
+    if (void 0 === config.mode) return 'workspace';
+    if ('workspace' !== config.mode && 'vertical' !== config.mode) throw new Error(`Unsupported UltraModern CodeSmith mode "${String(config.mode)}". Use "workspace" or "vertical".`);
+    return config.mode;
+}
+async function resolveName(context, config, label) {
+    const configuredName = config.name ?? config.targetName ?? config.packageName;
+    if (configuredName) return configuredName;
+    const prompt = context.prompt ?? context.inquirer?.prompt;
+    if (!prompt) throw new Error(`Missing UltraModern ${label} name. Pass config.name for non-interactive CodeSmith usage.`);
+    const answer = await prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: `UltraModern ${label} name`
+        }
+    ]);
+    const promptedName = answer.name;
+    if ('string' != typeof promptedName || 0 === promptedName.length) throw new Error(`Missing UltraModern ${label} name.`);
+    return promptedName;
+}
+function resolveTargetDir(basePath, targetDir, name) {
+    return node_path.resolve(basePath, targetDir ?? name);
+}
+function resolveWorkspaceRoot(basePath, workspaceRoot) {
+    return node_path.resolve(basePath, workspaceRoot ?? '.');
+}
+function resolvePackageSource(config) {
+    const packageSource = {
+        ...config.packageSource ?? {},
+        ...config.packageSourceStrategy ? {
+            strategy: config.packageSourceStrategy
+        } : {},
+        ...config.modernPackageVersion ? {
+            modernPackageVersion: config.modernPackageVersion
+        } : {},
+        ...config.registry ? {
+            registry: config.registry
+        } : {},
+        ...config.aliasScope ? {
+            aliasScope: config.aliasScope
+        } : {},
+        ...config.aliasPackageNamePrefix ? {
+            aliasPackageNamePrefix: config.aliasPackageNamePrefix
+        } : {}
+    };
+    return Object.keys(packageSource).length > 0 ? packageSource : void 0;
+}
+function runVerticalMode(options, dryRun) {
+    return dryRun ? planUltramodernVertical(options) : addUltramodernVertical(options);
+}
+export default ultramodernCodeSmithAdapter;

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

@@ -0,0 +1,320 @@
+import "node:module";
+import { ULTRAMODERN_CREATE_PACKAGE } from "../ultramodern-package-source.js";
+import { apiTopologyMetadata } from "./api.js";
+import { rpcPath } from "./api/rpc.js";
+import { createBackendFederationContract, createBackendFederationSummary, createServerExecutionOverlay } from "./backend-federation.js";
+import { defaultReactSingletons } from "./bridge-config/defaults.js";
+import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "./delivery-unit.js";
+import { appEmitsBrowserUi, createModuleFederationRemoteContracts, createShellHost, resolveApiPrefix, resolveApiProtocol, sharedPackages, shellApp, verticalApiApps } from "./descriptors.js";
+import { packageName } from "./naming.js";
+import { createCloudflareDeployContract } from "./policy.js";
+import { createAdditionalShellConfigEntry } from "./shells.js";
+import { createGeneratedToolingWrapperMap } from "./tooling-command-catalog.js";
+import { CLOUDFLARE_COMPATIBILITY_DATE, NODE_VERSION, PNPM_VERSION } from "./versions.js";
+function isJsonValue(value) {
+    return void 0 !== value;
+}
+function optionalJsonEntry(key, value) {
+    return void 0 === value ? {} : {
+        [key]: value
+    };
+}
+function jsonEntries(entries) {
+    return Object.fromEntries(entries.filter((entry)=>isJsonValue(entry[1])));
+}
+function presentJsonValues(values) {
+    return values.filter(isJsonValue);
+}
+function createReferenceRemoteContracts(app, remotes) {
+    return createModuleFederationRemoteContracts(app, remotes).map((remote)=>({
+            id: remote.id,
+            name: remote.name,
+            manifestUrl: remote.manifestUrl
+        }));
+}
+function createTopology(scope, remotes = [], primaryShell) {
+    const shellHost = primaryShell ?? createShellHost(remotes);
+    return {
+        schemaVersion: 1,
+        id: 'ultramodern-superapp-workspace-reference-topology',
+        description: 'Generated UltraModern SuperApp shell that can grow by adding full-stack verticals.',
+        preset: 'presetUltramodern',
+        shell: {
+            id: shellApp.id,
+            kind: 'shell',
+            package: packageName(scope, shellApp.packageSuffix),
+            verticalRefs: shellHost.verticalRefs ?? [],
+            moduleFederation: {
+                role: 'host',
+                name: shellApp.mfName,
+                remotes: createReferenceRemoteContracts(shellHost, remotes),
+                ssr: true,
+                sharedContractVersion: 'mf-ssr-contract-v1'
+            },
+            deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, shellApp)),
+            cloudflare: createCloudflareDeployContract(scope, shellApp),
+            ownership: shellApp.ownership
+        },
+        verticals: remotes.map((vertical)=>({
+                id: vertical.id,
+                kind: vertical.kind,
+                ...vertical.surfaceProfile ? {
+                    surfaceProfile: vertical.surfaceProfile
+                } : {},
+                ...vertical.deliveryUnitKind ? {
+                    deliveryUnitKind: vertical.deliveryUnitKind
+                } : {},
+                ...vertical.domain ? {
+                    domain: vertical.domain
+                } : {},
+                package: packageName(scope, vertical.packageSuffix),
+                path: vertical.directory,
+                moduleFederation: {
+                    role: 'remote',
+                    name: vertical.mfName,
+                    manifestUrl: `http://localhost:${vertical.port}/mf-manifest.json`,
+                    exposes: Object.keys(vertical.exposes ?? {}),
+                    ...vertical.verticalRefs?.length ? {
+                        verticalRefs: vertical.verticalRefs,
+                        remotes: createReferenceRemoteContracts(vertical, remotes)
+                    } : {},
+                    ssr: true,
+                    sharedContractVersion: 'mf-ssr-contract-v1'
+                },
+                ...optionalJsonEntry('backendFederation', createBackendFederationContract(scope, vertical)),
+                deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, vertical)),
+                ...optionalJsonEntry('api', apiTopologyMetadata(vertical)),
+                cloudflare: createCloudflareDeployContract(scope, vertical),
+                ownership: vertical.ownership
+            })),
+        sharedPackages: sharedPackages.map((sharedPackage)=>({
+                id: sharedPackage.id,
+                package: packageName(scope, sharedPackage.id),
+                path: sharedPackage.directory,
+                description: sharedPackage.description
+            })),
+        validation: {
+            script: "scripts/validate-ultramodern-workspace.mts",
+            commands: [
+                'pnpm i18n:boundaries',
+                'pnpm api:check',
+                'pnpm contract:check'
+            ]
+        }
+    };
+}
+function createOwnership(scope, remotes = []) {
+    return {
+        schemaVersion: 1,
+        preset: 'presetUltramodern',
+        owners: [
+            shellApp,
+            ...remotes,
+            ...sharedPackages.map((sharedPackage)=>({
+                    id: sharedPackage.id,
+                    packageSuffix: sharedPackage.id,
+                    directory: sharedPackage.directory,
+                    ownership: {
+                        team: 'super-app-platform',
+                        slack: '#super-app-platform',
+                        pagerDuty: 'pd-super-app-platform',
+                        runbookRef: `runbooks/wave2/${sharedPackage.id}.md`,
+                        adrRef: 'docs/super-app-rfc-adr/wave2/reference-topology.md#shared-packages',
+                        blastRadius: {
+                            tier: 'tier-1-shared-contract',
+                            references: [
+                                'docs/super-app-rfc-adr/wave2/blast-radius.md#shared-packages'
+                            ]
+                        }
+                    }
+                }))
+        ].map((owner)=>({
+                id: owner.id,
+                package: packageName(scope, owner.packageSuffix),
+                path: owner.directory,
+                ownership: owner.ownership
+            }))
+    };
+}
+function createDevelopmentOverlay(scope, remotes = []) {
+    return {
+        schemaVersion: 1,
+        environment: 'development',
+        preset: 'presetUltramodern',
+        ports: Object.fromEntries([
+            shellApp,
+            ...remotes
+        ].map((app)=>[
+                app.id,
+                app.port
+            ])),
+        manifests: Object.fromEntries(remotes.filter(appEmitsBrowserUi).map((remote)=>[
+                remote.id,
+                `http://localhost:${remote.port}/mf-manifest.json`
+            ])),
+        serverExecution: jsonEntries(verticalApiApps(remotes).map((app)=>[
+                app.id,
+                createServerExecutionOverlay(scope, app)
+            ])),
+        apis: Object.fromEntries(verticalApiApps(remotes).map((app)=>[
+                app.id,
+                `http://localhost:${app.port}${'rpc' === resolveApiProtocol(app) ? rpcPath(app) : resolveApiPrefix(app)}`
+            ]))
+    };
+}
+function createUltramodernConfig(scope, modernVersion, packageSource, apps = [
+    createShellHost()
+], enableTailwind = true, bridge, additionalShells = [], primaryShell) {
+    const remotes = apps.filter((app)=>'shell' !== app.kind);
+    const shellHost = primaryShell ?? createShellHost(remotes);
+    return {
+        schemaVersion: 1,
+        profile: 'cloudflare-ssr-mf-effect-v1',
+        generator: {
+            package: ULTRAMODERN_CREATE_PACKAGE,
+            version: modernVersion
+        },
+        workspace: {
+            packageScope: scope,
+            packageManager: {
+                name: 'pnpm',
+                version: PNPM_VERSION
+            },
+            node: {
+                version: NODE_VERSION,
+                engineRange: '>=26'
+            }
+        },
+        packageSource: {
+            strategy: packageSource.strategy,
+            modernPackageVersion: packageSource.modernPackageVersion,
+            ...packageSource.registry ? {
+                registry: packageSource.registry
+            } : {},
+            ...packageSource.aliasScope ? {
+                aliasScope: packageSource.aliasScope
+            } : {},
+            ...packageSource.aliasPackageNamePrefix ? {
+                aliasPackageNamePrefix: packageSource.aliasPackageNamePrefix
+            } : {}
+        },
+        features: {
+            tailwind: enableTailwind
+        },
+        topology: {
+            source: './topology/reference-topology.json',
+            apps: apps.map((app)=>({
+                    id: app.id,
+                    kind: app.kind,
+                    package: packageName(scope, app.packageSuffix),
+                    packageSuffix: app.packageSuffix,
+                    displayName: app.displayName,
+                    path: app.directory,
+                    ...app.domain ? {
+                        domain: app.domain
+                    } : {},
+                    ...app.surfaceProfile ? {
+                        surfaceProfile: app.surfaceProfile
+                    } : {},
+                    ...app.deliveryUnitKind ? {
+                        deliveryUnitKind: app.deliveryUnitKind
+                    } : {},
+                    port: app.port,
+                    portEnv: app.portEnv,
+                    moduleFederation: {
+                        role: 'shell' === app.kind ? 'host' : 'remote',
+                        name: app.mfName,
+                        exposes: Object.keys(app.exposes ?? {}),
+                        ...'shell' === app.kind ? {
+                            verticalRefs: shellHost.verticalRefs ?? [],
+                            remotes: createModuleFederationRemoteContracts(shellHost, remotes)
+                        } : app.verticalRefs?.length ? {
+                            verticalRefs: app.verticalRefs,
+                            remotes: createModuleFederationRemoteContracts(app, remotes)
+                        } : {},
+                        ssr: true,
+                        dts: {
+                            compilerInstance: 'effect-tsgo',
+                            tsConfigPath: './tsconfig.mf-types.json'
+                        }
+                    },
+                    ...optionalJsonEntry('backendFederation', createBackendFederationContract(scope, app)),
+                    deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, app)),
+                    ...app.api ? {
+                        api: {
+                            runtime: 'effect',
+                            stem: app.api.stem,
+                            prefix: app.api.prefix,
+                            consumedBy: app.api.consumedBy,
+                            serverEntry: `${app.directory}/api/index.ts`,
+                            ...void 0 === app.api.protocol ? {} : {
+                                protocol: app.api.protocol
+                            }
+                        }
+                    } : {},
+                    deploy: {
+                        cloudflare: createCloudflareDeployContract(scope, app)
+                    }
+                }))
+        },
+        ...additionalShells.length > 0 ? {
+            shells: additionalShells.map((shell)=>createAdditionalShellConfigEntry(scope, shell, remotes))
+        } : {},
+        bridge: bridge ?? {
+            enabled: false,
+            workspacePackages: [],
+            dependencies: [],
+            lockfilePolicy: 'nested',
+            gates: [],
+            reactSingletons: [
+                ...defaultReactSingletons
+            ]
+        },
+        deploy: {
+            worker: {
+                wrangler: {
+                    compatibility_date: CLOUDFLARE_COMPATIBILITY_DATE,
+                    compatibility_flags: [
+                        'nodejs_compat',
+                        'global_fetch_strictly_public'
+                    ]
+                },
+                artifacts: [],
+                publicAssetExcludes: []
+            }
+        },
+        moduleFederation: {
+            apps: apps.map((app)=>({
+                    id: app.id,
+                    path: app.directory,
+                    role: 'shell' === app.kind ? 'host' : 'remote',
+                    name: app.mfName,
+                    exposes: Object.keys(app.exposes ?? {}),
+                    hostOnly: 'shell' === app.kind && 0 === Object.keys(app.exposes ?? {}).length
+                }))
+        },
+        backendFederation: {
+            apps: presentJsonValues(verticalApiApps(remotes).map((app)=>createBackendFederationSummary(scope, app)))
+        },
+        agentSkills: {
+            target: 'codex',
+            lockfile: './.codex/skills-lock.json',
+            installDir: './.codex/skills',
+            mode: 'repo-owned-default-on',
+            selfContainedVendoring: true,
+            optOutEnv: [
+                'ULTRAMODERN_SKIP_CODEX_SKILLS=1',
+                'ULTRAMODERN_CODEX_SKILLS=0'
+            ]
+        },
+        tooling: {
+            command: 'ultramodern-create ultramodern',
+            wrappers: {
+                ...createGeneratedToolingWrapperMap(),
+                apiBoundaries: "scripts/check-ultramodern-api-boundaries.mts",
+                skills: "scripts/bootstrap-agent-skills.mts"
+            }
+        }
+    };
+}
+export { createDevelopmentOverlay, createOwnership, createTopology, createUltramodernConfig };