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

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 };

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

@@ -0,0 +1,7 @@
+import "node:module";
+export { addUltramodernVertical } from "./add-vertical/execute.js";
+export { planUltramodernVertical } from "./add-vertical/plan.js";
+export { prepareAddUltramodernVertical } from "./add-vertical/preflight.js";
+export { rewriteShellAppFiles, updateRootWorkspaceScripts } from "./add-vertical/shell-files.js";
+export { ownershipEntry, verticalTopologyEntry, verticalsFromTopology } from "./add-vertical/topology.js";
+export { assertCanCreate, assertValidVerticalName, existingBridgeConfig, existingPackageSource, existingTailwindEnabled, nextAvailablePort } from "./add-vertical/workspace-state.js";

package/dist/esm-node/ultramodern-workspace/api/checkout-cart.js

@@ -0,0 +1,87 @@
+import "node:module";
+import { resolveApiPrefix, resolveApiStem } from "../descriptors.js";
+import { renderFileTemplate } from "../fs-io.js";
+import { toPascalCase } from "../naming.js";
+import { verticalApiGroupName, verticalApiName } from "./names.js";
+function serviceHasCheckoutCartState(service) {
+    return 'checkout' === resolveApiStem(service);
+}
+function createCheckoutCartSharedSchemas(service) {
+    if (!serviceHasCheckoutCartState(service)) return '';
+    return renderFileTemplate('workspace/verticals/shared/api.checkout-cart-schemas.ts', {});
+}
+function createCheckoutCartEndpointDefinitions(service) {
+    if (!serviceHasCheckoutCartState(service)) return '';
+    return renderFileTemplate('workspace/verticals/shared/api.checkout-cart-endpoints.ts', {});
+}
+function createCheckoutCartOperationContexts(service) {
+    const apiName = verticalApiName(service);
+    const groupName = verticalApiGroupName(service);
+    if (!serviceHasCheckoutCartState(service)) return '';
+    return renderFileTemplate('workspace/verticals/shared/api.checkout-cart-operation-contexts.ts', {
+        value0: apiName,
+        value1: groupName,
+        value2: apiName,
+        value3: groupName,
+        value4: apiName,
+        value5: groupName,
+        value6: apiName,
+        value7: groupName
+    });
+}
+function createCheckoutCartApiContractFields(service) {
+    if (!serviceHasCheckoutCartState(service)) return '';
+    return renderFileTemplate('workspace/verticals/shared/api.checkout-cart-contract-fields.ts', {
+        value0: resolveApiPrefix(service)
+    });
+}
+function createCheckoutCartServerState(service) {
+    if (!serviceHasCheckoutCartState(service)) return '';
+    return renderFileTemplate('workspace/verticals/server/checkout-cart-state.ts', {});
+}
+function createCheckoutCartServerHandlers(service) {
+    const groupName = verticalApiGroupName(service);
+    if (!serviceHasCheckoutCartState(service)) return '';
+    return renderFileTemplate('workspace/verticals/server/checkout-cart-handlers.ts', {
+        value0: groupName,
+        value1: groupName,
+        value2: groupName,
+        value3: groupName,
+        value4: groupName,
+        value5: groupName,
+        value6: groupName,
+        value7: groupName
+    });
+}
+function createCheckoutCartClientExports(service) {
+    if (!serviceHasCheckoutCartState(service)) return '';
+    const stem = resolveApiStem(service);
+    const groupName = verticalApiGroupName(service);
+    const pascalStem = toPascalCase(stem);
+    const clientOptionsName = `${pascalStem}ClientOptions`;
+    const createClientName = `create${pascalStem}Client`;
+    const clientEffectTypeName = `${pascalStem}ClientEffect`;
+    return renderFileTemplate('workspace/verticals/src/api/checkout-cart-client-exports.ts', {
+        value0: clientOptionsName,
+        value1: clientEffectTypeName,
+        value2: createClientName,
+        value3: groupName,
+        value4: groupName,
+        value5: clientOptionsName,
+        value6: clientEffectTypeName,
+        value7: createClientName,
+        value8: groupName,
+        value9: groupName,
+        value10: clientOptionsName,
+        value11: clientEffectTypeName,
+        value12: createClientName,
+        value13: groupName,
+        value14: groupName,
+        value15: clientOptionsName,
+        value16: clientEffectTypeName,
+        value17: createClientName,
+        value18: groupName,
+        value19: groupName
+    });
+}
+export { createCheckoutCartApiContractFields, createCheckoutCartClientExports, createCheckoutCartEndpointDefinitions, createCheckoutCartOperationContexts, createCheckoutCartServerHandlers, createCheckoutCartServerState, createCheckoutCartSharedSchemas, serviceHasCheckoutCartState };

