@ahoo-wang/fetcher-generator 2.1.0 → 2.2.0

package/dist/index.js

@@ -1,70 +1,73 @@
-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 { VariableDeclarationKind as O, Scope as L } from "ts-morph";
+import { parse as Q } from "yaml";
+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 h(r) {
-  return r.$ref.split("/").pop();
+function f(n) {
+  return n.$ref.split("/").pop();
 }
-function E(r, e) {
-  const n = h(r);
-  return e.schemas?.[n];
+function S(n, e) {
+  const t = f(n);
+  return e.schemas?.[t];
 }
-function Q(r, e) {
-  const n = h(r);
-  return e.requestBodies?.[n];
+function V(n, e) {
+  const t = f(n);
+  return e.requestBodies?.[t];
 }
-function k(r, e) {
-  const n = h(r);
-  return e.parameters?.[n];
+function H(n, e) {
+  const t = f(n);
+  return e.parameters?.[t];
 }
-function y(r, e) {
+function C(n, e) {
   return {
-    key: h(r),
-    schema: E(r, e)
+    key: f(n),
+    schema: S(n, e)
   };
 }
-const x = /[-_\s.]+|(?=[A-Z])/;
-function O(r) {
-  if (r === "" || r.length === 0)
+const b = /[-_\s.]+|(?=[A-Z])/;
+function w(n) {
+  if (n === "" || n.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();
+  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 M(r) {
-  const e = O(r);
+function h(n) {
+  const e = w(n);
   return e.charAt(0).toLowerCase() + e.slice(1);
 }
-function U(r) {
-  return r.startsWith("http://") || r.startsWith("https://") ? J(r) : V(r);
+function Y(n) {
+  return n.startsWith("http://") || n.startsWith("https://") ? X(n) : Z(n);
 }
-async function J(r) {
-  return await (await fetch(r)).text();
+async function X(n) {
+  return await (await fetch(n)).text();
 }
-function V(r) {
-  return new Promise((e, n) => {
-    K(r, "utf-8", (t, o) => {
-      t ? n(t) : e(o);
+function Z(n) {
+  return new Promise((e, t) => {
+    k(n, "utf-8", (o, r) => {
+      o ? t(o) : e(r);
     });
   });
 }
-async function z(r) {
-  const e = await U(r);
-  switch (H(e)) {
+async function ee(n) {
+  const e = await Y(n);
+  switch (te(e)) {
     case "json":
       return JSON.parse(e);
     case "yaml":
-      return L(e);
+      return Q(e);
     default:
-      throw new Error(`Unsupported file format: ${r}`);
+      throw new Error(`Unsupported file format: ${n}`);
   }
 }
-function H(r) {
-  const e = r.trimStart();
+function te(n) {
+  const e = n.trimStart();
   if (e.startsWith("{") || e.startsWith("["))
     return "json";
   if (e.startsWith("-") || e.startsWith("%YAML"))
@@ -77,38 +80,69 @@ function H(r) {
   }
   throw new Error("Unable to infer file format");
 }
-function l(r) {
-  return !!(r && typeof r == "object" && "$ref" in r);
+function g(n) {
+  return !!(n && typeof n == "object" && "$ref" in n);
 }
-function Y(r) {
-  return !r || l(r) || !r.content ? void 0 : r.content[P.APPLICATION_JSON]?.schema;
+function oe(n) {
+  return !n || g(n) || !n.content ? void 0 : n.content[I.APPLICATION_JSON]?.schema;
 }
-function Z(r) {
+function ne(n) {
   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 }
+    { 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 j(r) {
-  return r.responses[200];
+function G(n) {
+  return n.responses[200];
 }
-function b(r) {
-  const e = j(r);
-  return Y(e);
+function M(n) {
+  const e = G(n);
+  return oe(e);
 }
-function X(r) {
-  return Array.isArray(r.enum) && r.enum.length > 0;
+const re = [
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "null"
+];
+function se(n) {
+  return Array.isArray(n) ? !0 : re.includes(n);
 }
-function $(r) {
-  if (Array.isArray(r))
-    return r.map((e) => $(e)).join(" | ");
-  switch (r) {
+function ie(n) {
+  return n.type === "array";
+}
+function ae(n) {
+  return Array.isArray(n.enum) && n.enum.length > 0;
+}
+function F(n) {
+  return Array.isArray(n.anyOf) && n.anyOf.length > 0;
+}
+function _(n) {
+  return Array.isArray(n.oneOf) && n.oneOf.length > 0;
+}
+function ce(n) {
+  return F(n) || _(n);
+}
+function ge(n) {
+  return Array.isArray(n.allOf) && n.allOf.length > 0;
+}
+function j(n) {
+  return F(n) || _(n) || ge(n);
+}
+function le(n) {
+  return n.includes("|") || n.includes("&") ? `(${n})[]` : `${n}[]`;
+}
+function N(n) {
+  if (Array.isArray(n))
+    return n.map((e) => N(e)).join(" | ");
+  switch (n) {
     case "string":
       return "string";
     case "number":
@@ -122,93 +156,92 @@ function $(r) {
       return "any";
   }
 }
-const ee = "types.ts", w = "@";
-function q(r) {
-  return A(r.path, ee);
+const W = "types.ts", pe = "@";
+function me(n) {
+  return q(n.path, W);
 }
-function T(r, e, n) {
-  const t = A(e, n), o = r.getSourceFile(t);
-  return o || r.createSourceFile(t, "", {
+function D(n, e, t) {
+  const o = q(e, t), r = n.getSourceFile(o);
+  return r || n.createSourceFile(o, "", {
     overwrite: !0
   });
 }
-function N(r, e, n) {
-  let t = r.getImportDeclaration(
-    (o) => o.getModuleSpecifierValue() === e
+function $(n, e, t) {
+  let o = n.getImportDeclaration(
+    (r) => r.getModuleSpecifierValue() === e
   );
-  t || (t = r.addImportDeclaration({
+  o || (o = n.addImportDeclaration({
     moduleSpecifier: e
-  })), n.forEach((o) => {
-    t.getNamedImports().some(
-      (s) => s.getName() === o
-    ) || t.addNamedImport(o);
+  })), t.forEach((r) => {
+    o.getNamedImports().some(
+      (i) => i.getName() === r
+    ) || o.addNamedImport(r);
   });
 }
-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 y(n, e, t) {
+  if (t.path.startsWith(pe)) {
+    $(n, t.path, [t.name]);
+    return;
+  }
+  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 te(r, e, n, t) {
-  r.path !== t.path && f(e, n, t);
+function E(n, e, t, o) {
+  n.path !== o.path && y(e, t, o);
 }
-function _(r, e) {
-  const n = [r, e].filter(
-    (t) => t !== void 0 && t.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 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 P(n, e, t) {
+  const o = de(e, t);
+  o && n.addJsDoc({
+    description: o
   });
 }
-function ne(r) {
-  const e = r.split(".");
+function ue(n) {
+  const e = n.split(".");
   return e.length != 2 || e[0].length === 0 || e[1].length === 0 ? null : e;
 }
-function re(r) {
-  const e = ne(r.name);
+function fe(n) {
+  const e = ue(n.name);
   return e ? {
-    tag: r,
+    tag: n,
     contextAlias: e[0],
     aggregateName: e[1]
   } : null;
 }
-function oe(r) {
-  const e = r?.map((t) => re(t)).filter((t) => t !== 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((t) => {
-    n.set(t.tag.name, {
-      aggregate: t,
+  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 ae(r) {
-  if (!r)
+function ye(n) {
+  if (!n)
     return null;
-  const e = r.split(".");
+  const e = n.split(".");
   return e.length != 3 ? null : e[2];
 }
-const se = "#/components/responses/wow.CommandOk", ie = "#/components/parameters/wow.id";
-class ce {
+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 = oe(e.tags), this.build();
+    this.openAPI = e, this.aggregates = he(e.tags), this.build();
   }
   aggregates;
   /**
@@ -216,10 +249,10 @@ class ce {
    * @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);
+    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);
     }
   }
   /**
@@ -228,12 +261,12 @@ class ce {
    */
   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 t = n.aggregate.contextAlias;
-      let o = e.get(t);
-      o || (o = /* @__PURE__ */ new Set(), e.set(t, 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;
   }
@@ -242,44 +275,44 @@ class ce {
    * @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")
+  commands(e, t) {
+    const o = t.operation;
+    if (o.operationId === "wow.command.send")
       return;
-    const o = ae(t.operationId);
-    if (!o)
+    const r = ye(o.operationId);
+    if (!r)
       return;
-    const a = j(t);
-    if (!a || !l(a) || a.$ref !== se || !t.requestBody)
+    const s = G(o);
+    if (!s || !g(s) || s.$ref !== Ae || !o.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"
+    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 m = k(
+      const d = H(
         c,
         this.openAPI.components
       );
-      i.push(m);
+      a.push(d);
     }
-    const u = t.requestBody.content[P.APPLICATION_JSON].schema, d = y(
-      u,
+    const m = o.requestBody.content[I.APPLICATION_JSON].schema, l = C(
+      m,
       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,
+    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: t.summary,
-      description: t.description,
-      schema: d,
-      operation: t
+      pathParameters: a,
+      summary: o.summary,
+      description: o.description,
+      schema: l,
+      operation: o
     };
-    t.tags?.forEach((m) => {
-      const I = this.aggregates.get(m);
-      I && I.commands.set(o, B);
+    o.tags?.forEach((d) => {
+      const T = this.aggregates.get(d);
+      T && T.commands.set(r, z);
     });
   }
   /**
@@ -289,16 +322,16 @@ class ce {
   state(e) {
     if (!e.operationId?.endsWith(".snapshot_state.single"))
       return;
-    const n = b(e);
-    if (!l(n))
+    const t = M(e);
+    if (!g(t))
       return;
-    const t = y(
-      n,
+    const o = C(
+      t,
       this.openAPI.components
     );
-    e.tags?.forEach((o) => {
-      const a = this.aggregates.get(o);
-      a && (a.state = t);
+    e.tags?.forEach((r) => {
+      const s = this.aggregates.get(r);
+      s && (s.state = o);
     });
   }
   /**
@@ -308,30 +341,30 @@ class ce {
   events(e) {
     if (!this.openAPI.components || !e.operationId?.endsWith(".event.list_query"))
       return;
-    const n = b(e);
-    if (l(n))
+    const t = M(e);
+    if (g(t))
       return;
-    const t = n?.items;
-    if (!l(t))
+    const o = t?.items;
+    if (!g(o))
       return;
-    const a = E(
-      t,
+    const s = S(
+      o,
       this.openAPI.components
-    ).properties.body.items.anyOf.map((s) => {
-      const c = s.title, i = s.properties.name.const, p = s.properties.body, u = y(
+    ).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 u.schema.title = u.schema.title || s.title, {
+      return m.schema.title = m.schema.title || i.title, {
         title: c,
-        name: i,
-        schema: u
+        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);
       });
     });
   }
@@ -342,20 +375,20 @@ class ce {
   fields(e) {
     if (!this.openAPI.components || !e.operationId?.endsWith(".snapshot.count"))
       return;
-    const t = Q(
+    const o = V(
       e.requestBody,
       this.openAPI.components
-    ).content[P.APPLICATION_JSON].schema, a = E(
-      t,
+    ).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 v = "@ahoo-wang/fetcher-wow", pe = {
+const A = "@ahoo-wang/fetcher-wow", $e = {
   "wow.command.CommandResult": "CommandResult",
   "wow.MessageHeaderSqlType": "MessageHeaderSqlType",
   "wow.api.BindingError": "BindingError",
@@ -384,29 +417,34 @@ const v = "@ahoo-wang/fetcher-wow", pe = {
   "wow.openapi.BatchResult": "BatchResult",
   "wow.messaging.CompensationTarget": "CompensationTarget"
 };
-function g(r) {
-  if (!r)
+function u(n) {
+  if (!n)
     return { name: "", path: "/" };
-  const e = pe[r];
+  const e = $e[n];
   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;
+    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 (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 };
+  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 C {
+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.
@@ -416,13 +454,13 @@ class C {
     this.project = e.project, this.openAPI = e.openAPI, this.outputDir = e.outputDir, this.contextAggregates = e.contextAggregates, this.logger = e.logger;
   }
 }
-class me extends C {
+class we extends x {
   constructor(e) {
     super(e);
   }
   getOrCreateSourceFile(e) {
-    const n = q(e);
-    return T(this.project, this.outputDir, n);
+    const t = me(e);
+    return D(this.project, this.outputDir, t);
   }
   /**
    * Generates models for all schemas in the OpenAPI specification.
@@ -435,14 +473,27 @@ class me extends C {
   generate() {
     const e = this.openAPI.components?.schemas;
     if (!e) {
-      this.logger?.info("No schemas found in OpenAPI specification");
+      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");
+    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.
@@ -458,174 +509,155 @@ class me extends C {
    * 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;
+  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, 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({
+  process(e, t, o) {
+    if (ae(o))
+      return t.addEnum({
         name: e.name,
         isExported: !0,
-        members: t.enum.filter((o) => typeof o == "string" && o.length > 0).map((o) => ({
-          name: o,
-          initializer: `'${o}'`
+        members: o.enum.filter((s) => typeof s == "string" && s.length > 0).map((s) => ({
+          name: s,
+          initializer: `'${s}'`
         }))
       });
-  }
-  /**
-   * 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({
+    const r = t.addInterface({
       name: e.name,
-      isExported: !0,
-      properties: Object.entries(o).map(([s, c]) => ({
-        name: s,
-        type: c
-      }))
+      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);
   }
-  /**
-   * 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)
+  processObject(e, t, o) {
+    const r = e.addInterface({
+      name: t.name,
+      isExported: !0
     });
+    return this.processInterface(
+      e,
+      t,
+      o,
+      r
+    );
   }
-  /**
-   * 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;
+  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;
   }
-  /**
-   * 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;
+  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 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 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 W(r, e, n, t) {
-  const o = `${n.contextAlias}/${n.aggregateName}/${t}.ts`;
-  return T(r, e, o);
+function B(n, e, t, o) {
+  const r = `${t.contextAlias}/${t.aggregateName}/${o}.ts`;
+  return D(n, e, r);
 }
-function le(r, e) {
-  return `${O(r.aggregateName)}${e}`;
+function Ee(n, e) {
+  return `${w(n.aggregateName)}${e}`;
 }
-class ge extends C {
+class Oe extends x {
   /**
    * Creates a new QueryClientGenerator instance.
    * @param context - The generation context containing OpenAPI spec and project details
@@ -637,17 +669,23 @@ class ge extends C {
    * 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((t) => {
-        this.logger?.progress(
-          `Processing query client for aggregate: ${t.aggregate.aggregateName}`
-        ), this.processQueryClient(t);
+    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);
       });
-    this.logger?.success("Query client generation completed");
+    this.logger.success("Query client generation completed");
   }
   /**
    * Creates or retrieves a source file for client generation.
@@ -655,12 +693,12 @@ class ge extends C {
    * @param fileName - The name of the client file
    * @returns The source file for the client
    */
-  createClientFilePath(e, n) {
-    return W(
+  createClientFilePath(e, t) {
+    return B(
       this.project,
       this.outputDir,
       e,
-      n
+      t
     );
   }
   /**
@@ -668,58 +706,77 @@ class ge extends C {
    * @param aggregate - The aggregate definition
    */
   processQueryClient(e) {
-    const n = this.createClientFilePath(
+    const t = this.createClientFilePath(
       e.aggregate,
       "queryClient"
     );
-    n.addImportDeclaration({
-      moduleSpecifier: v,
+    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 t = "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: t,
+          name: o,
           type: "QueryClientOptions",
           initializer: `{
         contextAlias: '${e.aggregate.contextAlias}',
         aggregateName: '${e.aggregate.aggregateName}',
-        resourceAttribution: ${ue(e)},
+        resourceAttribution: ${xe(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 r = [];
+    this.logger.info(
+      `Processing ${e.events.size} domain events for aggregate: ${e.aggregate.aggregateName}`
+    );
+    for (const m of e.events.values()) {
+      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((p) => p.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 = `${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,
+    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}>(${t})`
+          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 de extends C {
+class Ie extends x {
   commandEndpointPathsName = "COMMAND_ENDPOINT_PATHS";
   defaultCommandClientOptionsName = "DEFAULT_COMMAND_CLIENT_OPTIONS";
   /**
@@ -733,31 +790,44 @@ class de extends C {
    * 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((t) => {
-        this.logger?.progress(
-          `Processing command client for aggregate: ${t.aggregate.aggregateName}`
-        ), this.processAggregate(t);
+    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);
       });
-    this.logger?.success("Command client generation completed");
+    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.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,
@@ -768,8 +838,10 @@ class de extends C {
         }
       ],
       isExported: !1
-    }), n.addImportDeclaration({
-      moduleSpecifier: v,
+    }), this.logger.info(
+      `Adding imports from ${A}: CommandRequest, CommandResult, CommandResultEventStream, DeleteAggregate, RecoverAggregate`
+    ), t.addImportDeclaration({
+      moduleSpecifier: A,
       namedImports: [
         "CommandRequest",
         "CommandResult",
@@ -778,42 +850,58 @@ class de extends C {
         "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"]
-    }), N(n, "@ahoo-wang/fetcher", ["ContentTypeValues"]), N(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",
       "post",
       "put",
+      "patch",
       "del",
       "request",
       "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 t = 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) => {
-      t.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, t = !1) {
-    let o = "CommandClient", a = {
+  processCommandClient(e, t, o = !1) {
+    let r = "CommandClient", s = {
       name: "api",
       arguments: []
-    }, s = "Promise<CommandResult>";
-    t && (o = "Stream" + o, a = {
+    }, i = "Promise<CommandResult>";
+    o && (r = "Stream" + r, s = {
       name: "api",
       arguments: [
         "''",
@@ -822,28 +910,28 @@ class de extends C {
   resultExtractor: JsonEventStreamResultExtractor,
 }`
       ]
-    }, s = "Promise<CommandResultEventStream>");
-    const c = le(
-      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: F.Public,
+          scope: L.Public,
           isReadonly: !0,
           initializer: `${this.defaultCommandClientOptionsName}`
         }
       ]
-    }), n.commands.forEach((p) => {
-      this.processCommandMethod(e, i, p, s);
+    }), t.commands.forEach((p) => {
+      this.processCommandMethod(e, a, p, i);
     });
   }
   methodToDecorator(e) {
@@ -855,29 +943,41 @@ class de extends C {
    * @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,
+  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: [
@@ -887,24 +987,28 @@ class de extends C {
         }
       ]
     });
-    const c = n.addMethod({
-      name: M(t.name),
+    const c = t.addMethod({
+      name: h(o.name),
       decorators: [
         {
-          name: this.methodToDecorator(t.method),
-          arguments: [`${this.getEndpointPath(t)}`]
+          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(",")});`
       ]
     });
-    G(c, t.summary, t.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 fe extends C {
+class Se extends x {
   queryClientGenerator;
   commandClientGenerator;
   /**
@@ -912,37 +1016,49 @@ class fe extends C {
    * @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);
+    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);
-    this.queryClientGenerator.generate(), this.commandClientGenerator.generate(), this.logger?.success("Client generation completed");
+    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");
   }
   /**
    * 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(
+    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 Se {
+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;
   /**
@@ -951,18 +1067,113 @@ class Se {
    * and formats the output files.
    */
   async generate() {
-    const e = await z(this.options.inputPath), t = new ce(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: t,
+      contextAggregates: o,
       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();
+    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 {
-  Se as CodeGenerator
+  Me as CodeGenerator
 };
+//# sourceMappingURL=index.js.map