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

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

@@ -0,0 +1,206 @@
+import "node:module";
+import { resolveApiPrefix, resolveApiStem } from "../descriptors.js";
+import { toPascalCase } from "../naming.js";
+import { verticalApiGroupName, verticalApiNotFoundErrorExport } from "./names.js";
+function verticalRpcGroupExport(service) {
+    return `${verticalApiGroupName(service)}RpcGroup`;
+}
+function verticalRpcContractExport(service) {
+    return `${verticalApiGroupName(service)}RpcContract`;
+}
+function rpcItemSchemaExport(service) {
+    return `${verticalApiGroupName(service)}RpcItemSchema`;
+}
+function rpcPath(service) {
+    return `${resolveApiPrefix(service)}/rpc`;
+}
+const RPC_ROUTE_PATH = '/rpc';
+function createRpcContractFile(service) {
+    const groupName = verticalApiGroupName(service);
+    const groupExport = verticalRpcGroupExport(service);
+    const contractExport = verticalRpcContractExport(service);
+    const itemSchema = rpcItemSchemaExport(service);
+    const notFound = `${verticalApiNotFoundErrorExport(service)}Rpc`;
+    const stem = resolveApiStem(service);
+    const pascalStem = toPascalCase(stem);
+    return `import { Rpc, RpcGroup } from 'effect/unstable/rpc';
+import { Schema } from '@modern-js/plugin-bff/effect-client';
+
+export interface ${pascalStem}RpcItem {
+  readonly id: string;
+  readonly title: string;
+}
+
+export const ${itemSchema}: Schema.Codec<${pascalStem}RpcItem> = Schema.Struct({
+  id: Schema.String,
+  title: Schema.String,
+});
+
+export class ${notFound} extends Schema.TaggedError<${notFound}>()(
+  '${notFound}',
+  {
+  id: Schema.String,
+  },
+) {}
+
+// RpcGroup contract consumed by both the server handler layer and the client
+// (mirrors the shapes Effect BFF's RpcServer/RpcClient runtime accepts).
+export const ${groupExport} = RpcGroup.make(
+  Rpc.make('list', {
+    success: Schema.Struct({ items: Schema.Array(${itemSchema}) }),
+    payload: { limit: Schema.optional(Schema.Number) },
+  }),
+  Rpc.make('get', {
+    success: ${itemSchema},
+    error: ${notFound},
+    payload: { id: Schema.String },
+  }),
+);
+
+export const ${contractExport} = {
+  group: '${groupName}',
+  path: '${rpcPath(service)}',
+  protocol: 'rpc',
+  serialization: 'json',
+} as const;
+`;
+}
+function rpcServiceEntryWiring(service) {
+    if ((service.api?.protocol ?? 'rest') !== 'rpc') return {
+        imports: '',
+        layer: '',
+        field: ''
+    };
+    const groupName = verticalApiGroupName(service);
+    const groupExport = verticalRpcGroupExport(service);
+    const notFound = `${verticalApiNotFoundErrorExport(service)}Rpc`;
+    const imports = `import { ${groupExport}, ${notFound} } from '../shared/rpc.ts';
+`;
+    const layer = `
+const ${groupName}RpcLayer = ${groupExport}.toLayer(
+  ${groupExport}.of({
+    list: ({ limit }) =>
+      Effect.succeed({
+        items:
+          typeof limit === 'number'
+            ? ${groupName}Items.slice(0, limit).map(item => ({
+                id: item.id,
+                title: item.title,
+              }))
+            : ${groupName}Items.map(item => ({
+                id: item.id,
+                title: item.title,
+              })),
+      }),
+    get: ({ id }) => {
+      const matched = ${groupName}Items.find(candidate => candidate.id === id);
+      return matched === undefined
+        ? Effect.fail(new ${notFound}({ id }))
+        : Effect.succeed({ id: matched.id, title: matched.title });
+    },
+  }),
+);
+`;
+    const field = `
+  rpc: {
+    group: ${groupExport},
+    layer: ${groupName}RpcLayer,
+    path: '${RPC_ROUTE_PATH}',
+    serialization: 'json',
+  },`;
+    return {
+        imports,
+        layer,
+        field
+    };
+}
+function createRpcApiServiceEntry(service) {
+    const groupName = verticalApiGroupName(service);
+    const groupExport = verticalRpcGroupExport(service);
+    const rpc = rpcServiceEntryWiring(service);
+    const stem = resolveApiStem(service);
+    return `import {
+  defineEffectBff,
+  Effect,
+  HttpApi,
+  Layer,
+} from '@modern-js/plugin-bff/effect-edge';
+${rpc.imports}import { ultramodernApiMarker } from '../shared/ultramodern-build.ts';
+
+const ${groupName}Items = [
+  {
+    id: 'starter-${stem}',
+    marker: ultramodernApiMarker,
+    title: 'Wire a real ${stem} source here',
+  },
+];
+
+${rpc.layer}
+
+// Strict Effect uses this empty transport marker to discover the BFF entry.
+// It has no REST groups/endpoints; the canonical network surface is RPC.
+const rpcTransport = HttpApi.make('${groupName}RpcTransport');
+const layer = Layer.empty;
+
+const apiRuntime = defineEffectBff({
+  api: rpcTransport,
+  layer,
+${rpc.field}
+});
+
+export { ${groupExport} };
+export default apiRuntime;
+`;
+}
+function createRpcClientFile(service) {
+    const groupExport = verticalRpcGroupExport(service);
+    const contractExport = verticalRpcContractExport(service);
+    const stem = resolveApiStem(service);
+    const pascalStem = toPascalCase(stem);
+    return `import {
+  Effect,
+  makeEffectRpcClient,
+} from '@modern-js/plugin-bff/effect-client';
+import {
+  ${contractExport},
+  ${groupExport},
+} from '../../shared/rpc.ts';
+
+export { Effect } from '@modern-js/plugin-bff/effect-client';
+
+export const ${pascalStem}RpcContract = ${contractExport};
+
+export interface ${pascalStem}RpcClientOptions {
+  url?: string | URL;
+}
+
+export const make${pascalStem}RpcClient = (
+  options: ${pascalStem}RpcClientOptions = {},
+) =>
+  makeEffectRpcClient(${groupExport}, {
+    url: String(options.url ?? ${contractExport}.path),
+    serialization: 'json',
+  });
+
+export const list${pascalStem}Rpc = (
+  limit?: number,
+  options: ${pascalStem}RpcClientOptions = {},
+) =>
+  Effect.acquireUseRelease(
+    make${pascalStem}RpcClient(options),
+    client => client.list({ limit }),
+    client => Effect.promise(() => client.dispose()),
+  );
+
+export const get${pascalStem}Rpc = (
+  id: string,
+  options: ${pascalStem}RpcClientOptions = {},
+) =>
+  Effect.acquireUseRelease(
+    make${pascalStem}RpcClient(options),
+    client => client.get({ id }),
+    client => Effect.promise(() => client.dispose()),
+  );
+`;
+}
+export { RPC_ROUTE_PATH, createRpcApiServiceEntry, createRpcClientFile, createRpcContractFile, rpcPath, rpcServiceEntryWiring, verticalRpcContractExport, verticalRpcGroupExport };

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

