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

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

@@ -0,0 +1,178 @@
+import "node:module";
+import { 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,
+  runEffectRequest,
+} 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 };
+
+type ${pascalStem}ApiGroups = typeof ${apiExport} extends HttpApi.HttpApi<
+  infer _ApiId,
+  infer Groups
+>
+  ? Groups
+  : never;
+
+export type ${clientTypeName} = HttpApiClient.Client<
+  Extract<${pascalStem}ApiGroups, HttpApiGroup.Any>,
+  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 pascalSingular = toPascalCase(verticalApiErrorStem(remote));
+        const checkoutCartExports = serviceHasCheckoutCartState(remote) ? `  addCheckoutCartItem,
+  clearCheckoutCart,
+  getCheckoutCart,
+  removeCheckoutCartItem,
+  type CheckoutAddCartItemInput,
+  type CheckoutCart,
+  type CheckoutCartLine,
+` : '';
+        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,173 @@
+import "node:module";
+import { appHasApi, resolveApiStem } from "../descriptors.js";
+import { toPascalCase } from "../naming.js";
+import { serviceHasCheckoutCartState } from "./checkout-cart.js";
+import { verticalApiErrorStem, verticalApiGroupName, verticalApiNotFoundErrorExport } from "./names.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;
+    return {
+        runtime: 'effect',
+        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)
+    };
+}
+function createApiOperationContract(target) {
+    const stem = resolveApiStem(target);
+    const checkoutCartOperations = serviceHasCheckoutCartState(target) ? {
+        addCartItem: {
+            method: 'POST',
+            path: '/checkout/cart/items',
+            source: 'generated-client'
+        },
+        clearCart: {
+            method: 'POST',
+            path: '/checkout/cart/clear',
+            source: 'generated-client'
+        },
+        getCart: {
+            method: 'GET',
+            path: '/checkout/cart',
+            source: 'generated-client'
+        },
+        removeCartItem: {
+            method: 'POST',
+            path: '/checkout/cart/remove',
+            source: 'generated-client'
+        }
+    } : {};
+    return {
+        group: verticalApiGroupName(target),
+        notFound: verticalApiNotFoundErrorExport(target),
+        operations: {
+            ...checkoutCartOperations,
+            list: {
+                method: 'GET',
+                path: `/${stem}`,
+                source: 'generated-client'
+            },
+            readiness: {
+                method: 'GET',
+                path: `/${stem}/readiness`,
+                source: 'generated-client'
+            },
+            get: {
+                method: 'GET',
+                path: `/${stem}/:id`,
+                source: 'generated-client'
+            },
+            create: {
+                method: 'POST',
+                path: `/${stem}`,
+                source: 'generated-client'
+            }
+        }
+    };
+}
+export { apiTopologyMetadata, createApiDomainOperations, createApiOperationContract, createApiReadinessContract, createApiRequestContextContract };

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

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