package/dist/esm-node/ultramodern-workspace/api/client.js

@@ -0,0 +1,184 @@
+import "node:module";
+import { resolveApiProtocol, resolveApiStem, verticalApiApps } from "../descriptors.js";
+import { packageName, toPascalCase } from "../naming.js";
+import { createCheckoutCartClientExports, serviceHasCheckoutCartState } from "./checkout-cart.js";
+import { verticalApiErrorStem, verticalApiExport, verticalApiGroupName, verticalApiNotFoundErrorExport } from "./names.js";
+function createApiClient(service, contractImportPath) {
+    const apiExport = verticalApiExport(service);
+    const contractExport = verticalApiGroupName(service);
+    const stem = resolveApiStem(service);
+    const groupName = verticalApiGroupName(service);
+    const singular = verticalApiErrorStem(service);
+    const clientOptionsName = `${toPascalCase(stem)}ClientOptions`;
+    const createClientName = `create${toPascalCase(stem)}Client`;
+    const clientTypeName = `${toPascalCase(stem)}Client`;
+    const clientEffectTypeName = `${toPascalCase(stem)}ClientEffect`;
+    const listName = `list${toPascalCase(stem)}`;
+    const readinessName = `get${toPascalCase(stem)}Readiness`;
+    const getName = `get${toPascalCase(singular)}`;
+    const createName = `create${toPascalCase(singular)}`;
+    const notFoundErrorExport = verticalApiNotFoundErrorExport(service);
+    const pascalStem = toPascalCase(stem);
+    const itemType = `${pascalStem}Item`;
+    const readinessType = `${pascalStem}Readiness`;
+    const createResponseType = `${pascalStem}CreateResponse`;
+    const listResponseType = `${pascalStem}ListResponse`;
+    const checkoutCartClientExports = createCheckoutCartClientExports(service);
+    return `import {
+  Effect,
+  makeEffectHttpApiClient,
+} from '@modern-js/plugin-bff/effect-client';
+import type {
+  HttpClientError,
+  HttpApi,
+  HttpApiClient,
+  HttpApiGroup,
+  Schema,
+} from '@modern-js/plugin-bff/effect-client';
+import {
+  ${contractExport}ApiContract,
+  ${apiExport},
+  ${groupName}OperationContexts,
+} from '${contractImportPath}';
+import type {
+  ${createResponseType},
+  ${itemType},
+  ${listResponseType},
+  ${notFoundErrorExport},
+  OperationContext,
+  ${readinessType},
+} from '${contractImportPath}';
+
+export { Effect, runEffectRequest } from '@modern-js/plugin-bff/effect-client';
+
+type ${pascalStem}ApiGroups = typeof ${apiExport} extends HttpApi.HttpApi<
+  infer _ApiId,
+  infer Groups
+>
+  ? Groups
+  : never;
+
+export type ${clientTypeName} = HttpApiClient.Client<
+  Extract<${pascalStem}ApiGroups, HttpApiGroup.Constraint>,
+  never,
+  never
+>;
+
+export type ${pascalStem}ClientError =
+  | ${notFoundErrorExport}
+  | HttpClientError.HttpClientError
+  | Schema.SchemaError;
+
+export type ${clientEffectTypeName}<Success> = Effect.Effect<
+  Success,
+  ${pascalStem}ClientError,
+  never
+>;
+
+export interface ${clientOptionsName} {
+  baseUrl?: string | URL;
+  locale?: string;
+  operationContext?: OperationContext;
+  traceparent?: string;
+}
+
+export const ${createClientName} = (
+  options: ${clientOptionsName} = {},
+): ${clientEffectTypeName}<${clientTypeName}> =>
+  makeEffectHttpApiClient(${apiExport}, {
+    baseUrl: options.baseUrl ?? ${contractExport}ApiContract.apiPrefix,
+    requestContext: {
+      ...(options.locale === undefined ? {} : { locale: options.locale }),
+      ...(options.operationContext === undefined
+        ? {}
+        : { operationContext: options.operationContext }),
+      ...(options.traceparent === undefined
+        ? {}
+        : { traceparent: options.traceparent }),
+    },
+  });
+
+export const ${listName} = (
+  options: ${clientOptionsName} & { limit?: number } = {},
+): ${clientEffectTypeName}<${listResponseType}> =>
+  ${createClientName}({
+    ...options,
+    operationContext:
+      options.operationContext ?? ${groupName}OperationContexts.list,
+  }).pipe(
+    Effect.flatMap(client =>
+      client.${groupName}.list({ query: { limit: options.limit } }),
+    ),
+  );
+
+export const ${readinessName} = (
+  options: ${clientOptionsName} = {},
+): ${clientEffectTypeName}<${readinessType}> =>
+  ${createClientName}({
+    ...options,
+    operationContext:
+      options.operationContext ?? ${groupName}OperationContexts.readiness,
+  }).pipe(
+    Effect.flatMap(client => client.${groupName}.readiness({})),
+  );
+
+export const ${getName} = (
+  id: string,
+  options: ${clientOptionsName} = {},
+): ${clientEffectTypeName}<${itemType}> =>
+  ${createClientName}({
+    ...options,
+    operationContext:
+      options.operationContext ?? ${groupName}OperationContexts.get,
+  }).pipe(
+    Effect.flatMap(client => client.${groupName}.get({ params: { id } })),
+  );
+
+export const ${createName} = (
+  title: string,
+  options: ${clientOptionsName} = {},
+): ${clientEffectTypeName}<${createResponseType}> =>
+  ${createClientName}({
+    ...options,
+    operationContext:
+      options.operationContext ?? ${groupName}OperationContexts.create,
+  }).pipe(
+    Effect.flatMap(client =>
+      client.${groupName}.create({ payload: { title } }),
+    ),
+  );${checkoutCartClientExports}
+`;
+}
+function createShellApiClient(scope, remotes = []) {
+    const exports = verticalApiApps(remotes).map((remote)=>{
+        const stem = resolveApiStem(remote);
+        const pascalStem = toPascalCase(stem);
+        const rpc = 'rpc' === resolveApiProtocol(remote);
+        const pascalSingular = toPascalCase(verticalApiErrorStem(remote));
+        const checkoutCartExports = !rpc && serviceHasCheckoutCartState(remote) ? `  addCheckoutCartItem,
+  clearCheckoutCart,
+  getCheckoutCart,
+  removeCheckoutCartItem,
+  type CheckoutAddCartItemInput,
+  type CheckoutCart,
+  type CheckoutCartLine,
+` : '';
+        if (rpc) return `export {
+  get${pascalStem}Rpc,
+  list${pascalStem}Rpc,
+  make${pascalStem}RpcClient,
+  type ${pascalStem}RpcClientOptions,
+} from '${packageName(scope, remote.packageSuffix)}/api/rpc-client';`;
+        return `export {
+${checkoutCartExports}  create${pascalSingular},
+  create${pascalStem}Client,
+  get${pascalSingular},
+  get${pascalStem}Readiness,
+  list${pascalStem},
+  type ${pascalStem}ClientOptions,
+} from '${packageName(scope, remote.packageSuffix)}/api/client';`;
+    }).join('\n\n');
+    return exports ? `${exports}\n` : `export const ultramodernVerticalClients = [] as const;
+`;
+}
+export { createApiClient, createShellApiClient };

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