@@ -0,0 +1,212 @@
+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";
+import { createRpcApiServiceEntry, rpcPath, verticalRpcContractExport, verticalRpcGroupExport } from "./rpc.js";
+function createApiServiceEntry(service, contractImportPath) {
+    if ((service.api?.protocol ?? 'rest') === 'rpc') return createRpcApiServiceEntry(service);
+    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) {
+    if ((service.api?.protocol ?? 'rest') === 'rpc') {
+        const groupExport = verticalRpcGroupExport(service);
+        const contractExport = verticalRpcContractExport(service);
+        return `import { ultramodernApiMarker } from '../shared/ultramodern-build.ts';
+import {
+  ${contractExport},
+  ${groupExport},
+} from '../shared/rpc.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)}',
+  rpcPath: '${rpcPath(service)}',
+  rpcSerialization: 'json',
+  role: 'microvertical-server',
+  runtimeFramework: 'effect',
+  strictEffectApproach: true,
+} as const;
+
+export { default, default as runtime } from './index.ts';
+export {
+  ${contractExport} as contract,
+  ${groupExport} as rpc,
+} from '../shared/rpc.ts';
+export const api: unknown = ${groupExport};
+`;
+    }
+    const apiExport = verticalApiExport(service);
+    const groupName = verticalApiGroupName(service);
+    const apiPrefix = resolveApiPrefix(service);
+    const stem = resolveApiStem(service);
+    return `import { ultramodernApiMarker } from '../shared/ultramodern-build.ts';
+import { ${apiExport} } 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 { default, default as runtime } from './index.ts';
+export {
+  ${groupName}ApiContract as contract,
+  ${groupName}OperationContexts as operationContexts,
+} from '../shared/api.ts';
+export const api: unknown = ${apiExport};
+`;
+}
+export { createApiServiceEntry, createBackendEffectApiExpose };

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