@@ -0,0 +1,180 @@
+import "node:module";
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from "../backend-federation.js";
+import { createBackendFederationName, resolveApiPrefix, resolveApiStem } from "../descriptors.js";
+import { packageName } from "../naming.js";
+import { createCheckoutCartServerHandlers, createCheckoutCartServerState } from "./checkout-cart.js";
+import { verticalApiExport, verticalApiGroupName, verticalApiNotFoundErrorExport } from "./names.js";
+function createApiServiceEntry(service, contractImportPath) {
+    const apiExport = verticalApiExport(service);
+    const groupName = verticalApiGroupName(service);
+    const notFoundErrorExport = verticalApiNotFoundErrorExport(service);
+    const stem = resolveApiStem(service);
+    return `import {
+  defineEffectBff,
+  Effect,
+  HttpApiBuilder,
+  Layer,
+} from '@modern-js/plugin-bff/effect-edge';
+import type {
+  EffectBffDefinition,
+  EffectBffRuntime,
+  EffectRuntimeLayer,
+} from '@modern-js/plugin-bff/effect-edge';
+import { ultramodernApiMarker } from '../shared/ultramodern-build.ts';
+import {
+  ${apiExport},
+  ${groupName}OperationContexts,
+} from '${contractImportPath}';
+import type {
+  ${notFoundErrorExport},
+  OperationContext,
+} from '${contractImportPath}';
+
+const ${groupName}Items = [
+  {
+    id: 'starter-${stem}',
+    marker: ultramodernApiMarker,
+    title: 'Wire a real ${stem} source here',
+  },
+];
+${createCheckoutCartServerState(service)}
+
+const operationAttributes = (operationContext: OperationContext) => ({
+    'modernjs.operation.id': operationContext.operationId,
+    'modernjs.operation.method': operationContext.method,
+    'modernjs.operation.route': operationContext.routePath,
+    'modernjs.operation.source': operationContext.source,
+    ...(typeof operationContext.traceId === 'string'
+      ? { 'modernjs.trace.id': operationContext.traceId }
+      : {}),
+  });
+
+const ${groupName}Layer = HttpApiBuilder.group(
+  ${apiExport},
+  '${groupName}',
+  (handlers) =>
+    handlers
+      .handle('list', ({ query }) =>
+        Effect.succeed({
+          items:
+            typeof query.limit === 'number'
+              ? ${groupName}Items.slice(0, query.limit)
+              : ${groupName}Items,
+        }).pipe(
+          Effect.withSpan('ultramodern.api.${groupName}.list', {
+            attributes: operationAttributes(${groupName}OperationContexts.list),
+            kind: 'server',
+          }),
+        ),
+      )
+      .handle('readiness', () =>
+        Effect.succeed({
+          checks: {
+            api: 'ready' as const,
+            moduleFederation: 'ready' as const,
+            ssr: 'ready' as const,
+            translations: 'ready' as const,
+          },
+          marker: ultramodernApiMarker,
+          status: 'ready' as const,
+          versionSkew: 'none' as const,
+        }).pipe(
+          Effect.withSpan('ultramodern.api.${groupName}.readiness', {
+            attributes: operationAttributes(${groupName}OperationContexts.readiness),
+            kind: 'server',
+          }),
+        ),
+      )
+      .handle('get', ({ params }) => {
+        const matchedItem = ${groupName}Items.find(
+          candidate => candidate.id === params.id,
+        );
+        const notFound: ${notFoundErrorExport} = {
+          _tag: '${notFoundErrorExport}',
+          id: params.id,
+        };
+        const result =
+          matchedItem === undefined
+            ? Effect.fail(notFound)
+            : Effect.succeed(matchedItem);
+
+        return result.pipe(
+            Effect.withSpan('ultramodern.api.${groupName}.get', {
+              attributes: operationAttributes(${groupName}OperationContexts.get),
+              kind: 'server',
+            }),
+          );
+      })
+      .handle('create', ({ payload }) =>
+        Effect.succeed({
+          item: {
+            id: \`generated-${stem}-\${payload.title
+              .toLowerCase()
+              .replaceAll(/[^a-z0-9]+/gu, '-')
+              .replaceAll(/^-|-$/gu, '')}\`,
+            marker: ultramodernApiMarker,
+            title: payload.title,
+          },
+        }).pipe(
+          Effect.withSpan('ultramodern.api.${groupName}.create', {
+            attributes: operationAttributes(${groupName}OperationContexts.create),
+            kind: 'server',
+          }),
+        ),
+      )${createCheckoutCartServerHandlers(service)},
+);
+
+const layer = HttpApiBuilder.layer(${apiExport}).pipe(
+  Layer.provide(${groupName}Layer),
+) satisfies EffectRuntimeLayer;
+
+const apiRuntime: EffectBffDefinition<typeof ${apiExport}, EffectRuntimeLayer> &
+  EffectBffRuntime<typeof ${apiExport}, EffectRuntimeLayer> = defineEffectBff({
+  api: ${apiExport},
+  layer,
+});
+
+export default apiRuntime;
+`;
+}
+function createBackendEffectApiExpose(scope, service) {
+    const apiExport = verticalApiExport(service);
+    const groupName = verticalApiGroupName(service);
+    const apiPrefix = resolveApiPrefix(service);
+    const stem = resolveApiStem(service);
+    return `import apiRuntime from './index.ts';
+import { ultramodernApiMarker } from '../shared/ultramodern-build.ts';
+import {
+  ${apiExport},
+  ${groupName}ApiContract,
+  ${groupName}OperationContexts,
+} from '../shared/api.ts';
+
+export const backendFederationContract = {
+  compatibility: {
+    build: ultramodernApiMarker.build,
+    contractVersion: '${BACKEND_FEDERATION_CONTRACT_VERSION}',
+    nodeAdapterVersion: '${BACKEND_FEDERATION_NODE_ADAPTER_VERSION}',
+    packageName: '${packageName(scope, service.packageSuffix)}',
+    sourceRevision: ultramodernApiMarker.sourceRevision,
+    unitId: ultramodernApiMarker.unitId,
+  },
+  executionSurfaces: ['node-mf-runtime'],
+  exposes: ['./effect-api'],
+  name: '${createBackendFederationName(service)}',
+  openapiPath: '${apiPrefix}/openapi.json',
+  readinessPath: '${apiPrefix}/${stem}/readiness',
+  role: 'microvertical-server',
+  runtimeFramework: 'effect',
+  strictEffectApproach: true,
+} as const;
+
+export const api: unknown = ${apiExport};
+export const contract = ${groupName}ApiContract;
+export const operationContexts = ${groupName}OperationContexts;
+export const runtime = apiRuntime;
+
+export default apiRuntime;
+`;
+}
+export { createApiServiceEntry, createBackendEffectApiExpose };