@@ -0,0 +1,150 @@
+import "node:module";
+import { appHasApi, resolveApiProtocol, resolveApiStem } from "../descriptors.js";
+import { toPascalCase } from "../naming.js";
+import { serviceHasCheckoutCartState } from "./checkout-cart.js";
+import { verticalApiErrorStem, verticalApiGroupName } from "./names.js";
+import { RPC_ROUTE_PATH, rpcPath } from "./rpc.js";
+function createApiReadinessContract(app) {
+    const stem = resolveApiStem(app);
+    return {
+        endpoint: `/${stem}/readiness`,
+        marker: {
+            ui: 'ultramodernUiMarker',
+            api: 'ultramodernApiMarker',
+            skew: 'none'
+        },
+        checks: [
+            'moduleFederation',
+            'ssr',
+            'translations',
+            'api'
+        ]
+    };
+}
+function createApiRequestContextContract() {
+    return {
+        propagatedHeaders: [
+            'accept-language',
+            'authorization',
+            'traceparent',
+            'x-correlation-id',
+            'x-tenant-id',
+            'x-ultramodern-env',
+            'x-vertical-version-id'
+        ],
+        source: 'shell-to-vertical-api-client'
+    };
+}
+function createApiDomainOperations(app) {
+    const stem = resolveApiStem(app);
+    const group = verticalApiGroupName(app);
+    const basePath = `/${stem}`;
+    const checkoutCartOperations = serviceHasCheckoutCartState(app) ? {
+        checkoutCartAddItem: {
+            client: 'addCheckoutCartItem',
+            method: 'POST',
+            path: '/checkout/cart/items',
+            resource: 'checkout-cart',
+            owner: app.id
+        },
+        checkoutCartClear: {
+            client: 'clearCheckoutCart',
+            method: 'POST',
+            path: '/checkout/cart/clear',
+            resource: 'checkout-cart',
+            owner: app.id
+        },
+        checkoutCartRead: {
+            client: 'getCheckoutCart',
+            method: 'GET',
+            path: '/checkout/cart',
+            resource: 'checkout-cart',
+            owner: app.id
+        },
+        checkoutCartRemoveItem: {
+            client: 'removeCheckoutCartItem',
+            method: 'POST',
+            path: '/checkout/cart/remove',
+            resource: 'checkout-cart',
+            owner: app.id
+        }
+    } : {};
+    return {
+        ...checkoutCartOperations,
+        workspaceFeed: {
+            client: `list${toPascalCase(stem)}`,
+            method: 'GET',
+            path: basePath,
+            resource: 'workspace-items',
+            owner: app.id
+        },
+        workspaceDetail: {
+            client: `get${toPascalCase(verticalApiErrorStem(app))}`,
+            method: 'GET',
+            path: `${basePath}/:id`,
+            resource: 'workspace-item',
+            owner: app.id
+        },
+        workspaceCreate: {
+            client: `create${toPascalCase(verticalApiErrorStem(app))}`,
+            method: 'POST',
+            path: basePath,
+            resource: group,
+            owner: app.id
+        }
+    };
+}
+function apiTopologyMetadata(app) {
+    if (!appHasApi(app)) return;
+    if ('rpc' === resolveApiProtocol(app)) return {
+        runtime: 'effect',
+        protocol: 'rpc',
+        bff: {
+            prefix: app.api.prefix,
+            rpc: {
+                path: RPC_ROUTE_PATH,
+                serialization: 'json'
+            },
+            strictEffectApproach: true
+        },
+        stem: app.api.stem,
+        contract: {
+            export: './api',
+            path: `${app.directory}/shared/rpc.ts`
+        },
+        client: {
+            export: './api/rpc-client',
+            path: `${app.directory}/src/api/${app.api.stem}-rpc-client.ts`
+        },
+        serverEntry: `${app.directory}/api/index.ts`,
+        rpcPath: rpcPath(app),
+        rpcSerialization: 'json',
+        consumedBy: app.api.consumedBy
+    };
+    return {
+        runtime: 'effect',
+        ...void 0 === app.api.protocol ? {} : {
+            protocol: app.api.protocol
+        },
+        bff: {
+            prefix: app.api.prefix,
+            openapi: '/openapi.json',
+            strictEffectApproach: true
+        },
+        contract: {
+            export: './api',
+            path: `${app.directory}/shared/api.ts`
+        },
+        client: {
+            export: './api/client',
+            path: `${app.directory}/src/api/${app.api.stem}-client.ts`
+        },
+        serverEntry: `${app.directory}/api/index.ts`,
+        basePath: `${app.api.prefix}/${app.api.stem}`,
+        consumedBy: app.api.consumedBy,
+        readiness: createApiReadinessContract(app),
+        requestContext: createApiRequestContextContract(),
+        domainOperations: createApiDomainOperations(app)
+    };
+}
+export { apiTopologyMetadata };

