@bleedingdev/modern-js-create 3.5.0-ultramodern.9 → 3.5.0-ultramodern.90

package/dist/esm-node/ultramodern-workspace/add-vertical/topology.js

@@ -0,0 +1,109 @@
+import "node:module";
+import { apiTopologyMetadata } from "../api.js";
+import { createBackendFederationContract } from "../backend-federation.js";
+import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "../delivery-unit.js";
+import { createModuleFederationRemoteContracts, createNeutralOwnership, shellApp } from "../descriptors.js";
+import { packageName, toEnvSegment, toPascalCase } from "../naming.js";
+import { createCloudflareDeployContract } from "../policy.js";
+import { isVerticalApiProtocol, isVerticalPreset, isWorkspaceDeliveryUnitKind } from "../types.js";
+function verticalTopologyEntry(scope, vertical, remotes = []) {
+    const backendFederation = createBackendFederationContract(scope, vertical);
+    return {
+        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: createModuleFederationRemoteContracts(vertical, remotes)
+            } : {},
+            ssr: true,
+            sharedContractVersion: 'mf-ssr-contract-v1'
+        },
+        ...backendFederation ? {
+            backendFederation
+        } : {},
+        deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, vertical)),
+        ...apiTopologyMetadata(vertical) ? {
+            api: apiTopologyMetadata(vertical)
+        } : {},
+        cloudflare: createCloudflareDeployContract(scope, vertical),
+        ownership: vertical.ownership
+    };
+}
+function ownershipEntry(scope, owner) {
+    return {
+        id: owner.id,
+        package: packageName(scope, owner.packageSuffix),
+        path: owner.directory,
+        ownership: owner.ownership
+    };
+}
+function verticalsFromTopology(topology, ports) {
+    return (topology.verticals ?? []).map((vertical)=>{
+        const domain = vertical.domain ?? String(vertical.id);
+        const packageSuffix = vertical.package?.split('/').at(-1) ?? domain;
+        const apiTopology = vertical.api;
+        const apiProtocol = isVerticalApiProtocol(apiTopology?.protocol) ? apiTopology.protocol : void 0;
+        const surfaceProfile = isVerticalPreset(vertical.surfaceProfile) ? vertical.surfaceProfile : void 0;
+        const deliveryUnitKind = isWorkspaceDeliveryUnitKind(vertical.deliveryUnitKind) ? vertical.deliveryUnitKind : void 0;
+        const api = apiTopology?.runtime === 'effect' ? {
+            stem: 'string' == typeof apiTopology.stem ? apiTopology.stem : 'string' == typeof apiTopology.basePath ? apiTopology.basePath.split('/').filter(Boolean).at(-1) ?? domain : domain,
+            prefix: apiTopology.bff?.prefix ?? `/${domain}-api`,
+            consumedBy: Array.isArray(apiTopology.consumedBy) ? apiTopology.consumedBy : [
+                shellApp.id,
+                vertical.id
+            ],
+            ...void 0 === apiProtocol ? {} : {
+                protocol: apiProtocol
+            }
+        } : void 0;
+        return {
+            id: vertical.id,
+            directory: 'string' == typeof vertical.path ? vertical.path : `verticals/${domain}`,
+            packageSuffix,
+            displayName: vertical.displayName ?? `${toPascalCase(domain)} Vertical`,
+            kind: 'vertical',
+            domain,
+            portEnv: `VERTICAL_${toEnvSegment(domain)}_PORT`,
+            port: 'number' == typeof ports[vertical.id] ? ports[vertical.id] : 0,
+            mfName: vertical.moduleFederation?.name ?? `vertical${toPascalCase(domain)}`,
+            ...void 0 === surfaceProfile ? {} : {
+                surfaceProfile
+            },
+            ...void 0 === deliveryUnitKind ? {} : {
+                deliveryUnitKind
+            },
+            ...Array.isArray(vertical.moduleFederation?.exposes) ? {
+                exposes: Object.fromEntries(vertical.moduleFederation.exposes.map((expose)=>[
+                        expose,
+                        './Route' === expose ? './src/federation-entry.tsx' : './Widget' === expose ? `./src/components/${domain}-widget.tsx` : ''
+                    ]))
+            } : {},
+            ...Array.isArray(vertical.moduleFederation?.verticalRefs) ? {
+                verticalRefs: vertical.moduleFederation.verticalRefs
+            } : Array.isArray(vertical.moduleFederation?.remotes) ? {
+                verticalRefs: vertical.moduleFederation.remotes.map((entry)=>entry.id).filter((id)=>'string' == typeof id)
+            } : {},
+            ...api ? {
+                api
+            } : {},
+            ownership: vertical.ownership ?? createNeutralOwnership(vertical.id)
+        };
+    });
+}
+export { ownershipEntry, verticalTopologyEntry, verticalsFromTopology };

