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

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

@@ -0,0 +1,183 @@
+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.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 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/ultramodern-workspace/api/contracts.js

@@ -0,0 +1,201 @@
+import { appHasApi, resolveApiProtocol, resolveApiStem } from "../descriptors.js";
+import { toPascalCase } from "../naming.js";
+import { serviceHasCheckoutCartState } from "./checkout-cart.js";
+import { verticalApiErrorStem, verticalApiGroupName, verticalApiNotFoundErrorExport } 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)
+    };
+}
+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/ultramodern-workspace/api/names.js

@@ -0,0 +1,33 @@
+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/ultramodern-workspace/api/rpc.js

@@ -0,0 +1,205 @@
+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.ErrorClass<${notFound}>(
+  '${notFound}',
+)({
+  _tag: Schema.tag('${notFound}'),
+  id: Schema.String,
+}) {}
+
+// RpcGroup contract consumed by both the server handler layer and the client
+// (mirrors the shapes plugin-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 };