@bleedingdev/modern-js-create 3.2.0-ultramodern.120 → 3.2.0-ultramodern.122

package/dist/cjs/ultramodern-workspace/effect-api.cjs

@@ -0,0 +1,952 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createEffectClient: ()=>createEffectClient,
+    createEffectDomainOperations: ()=>createEffectDomainOperations,
+    createEffectOperationContract: ()=>createEffectOperationContract,
+    createEffectReadinessContract: ()=>createEffectReadinessContract,
+    createEffectRequestContextContract: ()=>createEffectRequestContextContract,
+    createEffectServiceEntry: ()=>createEffectServiceEntry,
+    createEffectSharedApi: ()=>createEffectSharedApi,
+    createEffectSharedApiContract: ()=>createEffectSharedApiContract,
+    createEffectSharedApiImports: ()=>createEffectSharedApiImports,
+    createShellEffectClient: ()=>createShellEffectClient,
+    effectApiTopologyMetadata: ()=>effectApiTopologyMetadata,
+    verticalEffectApiExport: ()=>verticalEffectApiExport,
+    verticalEffectApiName: ()=>verticalEffectApiName,
+    verticalEffectCreatePayloadSchemaExport: ()=>verticalEffectCreatePayloadSchemaExport,
+    verticalEffectErrorStem: ()=>verticalEffectErrorStem,
+    verticalEffectGroupName: ()=>verticalEffectGroupName,
+    verticalEffectMarkerSchemaExport: ()=>verticalEffectMarkerSchemaExport,
+    verticalEffectNotFoundErrorExport: ()=>verticalEffectNotFoundErrorExport,
+    verticalEffectNotFoundSchemaExport: ()=>verticalEffectNotFoundSchemaExport,
+    verticalEffectReadinessSchemaExport: ()=>verticalEffectReadinessSchemaExport,
+    verticalEffectSchemaExport: ()=>verticalEffectSchemaExport
+});
+const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
+const external_naming_cjs_namespaceObject = require("./naming.cjs");
+function verticalEffectApiExport(service) {
+    return `${(0, external_naming_cjs_namespaceObject.toCamelCase)((0, external_descriptors_cjs_namespaceObject.effectApiStem)(service))}EffectApi`;
+}
+function verticalEffectGroupName(service) {
+    return (0, external_naming_cjs_namespaceObject.toCamelCase)((0, external_descriptors_cjs_namespaceObject.effectApiStem)(service));
+}
+function verticalEffectApiName(service) {
+    return `${(0, external_naming_cjs_namespaceObject.toPascalCase)((0, external_descriptors_cjs_namespaceObject.effectApiStem)(service))}EffectApi`;
+}
+function verticalEffectSchemaExport(service) {
+    return `${(0, external_naming_cjs_namespaceObject.toCamelCase)((0, external_descriptors_cjs_namespaceObject.effectApiStem)(service))}ItemSchema`;
+}
+function verticalEffectMarkerSchemaExport(service) {
+    return `${(0, external_naming_cjs_namespaceObject.toCamelCase)((0, external_descriptors_cjs_namespaceObject.effectApiStem)(service))}MarkerSchema`;
+}
+function verticalEffectReadinessSchemaExport(service) {
+    return `${(0, external_naming_cjs_namespaceObject.toCamelCase)((0, external_descriptors_cjs_namespaceObject.effectApiStem)(service))}ReadinessSchema`;
+}
+function verticalEffectErrorStem(service) {
+    return (0, external_descriptors_cjs_namespaceObject.effectApiStem)(service);
+}
+function verticalEffectCreatePayloadSchemaExport(service) {
+    return `${(0, external_naming_cjs_namespaceObject.toCamelCase)((0, external_descriptors_cjs_namespaceObject.effectApiStem)(service))}CreatePayloadSchema`;
+}
+function verticalEffectNotFoundErrorExport(service) {
+    return `${(0, external_naming_cjs_namespaceObject.toPascalCase)(verticalEffectErrorStem(service))}NotFound`;
+}
+function verticalEffectNotFoundSchemaExport(service) {
+    return `${(0, external_naming_cjs_namespaceObject.toCamelCase)(verticalEffectErrorStem(service))}NotFoundSchema`;
+}
+function serviceHasCheckoutCartState(service) {
+    return 'checkout' === (0, external_descriptors_cjs_namespaceObject.effectApiStem)(service);
+}
+function createCheckoutCartSharedSchemas(service) {
+    if (!serviceHasCheckoutCartState(service)) return '';
+    return `
+export const checkoutCartLineSchema = Schema.Struct({
+  sku: Schema.String,
+  name: Schema.String,
+  quantity: Schema.Finite,
+  unitPriceCents: Schema.Finite,
+});
+
+export const checkoutCartSchema = Schema.Struct({
+  lines: Schema.Array(checkoutCartLineSchema),
+  subtotalCents: Schema.Finite,
+  totalQuantity: Schema.Finite,
+});
+
+export const checkoutAddCartItemPayloadSchema = Schema.Struct({
+  sku: Schema.String,
+  name: Schema.optional(Schema.String),
+  quantity: Schema.Finite,
+  unitPriceCents: Schema.optional(Schema.Finite),
+});
+
+export const checkoutRemoveCartItemPayloadSchema = Schema.Struct({
+  sku: Schema.String,
+});
+`;
+}
+function createCheckoutCartEndpointDefinitions(service) {
+    if (!serviceHasCheckoutCartState(service)) return '';
+    return `
+    .add(
+      HttpApiEndpoint.get('getCart', '/effect/checkout/cart', {
+        success: checkoutCartSchema,
+      }),
+    )
+    .add(
+      HttpApiEndpoint.post('addCartItem', '/effect/checkout/cart/items', {
+        payload: checkoutAddCartItemPayloadSchema,
+        success: checkoutCartSchema,
+      }),
+    )
+    .add(
+      HttpApiEndpoint.post('removeCartItem', '/effect/checkout/cart/remove', {
+        payload: checkoutRemoveCartItemPayloadSchema,
+        success: checkoutCartSchema,
+      }),
+    )
+    .add(
+      HttpApiEndpoint.post('clearCart', '/effect/checkout/cart/clear', {
+        success: checkoutCartSchema,
+      }),
+    )`;
+}
+function createCheckoutCartOperationContexts(service) {
+    const apiName = verticalEffectApiName(service);
+    const groupName = verticalEffectGroupName(service);
+    if (!serviceHasCheckoutCartState(service)) return '';
+    return `
+  addCartItem: {
+    method: 'POST',
+    operationId: '${apiName}:${groupName}:addCartItem',
+    routePath: '/effect/checkout/cart/items',
+    source: 'generated-client',
+  },
+  clearCart: {
+    method: 'POST',
+    operationId: '${apiName}:${groupName}:clearCart',
+    routePath: '/effect/checkout/cart/clear',
+    source: 'generated-client',
+  },
+  getCart: {
+    method: 'GET',
+    operationId: '${apiName}:${groupName}:getCart',
+    routePath: '/effect/checkout/cart',
+    source: 'generated-client',
+  },
+  removeCartItem: {
+    method: 'POST',
+    operationId: '${apiName}:${groupName}:removeCartItem',
+    routePath: '/effect/checkout/cart/remove',
+    source: 'generated-client',
+  },`;
+}
+function createCheckoutCartApiContractFields(service) {
+    if (!serviceHasCheckoutCartState(service)) return '';
+    return `  checkoutCartPath: '${(0, external_descriptors_cjs_namespaceObject.effectApiPrefix)(service)}/effect/checkout/cart',
+`;
+}
+function createCheckoutCartServerState(service) {
+    if (!serviceHasCheckoutCartState(service)) return '';
+    return `
+type CheckoutCartLine = {
+  sku: string;
+  name: string;
+  quantity: number;
+  unitPriceCents: number;
+};
+
+const checkoutCartLines = new Map<string, CheckoutCartLine>();
+
+const createCheckoutCartSnapshot = () => {
+  const lines = [...checkoutCartLines.values()].sort((left, right) =>
+    left.sku.localeCompare(right.sku),
+  );
+  return {
+    lines,
+    subtotalCents: lines.reduce(
+      (total, line) => total + line.quantity * line.unitPriceCents,
+      0,
+    ),
+    totalQuantity: lines.reduce((total, line) => total + line.quantity, 0),
+  };
+};
+`;
+}
+function createCheckoutCartServerHandlers(service) {
+    const groupName = verticalEffectGroupName(service);
+    if (!serviceHasCheckoutCartState(service)) return '';
+    return `
+      .handle('getCart', () =>
+        Effect.sync(() => createCheckoutCartSnapshot()).pipe(
+          Effect.withSpan('ultramodern.effect.${groupName}.checkout.getCart', {
+            attributes: operationAttributes(${groupName}OperationContexts.getCart),
+            kind: 'server',
+          }),
+        ),
+      )
+      .handle('addCartItem', ({ payload }) =>
+        Effect.sync(() => {
+          const existingLine = checkoutCartLines.get(payload.sku);
+          checkoutCartLines.set(payload.sku, {
+            sku: payload.sku,
+            name: payload.name ?? existingLine?.name ?? payload.sku,
+            quantity: (existingLine?.quantity ?? 0) + payload.quantity,
+            unitPriceCents:
+              payload.unitPriceCents ?? existingLine?.unitPriceCents ?? 0,
+          });
+          return createCheckoutCartSnapshot();
+        }).pipe(
+          Effect.withSpan('ultramodern.effect.${groupName}.checkout.addCartItem', {
+            attributes: operationAttributes(${groupName}OperationContexts.addCartItem),
+            kind: 'server',
+          }),
+        ),
+      )
+      .handle('removeCartItem', ({ payload }) =>
+        Effect.sync(() => {
+          checkoutCartLines.delete(payload.sku);
+          return createCheckoutCartSnapshot();
+        }).pipe(
+          Effect.withSpan('ultramodern.effect.${groupName}.checkout.removeCartItem', {
+            attributes: operationAttributes(${groupName}OperationContexts.removeCartItem),
+            kind: 'server',
+          }),
+        ),
+      )
+      .handle('clearCart', () =>
+        Effect.sync(() => {
+          checkoutCartLines.clear();
+          return createCheckoutCartSnapshot();
+        }).pipe(
+          Effect.withSpan('ultramodern.effect.${groupName}.checkout.clearCart', {
+            attributes: operationAttributes(${groupName}OperationContexts.clearCart),
+            kind: 'server',
+          }),
+        ),
+      )`;
+}
+function createCheckoutCartClientExports(service) {
+    if (!serviceHasCheckoutCartState(service)) return '';
+    const stem = (0, external_descriptors_cjs_namespaceObject.effectApiStem)(service);
+    const groupName = verticalEffectGroupName(service);
+    const pascalStem = (0, external_naming_cjs_namespaceObject.toPascalCase)(stem);
+    const clientOptionsName = `${pascalStem}ClientOptions`;
+    const createClientName = `create${pascalStem}Client`;
+    return `
+export interface CheckoutCartLine {
+  sku: string;
+  name: string;
+  quantity: number;
+  unitPriceCents: number;
+}
+
+export interface CheckoutCart {
+  lines: readonly CheckoutCartLine[];
+  subtotalCents: number;
+  totalQuantity: number;
+}
+
+export interface CheckoutAddCartItemInput {
+  sku: string;
+  name?: string;
+  quantity: number;
+  unitPriceCents?: number;
+}
+
+export const getCheckoutCart = (
+  options: ${clientOptionsName} = {},
+) =>
+  ${createClientName}({
+    ...options,
+    operationContext:
+      options.operationContext ?? ${groupName}OperationContexts.getCart,
+  }).pipe(
+    Effect.flatMap(client => client.${groupName}.getCart({})),
+  );
+
+export const addCheckoutCartItem = (
+  payload: CheckoutAddCartItemInput,
+  options: ${clientOptionsName} = {},
+) =>
+  ${createClientName}({
+    ...options,
+    operationContext:
+      options.operationContext ?? ${groupName}OperationContexts.addCartItem,
+  }).pipe(
+    Effect.flatMap(client =>
+      client.${groupName}.addCartItem({ payload }),
+    ),
+  );
+
+export const removeCheckoutCartItem = (
+  sku: string,
+  options: ${clientOptionsName} = {},
+) =>
+  ${createClientName}({
+    ...options,
+    operationContext:
+      options.operationContext ?? ${groupName}OperationContexts.removeCartItem,
+  }).pipe(
+    Effect.flatMap(client =>
+      client.${groupName}.removeCartItem({ payload: { sku } }),
+    ),
+  );
+
+export const clearCheckoutCart = (
+  options: ${clientOptionsName} = {},
+) =>
+  ${createClientName}({
+    ...options,
+    operationContext:
+      options.operationContext ?? ${groupName}OperationContexts.clearCart,
+  }).pipe(
+    Effect.flatMap(client => client.${groupName}.clearCart({})),
+  );
+`;
+}
+function createEffectSharedApiImports() {
+    return `import {
+  HttpApi,
+  HttpApiEndpoint,
+  HttpApiGroup,
+  HttpApiSchema,
+  Schema,
+} from '@modern-js/plugin-bff/effect-client';
+`;
+}
+function createEffectSharedApiContract(service) {
+    const schemaExport = verticalEffectSchemaExport(service);
+    const markerSchemaExport = verticalEffectMarkerSchemaExport(service);
+    const readinessSchemaExport = verticalEffectReadinessSchemaExport(service);
+    const createPayloadSchemaExport = verticalEffectCreatePayloadSchemaExport(service);
+    const notFoundErrorExport = verticalEffectNotFoundErrorExport(service);
+    const notFoundSchemaExport = verticalEffectNotFoundSchemaExport(service);
+    const apiExport = verticalEffectApiExport(service);
+    const apiName = verticalEffectApiName(service);
+    const groupName = verticalEffectGroupName(service);
+    const stem = (0, external_descriptors_cjs_namespaceObject.effectApiStem)(service);
+    const apiPrefix = (0, external_descriptors_cjs_namespaceObject.effectApiPrefix)(service);
+    const checkoutCartSharedSchemas = createCheckoutCartSharedSchemas(service);
+    const checkoutCartSharedSchemaSection = '' === checkoutCartSharedSchemas ? '' : `${checkoutCartSharedSchemas}\n`;
+    const checkoutCartOperationContexts = createCheckoutCartOperationContexts(service).trimStart();
+    const checkoutCartOperationContextEntries = '' === checkoutCartOperationContexts ? '' : `${checkoutCartOperationContexts}\n`;
+    return `export const ${markerSchemaExport} = Schema.Struct({
+  appId: Schema.String,
+  build: Schema.String,
+  deployProfile: Schema.String,
+  packageName: Schema.String,
+  surface: Schema.String,
+  version: Schema.String,
+});
+
+export const ${schemaExport} = Schema.Struct({
+  id: Schema.String,
+  marker: ${markerSchemaExport},
+  title: Schema.String,
+});
+
+export const ${readinessSchemaExport} = Schema.Struct({
+  checks: Schema.Struct({
+    effectBff: 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.Struct({
+  title: Schema.String,
+});
+
+${checkoutCartSharedSchemaSection}export class ${notFoundErrorExport} extends Schema.TaggedErrorClass<${notFoundErrorExport}>()(
+  '${notFoundErrorExport}',
+  {
+    id: Schema.String,
+  },
+) {}
+
+export const ${notFoundSchemaExport} = ${notFoundErrorExport}.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', '/effect/${stem}', {
+        query: {
+          limit: Schema.optional(Schema.FiniteFromString),
+        },
+        success: Schema.Struct({
+          items: Schema.Array(${schemaExport}),
+        }),
+      }),
+    )
+    .add(
+      HttpApiEndpoint.get('readiness', '/effect/${stem}/readiness', {
+        success: ${readinessSchemaExport},
+      }),
+    )
+    .add(
+      HttpApiEndpoint.get('get', '/effect/${stem}/:id', {
+        error: ${notFoundSchemaExport},
+        params: {
+          id: Schema.String,
+        },
+        success: ${schemaExport},
+      }),
+    )
+    .add(
+      HttpApiEndpoint.post('create', '/effect/${stem}', {
+        payload: ${createPayloadSchemaExport},
+        success: Schema.Struct({
+          item: ${schemaExport},
+        }),
+      }),
+    )${createCheckoutCartEndpointDefinitions(service)},
+);
+
+export const ${groupName}OperationContexts = {
+${checkoutCartOperationContextEntries}  create: {
+    method: 'POST',
+    operationId: '${apiName}:${groupName}:create',
+    routePath: '/effect/${stem}',
+    source: 'generated-client',
+  },
+  get: {
+    method: 'GET',
+    operationId: '${apiName}:${groupName}:get',
+    routePath: '/effect/${stem}/:id',
+    source: 'generated-client',
+  },
+  list: {
+    method: 'GET',
+    operationId: '${apiName}:${groupName}:list',
+    routePath: '/effect/${stem}',
+    source: 'generated-client',
+  },
+  readiness: {
+    method: 'GET',
+    operationId: '${apiName}:${groupName}:readiness',
+    routePath: '/effect/${stem}/readiness',
+    source: 'generated-client',
+  },
+} satisfies Record<string, OperationContext>;
+
+export const ${groupName}ApiContract = {
+  apiPrefix: '${apiPrefix}',
+  basePath: '${apiPrefix}/effect/${stem}',
+${createCheckoutCartApiContractFields(service)}  ownerId: '${service.id}',
+  readinessPath: '${apiPrefix}/effect/${stem}/readiness',
+} as const;
+`;
+}
+function createEffectSharedApi(service) {
+    return `${createEffectSharedApiImports()}
+${createEffectSharedApiContract(service)}`;
+}
+function createEffectServiceEntry(service, contractImportPath) {
+    const apiExport = verticalEffectApiExport(service);
+    const groupName = verticalEffectGroupName(service);
+    const notFoundErrorExport = verticalEffectNotFoundErrorExport(service);
+    const stem = (0, external_descriptors_cjs_namespaceObject.effectApiStem)(service);
+    return `import {
+  defineEffectBff,
+  Effect,
+  HttpApiBuilder,
+  Layer,
+} from '@modern-js/plugin-bff/effect-edge';
+import { ultramodernApiMarker } from '../../src/ultramodern-build.ts';
+import {
+  ${apiExport},
+  ${groupName}OperationContexts,
+  ${notFoundErrorExport},
+} from '${contractImportPath}';
+import type { 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.effect.${groupName}.list', {
+            attributes: operationAttributes(${groupName}OperationContexts.list),
+            kind: 'server',
+          }),
+        ),
+      )
+      .handle('readiness', () =>
+        Effect.succeed({
+          checks: {
+            effectBff: '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.effect.${groupName}.readiness', {
+            attributes: operationAttributes(${groupName}OperationContexts.readiness),
+            kind: 'server',
+          }),
+        ),
+      )
+      .handle('get', ({ params }) => {
+        const matchedItem = ${groupName}Items.find(
+          candidate => candidate.id === params.id,
+        );
+        const result =
+          matchedItem === undefined
+            ? Effect.fail(new ${notFoundErrorExport}({ id: params.id }))
+            : Effect.succeed(matchedItem);
+
+        return result.pipe(
+            Effect.withSpan('ultramodern.effect.${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.effect.${groupName}.create', {
+            attributes: operationAttributes(${groupName}OperationContexts.create),
+            kind: 'server',
+          }),
+        ),
+      )${createCheckoutCartServerHandlers(service)},
+);
+
+const layer = HttpApiBuilder.layer(${apiExport}).pipe(
+  Layer.provide(${groupName}Layer),
+);
+
+export default defineEffectBff({
+  api: ${apiExport},
+  layer,
+});
+`;
+}
+function createEffectClient(service, contractImportPath) {
+    const apiExport = verticalEffectApiExport(service);
+    const contractExport = verticalEffectGroupName(service);
+    const stem = (0, external_descriptors_cjs_namespaceObject.effectApiStem)(service);
+    const groupName = verticalEffectGroupName(service);
+    const singular = verticalEffectErrorStem(service);
+    const clientOptionsName = `${(0, external_naming_cjs_namespaceObject.toPascalCase)(stem)}ClientOptions`;
+    const createClientName = `create${(0, external_naming_cjs_namespaceObject.toPascalCase)(stem)}Client`;
+    const listName = `list${(0, external_naming_cjs_namespaceObject.toPascalCase)(stem)}`;
+    const readinessName = `get${(0, external_naming_cjs_namespaceObject.toPascalCase)(stem)}Readiness`;
+    const getName = `get${(0, external_naming_cjs_namespaceObject.toPascalCase)(singular)}`;
+    const createName = `create${(0, external_naming_cjs_namespaceObject.toPascalCase)(singular)}`;
+    const checkoutCartClientExports = createCheckoutCartClientExports(service);
+    return `import {
+  Effect,
+  makeEffectHttpApiClient,
+  runEffectRequest,
+} from '@modern-js/plugin-bff/effect-client';
+import {
+  ${contractExport}ApiContract,
+  ${apiExport},
+  ${groupName}OperationContexts,
+} from '${contractImportPath}';
+import type { OperationContext } from '${contractImportPath}';
+
+export { Effect, runEffectRequest };
+
+export interface ${clientOptionsName} {
+  baseUrl?: string | URL;
+  locale?: string;
+  operationContext?: OperationContext;
+  traceparent?: string;
+}
+
+export const ${createClientName} = (
+  options: ${clientOptionsName} = {},
+) =>
+  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 } = {},
+) =>
+  ${createClientName}({
+    ...options,
+    operationContext:
+      options.operationContext ?? ${groupName}OperationContexts.list,
+  }).pipe(
+    Effect.flatMap(client =>
+      client.${groupName}.list({ query: { limit: options.limit } }),
+    ),
+  );
+
+export const ${readinessName} = (
+  options: ${clientOptionsName} = {},
+) =>
+  ${createClientName}({
+    ...options,
+    operationContext:
+      options.operationContext ?? ${groupName}OperationContexts.readiness,
+  }).pipe(
+    Effect.flatMap(client => client.${groupName}.readiness({})),
+  );
+
+export const ${getName} = (
+  id: string,
+  options: ${clientOptionsName} = {},
+) =>
+  ${createClientName}({
+    ...options,
+    operationContext:
+      options.operationContext ?? ${groupName}OperationContexts.get,
+  }).pipe(
+    Effect.flatMap(client => client.${groupName}.get({ params: { id } })),
+  );
+
+export const ${createName} = (
+  title: string,
+  options: ${clientOptionsName} = {},
+) =>
+  ${createClientName}({
+    ...options,
+    operationContext:
+      options.operationContext ?? ${groupName}OperationContexts.create,
+  }).pipe(
+    Effect.flatMap(client =>
+      client.${groupName}.create({ payload: { title } }),
+    ),
+  );${checkoutCartClientExports}
+`;
+}
+function createShellEffectClient(scope, remotes = []) {
+    const exports1 = (0, external_descriptors_cjs_namespaceObject.verticalEffectApps)(remotes).map((remote)=>{
+        const stem = (0, external_descriptors_cjs_namespaceObject.effectApiStem)(remote);
+        const pascalStem = (0, external_naming_cjs_namespaceObject.toPascalCase)(stem);
+        const pascalSingular = (0, external_naming_cjs_namespaceObject.toPascalCase)(verticalEffectErrorStem(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 '${(0, external_naming_cjs_namespaceObject.packageName)(scope, remote.packageSuffix)}/effect/client';`;
+    }).join('\n\n');
+    return exports1 ? `${exports1}\n` : `export const ultramodernVerticalClients = [] as const;
+`;
+}
+function createEffectReadinessContract(app) {
+    const stem = (0, external_descriptors_cjs_namespaceObject.effectApiStem)(app);
+    return {
+        endpoint: `/effect/${stem}/readiness`,
+        marker: {
+            ui: 'ultramodernUiMarker',
+            api: 'ultramodernApiMarker',
+            skew: 'none'
+        },
+        checks: [
+            'moduleFederation',
+            'ssr',
+            'translations',
+            'effectBff'
+        ]
+    };
+}
+function createEffectRequestContextContract() {
+    return {
+        propagatedHeaders: [
+            'accept-language',
+            'authorization',
+            'traceparent',
+            'x-correlation-id',
+            'x-tenant-id',
+            'x-ultramodern-env',
+            'x-vertical-version-id'
+        ],
+        source: 'shell-to-vertical-effect-client'
+    };
+}
+function createEffectDomainOperations(app) {
+    const stem = (0, external_descriptors_cjs_namespaceObject.effectApiStem)(app);
+    const group = verticalEffectGroupName(app);
+    const basePath = `/effect/${stem}`;
+    const checkoutCartOperations = serviceHasCheckoutCartState(app) ? {
+        checkoutCartAddItem: {
+            client: 'addCheckoutCartItem',
+            method: 'POST',
+            path: '/effect/checkout/cart/items',
+            resource: 'checkout-cart',
+            owner: app.id
+        },
+        checkoutCartClear: {
+            client: 'clearCheckoutCart',
+            method: 'POST',
+            path: '/effect/checkout/cart/clear',
+            resource: 'checkout-cart',
+            owner: app.id
+        },
+        checkoutCartRead: {
+            client: 'getCheckoutCart',
+            method: 'GET',
+            path: '/effect/checkout/cart',
+            resource: 'checkout-cart',
+            owner: app.id
+        },
+        checkoutCartRemoveItem: {
+            client: 'removeCheckoutCartItem',
+            method: 'POST',
+            path: '/effect/checkout/cart/remove',
+            resource: 'checkout-cart',
+            owner: app.id
+        }
+    } : {};
+    return {
+        ...checkoutCartOperations,
+        workspaceFeed: {
+            client: `list${(0, external_naming_cjs_namespaceObject.toPascalCase)(stem)}`,
+            method: 'GET',
+            path: basePath,
+            resource: 'workspace-items',
+            owner: app.id
+        },
+        workspaceDetail: {
+            client: `get${(0, external_naming_cjs_namespaceObject.toPascalCase)(verticalEffectErrorStem(app))}`,
+            method: 'GET',
+            path: `${basePath}/:id`,
+            resource: 'workspace-item',
+            owner: app.id
+        },
+        workspaceCreate: {
+            client: `create${(0, external_naming_cjs_namespaceObject.toPascalCase)(verticalEffectErrorStem(app))}`,
+            method: 'POST',
+            path: basePath,
+            resource: group,
+            owner: app.id
+        }
+    };
+}
+function effectApiTopologyMetadata(app) {
+    if (!(0, external_descriptors_cjs_namespaceObject.appHasEffectApi)(app)) return;
+    return {
+        effect: {
+            runtime: 'effect',
+            bff: {
+                prefix: app.effectApi.prefix,
+                openapi: '/openapi.json'
+            },
+            contract: {
+                export: './shared/effect/api',
+                path: `${app.directory}/shared/effect/api.ts`
+            },
+            client: {
+                export: './effect/client',
+                path: `${app.directory}/src/effect/${app.effectApi.stem}-client.ts`
+            },
+            serverEntry: `${app.directory}/api/effect/index.ts`,
+            basePath: `${app.effectApi.prefix}/effect/${app.effectApi.stem}`,
+            consumedBy: app.effectApi.consumedBy,
+            readiness: createEffectReadinessContract(app),
+            requestContext: createEffectRequestContextContract(),
+            domainOperations: createEffectDomainOperations(app)
+        }
+    };
+}
+function createEffectOperationContract(target) {
+    const stem = (0, external_descriptors_cjs_namespaceObject.effectApiStem)(target);
+    const checkoutCartOperations = serviceHasCheckoutCartState(target) ? {
+        addCartItem: {
+            method: 'POST',
+            path: '/effect/checkout/cart/items',
+            source: 'generated-client'
+        },
+        clearCart: {
+            method: 'POST',
+            path: '/effect/checkout/cart/clear',
+            source: 'generated-client'
+        },
+        getCart: {
+            method: 'GET',
+            path: '/effect/checkout/cart',
+            source: 'generated-client'
+        },
+        removeCartItem: {
+            method: 'POST',
+            path: '/effect/checkout/cart/remove',
+            source: 'generated-client'
+        }
+    } : {};
+    return {
+        group: verticalEffectGroupName(target),
+        notFound: verticalEffectNotFoundErrorExport(target),
+        operations: {
+            ...checkoutCartOperations,
+            list: {
+                method: 'GET',
+                path: `/effect/${stem}`,
+                source: 'generated-client'
+            },
+            readiness: {
+                method: 'GET',
+                path: `/effect/${stem}/readiness`,
+                source: 'generated-client'
+            },
+            get: {
+                method: 'GET',
+                path: `/effect/${stem}/:id`,
+                source: 'generated-client'
+            },
+            create: {
+                method: 'POST',
+                path: `/effect/${stem}`,
+                source: 'generated-client'
+            }
+        }
+    };
+}
+exports.createEffectClient = __webpack_exports__.createEffectClient;
+exports.createEffectDomainOperations = __webpack_exports__.createEffectDomainOperations;
+exports.createEffectOperationContract = __webpack_exports__.createEffectOperationContract;
+exports.createEffectReadinessContract = __webpack_exports__.createEffectReadinessContract;
+exports.createEffectRequestContextContract = __webpack_exports__.createEffectRequestContextContract;
+exports.createEffectServiceEntry = __webpack_exports__.createEffectServiceEntry;
+exports.createEffectSharedApi = __webpack_exports__.createEffectSharedApi;
+exports.createEffectSharedApiContract = __webpack_exports__.createEffectSharedApiContract;
+exports.createEffectSharedApiImports = __webpack_exports__.createEffectSharedApiImports;
+exports.createShellEffectClient = __webpack_exports__.createShellEffectClient;
+exports.effectApiTopologyMetadata = __webpack_exports__.effectApiTopologyMetadata;
+exports.verticalEffectApiExport = __webpack_exports__.verticalEffectApiExport;
+exports.verticalEffectApiName = __webpack_exports__.verticalEffectApiName;
+exports.verticalEffectCreatePayloadSchemaExport = __webpack_exports__.verticalEffectCreatePayloadSchemaExport;
+exports.verticalEffectErrorStem = __webpack_exports__.verticalEffectErrorStem;
+exports.verticalEffectGroupName = __webpack_exports__.verticalEffectGroupName;
+exports.verticalEffectMarkerSchemaExport = __webpack_exports__.verticalEffectMarkerSchemaExport;
+exports.verticalEffectNotFoundErrorExport = __webpack_exports__.verticalEffectNotFoundErrorExport;
+exports.verticalEffectNotFoundSchemaExport = __webpack_exports__.verticalEffectNotFoundSchemaExport;
+exports.verticalEffectReadinessSchemaExport = __webpack_exports__.verticalEffectReadinessSchemaExport;
+exports.verticalEffectSchemaExport = __webpack_exports__.verticalEffectSchemaExport;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createEffectClient",
+    "createEffectDomainOperations",
+    "createEffectOperationContract",
+    "createEffectReadinessContract",
+    "createEffectRequestContextContract",
+    "createEffectServiceEntry",
+    "createEffectSharedApi",
+    "createEffectSharedApiContract",
+    "createEffectSharedApiImports",
+    "createShellEffectClient",
+    "effectApiTopologyMetadata",
+    "verticalEffectApiExport",
+    "verticalEffectApiName",
+    "verticalEffectCreatePayloadSchemaExport",
+    "verticalEffectErrorStem",
+    "verticalEffectGroupName",
+    "verticalEffectMarkerSchemaExport",
+    "verticalEffectNotFoundErrorExport",
+    "verticalEffectNotFoundSchemaExport",
+    "verticalEffectReadinessSchemaExport",
+    "verticalEffectSchemaExport"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});