package/dist/esm-node/ultramodern-workspace/add-vertical/transaction.js

@@ -0,0 +1,255 @@
+import "node:module";
+import { randomUUID } from "node:crypto";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { ignoredSnapshotDirectories } from "../generation-result.js";
+import { normalizePath } from "../naming.js";
+function walkWorkspaceFiles(root, onFile) {
+    if (!node_fs.existsSync(root)) return;
+    const collect = (currentDir)=>{
+        for (const entry of node_fs.readdirSync(currentDir, {
+            withFileTypes: true
+        })){
+            if (entry.isDirectory() && ignoredSnapshotDirectories.has(entry.name)) continue;
+            const entryPath = node_path.join(currentDir, entry.name);
+            if (entry.isDirectory()) collect(entryPath);
+            else if (entry.isFile()) onFile(normalizePath(node_path.relative(root, entryPath)), entryPath);
+        }
+    };
+    collect(root);
+}
+function captureWorkspaceBackup(root) {
+    const files = new Map();
+    walkWorkspaceFiles(root, (relativePath, absolutePath)=>{
+        let content;
+        try {
+            content = node_fs.readFileSync(absolutePath);
+        } catch (error) {
+            if ('ENOENT' === error.code) return;
+            throw error;
+        }
+        files.set(relativePath, content);
+    });
+    return {
+        root,
+        files
+    };
+}
+function listCurrentFiles(root) {
+    const current = [];
+    walkWorkspaceFiles(root, (relativePath)=>{
+        current.push(relativePath);
+    });
+    return current;
+}
+function pruneEmptyDirectories(root, relativeFilePath) {
+    let directory = node_path.dirname(node_path.join(root, relativeFilePath));
+    const stopAt = node_path.resolve(root);
+    while(node_path.resolve(directory) !== stopAt){
+        let entries;
+        try {
+            entries = node_fs.readdirSync(directory);
+        } catch  {
+            return;
+        }
+        if (entries.length > 0) return;
+        node_fs.rmdirSync(directory);
+        directory = node_path.dirname(directory);
+    }
+}
+function restoreWorkspaceBackup(backup) {
+    for (const relativePath of listCurrentFiles(backup.root))if (!backup.files.has(relativePath)) {
+        node_fs.rmSync(node_path.join(backup.root, relativePath), {
+            force: true
+        });
+        pruneEmptyDirectories(backup.root, relativePath);
+    }
+    for (const [relativePath, content] of backup.files){
+        const absolutePath = node_path.join(backup.root, relativePath);
+        if (!(node_fs.existsSync(absolutePath) && node_fs.readFileSync(absolutePath).equals(content))) {
+            node_fs.mkdirSync(node_path.dirname(absolutePath), {
+                recursive: true
+            });
+            node_fs.writeFileSync(absolutePath, content);
+        }
+    }
+}
+const ULTRAMODERN_LOCK_DIRECTORY = '.modernjs';
+const ULTRAMODERN_LOCK_FILE = '.ultramodern-mutation.lock';
+const DEFAULT_STALE_LOCK_MS = 30000;
+class WorkspaceLockedError extends Error {
+    constructor(message){
+        super(message), this.code = 'workspace-locked';
+        this.name = 'WorkspaceLockedError';
+    }
+}
+class WorkspaceLockIntegrityError extends Error {
+    constructor(message, options){
+        super(message), this.code = 'workspace-lock-integrity';
+        this.name = 'WorkspaceLockIntegrityError';
+        if (options?.cause !== void 0) this.cause = options.cause;
+    }
+}
+function lockFilePath(root) {
+    return node_path.join(root, ULTRAMODERN_LOCK_DIRECTORY, ULTRAMODERN_LOCK_FILE);
+}
+function parseLock(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (null === parsed || 'object' != typeof parsed) return;
+        const record = parsed;
+        if ('string' != typeof record.token || 'number' != typeof record.pid || !Number.isFinite(record.pid) || 'number' != typeof record.createdAt || !Number.isFinite(record.createdAt)) return;
+        return {
+            token: record.token,
+            pid: record.pid,
+            createdAt: record.createdAt
+        };
+    } catch  {
+        return;
+    }
+}
+function readLockObservation(lockPath) {
+    try {
+        const raw = node_fs.readFileSync(lockPath, 'utf-8');
+        return {
+            raw,
+            record: parseLock(raw)
+        };
+    } catch  {
+        return;
+    }
+}
+function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch (error) {
+        const code = error.code;
+        if ('ESRCH' === code) return false;
+        if ('EPERM' === code) return true;
+        return;
+    }
+}
+function writeLock(lockPath, record) {
+    try {
+        node_fs.writeFileSync(lockPath, JSON.stringify(record), {
+            flag: 'wx'
+        });
+        return true;
+    } catch (error) {
+        if ('EEXIST' === error.code) return false;
+        throw error;
+    }
+}
+function unlinkIfPresent(filePath) {
+    try {
+        node_fs.unlinkSync(filePath);
+    } catch (error) {
+        if ('ENOENT' !== error.code) throw error;
+    }
+}
+function restoreMovedLock(movedLockPath, lockPath) {
+    try {
+        node_fs.linkSync(movedLockPath, lockPath);
+    } catch (error) {
+        const code = error.code;
+        if ('EPERM' === code || 'EOPNOTSUPP' === code || 'ENOTSUP' === code) {
+            try {
+                node_fs.copyFileSync(movedLockPath, lockPath, node_fs.constants.COPYFILE_EXCL);
+            } catch (copyError) {
+                throw new WorkspaceLockIntegrityError(`Failed to restore moved workspace lock ${movedLockPath} -> ${lockPath}; moved lock bytes left in place for recovery.`, {
+                    cause: copyError
+                });
+            }
+            unlinkIfPresent(movedLockPath);
+            return;
+        }
+        throw new WorkspaceLockIntegrityError(`Failed to restore moved workspace lock ${movedLockPath} -> ${lockPath}; moved lock bytes left in place for recovery.`, {
+            cause: error
+        });
+    }
+    unlinkIfPresent(movedLockPath);
+}
+function workspaceLockedError(root) {
+    return new WorkspaceLockedError(`Workspace at ${root} is locked by another ultramodern mutation.`);
+}
+function isStaleLock(observation, staleLockMs) {
+    if (void 0 === observation.record) return true;
+    const age = Date.now() - observation.record.createdAt;
+    return age > staleLockMs || false === isProcessAlive(observation.record.pid);
+}
+function takeOverLock(lockPath, observed, replacement) {
+    const takeoverPath = `${lockPath}.takeover.${replacement.token}`;
+    try {
+        node_fs.renameSync(lockPath, takeoverPath);
+    } catch (error) {
+        if ('ENOENT' === error.code) return false;
+        throw error;
+    }
+    const claimed = readLockObservation(takeoverPath);
+    if (void 0 === claimed || '' === claimed.raw || claimed.raw !== observed.raw) {
+        restoreMovedLock(takeoverPath, lockPath);
+        return false;
+    }
+    try {
+        return writeLock(lockPath, replacement);
+    } finally{
+        unlinkIfPresent(takeoverPath);
+    }
+}
+function acquireWorkspaceLock(root, staleLockMs) {
+    const lockPath = lockFilePath(root);
+    node_fs.mkdirSync(node_path.dirname(lockPath), {
+        recursive: true
+    });
+    const record = {
+        token: randomUUID(),
+        pid: process.pid,
+        createdAt: Date.now()
+    };
+    if (writeLock(lockPath, record)) return {
+        lockPath,
+        token: record.token
+    };
+    const observed = readLockObservation(lockPath);
+    if (void 0 === observed) throw workspaceLockedError(root);
+    const age = void 0 === observed.record ? void 0 : Date.now() - observed.record.createdAt;
+    if (!isStaleLock(observed, staleLockMs)) throw workspaceLockedError(root);
+    process.emitWarning(`Taking over stale ultramodern workspace lock at ${lockPath} (age ${age ?? 'unknown'}ms).`);
+    if (takeOverLock(lockPath, observed, record)) return {
+        lockPath,
+        token: record.token
+    };
+    throw workspaceLockedError(root);
+}
+const __releaseTestHooks = {};
+function releaseWorkspaceLock(handle) {
+    const inPlace = readLockObservation(handle.lockPath);
+    if (inPlace?.record?.token !== handle.token) return;
+    __releaseTestHooks.afterOwnershipRead?.(handle);
+    const releasePath = `${handle.lockPath}.release.${handle.token}`;
+    try {
+        node_fs.renameSync(handle.lockPath, releasePath);
+    } catch (error) {
+        if ('ENOENT' === error.code) return;
+        throw error;
+    }
+    const moved = readLockObservation(releasePath);
+    if (moved?.record?.token === handle.token) return void unlinkIfPresent(releasePath);
+    __releaseTestHooks.beforeRestore?.(handle);
+    restoreMovedLock(releasePath, handle.lockPath);
+}
+function runWorkspaceTransaction(root, mutate, options) {
+    const lock = acquireWorkspaceLock(root, options?.staleLockMs ?? DEFAULT_STALE_LOCK_MS);
+    const backup = captureWorkspaceBackup(root);
+    try {
+        return mutate();
+    } catch (error) {
+        restoreWorkspaceBackup(backup);
+        throw error;
+    } finally{
+        releaseWorkspaceLock(lock);
+    }
+}
+export { DEFAULT_STALE_LOCK_MS, ULTRAMODERN_LOCK_DIRECTORY, ULTRAMODERN_LOCK_FILE, WorkspaceLockIntegrityError, WorkspaceLockedError, __releaseTestHooks, captureWorkspaceBackup, restoreWorkspaceBackup, runWorkspaceTransaction };