package/dist/esm-node/ultramodern-workspace/api/names.js

@@ -0,0 +1,34 @@
+import "node:module";
+import { resolveApiStem } from "../descriptors.js";
+import { toCamelCase, toPascalCase } from "../naming.js";
+function verticalApiExport(service) {
+    return `${toCamelCase(resolveApiStem(service))}Api`;
+}
+function verticalApiGroupName(service) {
+    return toCamelCase(resolveApiStem(service));
+}
+function verticalApiName(service) {
+    return `${toPascalCase(resolveApiStem(service))}Api`;
+}
+function verticalApiSchemaExport(service) {
+    return `${toCamelCase(resolveApiStem(service))}ItemSchema`;
+}
+function verticalApiMarkerSchemaExport(service) {
+    return `${toCamelCase(resolveApiStem(service))}MarkerSchema`;
+}
+function verticalApiReadinessSchemaExport(service) {
+    return `${toCamelCase(resolveApiStem(service))}ReadinessSchema`;
+}
+function verticalApiErrorStem(service) {
+    return resolveApiStem(service);
+}
+function verticalApiCreatePayloadSchemaExport(service) {
+    return `${toCamelCase(resolveApiStem(service))}CreatePayloadSchema`;
+}
+function verticalApiNotFoundErrorExport(service) {
+    return `${toPascalCase(verticalApiErrorStem(service))}NotFound`;
+}
+function verticalApiNotFoundSchemaExport(service) {
+    return `${toCamelCase(verticalApiErrorStem(service))}NotFoundSchema`;
+}
+export { verticalApiCreatePayloadSchemaExport, verticalApiErrorStem, verticalApiExport, verticalApiGroupName, verticalApiMarkerSchemaExport, verticalApiName, verticalApiNotFoundErrorExport, verticalApiNotFoundSchemaExport, verticalApiReadinessSchemaExport, verticalApiSchemaExport };