@ahoo-wang/fetcher-generator 2.1.0

package/dist/index.js

@@ -0,0 +1,968 @@
+import { VariableDeclarationKind as S, Scope as F } from "ts-morph";
+import { parse as L } from "yaml";
+import { readFile as K } from "fs";
+import { ContentTypeValues as P, combineURLs as A } from "@ahoo-wang/fetcher";
+import { ResourceAttributionPathSpec as R } from "@ahoo-wang/fetcher-wow";
+function h(r) {
+  return r.$ref.split("/").pop();
+}
+function E(r, e) {
+  const n = h(r);
+  return e.schemas?.[n];
+}
+function Q(r, e) {
+  const n = h(r);
+  return e.requestBodies?.[n];
+}
+function k(r, e) {
+  const n = h(r);
+  return e.parameters?.[n];
+}
+function y(r, e) {
+  return {
+    key: h(r),
+    schema: E(r, e)
+  };
+}
+const x = /[-_\s.]+|(?=[A-Z])/;
+function O(r) {
+  if (r === "" || r.length === 0)
+    return "";
+  let e;
+  return Array.isArray(r) ? e = r.flatMap((n) => n.split(x)) : e = r.split(x), e.filter((n) => n.length > 0).map((n) => {
+    if (n.length === 0) return "";
+    const t = n.charAt(0), o = n.slice(1);
+    return (/[a-zA-Z]/.test(t) ? t.toUpperCase() : t) + o.toLowerCase();
+  }).join("");
+}
+function M(r) {
+  const e = O(r);
+  return e.charAt(0).toLowerCase() + e.slice(1);
+}
+function U(r) {
+  return r.startsWith("http://") || r.startsWith("https://") ? J(r) : V(r);
+}
+async function J(r) {
+  return await (await fetch(r)).text();
+}
+function V(r) {
+  return new Promise((e, n) => {
+    K(r, "utf-8", (t, o) => {
+      t ? n(t) : e(o);
+    });
+  });
+}
+async function z(r) {
+  const e = await U(r);
+  switch (H(e)) {
+    case "json":
+      return JSON.parse(e);
+    case "yaml":
+      return L(e);
+    default:
+      throw new Error(`Unsupported file format: ${r}`);
+  }
+}
+function H(r) {
+  const e = r.trimStart();
+  if (e.startsWith("{") || e.startsWith("["))
+    return "json";
+  if (e.startsWith("-") || e.startsWith("%YAML"))
+    return "yaml";
+  try {
+    return JSON.parse(e), "json";
+  } catch {
+    if (e.length > 0)
+      return "yaml";
+  }
+  throw new Error("Unable to infer file format");
+}
+function l(r) {
+  return !!(r && typeof r == "object" && "$ref" in r);
+}
+function Y(r) {
+  return !r || l(r) || !r.content ? void 0 : r.content[P.APPLICATION_JSON]?.schema;
+}
+function Z(r) {
+  return [
+    { method: "get", operation: r.get },
+    { method: "put", operation: r.put },
+    { method: "post", operation: r.post },
+    { method: "delete", operation: r.delete },
+    { method: "options", operation: r.options },
+    { method: "head", operation: r.head },
+    { method: "patch", operation: r.patch },
+    { method: "trace", operation: r.trace }
+  ].filter(({ operation: e }) => e !== void 0);
+}
+function j(r) {
+  return r.responses[200];
+}
+function b(r) {
+  const e = j(r);
+  return Y(e);
+}
+function X(r) {
+  return Array.isArray(r.enum) && r.enum.length > 0;
+}
+function $(r) {
+  if (Array.isArray(r))
+    return r.map((e) => $(e)).join(" | ");
+  switch (r) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    default:
+      return "any";
+  }
+}
+const ee = "types.ts", w = "@";
+function q(r) {
+  return A(r.path, ee);
+}
+function T(r, e, n) {
+  const t = A(e, n), o = r.getSourceFile(t);
+  return o || r.createSourceFile(t, "", {
+    overwrite: !0
+  });
+}
+function N(r, e, n) {
+  let t = r.getImportDeclaration(
+    (o) => o.getModuleSpecifierValue() === e
+  );
+  t || (t = r.addImportDeclaration({
+    moduleSpecifier: e
+  })), n.forEach((o) => {
+    t.getNamedImports().some(
+      (s) => s.getName() === o
+    ) || t.addNamedImport(o);
+  });
+}
+function f(r, e, n) {
+  let t = q(n);
+  n.path.startsWith(w) || (t = A(e, t));
+  let o = t;
+  t.startsWith(w) || (o = A(w, t)), N(r, o, [n.name]);
+}
+function te(r, e, n, t) {
+  r.path !== t.path && f(e, n, t);
+}
+function _(r, e) {
+  const n = [r, e].filter(
+    (t) => t !== void 0 && t.length > 0
+  );
+  return n.length > 0 ? n.join(`
+`) : void 0;
+}
+function D(r, e) {
+  const n = _(r, e);
+  return n ? [n] : [];
+}
+function G(r, e, n) {
+  const t = _(e, n);
+  t && r.addJsDoc({
+    description: t
+  });
+}
+function ne(r) {
+  const e = r.split(".");
+  return e.length != 2 || e[0].length === 0 || e[1].length === 0 ? null : e;
+}
+function re(r) {
+  const e = ne(r.name);
+  return e ? {
+    tag: r,
+    contextAlias: e[0],
+    aggregateName: e[1]
+  } : null;
+}
+function oe(r) {
+  const e = r?.map((t) => re(t)).filter((t) => t !== null);
+  if (!e)
+    return /* @__PURE__ */ new Map();
+  const n = /* @__PURE__ */ new Map();
+  return e.forEach((t) => {
+    n.set(t.tag.name, {
+      aggregate: t,
+      commands: /* @__PURE__ */ new Map(),
+      events: /* @__PURE__ */ new Map()
+    });
+  }), n;
+}
+function ae(r) {
+  if (!r)
+    return null;
+  const e = r.split(".");
+  return e.length != 3 ? null : e[2];
+}
+const se = "#/components/responses/wow.CommandOk", ie = "#/components/parameters/wow.id";
+class ce {
+  /**
+   * Creates a new AggregateResolver instance.
+   * @param openAPI - The OpenAPI specification to resolve aggregates from
+   */
+  constructor(e) {
+    this.openAPI = e, this.aggregates = oe(e.tags), this.build();
+  }
+  aggregates;
+  /**
+   * Builds the aggregate definitions by processing all operations in the OpenAPI spec.
+   * @private
+   */
+  build() {
+    for (const [e, n] of Object.entries(this.openAPI.paths)) {
+      const t = Z(n);
+      for (const o of t)
+        this.commands(e, o), this.state(o.operation), this.events(o.operation), this.fields(o.operation);
+    }
+  }
+  /**
+   * Returns the resolved aggregate definitions.
+   * @returns Map of aggregate definitions keyed by context alias
+   */
+  resolve() {
+    const e = /* @__PURE__ */ new Map();
+    for (const n of this.aggregates.values()) {
+      if (!n.state || !n.fields)
+        continue;
+      const t = n.aggregate.contextAlias;
+      let o = e.get(t);
+      o || (o = /* @__PURE__ */ new Set(), e.set(t, o)), o.add(n);
+    }
+    return e;
+  }
+  /**
+   * Processes command operations and adds them to the appropriate aggregates.
+   * @param path - The API path
+   * @param methodOperation - The HTTP method and operation details
+   */
+  commands(e, n) {
+    const t = n.operation;
+    if (t.operationId === "wow.command.send")
+      return;
+    const o = ae(t.operationId);
+    if (!o)
+      return;
+    const a = j(t);
+    if (!a || !l(a) || a.$ref !== se || !t.requestBody)
+      return;
+    const s = t.parameters ?? [], c = s.filter((m) => l(m) && m.$ref === ie).at(0), i = s.filter(
+      (m) => !l(m) && m.in === "path"
+    );
+    if (c) {
+      const m = k(
+        c,
+        this.openAPI.components
+      );
+      i.push(m);
+    }
+    const u = t.requestBody.content[P.APPLICATION_JSON].schema, d = y(
+      u,
+      this.openAPI.components
+    );
+    d.schema.title = d.schema.title || t.summary, d.schema.description = d.schema.description || t.description;
+    const B = {
+      name: o,
+      method: n.method,
+      path: e,
+      pathParameters: i,
+      summary: t.summary,
+      description: t.description,
+      schema: d,
+      operation: t
+    };
+    t.tags?.forEach((m) => {
+      const I = this.aggregates.get(m);
+      I && I.commands.set(o, B);
+    });
+  }
+  /**
+   * Processes state snapshot operations and associates them with aggregates.
+   * @param operation - The OpenAPI operation
+   */
+  state(e) {
+    if (!e.operationId?.endsWith(".snapshot_state.single"))
+      return;
+    const n = b(e);
+    if (!l(n))
+      return;
+    const t = y(
+      n,
+      this.openAPI.components
+    );
+    e.tags?.forEach((o) => {
+      const a = this.aggregates.get(o);
+      a && (a.state = t);
+    });
+  }
+  /**
+   * Processes event stream operations and extracts domain events for aggregates.
+   * @param operation - The OpenAPI operation
+   */
+  events(e) {
+    if (!this.openAPI.components || !e.operationId?.endsWith(".event.list_query"))
+      return;
+    const n = b(e);
+    if (l(n))
+      return;
+    const t = n?.items;
+    if (!l(t))
+      return;
+    const a = E(
+      t,
+      this.openAPI.components
+    ).properties.body.items.anyOf.map((s) => {
+      const c = s.title, i = s.properties.name.const, p = s.properties.body, u = y(
+        p,
+        this.openAPI.components
+      );
+      return u.schema.title = u.schema.title || s.title, {
+        title: c,
+        name: i,
+        schema: u
+      };
+    });
+    e.tags?.forEach((s) => {
+      const c = this.aggregates.get(s);
+      c && a.forEach((i) => {
+        c.events.set(i.name, i);
+      });
+    });
+  }
+  /**
+   * Processes field query operations and associates field schemas with aggregates.
+   * @param operation - The OpenAPI operation
+   */
+  fields(e) {
+    if (!this.openAPI.components || !e.operationId?.endsWith(".snapshot.count"))
+      return;
+    const t = Q(
+      e.requestBody,
+      this.openAPI.components
+    ).content[P.APPLICATION_JSON].schema, a = E(
+      t,
+      this.openAPI.components
+    ).properties?.field, s = y(a, this.openAPI.components);
+    e.tags?.forEach((c) => {
+      const i = this.aggregates.get(c);
+      i && (i.fields = s);
+    });
+  }
+}
+const v = "@ahoo-wang/fetcher-wow", pe = {
+  "wow.command.CommandResult": "CommandResult",
+  "wow.MessageHeaderSqlType": "MessageHeaderSqlType",
+  "wow.api.BindingError": "BindingError",
+  "wow.api.DefaultErrorInfo": "ErrorInfo",
+  "wow.api.RecoverableType": "RecoverableType",
+  "wow.api.command.DefaultDeleteAggregate": "DeleteAggregate",
+  "wow.api.command.DefaultRecoverAggregate": "RecoverAggregate",
+  "wow.api.messaging.FunctionInfoData": "FunctionInfo",
+  "wow.api.messaging.FunctionKind": "FunctionKind",
+  "wow.api.modeling.AggregateId": "AggregateId",
+  "wow.api.query.Condition": "Condition",
+  "wow.api.query.ConditionOptions": "ConditionOptions",
+  "wow.api.query.ListQuery": "ListQuery",
+  "wow.api.query.Operator": "Operator",
+  "wow.api.query.PagedQuery": "PagedQuery",
+  "wow.api.query.Pagination": "Pagination",
+  "wow.api.query.Projection": "Projection",
+  "wow.api.query.Sort": "FieldSort",
+  "wow.api.query.Sort.Direction": "SortDirection",
+  "wow.command.CommandStage": "CommandStage",
+  "wow.command.SimpleWaitSignal": "WaitSignal",
+  "wow.configuration.Aggregate": "Aggregate",
+  "wow.configuration.BoundedContext": "BoundedContext",
+  "wow.configuration.WowMetadata": "WowMetadata",
+  "wow.modeling.DomainEvent": "DomainEvent",
+  "wow.openapi.BatchResult": "BatchResult",
+  "wow.messaging.CompensationTarget": "CompensationTarget"
+};
+function g(r) {
+  if (!r)
+    return { name: "", path: "/" };
+  const e = pe[r];
+  if (e)
+    return { name: e, path: v };
+  const n = r.split(".");
+  let t = -1;
+  for (let i = 0; i < n.length; i++)
+    if (n[i] && /^[A-Z]/.test(n[i])) {
+      t = i;
+      break;
+    }
+  if (t === -1)
+    return { name: r, path: "/" };
+  const o = n.slice(0, t), a = o.length > 0 ? `/${o.join("/")}` : "/", s = n.slice(t);
+  return { name: O(s), path: a };
+}
+class C {
+  project;
+  openAPI;
+  outputDir;
+  contextAggregates;
+  logger;
+  /**
+   * Creates a new ClientGenerator instance.
+   * @param context - The generation context containing OpenAPI spec and project details
+   */
+  constructor(e) {
+    this.project = e.project, this.openAPI = e.openAPI, this.outputDir = e.outputDir, this.contextAggregates = e.contextAggregates, this.logger = e.logger;
+  }
+}
+class me extends C {
+  constructor(e) {
+    super(e);
+  }
+  getOrCreateSourceFile(e) {
+    const n = q(e);
+    return T(this.project, this.outputDir, n);
+  }
+  /**
+   * Generates models for all schemas in the OpenAPI specification.
+   * Skips schemas with keys starting with 'wow.'.
+   *
+   * @remarks
+   * This method iterates through all schemas in the OpenAPI specification
+   * and generates corresponding TypeScript models for each one.
+   */
+  generate() {
+    const e = this.openAPI.components?.schemas;
+    if (!e) {
+      this.logger?.info("No schemas found in OpenAPI specification");
+      return;
+    }
+    this.logger?.progress(
+      `Generating models for ${Object.keys(e).length} schemas`
+    ), Object.entries(e).forEach(([n, t]) => {
+      n.startsWith("wow.") || (this.logger?.progress(`Processing schema: ${n}`), this.generateKeyedSchema(n, t));
+    }), this.logger?.success("Model generation completed");
+  }
+  /**
+   * Generates a model for a specific schema key.
+   * Processes enums, objects, unions, and type aliases in order.
+   *
+   * @param schemaKey - The key of the schema to generate
+   * @param schema - The schema definition
+   *
+   * @remarks
+   * The generation process follows this order:
+   * 1. Enum processing
+   * 2. Object processing
+   * 3. Union processing
+   * 4. Type alias processing
+   */
+  generateKeyedSchema(e, n) {
+    const t = g(e), o = this.getOrCreateSourceFile(t), a = this.process(t, o, n);
+    return G(a, n.title, n.description), o;
+  }
+  process(e, n, t) {
+    let o = this.processEnum(
+      e,
+      n,
+      t
+    );
+    return o || (o = this.processObject(e, n, t), o) || (o = this.processUnion(e, n, t), o) ? o : this.processTypeAlias(e, n, t);
+  }
+  /**
+   * Processes enum schemas and generates TypeScript enums.
+   *
+   * @param modelInfo - The model information
+   * @param sourceFile - The source file to add the enum to
+   * @param schema - The enum schema
+   * @returns true if the schema was processed as an enum, false otherwise
+   *
+   * @remarks
+   * This method filters out non-string enum values and generates
+   * a TypeScript enum with string literal initializers.
+   */
+  processEnum(e, n, t) {
+    if (X(t))
+      return n.addEnum({
+        name: e.name,
+        isExported: !0,
+        members: t.enum.filter((o) => typeof o == "string" && o.length > 0).map((o) => ({
+          name: o,
+          initializer: `'${o}'`
+        }))
+      });
+  }
+  /**
+   * Processes object schemas and generates TypeScript interfaces.
+   *
+   * @param modelInfo - The model information
+   * @param sourceFile - The source file to add the interface to
+   * @param schema - The object schema
+   * @returns true if the schema was processed as an object, false otherwise
+   *
+   * @remarks
+   * This method handles optional properties by checking the required array
+   * and adds undefined union types for optional properties.
+   */
+  processObject(e, n, t) {
+    if (t.type !== "object" || !t.properties)
+      return;
+    const o = {}, a = t.required || [];
+    for (const [s, c] of Object.entries(t.properties)) {
+      const i = this.resolveType(e, n, c), p = !a.includes(s);
+      o[s] = p ? `${i} | undefined` : i;
+    }
+    return n.addInterface({
+      name: e.name,
+      isExported: !0,
+      properties: Object.entries(o).map(([s, c]) => ({
+        name: s,
+        type: c
+      }))
+    });
+  }
+  /**
+   * Processes union schemas (allOf, anyOf, oneOf) and generates TypeScript type aliases.
+   *
+   * @param modelInfo - The model information
+   * @param sourceFile - The source file to add the type alias to
+   * @param schema - The union schema
+   * @returns true if the schema was processed as a union, false otherwise
+   *
+   * @remarks
+   * This method handles three types of unions:
+   * - allOf: Generates intersection types (&)
+   * - anyOf: Generates union types (|)
+   * - oneOf: Generates union types (|)
+   */
+  processUnion(e, n, t) {
+    let o = null;
+    if (t.allOf ? o = t.allOf.map((a) => this.resolveType(e, n, a)).join(" & ") : t.anyOf ? o = t.anyOf.map((a) => this.resolveType(e, n, a)).join(" | ") : t.oneOf && (o = t.oneOf.map((a) => this.resolveType(e, n, a)).join(" | ")), !!o)
+      return n.addTypeAlias({
+        name: e.name,
+        type: o,
+        isExported: !0,
+        docs: D(t.title, t.description)
+      });
+  }
+  /**
+   * Processes type alias schemas and generates TypeScript type aliases.
+   *
+   * @param modelInfo - The model information
+   * @param sourceFile - The source file to add the type alias to
+   * @param schema - The schema to process
+   *
+   * @remarks
+   * This method is used as a fallback for schemas that don't match
+   * enum, object, or union patterns. It resolves the type and creates
+   * a simple type alias.
+   */
+  processTypeAlias(e, n, t) {
+    const o = this.resolveType(e, n, t);
+    return n.addTypeAlias({
+      name: e.name,
+      type: o,
+      isExported: !0,
+      docs: D(t.title, t.description)
+    });
+  }
+  /**
+   * Resolves the TypeScript type for a given schema or reference.
+   * Handles arrays, objects, primitives, and references.
+   *
+   * @param modelInfo - The model information
+   * @param sourceFile - The source file for import management
+   * @param schema - The schema or reference to resolve
+   * @returns The resolved TypeScript type as a string
+   *
+   * @remarks
+   * This method handles various schema types:
+   * - References: Resolves to imported types
+   * - Arrays: Resolves item types and adds array notation
+   * - Objects: Resolves to Record<string, any> for generic objects
+   * - Primitives: Maps to TypeScript primitives
+   * - Nullable: Adds null union type
+   */
+  resolveType(e, n, t) {
+    if (l(t))
+      return this.resolveReference(e, n, t);
+    if (t.type === "array")
+      return `${t.items ? this.resolveType(e, n, t.items) : "any"}[]`;
+    if (t.type === "object" && !t.properties)
+      return "Record<string, any>";
+    let o;
+    return t.type ? o = $(t.type) : o = "any", t.nullable && (o = `${o} | null`), o;
+  }
+  /**
+   * Resolves a reference to another schema.
+   * Handles mapped types and imports.
+   *
+   * @param modelInfo - The current model information
+   * @param sourceFile - The source file for import management
+   * @param ref - The reference to resolve
+   * @returns The resolved type name
+   *
+   * @remarks
+   * This method checks for mapped types first (WOW_TYPE_MAPPING).
+   * If not found, it adds an import for the referenced model.
+   */
+  resolveReference(e, n, t) {
+    const o = h(t), a = g(o);
+    return te(e, n, this.outputDir, a), a.name;
+  }
+}
+function ue(r) {
+  let e = 0, n = 0;
+  return r.commands.forEach((t) => {
+    t.path.startsWith(R.TENANT) && (e += 1), t.path.startsWith(R.OWNER) && (n += 1);
+  }), e === 0 && n === 0 ? "ResourceAttributionPathSpec.NONE" : e > n ? "ResourceAttributionPathSpec.TENANT" : "ResourceAttributionPathSpec.OWNER";
+}
+function W(r, e, n, t) {
+  const o = `${n.contextAlias}/${n.aggregateName}/${t}.ts`;
+  return T(r, e, o);
+}
+function le(r, e) {
+  return `${O(r.aggregateName)}${e}`;
+}
+class ge extends C {
+  /**
+   * Creates a new QueryClientGenerator instance.
+   * @param context - The generation context containing OpenAPI spec and project details
+   */
+  constructor(e) {
+    super(e);
+  }
+  /**
+   * Generates query client classes for all aggregates.
+   */
+  generate() {
+    const e = Array.from(this.contextAggregates.values()).flat().length;
+    this.logger?.progress(
+      `Generating query clients for ${e} aggregates`
+    );
+    for (const [, n] of this.contextAggregates)
+      n.forEach((t) => {
+        this.logger?.progress(
+          `Processing query client for aggregate: ${t.aggregate.aggregateName}`
+        ), this.processQueryClient(t);
+      });
+    this.logger?.success("Query client generation completed");
+  }
+  /**
+   * Creates or retrieves a source file for client generation.
+   * @param aggregate - The aggregate metadata
+   * @param fileName - The name of the client file
+   * @returns The source file for the client
+   */
+  createClientFilePath(e, n) {
+    return W(
+      this.project,
+      this.outputDir,
+      e,
+      n
+    );
+  }
+  /**
+   * Processes and generates query client classes for an aggregate.
+   * @param aggregate - The aggregate definition
+   */
+  processQueryClient(e) {
+    const n = this.createClientFilePath(
+      e.aggregate,
+      "queryClient"
+    );
+    n.addImportDeclaration({
+      moduleSpecifier: v,
+      namedImports: [
+        "QueryClientFactory",
+        "QueryClientOptions",
+        "ResourceAttributionPathSpec"
+      ]
+    });
+    const t = "DEFAULT_QUERY_CLIENT_OPTIONS";
+    n.addVariableStatement({
+      declarationKind: S.Const,
+      declarations: [
+        {
+          name: t,
+          type: "QueryClientOptions",
+          initializer: `{
+        contextAlias: '${e.aggregate.contextAlias}',
+        aggregateName: '${e.aggregate.aggregateName}',
+        resourceAttribution: ${ue(e)},
+      }`
+        }
+      ],
+      isExported: !1
+    });
+    const o = [];
+    for (const p of e.events.values()) {
+      const u = g(p.schema.key);
+      f(n, this.outputDir, u), o.push(u);
+    }
+    const a = "DOMAIN_EVENT_TYPES";
+    n.addTypeAlias({
+      name: a,
+      type: o.map((p) => p.name).join(" | ")
+    });
+    const s = `${M(e.aggregate.aggregateName)}QueryClientFactory`, c = g(e.state.key), i = g(e.fields.key);
+    f(n, this.outputDir, c), f(n, this.outputDir, i), n.addVariableStatement({
+      declarationKind: S.Const,
+      declarations: [
+        {
+          name: s,
+          initializer: `new QueryClientFactory<${c.name}, ${i.name} | string, ${a}>(${t})`
+        }
+      ],
+      isExported: !0
+    });
+  }
+}
+class de extends C {
+  commandEndpointPathsName = "COMMAND_ENDPOINT_PATHS";
+  defaultCommandClientOptionsName = "DEFAULT_COMMAND_CLIENT_OPTIONS";
+  /**
+   * Creates a new CommandClientGenerator instance.
+   * @param context - The generation context containing OpenAPI spec and project details
+   */
+  constructor(e) {
+    super(e);
+  }
+  /**
+   * Generates command client classes for all aggregates.
+   */
+  generate() {
+    const e = Array.from(this.contextAggregates.values()).flat().length;
+    this.logger?.progress(
+      `Generating command clients for ${e} aggregates`
+    );
+    for (const [, n] of this.contextAggregates)
+      n.forEach((t) => {
+        this.logger?.progress(
+          `Processing command client for aggregate: ${t.aggregate.aggregateName}`
+        ), this.processAggregate(t);
+      });
+    this.logger?.success("Command client generation completed");
+  }
+  /**
+   * Processes and generates command client for an aggregate.
+   * @param aggregate - The aggregate definition
+   */
+  processAggregate(e) {
+    const n = W(
+      this.project,
+      this.outputDir,
+      e.aggregate,
+      "commandClient"
+    );
+    this.processCommandEndpointPaths(n, e), n.addVariableStatement({
+      declarationKind: S.Const,
+      declarations: [
+        {
+          name: this.defaultCommandClientOptionsName,
+          type: "ApiMetadata",
+          initializer: `{
+        basePath: '${e.aggregate.contextAlias}'
+      }`
+        }
+      ],
+      isExported: !1
+    }), n.addImportDeclaration({
+      moduleSpecifier: v,
+      namedImports: [
+        "CommandRequest",
+        "CommandResult",
+        "CommandResultEventStream",
+        "DeleteAggregate",
+        "RecoverAggregate"
+      ],
+      isTypeOnly: !0
+    }), n.addImportDeclaration({
+      moduleSpecifier: "@ahoo-wang/fetcher-eventstream",
+      namedImports: ["JsonEventStreamResultExtractor"]
+    }), N(n, "@ahoo-wang/fetcher", ["ContentTypeValues"]), N(n, "@ahoo-wang/fetcher-decorator", [
+      "type ApiMetadata",
+      "type ApiMetadataCapable",
+      "api",
+      "post",
+      "put",
+      "del",
+      "request",
+      "attribute",
+      "path",
+      "autoGeneratedError"
+    ]), this.processCommandClient(n, e), this.processCommandClient(n, e, !0);
+  }
+  processCommandEndpointPaths(e, n) {
+    const t = e.addEnum({
+      name: this.commandEndpointPathsName
+    });
+    n.commands.forEach((o) => {
+      t.addMember({
+        name: o.name.toUpperCase(),
+        initializer: `'${o.path}'`
+      });
+    });
+  }
+  getEndpointPath(e) {
+    return `${this.commandEndpointPathsName}.${e.name.toUpperCase()}`;
+  }
+  processCommandClient(e, n, t = !1) {
+    let o = "CommandClient", a = {
+      name: "api",
+      arguments: []
+    }, s = "Promise<CommandResult>";
+    t && (o = "Stream" + o, a = {
+      name: "api",
+      arguments: [
+        "''",
+        `{
+  headers: { Accept: ContentTypeValues.TEXT_EVENT_STREAM },
+  resultExtractor: JsonEventStreamResultExtractor,
+}`
+      ]
+    }, s = "Promise<CommandResultEventStream>");
+    const c = le(
+      n.aggregate,
+      o
+    ), i = e.addClass({
+      name: c,
+      isExported: !0,
+      decorators: [a],
+      implements: ["ApiMetadataCapable"]
+    });
+    i.addConstructor({
+      parameters: [
+        {
+          name: "apiMetadata",
+          type: "ApiMetadata",
+          scope: F.Public,
+          isReadonly: !0,
+          initializer: `${this.defaultCommandClientOptionsName}`
+        }
+      ]
+    }), n.commands.forEach((p) => {
+      this.processCommandMethod(e, i, p, s);
+    });
+  }
+  methodToDecorator(e) {
+    return e === "delete" ? "del" : e;
+  }
+  /**
+   * Processes and generates a command method for the command client.
+   * @param sourceFile - The source file containing the client
+   * @param client - The client class declaration
+   * @param definition - The command definition
+   */
+  processCommandMethod(e, n, t, o) {
+    const a = g(t.schema.key);
+    f(e, this.outputDir, a);
+    const s = t.pathParameters.map((i) => ({
+      name: i.name,
+      type: "string",
+      decorators: [
+        {
+          name: "path",
+          arguments: [`'${i.name}'`]
+        }
+      ]
+    }));
+    s.push({
+      name: "commandRequest",
+      type: `CommandRequest<${a.name}>`,
+      decorators: [
+        {
+          name: "request",
+          arguments: []
+        }
+      ]
+    }), s.push({
+      name: "attributes",
+      type: "Record<string, any>",
+      decorators: [
+        {
+          name: "attribute",
+          arguments: []
+        }
+      ]
+    });
+    const c = n.addMethod({
+      name: M(t.name),
+      decorators: [
+        {
+          name: this.methodToDecorator(t.method),
+          arguments: [`${this.getEndpointPath(t)}`]
+        }
+      ],
+      parameters: s,
+      returnType: o,
+      statements: [
+        `throw autoGeneratedError(${s.map((i) => i.name).join(",")});`
+      ]
+    });
+    G(c, t.summary, t.description);
+  }
+}
+class fe extends C {
+  queryClientGenerator;
+  commandClientGenerator;
+  /**
+   * Creates a new ClientGenerator instance.
+   * @param context - The generation context containing OpenAPI spec and project details
+   */
+  constructor(e) {
+    super(e), this.queryClientGenerator = new ge(e), this.commandClientGenerator = new de(e);
+  }
+  /**
+   * Generates client classes for all aggregates.
+   */
+  generate() {
+    this.logger?.progress(
+      `Generating clients for ${this.contextAggregates.size} bounded contexts`
+    );
+    for (const [e] of this.contextAggregates)
+      this.logger?.progress(`Processing bounded context: ${e}`), this.processBoundedContext(e);
+    this.queryClientGenerator.generate(), this.commandClientGenerator.generate(), this.logger?.success("Client generation completed");
+  }
+  /**
+   * Processes a bounded context by creating a file with the context alias constant.
+   * @param contextAlias - The alias of the bounded context to process
+   */
+  processBoundedContext(e) {
+    const n = `${e}/boundedContext.ts`;
+    T(this.project, this.outputDir, n).addStatements(
+      `export const BOUNDED_CONTEXT_ALIAS = '${e}';`
+    );
+  }
+}
+class Se {
+  /**
+   * Creates a new CodeGenerator instance.
+   * @param options - Configuration options for code generation
+   */
+  constructor(e) {
+    this.options = e, this.project = e.project;
+  }
+  project;
+  /**
+   * Generates TypeScript code from the OpenAPI specification.
+   * Parses the OpenAPI spec, resolves aggregates, generates models and clients,
+   * and formats the output files.
+   */
+  async generate() {
+    const e = await z(this.options.inputPath), t = new ce(e).resolve(), o = {
+      openAPI: e,
+      project: this.project,
+      outputDir: this.options.outputDir,
+      contextAggregates: t,
+      logger: this.options.logger
+    };
+    new me(o).generate(), new fe(o).generate(), this.project.getSourceFiles().forEach((c) => {
+      c.formatText(), c.organizeImports(), c.fixMissingImports();
+    }), await this.project.save();
+  }
+}
+export {
+  Se as CodeGenerator
+};