package/dist/esm-node/ultramodern-workspace/add-vertical/workspace-state.js

@@ -0,0 +1,68 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { readUltramodernConfig } from "../../ultramodern-tooling/config.js";
+import { ULTRAMODERN_CONFIG_PATH } from "../descriptors.js";
+import { toKebabCase } from "../naming.js";
+import { resolvePackageSource } from "../package-source.js";
+import { FIRST_VERTICAL_PORT } from "./constants.js";
+function existingPackageSource(workspaceRoot, modernVersion, packageSource) {
+    if (packageSource) return resolvePackageSource({
+        targetDir: workspaceRoot,
+        packageName: node_path.basename(workspaceRoot),
+        modernVersion,
+        packageSource
+    });
+    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
+    if (node_fs.existsSync(compactPath)) {
+        const compactConfig = readUltramodernConfig(workspaceRoot);
+        if (compactConfig.packageSource) return compactConfig.packageSource;
+    }
+    throw new Error(`Missing UltraModern workspace file: ${compactPath}`);
+}
+function existingTailwindEnabled(workspaceRoot) {
+    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
+    if (node_fs.existsSync(compactPath)) return readUltramodernConfig(workspaceRoot).features.tailwind;
+    throw new Error(`Missing UltraModern workspace file: ${compactPath}`);
+}
+function existingBridgeConfig(workspaceRoot) {
+    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
+    return node_fs.existsSync(compactPath) ? readUltramodernConfig(workspaceRoot).bridge : void 0;
+}
+function assertValidVerticalName(name) {
+    const normalized = toKebabCase(name);
+    if (!normalized || normalized !== name) throw new Error(`Invalid Vertical name "${name}". Use lowercase kebab-case.`);
+    return normalized;
+}
+function configuredDevelopmentPorts(ports, additionalShells = []) {
+    return [
+        ...new Set([
+            ...Object.values(ports),
+            ...additionalShells.map((shell)=>shell.port)
+        ].filter((value)=>'number' == typeof value && Number.isFinite(value)))
+    ];
+}
+function assertGlobalPortUniqueness(ports, additionalShells = []) {
+    const owners = new Map();
+    for (const [id, value] of Object.entries(ports)){
+        if ('number' != typeof value || !Number.isFinite(value)) continue;
+        const previous = owners.get(value);
+        if (previous) throw new Error(`Duplicate development port "${value}" for ${previous} and ${id}.`);
+        owners.set(value, id);
+    }
+    for (const shell of additionalShells){
+        const previous = owners.get(shell.port);
+        if (previous) throw new Error(`Duplicate development port "${shell.port}" for ${previous} and ${shell.id}.`);
+        owners.set(shell.port, shell.id);
+    }
+}
+function nextAvailablePort(ports, additionalShells = [], minimumPort = FIRST_VERTICAL_PORT) {
+    const used = new Set(configuredDevelopmentPorts(ports, additionalShells));
+    let candidate = minimumPort;
+    while(used.has(candidate))candidate += 1;
+    return candidate;
+}
+function assertCanCreate(workspaceRoot, relativePath) {
+    if (node_fs.existsSync(node_path.join(workspaceRoot, relativePath))) throw new Error(`Refusing to overwrite existing path: ${relativePath}`);
+}
+export { assertCanCreate, assertGlobalPortUniqueness, assertValidVerticalName, configuredDevelopmentPorts, existingBridgeConfig, existingPackageSource, existingTailwindEnabled, nextAvailablePort };