@bleedingdev/modern-js-create 3.5.0-ultramodern.3 → 3.5.0-ultramodern.30

package/dist/cjs/ultramodern-workspace/contracts.cjs

@@ -34,9 +34,12 @@ __webpack_require__.d(__webpack_exports__, {
     createUltramodernConfig: ()=>createUltramodernConfig
 });
 const external_api_cjs_namespaceObject = require("./api.cjs");
+const external_backend_federation_cjs_namespaceObject = require("./backend-federation.cjs");
+const external_delivery_unit_cjs_namespaceObject = require("./delivery-unit.cjs");
 const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
 const external_naming_cjs_namespaceObject = require("./naming.cjs");
 const external_policy_cjs_namespaceObject = require("./policy.cjs");
+const external_tooling_command_catalog_cjs_namespaceObject = require("./tooling-command-catalog.cjs");
 const external_versions_cjs_namespaceObject = require("./versions.cjs");
 function createTopology(scope, remotes = []) {
     const shellHost = (0, external_descriptors_cjs_namespaceObject.createShellHost)(remotes);
@@ -79,6 +82,12 @@ function createTopology(scope, remotes = []) {
                     fallbackTelemetryEvent: 'modernjs:mv-runtime-parity',
                     sharedContractVersion: 'mf-ssr-contract-v1'
                 },
+                ...(0, external_backend_federation_cjs_namespaceObject.createBackendFederationContract)(scope, vertical) ? {
+                    backendFederation: (0, external_backend_federation_cjs_namespaceObject.createBackendFederationContract)(scope, vertical)
+                } : {},
+                ...vertical.api ? {
+                    deliveryUnit: (0, external_delivery_unit_cjs_namespaceObject.deliveryUnitContractBlock)((0, external_delivery_unit_cjs_namespaceObject.createDeliveryUnitRecord)(scope, vertical))
+                } : {},
                 ...(0, external_api_cjs_namespaceObject.apiTopologyMetadata)(vertical) ? {
                     api: (0, external_api_cjs_namespaceObject.apiTopologyMetadata)(vertical)
                 } : {},
@@ -134,7 +143,7 @@ function createOwnership(scope, remotes = []) {
             }))
     };
 }