@@ -0,0 +1,227 @@
+import "node:module";
+import { resolveApiPrefix, resolveApiStem } from "../descriptors.js";
+import { renderTemplate } from "../fs-io.js";
+import { toPascalCase } from "../naming.js";
+import { createCheckoutCartApiContractFields, createCheckoutCartEndpointDefinitions, createCheckoutCartOperationContexts, createCheckoutCartSharedSchemas } from "./checkout-cart.js";
+import { verticalApiCreatePayloadSchemaExport, verticalApiExport, verticalApiGroupName, verticalApiMarkerSchemaExport, verticalApiName, verticalApiNotFoundErrorExport, verticalApiNotFoundSchemaExport, verticalApiReadinessSchemaExport, verticalApiSchemaExport } from "./names.js";
+function createSharedApiImports() {
+    return `import {
+  HttpApi,
+  HttpApiEndpoint,
+  HttpApiGroup,
+  HttpApiSchema,
+  Schema,
+} from '@modern-js/plugin-bff/effect-client';
+`;
+}
+function createSharedApiContract(service) {
+    const schemaExport = verticalApiSchemaExport(service);
+    const markerSchemaExport = verticalApiMarkerSchemaExport(service);
+    const readinessSchemaExport = verticalApiReadinessSchemaExport(service);
+    const createPayloadSchemaExport = verticalApiCreatePayloadSchemaExport(service);
+    const notFoundErrorExport = verticalApiNotFoundErrorExport(service);
+    const notFoundSchemaExport = verticalApiNotFoundSchemaExport(service);
+    const apiExport = verticalApiExport(service);
+    const apiName = verticalApiName(service);
+    const groupName = verticalApiGroupName(service);
+    const stem = resolveApiStem(service);
+    const pascalStem = toPascalCase(stem);
+    const markerType = `${pascalStem}Marker`;
+    const itemType = `${pascalStem}Item`;
+    const readinessType = `${pascalStem}Readiness`;
+    const createPayloadType = `${pascalStem}CreatePayload`;
+    const createResponseType = `${pascalStem}CreateResponse`;
+    const listResponseType = `${pascalStem}ListResponse`;
+    const apiPrefix = resolveApiPrefix(service);
+    const checkoutCartSharedSchemas = createCheckoutCartSharedSchemas(service);
+    const checkoutCartSharedSchemaSection = '' === checkoutCartSharedSchemas ? '' : `${checkoutCartSharedSchemas}\n`;
+    const createOperationContext = `  create: {
+    method: 'POST',
+    operationId: '${apiName}:${groupName}:create',
+    routePath: '/${stem}',
+    source: 'generated-client',
+  },`;
+    const getOperationContext = `  get: {
+    method: 'GET',
+    operationId: '${apiName}:${groupName}:get',
+    routePath: '/${stem}/:id',
+    source: 'generated-client',
+  },`;
+    const listOperationContext = `  list: {
+    method: 'GET',
+    operationId: '${apiName}:${groupName}:list',
+    routePath: '/${stem}',
+    source: 'generated-client',
+  },`;
+    const readinessOperationContext = `  readiness: {
+    method: 'GET',
+    operationId: '${apiName}:${groupName}:readiness',
+    routePath: '/${stem}/readiness',
+    source: 'generated-client',
+  },`;
+    const checkoutCartOperationContextTemplate = createCheckoutCartOperationContexts(service);
+    const operationContextEntries = '' === checkoutCartOperationContextTemplate ? [
+        createOperationContext,
+        getOperationContext,
+        listOperationContext,
+        readinessOperationContext
+    ].join('\n') : renderTemplate(checkoutCartOperationContextTemplate, {
+        createOperationContext,
+        getOperationContext,
+        listOperationContext,
+        readinessOperationContext
+    }).trim();
+    return `export interface ${markerType} {
+  readonly appId: string;
+  readonly build: string;
+  readonly buildMarker: string;
+  readonly deployProfile: string;
+  readonly packageName: string;
+  readonly sourceRevision: string;
+  readonly surface: string;
+  readonly unitId: string;
+  readonly version: string;
+}
+
+export interface ${itemType} {
+  readonly id: string;
+  readonly marker: ${markerType};
+  readonly title: string;
+}
+
+export interface ${readinessType} {
+  readonly checks: {
+    readonly api: 'ready';
+    readonly moduleFederation: 'ready';
+    readonly ssr: 'ready';
+    readonly translations: 'ready';
+  };
+  readonly marker: ${markerType};
+  readonly status: 'ready';
+  readonly versionSkew: 'none';
+}
+
+export interface ${createPayloadType} {
+  readonly title: string;
+}
+
+export interface ${listResponseType} {
+  readonly items: readonly ${itemType}[];
+}
+
+export interface ${createResponseType} {
+  readonly item: ${itemType};
+}
+
+export interface ${notFoundErrorExport} {
+  readonly _tag: '${notFoundErrorExport}';
+  readonly id: string;
+}
+
+export const ${markerSchemaExport}: Schema.Codec<${markerType}> = Schema.Struct({
+  appId: Schema.String,
+  build: Schema.String,
+  buildMarker: Schema.String,
+  deployProfile: Schema.String,
+  packageName: Schema.String,
+  sourceRevision: Schema.String,
+  surface: Schema.String,
+  unitId: Schema.String,
+  version: Schema.String,
+});
+
+export const ${schemaExport}: Schema.Codec<${itemType}> = Schema.Struct({
+  id: Schema.String,
+  marker: ${markerSchemaExport},
+  title: Schema.String,
+});
+
+export const ${readinessSchemaExport}: Schema.Codec<${readinessType}> = Schema.Struct({
+  checks: Schema.Struct({
+    api: Schema.Literal('ready'),
+    moduleFederation: Schema.Literal('ready'),
+    ssr: Schema.Literal('ready'),
+    translations: Schema.Literal('ready'),
+  }),
+  marker: ${markerSchemaExport},
+  status: Schema.Literal('ready'),
+  versionSkew: Schema.Literal('none'),
+});
+
+export const ${createPayloadSchemaExport}: Schema.Codec<${createPayloadType}> = Schema.Struct({
+  title: Schema.String,
+});
+
+${checkoutCartSharedSchemaSection}export const ${notFoundSchemaExport}: Schema.Codec<${notFoundErrorExport}> = Schema.TaggedStruct('${notFoundErrorExport}', {
+  id: Schema.String,
+}).pipe(
+  HttpApiSchema.status(404),
+);
+
+export interface OperationContext {
+  method: string;
+  operationId: string;
+  routePath: string;
+  source:
+    | 'client'
+    | 'server'
+    | 'generated-client'
+    | 'effect-adapter'
+    | 'data-platform'
+    | 'unknown';
+  traceId?: string;
+}
+
+export const ${apiExport} = HttpApi.make('${apiName}').add(
+  HttpApiGroup.make('${groupName}')
+    .add(
+      HttpApiEndpoint.get('list', '/${stem}', {
+        query: {
+          limit: Schema.optional(Schema.FiniteFromString),
+        },
+        success: Schema.Struct({
+          items: Schema.Array(${schemaExport}),
+        }),
+      }),
+    )
+    .add(
+      HttpApiEndpoint.get('readiness', '/${stem}/readiness', {
+        success: ${readinessSchemaExport},
+      }),
+    )
+    .add(
+      HttpApiEndpoint.get('get', '/${stem}/:id', {
+        error: ${notFoundSchemaExport},
+        params: {
+          id: Schema.String,
+        },
+        success: ${schemaExport},
+      }),
+    )
+    .add(
+      HttpApiEndpoint.post('create', '/${stem}', {
+        payload: ${createPayloadSchemaExport},
+        success: Schema.Struct({
+          item: ${schemaExport},
+        }),
+      }),
+    )${createCheckoutCartEndpointDefinitions(service)},
+);
+
+export const ${groupName}OperationContexts = {
+${operationContextEntries}
+} satisfies Record<string, OperationContext>;
+
+export const ${groupName}ApiContract = {
+  apiPrefix: '${apiPrefix}',
+  basePath: '${apiPrefix}/${stem}',
+${createCheckoutCartApiContractFields(service)}  ownerId: '${service.id}',
+  readinessPath: '${apiPrefix}/${stem}/readiness',
+} as const;
+`;
+}
+function createSharedApi(service) {
+    return `${createSharedApiImports()}
+${createSharedApiContract(service)}`;
+}
+export { createSharedApi };

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

@@ -0,0 +1,7 @@
+import "node:module";
+export { createApiClient, createShellApiClient } from "./api/client.js";
+export { apiTopologyMetadata } from "./api/contracts.js";
+export { verticalApiCreatePayloadSchemaExport, verticalApiErrorStem, verticalApiExport, verticalApiGroupName, verticalApiMarkerSchemaExport, verticalApiName, verticalApiNotFoundErrorExport, verticalApiNotFoundSchemaExport, verticalApiReadinessSchemaExport, verticalApiSchemaExport } from "./api/names.js";
+export { createRpcApiServiceEntry, createRpcClientFile, createRpcContractFile, rpcPath, verticalRpcContractExport, verticalRpcGroupExport } from "./api/rpc.js";
+export { createApiServiceEntry, createBackendEffectApiExpose } from "./api/service.js";
+export { createSharedApi } from "./api/shared.js";