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

package/dist/esm/ultramodern-workspace/delivery-unit-schema/types.js

@@ -0,0 +1,236 @@
+import { DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION } from "@modern-js/utils/universal";
+import { isVerticalApiProtocol } from "../types.js";
+const SEGMENT_PATTERN = /^[A-Za-z0-9._-]+$/;
+const MAJOR_PATTERN = /^v[1-9][0-9]*$/;
+function parseSurfaceRef(input) {
+    if ('' === input) return {
+        ok: false,
+        error: {
+            code: 'empty'
+        }
+    };
+    const hashCount = countChar(input, '#');
+    if (0 === hashCount) return {
+        ok: false,
+        error: {
+            code: 'missing-surface-separator'
+        }
+    };
+    if (hashCount > 1) return {
+        ok: false,
+        error: {
+            code: 'multiple-surface-separators'
+        }
+    };
+    const hashIndex = input.indexOf('#');
+    const unitPart = input.slice(0, hashIndex);
+    const rest = input.slice(hashIndex + 1);
+    const atIndex = rest.indexOf('@');
+    const surfaceId = -1 === atIndex ? rest : rest.slice(0, atIndex);
+    const ref = {
+        unitId: unitPart,
+        surfaceId
+    };
+    if (-1 !== atIndex) {
+        const majorPart = rest.slice(atIndex + 1);
+        if ('' === majorPart) return {
+            ok: false,
+            error: {
+                code: 'empty-major'
+            }
+        };
+        if (!MAJOR_PATTERN.test(majorPart)) return {
+            ok: false,
+            error: {
+                code: 'invalid-major',
+                value: majorPart
+            }
+        };
+        ref.major = Number(majorPart.slice(1));
+    }
+    const error = validateSurfaceRef(ref);
+    return void 0 === error ? {
+        ok: true,
+        ref
+    } : {
+        ok: false,
+        error
+    };
+}
+function formatSurfaceRef(ref) {
+    const error = validateSurfaceRef(ref);
+    if (void 0 !== error) throw new TypeError(`Cannot format invalid SurfaceRef: ${error.code}.`);
+    const base = `${ref.unitId}#${ref.surfaceId}`;
+    return void 0 === ref.major ? base : `${base}@v${ref.major}`;
+}
+function validateSurfaceRef(ref) {
+    if ('' === ref.unitId) return {
+        code: 'empty-unit-id'
+    };
+    for (const segment of ref.unitId.split('/'))if (!SEGMENT_PATTERN.test(segment)) return {
+        code: 'invalid-unit-id',
+        segment
+    };
+    if ('' === ref.surfaceId) return {
+        code: 'empty-surface-id'
+    };
+    if (!SEGMENT_PATTERN.test(ref.surfaceId)) return {
+        code: 'invalid-surface-id'
+    };
+    if (void 0 !== ref.major && (!Number.isSafeInteger(ref.major) || ref.major < 1)) return {
+        code: 'invalid-major',
+        value: String(ref.major)
+    };
+}
+function countChar(input, char) {
+    let count = 0;
+    for (const current of input)if (current === char) count += 1;
+    return count;
+}
+function resolvePublicationZone(zone) {
+    return zone ?? {
+        zone: 'coordinated'
+    };
+}
+const KNOWN_DESCRIPTOR_KEYS = new Set([
+    'unitId',
+    'kind',
+    'owner',
+    'sourceRevision',
+    'buildMarker',
+    'baselineCohort',
+    'publicationZone',
+    'surfaces'
+]);
+const KNOWN_SURFACE_KEYS = new Set([
+    'kind',
+    'surfaceId',
+    'locations',
+    'protocol',
+    'externallyPublished'
+]);
+function splitUnknown(source, known) {
+    const unknown = {};
+    let hasUnknown = false;
+    for (const [key, value] of Object.entries(source))if (!known.has(key)) {
+        unknown[key] = value;
+        hasUnknown = true;
+    }
+    return hasUnknown ? unknown : void 0;
+}
+function parseDeliveryUnitDescriptor(source) {
+    const rawSurfaces = Array.isArray(source.surfaces) ? source.surfaces : [];
+    const surfaces = rawSurfaces.map((entry)=>{
+        const surface = entry;
+        const unknown = splitUnknown(entry, KNOWN_SURFACE_KEYS);
+        return void 0 === unknown ? surface : {
+            ...surface,
+            unknownFields: unknown
+        };
+    });
+    const descriptor = {
+        unitId: source.unitId,
+        kind: source.kind,
+        owner: source.owner,
+        sourceRevision: source.sourceRevision,
+        buildMarker: source.buildMarker,
+        baselineCohort: source.baselineCohort,
+        surfaces
+    };
+    if (void 0 !== source.publicationZone) descriptor.publicationZone = source.publicationZone;
+    const unknown = splitUnknown(source, KNOWN_DESCRIPTOR_KEYS);
+    if (void 0 !== unknown) descriptor.unknownFields = unknown;
+    return descriptor;
+}
+function serializeDeliveryUnitDescriptor(descriptor) {
+    const surfaces = descriptor.surfaces.map((surface)=>{
+        const { unknownFields, ...known } = surface;
+        return {
+            ...unknownFields ?? {},
+            ...known
+        };
+    });
+    const { unknownFields, surfaces: _surfaces, ...knownRest } = descriptor;
+    const output = {
+        ...unknownFields ?? {},
+        ...knownRest,
+        surfaces
+    };
+    return output;
+}
+function projectKind(kind) {
+    switch(kind){
+        case 'shell':
+            return 'shell';
+        case 'microvertical':
+        case 'horizontal-remote':
+            return 'vertical';
+        default:
+            return assertNever(kind);
+    }
+}
+function lastSegment(unitId) {
+    const segments = unitId.split('/');
+    return segments[segments.length - 1] ?? unitId;
+}
+function projectApi(surfaces, mode) {
+    const apiSurface = surfaces.find((surface)=>'api' === surface.kind);
+    if (void 0 === apiSurface) return;
+    const http = apiSurface.locations.find((location)=>'http' === location.platform);
+    return {
+        stem: apiSurface.surfaceId,
+        prefix: http?.address ?? `/${apiSurface.surfaceId}`,
+        consumedBy: [],
+        ...'extended-v1' === mode && isVerticalApiProtocol(apiSurface.protocol) ? {
+            protocol: apiSurface.protocol
+        } : {}
+    };
+}
+function projectDeliveryUnitToV1(descriptor, context) {
+    const appId = lastSegment(descriptor.unitId);
+    const mode = context.mode ?? 'strict-legacy';
+    const api = projectApi(descriptor.surfaces, mode);
+    const ownership = 'team' === descriptor.owner.kind ? context.ownership : {
+        ...context.ownership,
+        owner: {
+            ...descriptor.owner
+        }
+    };
+    const app = {
+        id: appId,
+        directory: context.directory,
+        packageSuffix: context.packageSuffix,
+        displayName: context.displayName,
+        kind: projectKind(descriptor.kind),
+        portEnv: context.portEnv,
+        port: context.port,
+        mfName: context.mfName,
+        ownership,
+        ...'extended-v1' === mode && 'horizontal-remote' === descriptor.kind ? {
+            deliveryUnitKind: 'horizontal-remote'
+        } : {},
+        ...void 0 === api ? {} : {
+            api
+        }
+    };
+    const deliveryUnitRecord = {
+        appId,
+        buildMarker: descriptor.buildMarker,
+        deployProfile: DELIVERY_UNIT_DEPLOY_PROFILE,
+        kind: DELIVERY_UNIT_KIND,
+        packageName: context.packageName,
+        schemaVersion: DELIVERY_UNIT_SCHEMA_VERSION,
+        sourceRevision: descriptor.sourceRevision,
+        unitId: descriptor.unitId,
+        version: context.version
+    };
+    return {
+        app,
+        deliveryUnitRecord,
+        preservedUnknownFields: descriptor.unknownFields ?? {}
+    };
+}
+function assertNever(value) {
+    throw new Error(`Unexpected variant: ${JSON.stringify(value)}`);
+}
+export { assertNever, formatSurfaceRef, parseDeliveryUnitDescriptor, parseSurfaceRef, projectDeliveryUnitToV1, resolvePublicationZone, serializeDeliveryUnitDescriptor };