-function createDevelopmentOverlay(remotes = []) {
+function createDevelopmentOverlay(scope, remotes = []) {
     return {
         schemaVersion: 1,
         environment: 'development',
@@ -150,6 +159,10 @@ function createDevelopmentOverlay(remotes = []) {
                 remote.id,
                 `http://localhost:${remote.port}/mf-manifest.json`
             ])),
+        serverExecution: Object.fromEntries((0, external_descriptors_cjs_namespaceObject.verticalApiApps)(remotes).map((app)=>[
+                app.id,
+                (0, external_backend_federation_cjs_namespaceObject.createServerExecutionOverlay)(scope, app)
+            ])),
         apis: Object.fromEntries((0, external_descriptors_cjs_namespaceObject.verticalApiApps)(remotes).map((app)=>[
                 app.id,
                 `http://localhost:${app.port}${(0, external_descriptors_cjs_namespaceObject.resolveApiPrefix)(app)}`
@@ -226,6 +239,12 @@ function createUltramodernConfig(scope, modernVersion, packageSource, apps = [
                             tsConfigPath: './tsconfig.mf-types.json'
                         }
                     },
+                    ...(0, external_backend_federation_cjs_namespaceObject.createBackendFederationContract)(scope, app) ? {
+                        backendFederation: (0, external_backend_federation_cjs_namespaceObject.createBackendFederationContract)(scope, app)
+                    } : {},
+                    ...app.api ? {
+                        deliveryUnit: (0, external_delivery_unit_cjs_namespaceObject.deliveryUnitContractBlock)((0, external_delivery_unit_cjs_namespaceObject.createDeliveryUnitRecord)(scope, app))
+                    } : {},
                     ...app.api ? {
                         api: {
                             stem: app.api.stem,
@@ -269,6 +288,9 @@ function createUltramodernConfig(scope, modernVersion, packageSource, apps = [
                     hostOnly: 'shell' === app.kind && 0 === Object.keys(app.exposes ?? {}).length
                 }))
         },
+        backendFederation: {
+            apps: (0, external_descriptors_cjs_namespaceObject.verticalApiApps)(remotes).map((app)=>(0, external_backend_federation_cjs_namespaceObject.createBackendFederationSummary)(scope, app))
+        },
         agentSkills: {
             target: 'codex',
             lockfile: './.codex/skills-lock.json',
@@ -283,13 +305,7 @@ function createUltramodernConfig(scope, modernVersion, packageSource, apps = [
         tooling: {
             command: 'modern-js-create ultramodern',
             wrappers: {
-                validate: "scripts/validate-ultramodern-workspace.mts",
-                typecheck: "scripts/ultramodern-typecheck.mts",
-                mfTypes: "scripts/assert-mf-types.mts",
-                publicSurface: "scripts/generate-public-surface-assets.mts",
-                cloudflareProof: "scripts/proof-cloudflare-version.mts",
-                performanceReadiness: "scripts/ultramodern-performance-readiness.mts",
-                migrateStrictEffect: "scripts/migrate-strict-effect.mts",
+                ...(0, external_tooling_command_catalog_cjs_namespaceObject.createGeneratedToolingWrapperMap)(),
                 apiBoundaries: "scripts/check-ultramodern-api-boundaries.mts",
                 skills: "scripts/bootstrap-agent-skills.mts"
             }

package/dist/cjs/ultramodern-workspace/delivery-unit-sync.cjs

@@ -0,0 +1,157 @@
+"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__, {
+    runSyncDeliveryUnit: ()=>runSyncDeliveryUnit
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const config_cjs_namespaceObject = require("../ultramodern-tooling/config.cjs");
+const external_backend_federation_cjs_namespaceObject = require("./backend-federation.cjs");
+const external_delivery_unit_cjs_namespaceObject = require("./delivery-unit.cjs");
+const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
+const external_module_federation_cjs_namespaceObject = require("./module-federation.cjs");
+const REFERENCE_TOPOLOGY_PATH = 'topology/reference-topology.json';
+function readOption(args, name) {
+    const prefix = `${name}=`;
+    const inline = args.find((arg)=>arg.startsWith(prefix));
+    if (inline) {
+        const value = inline.slice(prefix.length);
+        if (!value) throw new Error(`${name} needs a value.`);
+        return value;
+    }
+    const index = args.indexOf(name);
+    if (-1 === index) return;
+    const value = args[index + 1];
+    if (!value || value.startsWith('--')) throw new Error(`${name} needs a value.`);
+    return value;
+}
+function isPlainObject(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function writeTextIfChanged(absolutePath, content) {
+    if (external_node_fs_default().existsSync(absolutePath) && external_node_fs_default().readFileSync(absolutePath, 'utf-8') === content) return false;
+    external_node_fs_default().mkdirSync(external_node_path_default().dirname(absolutePath), {
+        recursive: true
+    });
+    external_node_fs_default().writeFileSync(absolutePath, content, 'utf-8');
+    return true;
+}
+function writeJsonIfChanged(absolutePath, value) {
+    return writeTextIfChanged(absolutePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function stampDeliveryUnitIdentity(entry, scope, app) {
+    const block = (0, external_delivery_unit_cjs_namespaceObject.deliveryUnitContractBlock)((0, external_delivery_unit_cjs_namespaceObject.createDeliveryUnitRecord)(scope, app));
+    entry.deliveryUnit = block;
+    if (isPlainObject(entry.backendFederation)) {
+        entry.backendFederation.deliveryUnit = block;
+        if (!isPlainObject(entry.backendFederation.versionBoundary)) entry.backendFederation.versionBoundary = {};
+        entry.backendFederation.versionBoundary.identityRoot = 'deliveryUnit';
+    } else entry.backendFederation = (0, external_backend_federation_cjs_namespaceObject.createBackendFederationContract)(scope, app);
+}
+function runSyncDeliveryUnit(args, context) {
+    if (args.includes('--help') || args.includes('-h')) {
+        process.stdout.write(`Usage:
+  modern-js-create ultramodern sync-delivery-unit [--workspace <dir>]
+
+Backfills the per-vertical delivery-unit identity blocks required by
+\`ultramodern validate\` onto an existing generated workspace, in place and
+through framework tooling only. For each full-stack vertical it writes the
+delivery-unit block into .modernjs/ultramodern.json topology.apps[] and
+topology/reference-topology.json verticals[] (plus backendFederation.deliveryUnit
+and backendFederation.versionBoundary.identityRoot) and regenerates
+verticals/<id>/shared/ultramodern-build.ts. Idempotent: a second run writes
+nothing.
+`);
+        return 0;
+    }
+    const workspaceOverride = readOption(args, '--workspace');
+    const workspaceRoot = workspaceOverride ? external_node_path_default().resolve(context.invocationCwd, workspaceOverride) : context.workspaceRoot;
+    const compactPath = external_node_path_default().join(workspaceRoot, external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH);
+    if (!external_node_fs_default().existsSync(compactPath)) throw new Error(`Missing ${external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH}. sync-delivery-unit needs the compact UltraModern config; run \`modern-js-create ultramodern migrate-strict-effect\` first.`);
+    const config = (0, config_cjs_namespaceObject.readUltramodernConfig)(workspaceRoot);
+    const scope = config.workspace.packageScope;
+    const apiApps = (0, config_cjs_namespaceObject.workspaceAppsFromToolingConfig)(config).filter((app)=>Boolean(app.api));
+    const written = [];
+    const unchanged = [];
+    const track = (relativePath, changed)=>{
+        (changed ? written : unchanged).push(relativePath);
+    };
+    const appById = new Map(apiApps.map((app)=>[
+            app.id,
+            app
+        ]));
+    const compact = JSON.parse(external_node_fs_default().readFileSync(compactPath, 'utf-8'));
+    if (isPlainObject(compact) && Array.isArray(compact.topology?.apps)) for (const entry of compact.topology.apps){
+        if (!isPlainObject(entry)) continue;
+        const app = appById.get(String(entry.id));
+        if (app) stampDeliveryUnitIdentity(entry, scope, app);
+    }
+    track(external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH, writeJsonIfChanged(compactPath, compact));
+    const topologyPath = external_node_path_default().join(workspaceRoot, REFERENCE_TOPOLOGY_PATH);
+    if (external_node_fs_default().existsSync(topologyPath)) {
+        const topology = JSON.parse(external_node_fs_default().readFileSync(topologyPath, 'utf-8'));
+        if (isPlainObject(topology) && Array.isArray(topology.verticals)) for (const entry of topology.verticals){
+            if (!isPlainObject(entry)) continue;
+            const app = appById.get(String(entry.id));
+            if (app) stampDeliveryUnitIdentity(entry, scope, app);
+        }
+        track(REFERENCE_TOPOLOGY_PATH, writeJsonIfChanged(topologyPath, topology));
+    }
+    for (const app of apiApps){
+        const relativePath = external_node_path_default().join(app.directory, 'shared/ultramodern-build.ts');
+        const changed = writeTextIfChanged(external_node_path_default().join(workspaceRoot, relativePath), (0, external_module_federation_cjs_namespaceObject.createUltramodernBuildModule)(scope, app));
+        track(relativePath, changed);
+    }
+    if (0 === written.length) process.stdout.write('[ultramodern] sync-delivery-unit: already in sync; no files written.\n');
+    else {
+        process.stdout.write(`[ultramodern] sync-delivery-unit: wrote ${written.length} file(s):\n`);
+        for (const relativePath of written)process.stdout.write(`  wrote    ${relativePath}\n`);
+        for (const relativePath of unchanged)process.stdout.write(`  in-sync  ${relativePath}\n`);
+    }
+    return 0;
+}
+exports.runSyncDeliveryUnit = __webpack_exports__.runSyncDeliveryUnit;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runSyncDeliveryUnit"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/delivery-unit.cjs

@@ -0,0 +1,88 @@
+"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__, {
+    DELIVERY_UNIT_SCHEMA_VERSION: ()=>DELIVERY_UNIT_SCHEMA_VERSION,
+    createBuildMarker: ()=>createBuildMarker,
+    createDeliveryUnitRecord: ()=>createDeliveryUnitRecord,
+    deliveryUnitContractBlock: ()=>deliveryUnitContractBlock
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+var external_node_crypto_default = /*#__PURE__*/ __webpack_require__.n(external_node_crypto_namespaceObject);
+const external_naming_cjs_namespaceObject = require("./naming.cjs");
+const DELIVERY_UNIT_SCHEMA_VERSION = 1;
+function createBuildMarker(scope, app) {
+    return external_node_crypto_default().createHash('sha256').update(`${scope}:${app.packageSuffix}:${app.id}:0.1.0`).digest('hex').slice(0, 16);
+}
+function deliveryUnitContractBlock(record) {
+    return {
+        schemaVersion: record.schemaVersion,
+        kind: record.kind,
+        unitId: record.unitId,
+        packageName: record.packageName,
+        version: record.version,
+        buildMarker: record.buildMarker,
+        sourceRevision: record.sourceRevision
+    };
+}
+function createDeliveryUnitRecord(scope, app) {
+    return {
+        schemaVersion: DELIVERY_UNIT_SCHEMA_VERSION,
+        kind: 'microvertical-delivery-unit',
+        unitId: `${scope}/${app.domain ?? app.id}`,
+        appId: app.id,
+        packageName: (0, external_naming_cjs_namespaceObject.packageName)(scope, app.packageSuffix),
+        version: '0.1.0',
+        sourceRevision: 'workspace',
+        buildMarker: createBuildMarker(scope, app),
+        deployProfile: 'cloudflare-ssr-mf-effect-v1'
+    };
+}
+exports.DELIVERY_UNIT_SCHEMA_VERSION = __webpack_exports__.DELIVERY_UNIT_SCHEMA_VERSION;
+exports.createBuildMarker = __webpack_exports__.createBuildMarker;
+exports.createDeliveryUnitRecord = __webpack_exports__.createDeliveryUnitRecord;
+exports.deliveryUnitContractBlock = __webpack_exports__.deliveryUnitContractBlock;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DELIVERY_UNIT_SCHEMA_VERSION",
+    "createBuildMarker",
+    "createDeliveryUnitRecord",
+    "deliveryUnitContractBlock"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/descriptors.cjs

@@ -31,6 +31,10 @@ __webpack_require__.d(__webpack_exports__, {
     ULTRAMODERN_CONFIG_PATH: ()=>ULTRAMODERN_CONFIG_PATH,
     appHasApi: ()=>appHasApi,
     appI18nNamespace: ()=>appI18nNamespace,
+    createBackendFederationContainerEntry: ()=>createBackendFederationContainerEntry,
+    createBackendFederationManifestEnv: ()=>createBackendFederationManifestEnv,
+    createBackendFederationManifestUrl: ()=>createBackendFederationManifestUrl,
+    createBackendFederationName: ()=>createBackendFederationName,
     createCloudflarePublicUrlEnv: ()=>createCloudflarePublicUrlEnv,
     createCloudflareWorkerName: ()=>createCloudflareWorkerName,
     createModuleFederationRemoteContracts: ()=>createModuleFederationRemoteContracts,
@@ -161,6 +165,18 @@ function resolveRemoteRefs(app, remotes = []) {
 function createRemoteManifestEnv(remote) {
     return `VERTICAL_${(0, external_naming_cjs_namespaceObject.toEnvSegment)(remote.domain ?? remote.id)}_MF_MANIFEST`;
 }
+function createBackendFederationManifestEnv(remote) {
+    return `VERTICAL_${(0, external_naming_cjs_namespaceObject.toEnvSegment)(remote.domain ?? remote.id)}_BACKEND_MF_MANIFEST`;
+}
+function createBackendFederationName(app) {
+    return `${app.mfName}Backend`;
+}
+function createBackendFederationManifestUrl(app) {
+    return `http://localhost:${app.port}/backend-mf-manifest.json`;
+}
+function createBackendFederationContainerEntry(app) {
+    return `http://localhost:${app.port}/backendRemoteEntry.mjs`;
+}
 function createModuleFederationRemoteContracts(app, remotes = []) {
     return resolveRemoteRefs(app, remotes).map((remote)=>({
             id: remote.id,
@@ -182,6 +198,10 @@ function appI18nNamespace(app) {
 exports.ULTRAMODERN_CONFIG_PATH = __webpack_exports__.ULTRAMODERN_CONFIG_PATH;
 exports.appHasApi = __webpack_exports__.appHasApi;
 exports.appI18nNamespace = __webpack_exports__.appI18nNamespace;
+exports.createBackendFederationContainerEntry = __webpack_exports__.createBackendFederationContainerEntry;
+exports.createBackendFederationManifestEnv = __webpack_exports__.createBackendFederationManifestEnv;
+exports.createBackendFederationManifestUrl = __webpack_exports__.createBackendFederationManifestUrl;
+exports.createBackendFederationName = __webpack_exports__.createBackendFederationName;
 exports.createCloudflarePublicUrlEnv = __webpack_exports__.createCloudflarePublicUrlEnv;
 exports.createCloudflareWorkerName = __webpack_exports__.createCloudflareWorkerName;
 exports.createModuleFederationRemoteContracts = __webpack_exports__.createModuleFederationRemoteContracts;
@@ -201,6 +221,10 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "ULTRAMODERN_CONFIG_PATH",
     "appHasApi",
     "appI18nNamespace",
+    "createBackendFederationContainerEntry",
+    "createBackendFederationManifestEnv",
+    "createBackendFederationManifestUrl",
+    "createBackendFederationName",
     "createCloudflarePublicUrlEnv",
     "createCloudflareWorkerName",
     "createModuleFederationRemoteContracts",