@ahoo-wang/fetcher-generator 2.1.1 → 2.2.0

package/dist/index.js

@@ -1,70 +1,73 @@
-import { VariableDeclarationKind as S, Scope as k } from "ts-morph";
+import { VariableDeclarationKind as O, Scope as L } from "ts-morph";
 import { parse as Q } from "yaml";
-import { readFile as K } from "fs";
-import { ContentTypeValues as T, combineURLs as C } from "@ahoo-wang/fetcher";
-import { ResourceAttributionPathSpec as b } from "@ahoo-wang/fetcher-wow";
-function d(t) {
-  return t.$ref.split("/").pop();
+import * as v from "fs";
+import { readFile as k } from "fs";
+import { ContentTypeValues as I, combineURLs as q } from "@ahoo-wang/fetcher";
+import * as K from "path";
+import { join as U, relative as J } from "path";
+import { ResourceAttributionPathSpec as R } from "@ahoo-wang/fetcher-wow";
+function f(n) {
+  return n.$ref.split("/").pop();
 }
-function R(t, e) {
-  const n = d(t);
-  return e.schemas?.[n];
+function S(n, e) {
+  const t = f(n);
+  return e.schemas?.[t];
 }
-function J(t, e) {
-  const n = d(t);
-  return e.requestBodies?.[n];
+function V(n, e) {
+  const t = f(n);
+  return e.requestBodies?.[t];
 }
-function U(t, e) {
-  const n = d(t);
-  return e.parameters?.[n];
+function H(n, e) {
+  const t = f(n);
+  return e.parameters?.[t];
 }
-function y(t, e) {
+function C(n, e) {
   return {
-    key: d(t),
-    schema: R(t, e)
+    key: f(n),
+    schema: S(n, e)
   };
 }
-const $ = /[-_\s.]+|(?=[A-Z])/;
-function P(t) {
-  if (t === "" || t.length === 0)
+const b = /[-_\s.]+|(?=[A-Z])/;
+function w(n) {
+  if (n === "" || n.length === 0)
     return "";
   let e;
-  return Array.isArray(t) ? e = t.flatMap((n) => n.split($)) : e = t.split($), e.filter((n) => n.length > 0).map((n) => {
-    if (n.length === 0) return "";
-    const r = n.charAt(0), o = n.slice(1);
-    return (/[a-zA-Z]/.test(r) ? r.toUpperCase() : r) + o.toLowerCase();
+  return Array.isArray(n) ? e = n.flatMap((t) => t.split(b)) : e = n.split(b), e.filter((t) => t.length > 0).map((t) => {
+    if (t.length === 0) return "";
+    const o = t.charAt(0), r = t.slice(1);
+    return (/[a-zA-Z]/.test(o) ? o.toUpperCase() : o) + r.toLowerCase();
   }).join("");
 }
-function q(t) {
-  const e = P(t);
+function h(n) {
+  const e = w(n);
   return e.charAt(0).toLowerCase() + e.slice(1);
 }
-function V(t) {
-  return t.startsWith("http://") || t.startsWith("https://") ? z(t) : H(t);
+function Y(n) {
+  return n.startsWith("http://") || n.startsWith("https://") ? X(n) : Z(n);
 }
-async function z(t) {
-  return await (await fetch(t)).text();
+async function X(n) {
+  return await (await fetch(n)).text();
 }
-function H(t) {
-  return new Promise((e, n) => {
-    K(t, "utf-8", (r, o) => {
-      r ? n(r) : e(o);
+function Z(n) {
+  return new Promise((e, t) => {
+    k(n, "utf-8", (o, r) => {
+      o ? t(o) : e(r);
     });
   });
 }
-async function Y(t) {
-  const e = await V(t);
-  switch (Z(e)) {
+async function ee(n) {
+  const e = await Y(n);
+  switch (te(e)) {
     case "json":
       return JSON.parse(e);
     case "yaml":
       return Q(e);
     default:
-      throw new Error(`Unsupported file format: ${t}`);
+      throw new Error(`Unsupported file format: ${n}`);
   }
 }
-function Z(t) {
-  const e = t.trimStart();
+function te(n) {
+  const e = n.trimStart();
   if (e.startsWith("{") || e.startsWith("["))
     return "json";
   if (e.startsWith("-") || e.startsWith("%YAML"))
@@ -77,69 +80,69 @@ function Z(t) {
   }
   throw new Error("Unable to infer file format");
 }
-function u(t) {
-  return !!(t && typeof t == "object" && "$ref" in t);
+function g(n) {
+  return !!(n && typeof n == "object" && "$ref" in n);
 }
-function X(t) {
-  return !t || u(t) || !t.content ? void 0 : t.content[T.APPLICATION_JSON]?.schema;
+function oe(n) {
+  return !n || g(n) || !n.content ? void 0 : n.content[I.APPLICATION_JSON]?.schema;
 }
-function ee(t) {
+function ne(n) {
   return [
-    { method: "get", operation: t.get },
-    { method: "put", operation: t.put },
-    { method: "post", operation: t.post },
-    { method: "delete", operation: t.delete },
-    { method: "options", operation: t.options },
-    { method: "head", operation: t.head },
-    { method: "patch", operation: t.patch },
-    { method: "trace", operation: t.trace }
+    { method: "get", operation: n.get },
+    { method: "put", operation: n.put },
+    { method: "post", operation: n.post },
+    { method: "delete", operation: n.delete },
+    { method: "options", operation: n.options },
+    { method: "head", operation: n.head },
+    { method: "patch", operation: n.patch },
+    { method: "trace", operation: n.trace }
   ].filter(({ operation: e }) => e !== void 0);
 }
-function _(t) {
-  return t.responses[200];
+function G(n) {
+  return n.responses[200];
 }
-function M(t) {
-  const e = _(t);
-  return X(e);
+function M(n) {
+  const e = G(n);
+  return oe(e);
 }
-const te = [
+const re = [
   "string",
   "number",
   "integer",
   "boolean",
   "null"
 ];
-function ne(t) {
-  return Array.isArray(t) ? !0 : te.includes(t);
+function se(n) {
+  return Array.isArray(n) ? !0 : re.includes(n);
 }
-function re(t) {
-  return t.type === "array";
+function ie(n) {
+  return n.type === "array";
 }
-function oe(t) {
-  return Array.isArray(t.enum) && t.enum.length > 0;
+function ae(n) {
+  return Array.isArray(n.enum) && n.enum.length > 0;
 }
-function G(t) {
-  return Array.isArray(t.anyOf) && t.anyOf.length > 0;
+function F(n) {
+  return Array.isArray(n.anyOf) && n.anyOf.length > 0;
 }
-function W(t) {
-  return Array.isArray(t.oneOf) && t.oneOf.length > 0;
+function _(n) {
+  return Array.isArray(n.oneOf) && n.oneOf.length > 0;
 }
-function ae(t) {
-  return G(t) || W(t);
+function ce(n) {
+  return F(n) || _(n);
 }
-function se(t) {
-  return Array.isArray(t.allOf) && t.allOf.length > 0;
+function ge(n) {
+  return Array.isArray(n.allOf) && n.allOf.length > 0;
 }
-function j(t) {
-  return G(t) || W(t) || se(t);
+function j(n) {
+  return F(n) || _(n) || ge(n);
 }
-function ie(t) {
-  return t.includes("|") || t.includes("&") ? `(${t})[]` : `${t}[]`;
+function le(n) {
+  return n.includes("|") || n.includes("&") ? `(${n})[]` : `${n}[]`;
 }
-function x(t) {
-  if (Array.isArray(t))
-    return t.map((e) => x(e)).join(" | ");
-  switch (t) {
+function N(n) {
+  if (Array.isArray(n))
+    return n.map((e) => N(e)).join(" | ");
+  switch (n) {
     case "string":
       return "string";
     case "number":
@@ -153,291 +156,92 @@ function x(t) {
       return "any";
   }
 }
-const E = "@ahoo-wang/fetcher-wow", ce = {
-  "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 l(t) {
-  if (!t)
-    return { name: "", path: "/" };
-  const e = ce[t];
-  if (e)
-    return { name: e, path: E };
-  const n = t.split(".");
-  let r = -1;
-  for (let i = 0; i < n.length; i++)
-    if (n[i] && /^[A-Z]/.test(n[i])) {
-      r = i;
-      break;
-    }
-  if (r === -1)
-    return { name: t, path: "/" };
-  const o = n.slice(0, r), a = o.length > 0 ? `/${o.join("/")}` : "/", s = n.slice(r);
-  return { name: P(s), path: a };
+const W = "types.ts", pe = "@";
+function me(n) {
+  return q(n.path, W);
 }
-class O {
-  /** The ts-morph project instance used for code generation */
-  project;
-  /** The OpenAPI specification object */
-  openAPI;
-  /** The output directory path for generated files */
-  outputDir;
-  /** Map of bounded context aggregates for domain modeling */
-  contextAggregates;
-  /** Optional logger for generation progress and errors */
-  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 ue extends O {
-  constructor(e) {
-    super(e);
-  }
-  getOrCreateSourceFile(e) {
-    const n = B(e);
-    return v(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, r]) => {
-      if (n.startsWith("wow."))
-        return;
-      this.logger.progress(`Processing schema: ${n}`);
-      const o = {
-        key: n,
-        schema: r
-      };
-      this.generateKeyedSchema(o);
-    }), 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({ key: e, schema: n }) {
-    const r = l(e), o = this.getOrCreateSourceFile(r), a = this.process(r, o, n);
-    a && A(a, n.title, n.description);
-  }
-  process(e, n, r) {
-    if (oe(r))
-      return n.addEnum({
-        name: e.name,
-        isExported: !0,
-        members: r.enum.filter((a) => typeof a == "string" && a.length > 0).map((a) => ({
-          name: a,
-          initializer: `'${a}'`
-        }))
-      });
-    const o = n.addInterface({
-      name: e.name,
-      isExported: !0
-    });
-    return r.type === "object" && r.properties ? this.processInterface(n, e, r, o) : (j(r) && (r.anyOf || r.oneOf || r.allOf).forEach((s) => {
-      if (u(s)) {
-        const c = l(d(s));
-        N(e, n, this.outputDir, c), o.addExtends(c.name);
-        return;
-      }
-      this.processInterface(n, e, s, o);
-    }), o);
-  }
-  processObject(e, n, r) {
-    const o = e.addInterface({
-      name: n.name,
-      isExported: !0
-    });
-    return this.processInterface(e, n, r, o);
-  }
-  processInterface(e, n, r, o) {
-    for (const [a, s] of Object.entries(r.properties)) {
-      const c = this.resolvePropertyType(n, e, a, s);
-      let i = o.getProperty(a);
-      i ? i.setType(c) : i = o.addProperty({
-        name: a,
-        type: c
-      }), u(s) || A(i, s.title, s.description);
-    }
-    return o;
-  }
-  resolvePropertyType(e, n, r, o) {
-    if (u(o)) {
-      const a = l(d(o));
-      return N(e, n, this.outputDir, a), a.name;
-    }
-    if (o.const)
-      return `'${o.const}'`;
-    if (re(o)) {
-      const a = this.resolvePropertyType(e, n, r, o.items);
-      return ie(a);
-    }
-    if (o.type && ne(o.type))
-      return x(o.type);
-    if (j(o))
-      return this.resolvePropertyCompositionType(e, n, o);
-    if (o.type === "object" && o.properties) {
-      const a = {
-        path: e.path,
-        name: `${e.name}${P(r)}`
-      }, s = this.processObject(n, a, o);
-      return A(s, o.title, o.description), a.name;
-    }
-    return "any";
-  }
-  resolvePropertyCompositionType(e, n, r) {
-    const o = r.anyOf || r.oneOf || r.allOf, a = /* @__PURE__ */ new Set();
-    o.forEach((c) => {
-      if (u(c)) {
-        const i = l(d(c));
-        N(e, n, this.outputDir, i), a.add(i.name);
-        return;
-      }
-      a.add(x(c.type ?? "string"));
-    });
-    const s = ae(r) ? "|" : "&";
-    return Array.from(a).join(s);
-  }
-}
-const pe = "types.ts", I = "@";
-function B(t) {
-  return C(t.path, pe);
-}
-function v(t, e, n) {
-  const r = C(e, n), o = t.getSourceFile(r);
-  return o || t.createSourceFile(r, "", {
+function D(n, e, t) {
+  const o = q(e, t), r = n.getSourceFile(o);
+  return r || n.createSourceFile(o, "", {
     overwrite: !0
   });
 }
-function w(t, e, n) {
-  let r = t.getImportDeclaration(
-    (o) => o.getModuleSpecifierValue() === e
+function $(n, e, t) {
+  let o = n.getImportDeclaration(
+    (r) => r.getModuleSpecifierValue() === e
   );
-  r || (r = t.addImportDeclaration({
+  o || (o = n.addImportDeclaration({
     moduleSpecifier: e
-  })), n.forEach((o) => {
-    r.getNamedImports().some(
-      (s) => s.getName() === o
-    ) || r.addNamedImport(o);
+  })), t.forEach((r) => {
+    o.getNamedImports().some(
+      (i) => i.getName() === r
+    ) || o.addNamedImport(r);
   });
 }
-function h(t, e, n) {
-  if (n.path === E) {
-    w(t, n.path, [n.name]);
+function y(n, e, t) {
+  if (t.path.startsWith(pe)) {
+    $(n, t.path, [t.name]);
     return;
   }
-  let r = B(n);
-  n.path.startsWith(I) || (r = C(e, r));
-  let o = r;
-  r.startsWith(I) || (o = C(I, r)), w(t, o, [n.name]);
+  const o = n.getDirectoryPath(), r = U(e, t.path, W);
+  let s = J(o, r);
+  s = s.replace(/\.ts$/, ""), s.startsWith(".") || (s = "./" + s), $(n, s, [t.name]);
 }
-function N(t, e, n, r) {
-  t.path !== r.path && h(e, n, r);
+function E(n, e, t, o) {
+  n.path !== o.path && y(e, t, o);
 }
-function me(t, e) {
-  const n = [t, e].filter(
-    (r) => r !== void 0 && r.length > 0
+function de(n, e) {
+  const t = [n, e].filter(
+    (o) => o !== void 0 && o.length > 0
   );
-  return n.length > 0 ? n.join(`
+  return t.length > 0 ? t.join(`
 `) : void 0;
 }
-function A(t, e, n) {
-  const r = me(e, n);
-  r && t.addJsDoc({
-    description: r
+function P(n, e, t) {
+  const o = de(e, t);
+  o && n.addJsDoc({
+    description: o
   });
 }
-function ge(t) {
-  const e = t.split(".");
+function ue(n) {
+  const e = n.split(".");
   return e.length != 2 || e[0].length === 0 || e[1].length === 0 ? null : e;
 }
-function le(t) {
-  const e = ge(t.name);
+function fe(n) {
+  const e = ue(n.name);
   return e ? {
-    tag: t,
+    tag: n,
     contextAlias: e[0],
     aggregateName: e[1]
   } : null;
 }
-function de(t) {
-  const e = t?.map((r) => le(r)).filter((r) => r !== null);
+function he(n) {
+  const e = n?.map((o) => fe(o)).filter((o) => o !== null);
   if (!e)
     return /* @__PURE__ */ new Map();
-  const n = /* @__PURE__ */ new Map();
-  return e.forEach((r) => {
-    n.set(r.tag.name, {
-      aggregate: r,
+  const t = /* @__PURE__ */ new Map();
+  return e.forEach((o) => {
+    t.set(o.tag.name, {
+      aggregate: o,
       commands: /* @__PURE__ */ new Map(),
       events: /* @__PURE__ */ new Map()
     });
-  }), n;
+  }), t;
 }
-function fe(t) {
-  if (!t)
+function ye(n) {
+  if (!n)
     return null;
-  const e = t.split(".");
+  const e = n.split(".");
   return e.length != 3 ? null : e[2];
 }
-const he = "#/components/responses/wow.CommandOk", ye = "#/components/parameters/wow.id";
-class Ae {
+const Ae = "#/components/responses/wow.CommandOk", Ce = "#/components/parameters/wow.id";
+class Pe {
   /**
    * Creates a new AggregateResolver instance.
    * @param openAPI - The OpenAPI specification to resolve aggregates from
    */
   constructor(e) {
-    this.openAPI = e, this.aggregates = de(e.tags), this.build();
+    this.openAPI = e, this.aggregates = he(e.tags), this.build();
   }
   aggregates;
   /**
@@ -445,10 +249,10 @@ class Ae {
    * @private
    */
   build() {
-    for (const [e, n] of Object.entries(this.openAPI.paths)) {
-      const r = ee(n);
-      for (const o of r)
-        this.commands(e, o), this.state(o.operation), this.events(o.operation), this.fields(o.operation);
+    for (const [e, t] of Object.entries(this.openAPI.paths)) {
+      const o = ne(t);
+      for (const r of o)
+        this.commands(e, r), this.state(r.operation), this.events(r.operation), this.fields(r.operation);
     }
   }
   /**
@@ -457,12 +261,12 @@ class Ae {
    */
   resolve() {
     const e = /* @__PURE__ */ new Map();
-    for (const n of this.aggregates.values()) {
-      if (!n.state || !n.fields)
+    for (const t of this.aggregates.values()) {
+      if (!t.state || !t.fields)
         continue;
-      const r = n.aggregate.contextAlias;
-      let o = e.get(r);
-      o || (o = /* @__PURE__ */ new Set(), e.set(r, o)), o.add(n);
+      const o = t.aggregate.contextAlias;
+      let r = e.get(o);
+      r || (r = /* @__PURE__ */ new Set(), e.set(o, r)), r.add(t);
     }
     return e;
   }
@@ -471,44 +275,44 @@ class Ae {
    * @param path - The API path
    * @param methodOperation - The HTTP method and operation details
    */
-  commands(e, n) {
-    const r = n.operation;
-    if (r.operationId === "wow.command.send")
+  commands(e, t) {
+    const o = t.operation;
+    if (o.operationId === "wow.command.send")
       return;
-    const o = fe(r.operationId);
-    if (!o)
+    const r = ye(o.operationId);
+    if (!r)
       return;
-    const a = _(r);
-    if (!a || !u(a) || a.$ref !== he || !r.requestBody)
+    const s = G(o);
+    if (!s || !g(s) || s.$ref !== Ae || !o.requestBody)
       return;
-    const s = r.parameters ?? [], c = s.filter((p) => u(p) && p.$ref === ye).at(0), i = s.filter(
-      (p) => !u(p) && p.in === "path"
+    const i = o.parameters ?? [], c = i.filter((d) => g(d) && d.$ref === Ce).at(0), a = i.filter(
+      (d) => !g(d) && d.in === "path"
     );
     if (c) {
-      const p = U(
+      const d = H(
         c,
         this.openAPI.components
       );
-      i.push(p);
+      a.push(d);
     }
-    const g = r.requestBody.content[T.APPLICATION_JSON].schema, f = y(
-      g,
+    const m = o.requestBody.content[I.APPLICATION_JSON].schema, l = C(
+      m,
       this.openAPI.components
     );
-    f.schema.title = f.schema.title || r.summary, f.schema.description = f.schema.description || r.description;
-    const L = {
-      name: o,
-      method: n.method,
+    l.schema.title = l.schema.title || o.summary, l.schema.description = l.schema.description || o.description;
+    const z = {
+      name: r,
+      method: t.method,
       path: e,
-      pathParameters: i,
-      summary: r.summary,
-      description: r.description,
-      schema: f,
-      operation: r
+      pathParameters: a,
+      summary: o.summary,
+      description: o.description,
+      schema: l,
+      operation: o
     };
-    r.tags?.forEach((p) => {
-      const D = this.aggregates.get(p);
-      D && D.commands.set(o, L);
+    o.tags?.forEach((d) => {
+      const T = this.aggregates.get(d);
+      T && T.commands.set(r, z);
     });
   }
   /**
@@ -518,16 +322,16 @@ class Ae {
   state(e) {
     if (!e.operationId?.endsWith(".snapshot_state.single"))
       return;
-    const n = M(e);
-    if (!u(n))
+    const t = M(e);
+    if (!g(t))
       return;
-    const r = y(
-      n,
+    const o = C(
+      t,
       this.openAPI.components
     );
-    e.tags?.forEach((o) => {
-      const a = this.aggregates.get(o);
-      a && (a.state = r);
+    e.tags?.forEach((r) => {
+      const s = this.aggregates.get(r);
+      s && (s.state = o);
     });
   }
   /**
@@ -537,30 +341,30 @@ class Ae {
   events(e) {
     if (!this.openAPI.components || !e.operationId?.endsWith(".event.list_query"))
       return;
-    const n = M(e);
-    if (u(n))
+    const t = M(e);
+    if (g(t))
       return;
-    const r = n?.items;
-    if (!u(r))
+    const o = t?.items;
+    if (!g(o))
       return;
-    const a = R(
-      r,
+    const s = S(
+      o,
       this.openAPI.components
-    ).properties.body.items.anyOf.map((s) => {
-      const c = s.title, i = s.properties.name.const, m = s.properties.body, g = y(
-        m,
+    ).properties.body.items.anyOf.map((i) => {
+      const c = i.title, a = i.properties.name.const, p = i.properties.body, m = C(
+        p,
         this.openAPI.components
       );
-      return g.schema.title = g.schema.title || s.title, {
+      return m.schema.title = m.schema.title || i.title, {
         title: c,
-        name: i,
-        schema: g
+        name: a,
+        schema: m
       };
     });
-    e.tags?.forEach((s) => {
-      const c = this.aggregates.get(s);
-      c && a.forEach((i) => {
-        c.events.set(i.name, i);
+    e.tags?.forEach((i) => {
+      const c = this.aggregates.get(i);
+      c && s.forEach((a) => {
+        c.events.set(a.name, a);
       });
     });
   }
@@ -571,33 +375,289 @@ class Ae {
   fields(e) {
     if (!this.openAPI.components || !e.operationId?.endsWith(".snapshot.count"))
       return;
-    const r = J(
+    const o = V(
       e.requestBody,
       this.openAPI.components
-    ).content[T.APPLICATION_JSON].schema, a = R(
-      r,
+    ).content[I.APPLICATION_JSON].schema, s = S(
+      o,
       this.openAPI.components
-    ).properties?.field, s = y(a, this.openAPI.components);
+    ).properties?.field, i = C(s, this.openAPI.components);
     e.tags?.forEach((c) => {
-      const i = this.aggregates.get(c);
-      i && (i.fields = s);
+      const a = this.aggregates.get(c);
+      a && (a.fields = i);
+    });
+  }
+}
+const A = "@ahoo-wang/fetcher-wow", $e = {
+  "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 u(n) {
+  if (!n)
+    return { name: "", path: "/" };
+  const e = $e[n];
+  if (e)
+    return { name: e, path: A };
+  const t = n.split(".");
+  let o = -1;
+  for (let a = 0; a < t.length; a++)
+    if (t[a] && /^[A-Z]/.test(t[a])) {
+      o = a;
+      break;
+    }
+  if (o === -1)
+    return { name: n, path: "/" };
+  const r = t.slice(0, o), s = r.length > 0 ? `/${r.join("/")}` : "/", i = t.slice(o);
+  return { name: w(i), path: s };
+}
+class x {
+  /** The ts-morph project instance used for code generation */
+  project;
+  /** The OpenAPI specification object */
+  openAPI;
+  /** The output directory path for generated files */
+  outputDir;
+  /** Map of bounded context aggregates for domain modeling */
+  contextAggregates;
+  /** Optional logger for generation progress and errors */
+  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 we extends x {
+  constructor(e) {
+    super(e);
+  }
+  getOrCreateSourceFile(e) {
+    const t = me(e);
+    return D(this.project, this.outputDir, t);
+  }
+  /**
+   * 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;
+    }
+    const t = Object.entries(e).filter(
+      ([o]) => !o.startsWith("wow.")
+    );
+    this.logger.progress(
+      `Generating models for ${t.length} schemas`
+    ), t.forEach(([o, r], s) => {
+      this.logger.progressWithCount(
+        s + 1,
+        t.length,
+        `Processing schema: ${o}`,
+        2
+      );
+      const i = {
+        key: o,
+        schema: r
+      };
+      this.generateKeyedSchema(i);
+    }), 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({ key: e, schema: t }) {
+    const o = u(e), r = this.getOrCreateSourceFile(o), s = this.process(o, r, t);
+    s && P(s, t.title, t.description);
+  }
+  process(e, t, o) {
+    if (ae(o))
+      return t.addEnum({
+        name: e.name,
+        isExported: !0,
+        members: o.enum.filter((s) => typeof s == "string" && s.length > 0).map((s) => ({
+          name: s,
+          initializer: `'${s}'`
+        }))
+      });
+    const r = t.addInterface({
+      name: e.name,
+      isExported: !0
+    });
+    return o.type === "object" && o.properties ? this.processInterface(
+      t,
+      e,
+      o,
+      r
+    ) : (j(o) && (o.anyOf || o.oneOf || o.allOf).forEach((i) => {
+      if (g(i)) {
+        const c = u(
+          f(i)
+        );
+        E(
+          e,
+          t,
+          this.outputDir,
+          c
+        ), r.addExtends(c.name);
+        return;
+      }
+      this.processInterface(
+        t,
+        e,
+        i,
+        r
+      );
+    }), r);
+  }
+  processObject(e, t, o) {
+    const r = e.addInterface({
+      name: t.name,
+      isExported: !0
+    });
+    return this.processInterface(
+      e,
+      t,
+      o,
+      r
+    );
+  }
+  processInterface(e, t, o, r) {
+    for (const [s, i] of Object.entries(o.properties)) {
+      const c = this.resolvePropertyType(
+        t,
+        e,
+        s,
+        i
+      );
+      let a = r.getProperty(s);
+      a ? a.setType(c) : a = r.addProperty({
+        name: s,
+        type: c
+      }), g(i) || P(a, i.title, i.description);
+    }
+    return r;
+  }
+  resolvePropertyType(e, t, o, r) {
+    if (g(r)) {
+      const s = u(f(r));
+      return E(
+        e,
+        t,
+        this.outputDir,
+        s
+      ), s.name;
+    }
+    if (r.const)
+      return `'${r.const}'`;
+    if (ie(r)) {
+      const s = this.resolvePropertyType(
+        e,
+        t,
+        o,
+        r.items
+      );
+      return le(s);
+    }
+    if (r.type && se(r.type))
+      return N(r.type);
+    if (j(r))
+      return this.resolvePropertyCompositionType(
+        e,
+        t,
+        r
+      );
+    if (r.type === "object" && r.properties) {
+      const s = {
+        path: e.path,
+        name: `${e.name}${w(o)}`
+      }, i = this.processObject(
+        t,
+        s,
+        r
+      );
+      return P(i, r.title, r.description), s.name;
+    }
+    return "any";
+  }
+  resolvePropertyCompositionType(e, t, o) {
+    const r = o.anyOf || o.oneOf || o.allOf, s = /* @__PURE__ */ new Set();
+    r.forEach((c) => {
+      if (g(c)) {
+        const a = u(
+          f(c)
+        );
+        E(
+          e,
+          t,
+          this.outputDir,
+          a
+        ), s.add(a.name);
+        return;
+      }
+      s.add(N(c.type ?? "string"));
     });
+    const i = ce(o) ? "|" : "&";
+    return Array.from(s).join(i);
   }
 }
-function Ce(t) {
-  let e = 0, n = 0;
-  return t.commands.forEach((r) => {
-    r.path.startsWith(b.TENANT) && (e += 1), r.path.startsWith(b.OWNER) && (n += 1);
-  }), e === 0 && n === 0 ? "ResourceAttributionPathSpec.NONE" : e > n ? "ResourceAttributionPathSpec.TENANT" : "ResourceAttributionPathSpec.OWNER";
+function xe(n) {
+  let e = 0, t = 0;
+  return n.commands.forEach((o) => {
+    o.path.startsWith(R.TENANT) && (e += 1), o.path.startsWith(R.OWNER) && (t += 1);
+  }), e === 0 && t === 0 ? "ResourceAttributionPathSpec.NONE" : e > t ? "ResourceAttributionPathSpec.TENANT" : "ResourceAttributionPathSpec.OWNER";
 }
-function F(t, e, n, r) {
-  const o = `${n.contextAlias}/${n.aggregateName}/${r}.ts`;
-  return v(t, e, o);
+function B(n, e, t, o) {
+  const r = `${t.contextAlias}/${t.aggregateName}/${o}.ts`;
+  return D(n, e, r);
 }
-function we(t, e) {
-  return `${P(t.aggregateName)}${e}`;
+function Ee(n, e) {
+  return `${w(n.aggregateName)}${e}`;
 }
-class Pe extends O {
+class Oe extends x {
   /**
    * Creates a new QueryClientGenerator instance.
    * @param context - The generation context containing OpenAPI spec and project details
@@ -609,13 +669,19 @@ class Pe extends O {
    * Generates query client classes for all aggregates.
    */
   generate() {
-    const e = Array.from(this.contextAggregates.values()).flat().length;
-    this.logger.progress(
+    const e = Array.from(this.contextAggregates.values()).reduce(
+      (o, r) => o + r.size,
+      0
+    );
+    this.logger.info("--- Generating Query Clients ---"), this.logger.progress(
       `Generating query clients for ${e} aggregates`
     );
-    for (const [, n] of this.contextAggregates)
-      n.forEach((r) => {
-        this.logger.progress(
+    let t = 0;
+    for (const [, o] of this.contextAggregates)
+      o.forEach((r) => {
+        t++, this.logger.progressWithCount(
+          t,
+          e,
           `Processing query client for aggregate: ${r.aggregate.aggregateName}`
         ), this.processQueryClient(r);
       });
@@ -627,12 +693,12 @@ class Pe extends O {
    * @param fileName - The name of the client file
    * @returns The source file for the client
    */
-  createClientFilePath(e, n) {
-    return F(
+  createClientFilePath(e, t) {
+    return B(
       this.project,
       this.outputDir,
       e,
-      n
+      t
     );
   }
   /**
@@ -640,58 +706,77 @@ class Pe extends O {
    * @param aggregate - The aggregate definition
    */
   processQueryClient(e) {
-    const n = this.createClientFilePath(
+    const t = this.createClientFilePath(
       e.aggregate,
       "queryClient"
     );
-    n.addImportDeclaration({
-      moduleSpecifier: E,
+    this.logger.info(
+      `Processing query client for aggregate: ${e.aggregate.aggregateName} in context: ${e.aggregate.contextAlias}`
+    ), this.logger.info(
+      `Adding imports from ${A}: QueryClientFactory, QueryClientOptions, ResourceAttributionPathSpec`
+    ), t.addImportDeclaration({
+      moduleSpecifier: A,
       namedImports: [
         "QueryClientFactory",
         "QueryClientOptions",
         "ResourceAttributionPathSpec"
       ]
     });
-    const r = "DEFAULT_QUERY_CLIENT_OPTIONS";
-    n.addVariableStatement({
-      declarationKind: S.Const,
+    const o = "DEFAULT_QUERY_CLIENT_OPTIONS";
+    this.logger.info(
+      `Creating default query client options: ${o}`
+    ), t.addVariableStatement({
+      declarationKind: O.Const,
       declarations: [
         {
-          name: r,
+          name: o,
           type: "QueryClientOptions",
           initializer: `{
         contextAlias: '${e.aggregate.contextAlias}',
         aggregateName: '${e.aggregate.aggregateName}',
-        resourceAttribution: ${Ce(e)},
+        resourceAttribution: ${xe(e)},
       }`
         }
       ],
       isExported: !1
     });
-    const o = [];
+    const r = [];
+    this.logger.info(
+      `Processing ${e.events.size} domain events for aggregate: ${e.aggregate.aggregateName}`
+    );
     for (const m of e.events.values()) {
-      const g = l(m.schema.key);
-      h(n, this.outputDir, g), o.push(g);
+      const l = u(m.schema.key);
+      this.logger.info(
+        `Adding import for event model: ${l.name} from path: ${l.path}`
+      ), y(t, this.outputDir, l), r.push(l);
     }
-    const a = "DOMAIN_EVENT_TYPES";
-    n.addTypeAlias({
-      name: a,
-      type: o.map((m) => m.name).join(" | ")
+    const s = "DOMAIN_EVENT_TYPES", i = r.map((m) => m.name).join(" | ");
+    this.logger.info(
+      `Creating domain event types union: ${s} = ${i}`
+    ), t.addTypeAlias({
+      name: s,
+      type: i
     });
-    const s = `${q(e.aggregate.aggregateName)}QueryClientFactory`, c = l(e.state.key), i = l(e.fields.key);
-    h(n, this.outputDir, c), h(n, this.outputDir, i), n.addVariableStatement({
-      declarationKind: S.Const,
+    const c = `${h(e.aggregate.aggregateName)}QueryClientFactory`, a = u(e.state.key), p = u(e.fields.key);
+    this.logger.info(
+      `Adding import for state model: ${a.name} from path: ${a.path}`
+    ), y(t, this.outputDir, a), this.logger.info(
+      `Adding import for fields model: ${p.name} from path: ${p.path}`
+    ), y(t, this.outputDir, p), this.logger.info(`Creating query client factory: ${c}`), t.addVariableStatement({
+      declarationKind: O.Const,
       declarations: [
         {
-          name: s,
-          initializer: `new QueryClientFactory<${c.name}, ${i.name} | string, ${a}>(${r})`
+          name: c,
+          initializer: `new QueryClientFactory<${a.name}, ${p.name} | string, ${s}>(${o})`
         }
       ],
       isExported: !0
-    });
+    }), this.logger.success(
+      `Query client generation completed for aggregate: ${e.aggregate.aggregateName}`
+    );
   }
 }
-class Ee extends O {
+class Ie extends x {
   commandEndpointPathsName = "COMMAND_ENDPOINT_PATHS";
   defaultCommandClientOptionsName = "DEFAULT_COMMAND_CLIENT_OPTIONS";
   /**
@@ -705,13 +790,19 @@ class Ee extends O {
    * Generates command client classes for all aggregates.
    */
   generate() {
-    const e = Array.from(this.contextAggregates.values()).flat().length;
-    this.logger.progress(
+    const e = Array.from(this.contextAggregates.values()).reduce(
+      (o, r) => o + r.size,
+      0
+    );
+    this.logger.info("--- Generating Command Clients ---"), this.logger.progress(
       `Generating command clients for ${e} aggregates`
     );
-    for (const [, n] of this.contextAggregates)
-      n.forEach((r) => {
-        this.logger.progress(
+    let t = 0;
+    for (const [, o] of this.contextAggregates)
+      o.forEach((r) => {
+        t++, this.logger.progressWithCount(
+          t,
+          e,
           `Processing command client for aggregate: ${r.aggregate.aggregateName}`
         ), this.processAggregate(r);
       });
@@ -722,14 +813,21 @@ class Ee extends O {
    * @param aggregate - The aggregate definition
    */
   processAggregate(e) {
-    const n = F(
+    this.logger.info(
+      `Processing command client for aggregate: ${e.aggregate.aggregateName} in context: ${e.aggregate.contextAlias}`
+    );
+    const t = B(
       this.project,
       this.outputDir,
       e.aggregate,
       "commandClient"
     );
-    this.processCommandEndpointPaths(n, e), n.addVariableStatement({
-      declarationKind: S.Const,
+    this.logger.info(
+      `Processing command endpoint paths for ${e.commands.size} commands`
+    ), this.processCommandEndpointPaths(t, e), this.logger.info(
+      `Creating default command client options: ${this.defaultCommandClientOptionsName}`
+    ), t.addVariableStatement({
+      declarationKind: O.Const,
       declarations: [
         {
           name: this.defaultCommandClientOptionsName,
@@ -740,8 +838,10 @@ class Ee extends O {
         }
       ],
       isExported: !1
-    }), n.addImportDeclaration({
-      moduleSpecifier: E,
+    }), this.logger.info(
+      `Adding imports from ${A}: CommandRequest, CommandResult, CommandResultEventStream, DeleteAggregate, RecoverAggregate`
+    ), t.addImportDeclaration({
+      moduleSpecifier: A,
       namedImports: [
         "CommandRequest",
         "CommandResult",
@@ -750,10 +850,16 @@ class Ee extends O {
         "RecoverAggregate"
       ],
       isTypeOnly: !0
-    }), n.addImportDeclaration({
+    }), this.logger.info(
+      "Adding import from @ahoo-wang/fetcher-eventstream: JsonEventStreamResultExtractor"
+    ), t.addImportDeclaration({
       moduleSpecifier: "@ahoo-wang/fetcher-eventstream",
       namedImports: ["JsonEventStreamResultExtractor"]
-    }), w(n, "@ahoo-wang/fetcher", ["ContentTypeValues"]), w(n, "@ahoo-wang/fetcher-decorator", [
+    }), this.logger.info(
+      "Adding import from @ahoo-wang/fetcher: ContentTypeValues"
+    ), $(t, "@ahoo-wang/fetcher", ["ContentTypeValues"]), this.logger.info(
+      "Adding imports from @ahoo-wang/fetcher-decorator: ApiMetadata types and decorators"
+    ), $(t, "@ahoo-wang/fetcher-decorator", [
       "type ApiMetadata",
       "type ApiMetadataCapable",
       "api",
@@ -765,28 +871,37 @@ class Ee extends O {
       "attribute",
       "path",
       "autoGeneratedError"
-    ]), this.processCommandClient(n, e), this.processCommandClient(n, e, !0);
+    ]), this.logger.info("Generating standard command client class"), this.processCommandClient(t, e), this.logger.info("Generating stream command client class"), this.processCommandClient(t, e, !0), this.logger.success(
+      `Command client generation completed for aggregate: ${e.aggregate.aggregateName}`
+    );
   }
-  processCommandEndpointPaths(e, n) {
-    const r = e.addEnum({
+  processCommandEndpointPaths(e, t) {
+    this.logger.info(
+      `Creating command endpoint paths enum: ${this.commandEndpointPathsName}`
+    );
+    const o = e.addEnum({
       name: this.commandEndpointPathsName
     });
-    n.commands.forEach((o) => {
-      r.addMember({
-        name: o.name.toUpperCase(),
-        initializer: `'${o.path}'`
+    t.commands.forEach((r) => {
+      this.logger.info(
+        `Adding command endpoint: ${r.name.toUpperCase()} = '${r.path}'`
+      ), o.addMember({
+        name: r.name.toUpperCase(),
+        initializer: `'${r.path}'`
       });
-    });
+    }), this.logger.success(
+      `Command endpoint paths enum created with ${t.commands.size} entries`
+    );
   }
   getEndpointPath(e) {
     return `${this.commandEndpointPathsName}.${e.name.toUpperCase()}`;
   }
-  processCommandClient(e, n, r = !1) {
-    let o = "CommandClient", a = {
+  processCommandClient(e, t, o = !1) {
+    let r = "CommandClient", s = {
       name: "api",
       arguments: []
-    }, s = "Promise<CommandResult>";
-    r && (o = "Stream" + o, a = {
+    }, i = "Promise<CommandResult>";
+    o && (r = "Stream" + r, s = {
       name: "api",
       arguments: [
         "''",
@@ -795,28 +910,28 @@ class Ee extends O {
   resultExtractor: JsonEventStreamResultExtractor,
 }`
       ]
-    }, s = "Promise<CommandResultEventStream>");
-    const c = we(
-      n.aggregate,
-      o
-    ), i = e.addClass({
+    }, i = "Promise<CommandResultEventStream>");
+    const c = Ee(
+      t.aggregate,
+      r
+    ), a = e.addClass({
       name: c,
       isExported: !0,
-      decorators: [a],
+      decorators: [s],
       implements: ["ApiMetadataCapable"]
     });
-    i.addConstructor({
+    a.addConstructor({
       parameters: [
         {
           name: "apiMetadata",
           type: "ApiMetadata",
-          scope: k.Public,
+          scope: L.Public,
           isReadonly: !0,
           initializer: `${this.defaultCommandClientOptionsName}`
         }
       ]
-    }), n.commands.forEach((m) => {
-      this.processCommandMethod(e, i, m, s);
+    }), t.commands.forEach((p) => {
+      this.processCommandMethod(e, a, p, i);
     });
   }
   methodToDecorator(e) {
@@ -828,29 +943,41 @@ class Ee extends O {
    * @param client - The client class declaration
    * @param definition - The command definition
    */
-  processCommandMethod(e, n, r, o) {
-    const a = l(r.schema.key);
-    h(e, this.outputDir, a);
-    const s = r.pathParameters.map((i) => ({
-      name: i.name,
+  processCommandMethod(e, t, o, r) {
+    const s = u(o.schema.key);
+    this.logger.info(
+      `Adding import for command model: ${s.name} from path: ${s.path}`
+    ), y(e, this.outputDir, s), this.logger.info(
+      `Generating command method: ${h(o.name)} for command: ${o.name}`
+    ), this.logger.info(
+      `Command method details: HTTP ${o.method}, path: ${o.path}, return type: ${r}`
+    );
+    const i = o.pathParameters.map((a) => (this.logger.info(
+      `Adding path parameter: ${a.name} (type: string)`
+    ), {
+      name: a.name,
       type: "string",
       decorators: [
         {
           name: "path",
-          arguments: [`'${i.name}'`]
+          arguments: [`'${a.name}'`]
         }
       ]
     }));
-    s.push({
+    this.logger.info(
+      `Adding command request parameter: commandRequest (type: CommandRequest<${s.name}>)`
+    ), i.push({
       name: "commandRequest",
-      type: `CommandRequest<${a.name}>`,
+      type: `CommandRequest<${s.name}>`,
       decorators: [
         {
           name: "request",
           arguments: []
         }
       ]
-    }), s.push({
+    }), this.logger.info(
+      "Adding attributes parameter: attributes (type: Record<string, any>)"
+    ), i.push({
       name: "attributes",
       type: "Record<string, any>",
       decorators: [
@@ -860,24 +987,28 @@ class Ee extends O {
         }
       ]
     });
-    const c = n.addMethod({
-      name: q(r.name),
+    const c = t.addMethod({
+      name: h(o.name),
       decorators: [
         {
-          name: this.methodToDecorator(r.method),
-          arguments: [`${this.getEndpointPath(r)}`]
+          name: this.methodToDecorator(o.method),
+          arguments: [`${this.getEndpointPath(o)}`]
         }
       ],
-      parameters: s,
-      returnType: o,
+      parameters: i,
+      returnType: r,
       statements: [
-        `throw autoGeneratedError(${s.map((i) => i.name).join(",")});`
+        `throw autoGeneratedError(${i.map((a) => a.name).join(",")});`
       ]
     });
-    A(c, r.summary, r.description);
+    (o.summary || o.description) && this.logger.info(
+      `Adding JSDoc documentation for method: ${h(o.name)}`
+    ), P(c, o.summary, o.description), this.logger.success(
+      `Command method generated: ${h(o.name)}`
+    );
   }
 }
-class Oe extends O {
+class Se extends x {
   queryClientGenerator;
   commandClientGenerator;
   /**
@@ -885,17 +1016,23 @@ class Oe extends O {
    * @param context - The generation context containing OpenAPI spec and project details
    */
   constructor(e) {
-    super(e), this.queryClientGenerator = new Pe(e), this.commandClientGenerator = new Ee(e);
+    super(e), this.queryClientGenerator = new Oe(e), this.commandClientGenerator = new Ie(e);
   }
   /**
    * Generates client classes for all aggregates.
    */
   generate() {
-    this.logger.progress(
+    this.logger.info("--- Generating Clients ---"), 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);
+    let e = 0;
+    for (const [t] of this.contextAggregates)
+      e++, this.logger.progressWithCount(
+        e,
+        this.contextAggregates.size,
+        `Processing bounded context: ${t}`,
+        1
+      ), this.processBoundedContext(t);
     this.queryClientGenerator.generate(), this.commandClientGenerator.generate(), this.logger.success("Client generation completed");
   }
   /**
@@ -903,19 +1040,25 @@ class Oe extends O {
    * @param contextAlias - The alias of the bounded context to process
    */
   processBoundedContext(e) {
-    const n = `${e}/boundedContext.ts`;
-    v(this.project, this.outputDir, n).addStatements(
+    const t = `${e}/boundedContext.ts`;
+    this.logger.info(`Creating bounded context file: ${t}`);
+    const o = D(this.project, this.outputDir, t);
+    this.logger.info(
+      `Adding bounded context alias constant: BOUNDED_CONTEXT_ALIAS = '${e}'`
+    ), o.addStatements(
       `export const BOUNDED_CONTEXT_ALIAS = '${e}';`
+    ), this.logger.success(
+      `Bounded context file created successfully: ${t}`
     );
   }
 }
-class xe {
+class Me {
   /**
    * Creates a new CodeGenerator instance.
    * @param options - Configuration options for code generation
    */
   constructor(e) {
-    this.options = e, this.project = e.project;
+    this.options = e, this.project = e.project, this.options.logger.info("CodeGenerator instance created");
   }
   project;
   /**
@@ -924,19 +1067,113 @@ class xe {
    * and formats the output files.
    */
   async generate() {
-    const e = await Y(this.options.inputPath), r = new Ae(e).resolve(), o = {
+    this.options.logger.info(
+      "Starting code generation from OpenAPI specification"
+    ), this.options.logger.info(`Input path: ${this.options.inputPath}`), this.options.logger.info(`Output directory: ${this.options.outputDir}`), this.options.logger.info("Parsing OpenAPI specification");
+    const e = await ee(this.options.inputPath);
+    this.options.logger.info("OpenAPI specification parsed successfully"), this.options.logger.info("Resolving bounded context aggregates");
+    const o = new Pe(e).resolve();
+    this.options.logger.info(
+      `Resolved ${o.size} bounded context aggregates`
+    );
+    const r = {
       openAPI: e,
       project: this.project,
       outputDir: this.options.outputDir,
-      contextAggregates: r,
+      contextAggregates: o,
       logger: this.options.logger
     };
-    new ue(o).generate(), new Oe(o).generate(), this.project.getSourceFiles().forEach((c) => {
-      c.formatText(), c.organizeImports(), c.fixMissingImports();
-    }), await this.project.save();
+    this.options.logger.info("Generating models"), new we(r).generate(), this.options.logger.info("Models generated successfully"), this.options.logger.info("Generating clients"), new Se(r).generate(), this.options.logger.info("Clients generated successfully"), this.options.logger.info("Generating index files"), this.generateIndex(), this.options.logger.info("Index files generated successfully"), this.options.logger.info("Optimizing source files"), this.optimizeSourceFiles(), this.options.logger.info("Source files optimized successfully"), this.options.logger.info("Saving project to disk"), await this.project.save(), this.options.logger.info("Code generation completed successfully");
+  }
+  /**
+   * Generates index.ts files for all subdirectories in the output directory.
+   * Scans all directories, gets all .ts files in each directory,
+   * and creates index.ts files with export * from './xxx' statements.
+   */
+  generateIndex() {
+    this.options.logger.info(
+      `Generating index files for output directory: ${this.options.outputDir}`
+    );
+    const e = this.project.getDirectory(this.options.outputDir);
+    if (!e) {
+      this.options.logger.info(
+        "Output directory not found, skipping index generation"
+      );
+      return;
+    }
+    this.processDirectory(e), this.options.logger.info("Index file generation completed");
+  }
+  processDirectory(e) {
+    const t = e.getDirectories();
+    this.options.logger.info(`Processing ${t.length} subdirectories`);
+    for (const o of t)
+      this.options.logger.info(`Processing subdirectory: ${o.getPath()}`), this.generateIndexForDirectory(o), this.processDirectory(o);
+  }
+  /**
+   * Generates an index.ts file for a specific directory.
+   * @param dir - The directory to generate index.ts for
+   */
+  generateIndexForDirectory(e) {
+    const t = e.getPath();
+    this.options.logger.info(`Generating index for directory: ${t}`);
+    const o = e.getSourceFiles().filter(
+      (c) => c.getBaseName().endsWith(".ts") && c.getBaseName() !== "index.ts"
+    );
+    let r = [];
+    try {
+      r = v.readdirSync(t).filter((c) => {
+        const a = K.join(t, c);
+        return v.statSync(a).isDirectory();
+      });
+    } catch (c) {
+      this.options.logger.error(
+        `Failed to read subdirectories for ${t}: ${c}`
+      );
+    }
+    if (this.options.logger.info(
+      `Found ${o.length} TypeScript files and ${r.length} subdirectories in ${t}`
+    ), o.length === 0 && r.length === 0) {
+      this.options.logger.info(
+        `No files or subdirectories to export in ${t}, skipping index generation`
+      );
+      return;
+    }
+    const s = `${t}/index.ts`;
+    this.options.logger.info(`Creating/updating index file: ${s}`);
+    const i = this.project.getSourceFile(s) || this.project.createSourceFile(s, "", { overwrite: !0 });
+    i.removeText();
+    for (const c of o) {
+      const a = `./${c.getBaseNameWithoutExtension()}`;
+      this.options.logger.info(`Adding export for file: ${a}`), i.addExportDeclaration({
+        moduleSpecifier: a,
+        isTypeOnly: !1,
+        namedExports: []
+      });
+    }
+    for (const c of r) {
+      const a = `./${c}`;
+      this.options.logger.info(
+        `Adding export for subdirectory: ${a}`
+      ), i.addExportDeclaration({
+        moduleSpecifier: a,
+        isTypeOnly: !1,
+        namedExports: []
+      });
+    }
+    this.options.logger.info(
+      `Index file generated for ${t} with ${o.length + r.length} exports`
+    );
+  }
+  optimizeSourceFiles() {
+    const e = this.project.getSourceFiles();
+    this.options.logger.info(`Optimizing ${e.length} source files`), e.forEach((t, o) => {
+      this.options.logger.info(
+        `Optimizing file ${o + 1}/${e.length}`
+      ), t.formatText(), t.organizeImports(), t.fixMissingImports();
+    }), this.options.logger.info("All source files optimized");
   }
 }
 export {
-  xe as CodeGenerator
+  Me as CodeGenerator
 };
 //# sourceMappingURL=index.js.map