package/dist/esm/ultramodern-workspace/delivery-unit-schema/up-projection.js

@@ -0,0 +1,129 @@
+function ownershipToOwner(ownership) {
+    if (void 0 !== ownership.owner) {
+        const { kind, id, contact } = ownership.owner;
+        return void 0 === contact ? {
+            kind,
+            id
+        } : {
+            kind,
+            id,
+            contact
+        };
+    }
+    return {
+        kind: 'team',
+        id: ownership.team,
+        contact: ownership.slack
+    };
+}
+function projectKindUp(app, mode) {
+    if ('shell' === app.kind) return 'shell';
+    return 'extended-v1' === mode && 'horizontal-remote' === app.deliveryUnitKind ? 'horizontal-remote' : 'microvertical';
+}
+const SEGMENT_UNSAFE = /[^A-Za-z0-9._-]+/g;
+const SEGMENT_TRIM = /^-+|-+$/g;
+function exposeSurfaceId(key) {
+    const trimmed = key.replace(/^\.\//, '');
+    const cleaned = trimmed.replace(SEGMENT_UNSAFE, '-').replace(SEGMENT_TRIM, '');
+    return '' === cleaned ? 'surface' : cleaned;
+}
+function exposeSurface(app, key, value) {
+    const isRoute = /route/i.test(key) || /route/i.test(value);
+    const location = {
+        platform: 'browser-mf',
+        manifestUrl: `http://localhost:${app.port}/mf-manifest.json`
+    };
+    const common = {
+        surfaceId: exposeSurfaceId(key),
+        locations: [
+            location
+        ]
+    };
+    return isRoute ? {
+        kind: 'route',
+        ...common
+    } : {
+        kind: 'component',
+        ...common
+    };
+}
+function apiSurface(api, protocol, address = api.prefix) {
+    return {
+        kind: 'api',
+        surfaceId: api.stem,
+        protocol,
+        locations: [
+            {
+                platform: 'http',
+                address
+            }
+        ]
+    };
+}
+function projectSurfaces(app, protocol) {
+    const surfaces = [];
+    for (const [key, value] of Object.entries(app.exposes ?? {}))surfaces.push(exposeSurface(app, key, value));
+    if (void 0 !== app.api) surfaces.push(apiSurface(app.api, protocol));
+    return surfaces;
+}
+function projectV1ToDeliveryUnit(app, context) {
+    const mode = context.mode ?? 'strict-legacy';
+    const protocol = context.apiProtocol ?? ('extended-v1' === mode ? app.api?.protocol : void 0) ?? 'rest';
+    return {
+        unitId: `${context.scope}/${app.domain ?? app.id}`,
+        kind: projectKindUp(app, mode),
+        owner: ownershipToOwner(app.ownership),
+        sourceRevision: context.sourceRevision,
+        buildMarker: context.buildMarker,
+        baselineCohort: context.baselineCohort,
+        publicationZone: {
+            zone: 'coordinated'
+        },
+        surfaces: projectSurfaces(app, protocol)
+    };
+}
+class V1UnrepresentableError extends Error {
+    constructor(reason){
+        super(`Descriptor unrepresentable in v1: ${reason}.`), this.code = 'unrepresentable-in-v1';
+        this.name = 'V1UnrepresentableError';
+        this.reason = reason;
+    }
+}
+function checkSurfaceRepresentable(surface, mode) {
+    if ('component' === surface.kind || 'route' === surface.kind) return 'component-or-route-surface';
+    if ('backend' === surface.kind) return 'backend-surface';
+    if ('rest' !== surface.protocol && !('extended-v1' === mode && 'rpc' === surface.protocol)) return 'non-rest-protocol';
+    const [first, ...rest] = surface.locations;
+    if (void 0 === first || rest.length > 0 || 'http' !== first.platform) return 'unsupported-surface-shape';
+    if (void 0 !== surface.externallyPublished || void 0 !== surface.unknownFields) return 'unsupported-surface-shape';
+}
+function checkV1Representable(descriptor, mode = 'strict-legacy') {
+    const unrepresentable = (reason)=>({
+            representable: false,
+            code: 'unrepresentable-in-v1',
+            reason
+        });
+    if ('strict-legacy' === mode && 'horizontal-remote' === descriptor.kind) return unrepresentable('horizontal-remote-kind');
+    if (void 0 !== descriptor.unknownFields) return unrepresentable('unknown-fields');
+    const zone = descriptor.publicationZone;
+    if (void 0 === zone) return unrepresentable('non-canonical-zone');
+    if ('external' === zone.zone) return unrepresentable('external-zone');
+    if ('coordinated' !== zone.zone || 1 !== Object.keys(zone).length) return unrepresentable('non-canonical-zone');
+    let apiSurfaceCount = 0;
+    for (const surface of descriptor.surfaces){
+        if ('api' === surface.kind) {
+            apiSurfaceCount += 1;
+            if (apiSurfaceCount > 1) return unrepresentable('multiple-api-surfaces');
+        }
+        const reason = checkSurfaceRepresentable(surface, mode);
+        if (void 0 !== reason) return unrepresentable(reason);
+    }
+    return {
+        representable: true
+    };
+}
+function assertV1Representable(descriptor, mode = 'strict-legacy') {
+    const result = checkV1Representable(descriptor, mode);
+    if (!result.representable) throw new V1UnrepresentableError(result.reason);
+}
+export { V1UnrepresentableError, apiSurface, assertV1Representable, checkV1Representable, exposeSurface, exposeSurfaceId, ownershipToOwner, projectV1ToDeliveryUnit };

package/dist/esm/ultramodern-workspace/delivery-unit-stamp.js

@@ -0,0 +1,18 @@
+import { createBackendFederationContract } from "./backend-federation.js";
+import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "./delivery-unit.js";
+function isPlainObject(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function stampDeliveryUnitIdentity(entry, scope, app) {
+    const block = deliveryUnitContractBlock(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';
+        return;
+    }
+    const contract = createBackendFederationContract(scope, app);
+    if (void 0 !== contract) entry.backendFederation = contract;
+}
+export { isPlainObject, stampDeliveryUnitIdentity };

package/dist/esm/ultramodern-workspace/delivery-unit-sync.js

@@ -0,0 +1,101 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { parseArgs } from "node:util";
+import { readUltramodernConfig, workspaceAppsFromToolingConfig } from "../ultramodern-tooling/config.js";
+import { isPlainObject, stampDeliveryUnitIdentity } from "./delivery-unit-stamp.js";
+import { ULTRAMODERN_CONFIG_PATH } from "./descriptors.js";
+import { createUltramodernBuildArtifactJson, createUltramodernBuildModule } from "./module-federation.js";
+const REFERENCE_TOPOLOGY_PATH = 'topology/reference-topology.json';
+function writeTextIfChanged(absolutePath, content) {
+    if (node_fs.existsSync(absolutePath) && node_fs.readFileSync(absolutePath, 'utf-8') === content) return false;
+    node_fs.mkdirSync(node_path.dirname(absolutePath), {
+        recursive: true
+    });
+    node_fs.writeFileSync(absolutePath, content, 'utf-8');
+    return true;
+}
+function writeJsonIfChanged(absolutePath, value) {
+    return writeTextIfChanged(absolutePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function runSyncDeliveryUnit(args, context) {
+    const parsed = parseArgs({
+        args,
+        options: {
+            help: {
+                type: 'boolean',
+                short: 'h'
+            },
+            workspace: {
+                type: 'string'
+            }
+        },
+        strict: true,
+        allowPositionals: false
+    });
+    if (parsed.values.help) {
+        process.stdout.write(`Usage:
+  ultramodern-create ultramodern sync-delivery-unit [--workspace <dir>]
+
+Backfills the per-delivery-unit identity blocks required by
+\`ultramodern validate\` onto an existing generated workspace, in place and
+through framework tooling only. For each delivery unit 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
+<app>/shared/ultramodern-build.{json,ts}. Idempotent: a second run writes
+nothing.
+`);
+        return 0;
+    }
+    const workspaceOverride = parsed.values.workspace;
+    const workspaceRoot = workspaceOverride ? node_path.resolve(context.invocationCwd, workspaceOverride) : context.workspaceRoot;
+    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
+    if (!node_fs.existsSync(compactPath)) throw new Error(`Missing ${ULTRAMODERN_CONFIG_PATH}. sync-delivery-unit needs the compact UltraModern config; run \`ultramodern-create ultramodern migrate-strict-effect\` first.`);
+    const config = readUltramodernConfig(workspaceRoot);
+    const scope = config.workspace.packageScope;
+    const workspaceApps = workspaceAppsFromToolingConfig(config);
+    const written = [];
+    const unchanged = [];
+    const track = (relativePath, changed)=>{
+        (changed ? written : unchanged).push(relativePath);
+    };
+    const appById = new Map(workspaceApps.map((app)=>[
+            app.id,
+            app
+        ]));
+    const compact = JSON.parse(node_fs.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(ULTRAMODERN_CONFIG_PATH, writeJsonIfChanged(compactPath, compact));
+    const topologyPath = node_path.join(workspaceRoot, REFERENCE_TOPOLOGY_PATH);
+    if (node_fs.existsSync(topologyPath)) {
+        const topology = JSON.parse(node_fs.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);
+        }
+        if (isPlainObject(topology) && isPlainObject(topology.shell)) {
+            const shell = appById.get(String(topology.shell.id));
+            if (shell) stampDeliveryUnitIdentity(topology.shell, scope, shell);
+        }
+        track(REFERENCE_TOPOLOGY_PATH, writeJsonIfChanged(topologyPath, topology));
+    }
+    for (const app of workspaceApps){
+        const buildModulePath = node_path.join(app.directory, 'shared/ultramodern-build.ts');
+        const buildArtifactPath = node_path.join(app.directory, 'shared/ultramodern-build.json');
+        track(buildModulePath, writeTextIfChanged(node_path.join(workspaceRoot, buildModulePath), createUltramodernBuildModule(scope, app)));
+        track(buildArtifactPath, writeTextIfChanged(node_path.join(workspaceRoot, buildArtifactPath), createUltramodernBuildArtifactJson(scope, app)));
+    }
+    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;
+}
+export { runSyncDeliveryUnit };

package/dist/esm/ultramodern-workspace/delivery-unit.js

@@ -0,0 +1,21 @@
+import node_crypto from "node:crypto";
+import { DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION, deliveryUnitContractBlock } from "@modern-js/utils/universal";
+import { packageName } from "./naming.js";
+const deliveryUnitGenerationSeed = 'ultramodern-delivery-unit-build-marker:v1';
+function createBuildMarker(scope, app) {
+    return node_crypto.createHash('sha256').update(`${deliveryUnitGenerationSeed}:${scope}:${app.packageSuffix}:${app.id}:0.1.0`).digest('hex').slice(0, 16);
+}
+function createDeliveryUnitRecord(scope, app) {
+    return {
+        appId: app.id,
+        buildMarker: createBuildMarker(scope, app),
+        deployProfile: DELIVERY_UNIT_DEPLOY_PROFILE,
+        kind: DELIVERY_UNIT_KIND,
+        packageName: packageName(scope, app.packageSuffix),
+        schemaVersion: DELIVERY_UNIT_SCHEMA_VERSION,
+        sourceRevision: 'workspace',
+        unitId: `${scope}/${app.domain ?? app.id}`,
+        version: '0.1.0'
+    };
+}
+export { createBuildMarker, createDeliveryUnitRecord, deliveryUnitContractBlock };