@ahoo-wang/fetcher-generator 2.1.0 → 2.1.1

package/dist/index.js

@@ -1,70 +1,70 @@
-import { VariableDeclarationKind as S, Scope as F } from "ts-morph";
-import { parse as L } from "yaml";
+import { VariableDeclarationKind as S, Scope as k } from "ts-morph";
+import { parse as Q } from "yaml";
 import { readFile as K } from "fs";
-import { ContentTypeValues as P, combineURLs as A } from "@ahoo-wang/fetcher";
-import { ResourceAttributionPathSpec as R } from "@ahoo-wang/fetcher-wow";
-function h(r) {
-  return r.$ref.split("/").pop();
+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();
 }
-function E(r, e) {
-  const n = h(r);
+function R(t, e) {
+  const n = d(t);
   return e.schemas?.[n];
 }
-function Q(r, e) {
-  const n = h(r);
+function J(t, e) {
+  const n = d(t);
   return e.requestBodies?.[n];
 }
-function k(r, e) {
-  const n = h(r);
+function U(t, e) {
+  const n = d(t);
   return e.parameters?.[n];
 }
-function y(r, e) {
+function y(t, e) {
   return {
-    key: h(r),
-    schema: E(r, e)
+    key: d(t),
+    schema: R(t, e)
   };
 }
-const x = /[-_\s.]+|(?=[A-Z])/;
-function O(r) {
-  if (r === "" || r.length === 0)
+const $ = /[-_\s.]+|(?=[A-Z])/;
+function P(t) {
+  if (t === "" || t.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) => {
+  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 t = n.charAt(0), o = n.slice(1);
-    return (/[a-zA-Z]/.test(t) ? t.toUpperCase() : t) + o.toLowerCase();
+    const r = n.charAt(0), o = n.slice(1);
+    return (/[a-zA-Z]/.test(r) ? r.toUpperCase() : r) + o.toLowerCase();
   }).join("");
 }
-function M(r) {
-  const e = O(r);
+function q(t) {
+  const e = P(t);
   return e.charAt(0).toLowerCase() + e.slice(1);
 }
-function U(r) {
-  return r.startsWith("http://") || r.startsWith("https://") ? J(r) : V(r);
+function V(t) {
+  return t.startsWith("http://") || t.startsWith("https://") ? z(t) : H(t);
 }
-async function J(r) {
-  return await (await fetch(r)).text();
+async function z(t) {
+  return await (await fetch(t)).text();
 }
-function V(r) {
+function H(t) {
   return new Promise((e, n) => {
-    K(r, "utf-8", (t, o) => {
-      t ? n(t) : e(o);
+    K(t, "utf-8", (r, o) => {
+      r ? n(r) : e(o);
     });
   });
 }
-async function z(r) {
-  const e = await U(r);
-  switch (H(e)) {
+async function Y(t) {
+  const e = await V(t);
+  switch (Z(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: ${t}`);
   }
 }
-function H(r) {
-  const e = r.trimStart();
+function Z(t) {
+  const e = t.trimStart();
   if (e.startsWith("{") || e.startsWith("["))
     return "json";
   if (e.startsWith("-") || e.startsWith("%YAML"))
@@ -77,38 +77,69 @@ function H(r) {
   }
   throw new Error("Unable to infer file format");
 }
-function l(r) {
-  return !!(r && typeof r == "object" && "$ref" in r);
+function u(t) {
+  return !!(t && typeof t == "object" && "$ref" in t);
 }
-function Y(r) {
-  return !r || l(r) || !r.content ? void 0 : r.content[P.APPLICATION_JSON]?.schema;
+function X(t) {
+  return !t || u(t) || !t.content ? void 0 : t.content[T.APPLICATION_JSON]?.schema;
 }
-function Z(r) {
+function ee(t) {
   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: 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 }
   ].filter(({ operation: e }) => e !== void 0);
 }
-function j(r) {
-  return r.responses[200];
+function _(t) {
+  return t.responses[200];
 }
-function b(r) {
-  const e = j(r);
-  return Y(e);
+function M(t) {
+  const e = _(t);
+  return X(e);
 }
-function X(r) {
-  return Array.isArray(r.enum) && r.enum.length > 0;
+const te = [
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "null"
+];
+function ne(t) {
+  return Array.isArray(t) ? !0 : te.includes(t);
 }
-function $(r) {
-  if (Array.isArray(r))
-    return r.map((e) => $(e)).join(" | ");
-  switch (r) {
+function re(t) {
+  return t.type === "array";
+}
+function oe(t) {
+  return Array.isArray(t.enum) && t.enum.length > 0;
+}
+function G(t) {
+  return Array.isArray(t.anyOf) && t.anyOf.length > 0;
+}
+function W(t) {
+  return Array.isArray(t.oneOf) && t.oneOf.length > 0;
+}
+function ae(t) {
+  return G(t) || W(t);
+}
+function se(t) {
+  return Array.isArray(t.allOf) && t.allOf.length > 0;
+}
+function j(t) {
+  return G(t) || W(t) || se(t);
+}
+function ie(t) {
+  return t.includes("|") || t.includes("&") ? `(${t})[]` : `${t}[]`;
+}
+function x(t) {
+  if (Array.isArray(t))
+    return t.map((e) => x(e)).join(" | ");
+  switch (t) {
     case "string":
       return "string";
     case "number":
@@ -122,93 +153,291 @@ function $(r) {
       return "any";
   }
 }
-const ee = "types.ts", w = "@";
-function q(r) {
-  return A(r.path, ee);
+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 };
+}
+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;
+  }
 }
-function T(r, e, n) {
-  const t = A(e, n), o = r.getSourceFile(t);
-  return o || r.createSourceFile(t, "", {
+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, "", {
     overwrite: !0
   });
 }
-function N(r, e, n) {
-  let t = r.getImportDeclaration(
+function w(t, e, n) {
+  let r = t.getImportDeclaration(
     (o) => o.getModuleSpecifierValue() === e
   );
-  t || (t = r.addImportDeclaration({
+  r || (r = t.addImportDeclaration({
     moduleSpecifier: e
   })), n.forEach((o) => {
-    t.getNamedImports().some(
+    r.getNamedImports().some(
       (s) => s.getName() === o
-    ) || t.addNamedImport(o);
+    ) || r.addNamedImport(o);
   });
 }
-function f(r, e, n) {
-  let t = q(n);
-  n.path.startsWith(w) || (t = A(e, t));
-  let o = t;
-  t.startsWith(w) || (o = A(w, t)), N(r, o, [n.name]);
+function h(t, e, n) {
+  if (n.path === E) {
+    w(t, n.path, [n.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]);
 }
-function te(r, e, n, t) {
-  r.path !== t.path && f(e, n, t);
+function N(t, e, n, r) {
+  t.path !== r.path && h(e, n, r);
 }
-function _(r, e) {
-  const n = [r, e].filter(
-    (t) => t !== void 0 && t.length > 0
+function me(t, e) {
+  const n = [t, e].filter(
+    (r) => r !== void 0 && r.length > 0
   );
   return n.length > 0 ? n.join(`
 `) : void 0;
 }
-function D(r, e) {
-  const n = _(r, e);
-  return n ? [n] : [];
-}
-function G(r, e, n) {
-  const t = _(e, n);
-  t && r.addJsDoc({
-    description: t
+function A(t, e, n) {
+  const r = me(e, n);
+  r && t.addJsDoc({
+    description: r
   });
 }
-function ne(r) {
-  const e = r.split(".");
+function ge(t) {
+  const e = t.split(".");
   return e.length != 2 || e[0].length === 0 || e[1].length === 0 ? null : e;
 }
-function re(r) {
-  const e = ne(r.name);
+function le(t) {
+  const e = ge(t.name);
   return e ? {
-    tag: r,
+    tag: t,
     contextAlias: e[0],
     aggregateName: e[1]
   } : null;
 }
-function oe(r) {
-  const e = r?.map((t) => re(t)).filter((t) => t !== null);
+function de(t) {
+  const e = t?.map((r) => le(r)).filter((r) => r !== null);
   if (!e)
     return /* @__PURE__ */ new Map();
   const n = /* @__PURE__ */ new Map();
-  return e.forEach((t) => {
-    n.set(t.tag.name, {
-      aggregate: t,
+  return e.forEach((r) => {
+    n.set(r.tag.name, {
+      aggregate: r,
       commands: /* @__PURE__ */ new Map(),
       events: /* @__PURE__ */ new Map()
     });
   }), n;
 }
-function ae(r) {
-  if (!r)
+function fe(t) {
+  if (!t)
     return null;
-  const e = r.split(".");
+  const e = t.split(".");
   return e.length != 3 ? null : e[2];
 }
-const se = "#/components/responses/wow.CommandOk", ie = "#/components/parameters/wow.id";
-class ce {
+const he = "#/components/responses/wow.CommandOk", ye = "#/components/parameters/wow.id";
+class Ae {
   /**
    * 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 = de(e.tags), this.build();
   }
   aggregates;
   /**
@@ -217,8 +446,8 @@ class ce {
    */
   build() {
     for (const [e, n] of Object.entries(this.openAPI.paths)) {
-      const t = Z(n);
-      for (const o of t)
+      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);
     }
   }
@@ -231,9 +460,9 @@ class ce {
     for (const n of this.aggregates.values()) {
       if (!n.state || !n.fields)
         continue;
-      const t = n.aggregate.contextAlias;
-      let o = e.get(t);
-      o || (o = /* @__PURE__ */ new Set(), e.set(t, o)), o.add(n);
+      const r = n.aggregate.contextAlias;
+      let o = e.get(r);
+      o || (o = /* @__PURE__ */ new Set(), e.set(r, o)), o.add(n);
     }
     return e;
   }
@@ -243,43 +472,43 @@ class ce {
    * @param methodOperation - The HTTP method and operation details
    */
   commands(e, n) {
-    const t = n.operation;
-    if (t.operationId === "wow.command.send")
+    const r = n.operation;
+    if (r.operationId === "wow.command.send")
       return;
-    const o = ae(t.operationId);
+    const o = fe(r.operationId);
     if (!o)
       return;
-    const a = j(t);
-    if (!a || !l(a) || a.$ref !== se || !t.requestBody)
+    const a = _(r);
+    if (!a || !u(a) || a.$ref !== he || !r.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 s = r.parameters ?? [], c = s.filter((p) => u(p) && p.$ref === ye).at(0), i = s.filter(
+      (p) => !u(p) && p.in === "path"
     );
     if (c) {
-      const m = k(
+      const p = U(
         c,
         this.openAPI.components
       );
-      i.push(m);
+      i.push(p);
     }
-    const u = t.requestBody.content[P.APPLICATION_JSON].schema, d = y(
-      u,
+    const g = r.requestBody.content[T.APPLICATION_JSON].schema, f = y(
+      g,
       this.openAPI.components
     );
-    d.schema.title = d.schema.title || t.summary, d.schema.description = d.schema.description || t.description;
-    const B = {
+    f.schema.title = f.schema.title || r.summary, f.schema.description = f.schema.description || r.description;
+    const L = {
       name: o,
       method: n.method,
       path: e,
       pathParameters: i,
-      summary: t.summary,
-      description: t.description,
-      schema: d,
-      operation: t
+      summary: r.summary,
+      description: r.description,
+      schema: f,
+      operation: r
     };
-    t.tags?.forEach((m) => {
-      const I = this.aggregates.get(m);
-      I && I.commands.set(o, B);
+    r.tags?.forEach((p) => {
+      const D = this.aggregates.get(p);
+      D && D.commands.set(o, L);
     });
   }
   /**
@@ -289,16 +518,16 @@ class ce {
   state(e) {
     if (!e.operationId?.endsWith(".snapshot_state.single"))
       return;
-    const n = b(e);
-    if (!l(n))
+    const n = M(e);
+    if (!u(n))
       return;
-    const t = y(
+    const r = y(
       n,
       this.openAPI.components
     );
     e.tags?.forEach((o) => {
       const a = this.aggregates.get(o);
-      a && (a.state = t);
+      a && (a.state = r);
     });
   }
   /**
@@ -308,24 +537,24 @@ class ce {
   events(e) {
     if (!this.openAPI.components || !e.operationId?.endsWith(".event.list_query"))
       return;
-    const n = b(e);
-    if (l(n))
+    const n = M(e);
+    if (u(n))
       return;
-    const t = n?.items;
-    if (!l(t))
+    const r = n?.items;
+    if (!u(r))
       return;
-    const a = E(
-      t,
+    const a = R(
+      r,
       this.openAPI.components
     ).properties.body.items.anyOf.map((s) => {
-      const c = s.title, i = s.properties.name.const, p = s.properties.body, u = y(
-        p,
+      const c = s.title, i = s.properties.name.const, m = s.properties.body, g = y(
+        m,
         this.openAPI.components
       );
-      return u.schema.title = u.schema.title || s.title, {
+      return g.schema.title = g.schema.title || s.title, {
         title: c,
         name: i,
-        schema: u
+        schema: g
       };
     });
     e.tags?.forEach((s) => {
@@ -342,11 +571,11 @@ class ce {
   fields(e) {
     if (!this.openAPI.components || !e.operationId?.endsWith(".snapshot.count"))
       return;
-    const t = Q(
+    const r = J(
       e.requestBody,
       this.openAPI.components
-    ).content[P.APPLICATION_JSON].schema, a = E(
-      t,
+    ).content[T.APPLICATION_JSON].schema, a = R(
+      r,
       this.openAPI.components
     ).properties?.field, s = y(a, this.openAPI.components);
     e.tags?.forEach((c) => {
@@ -355,277 +584,20 @@ class ce {
     });
   }
 }
-const v = "@ahoo-wang/fetcher-wow", pe = {
-  "wow.command.CommandResult": "CommandResult",
-  "wow.MessageHeaderSqlType": "MessageHeaderSqlType",
-  "wow.api.BindingError": "BindingError",
-  "wow.api.DefaultErrorInfo": "ErrorInfo",
-  "wow.api.RecoverableType": "RecoverableType",
-  "wow.api.command.DefaultDeleteAggregate": "DeleteAggregate",
-  "wow.api.command.DefaultRecoverAggregate": "RecoverAggregate",
-  "wow.api.messaging.FunctionInfoData": "FunctionInfo",
-  "wow.api.messaging.FunctionKind": "FunctionKind",
-  "wow.api.modeling.AggregateId": "AggregateId",
-  "wow.api.query.Condition": "Condition",
-  "wow.api.query.ConditionOptions": "ConditionOptions",
-  "wow.api.query.ListQuery": "ListQuery",
-  "wow.api.query.Operator": "Operator",
-  "wow.api.query.PagedQuery": "PagedQuery",
-  "wow.api.query.Pagination": "Pagination",
-  "wow.api.query.Projection": "Projection",
-  "wow.api.query.Sort": "FieldSort",
-  "wow.api.query.Sort.Direction": "SortDirection",
-  "wow.command.CommandStage": "CommandStage",
-  "wow.command.SimpleWaitSignal": "WaitSignal",
-  "wow.configuration.Aggregate": "Aggregate",
-  "wow.configuration.BoundedContext": "BoundedContext",
-  "wow.configuration.WowMetadata": "WowMetadata",
-  "wow.modeling.DomainEvent": "DomainEvent",
-  "wow.openapi.BatchResult": "BatchResult",
-  "wow.messaging.CompensationTarget": "CompensationTarget"
-};
-function g(r) {
-  if (!r)
-    return { name: "", path: "/" };
-  const e = pe[r];
-  if (e)
-    return { name: e, path: v };
-  const n = r.split(".");
-  let t = -1;
-  for (let i = 0; i < n.length; i++)
-    if (n[i] && /^[A-Z]/.test(n[i])) {
-      t = i;
-      break;
-    }
-  if (t === -1)
-    return { name: r, path: "/" };
-  const o = n.slice(0, t), a = o.length > 0 ? `/${o.join("/")}` : "/", s = n.slice(t);
-  return { name: O(s), path: a };
-}
-class C {
-  project;
-  openAPI;
-  outputDir;
-  contextAggregates;
-  logger;
-  /**
-   * Creates a new ClientGenerator instance.
-   * @param context - The generation context containing OpenAPI spec and project details
-   */
-  constructor(e) {
-    this.project = e.project, this.openAPI = e.openAPI, this.outputDir = e.outputDir, this.contextAggregates = e.contextAggregates, this.logger = e.logger;
-  }
-}
-class me extends C {
-  constructor(e) {
-    super(e);
-  }
-  getOrCreateSourceFile(e) {
-    const n = q(e);
-    return T(this.project, this.outputDir, n);
-  }
-  /**
-   * Generates models for all schemas in the OpenAPI specification.
-   * Skips schemas with keys starting with 'wow.'.
-   *
-   * @remarks
-   * This method iterates through all schemas in the OpenAPI specification
-   * and generates corresponding TypeScript models for each one.
-   */
-  generate() {
-    const e = this.openAPI.components?.schemas;
-    if (!e) {
-      this.logger?.info("No schemas found in OpenAPI specification");
-      return;
-    }
-    this.logger?.progress(
-      `Generating models for ${Object.keys(e).length} schemas`
-    ), Object.entries(e).forEach(([n, t]) => {
-      n.startsWith("wow.") || (this.logger?.progress(`Processing schema: ${n}`), this.generateKeyedSchema(n, t));
-    }), this.logger?.success("Model generation completed");
-  }
-  /**
-   * Generates a model for a specific schema key.
-   * Processes enums, objects, unions, and type aliases in order.
-   *
-   * @param schemaKey - The key of the schema to generate
-   * @param schema - The schema definition
-   *
-   * @remarks
-   * The generation process follows this order:
-   * 1. Enum processing
-   * 2. Object processing
-   * 3. Union processing
-   * 4. Type alias processing
-   */
-  generateKeyedSchema(e, n) {
-    const t = g(e), o = this.getOrCreateSourceFile(t), a = this.process(t, o, n);
-    return G(a, n.title, n.description), o;
-  }
-  process(e, n, t) {
-    let o = this.processEnum(
-      e,
-      n,
-      t
-    );
-    return o || (o = this.processObject(e, n, t), o) || (o = this.processUnion(e, n, t), o) ? o : this.processTypeAlias(e, n, t);
-  }
-  /**
-   * Processes enum schemas and generates TypeScript enums.
-   *
-   * @param modelInfo - The model information
-   * @param sourceFile - The source file to add the enum to
-   * @param schema - The enum schema
-   * @returns true if the schema was processed as an enum, false otherwise
-   *
-   * @remarks
-   * This method filters out non-string enum values and generates
-   * a TypeScript enum with string literal initializers.
-   */
-  processEnum(e, n, t) {
-    if (X(t))
-      return n.addEnum({
-        name: e.name,
-        isExported: !0,
-        members: t.enum.filter((o) => typeof o == "string" && o.length > 0).map((o) => ({
-          name: o,
-          initializer: `'${o}'`
-        }))
-      });
-  }
-  /**
-   * Processes object schemas and generates TypeScript interfaces.
-   *
-   * @param modelInfo - The model information
-   * @param sourceFile - The source file to add the interface to
-   * @param schema - The object schema
-   * @returns true if the schema was processed as an object, false otherwise
-   *
-   * @remarks
-   * This method handles optional properties by checking the required array
-   * and adds undefined union types for optional properties.
-   */
-  processObject(e, n, t) {
-    if (t.type !== "object" || !t.properties)
-      return;
-    const o = {}, a = t.required || [];
-    for (const [s, c] of Object.entries(t.properties)) {
-      const i = this.resolveType(e, n, c), p = !a.includes(s);
-      o[s] = p ? `${i} | undefined` : i;
-    }
-    return n.addInterface({
-      name: e.name,
-      isExported: !0,
-      properties: Object.entries(o).map(([s, c]) => ({
-        name: s,
-        type: c
-      }))
-    });
-  }
-  /**
-   * Processes union schemas (allOf, anyOf, oneOf) and generates TypeScript type aliases.
-   *
-   * @param modelInfo - The model information
-   * @param sourceFile - The source file to add the type alias to
-   * @param schema - The union schema
-   * @returns true if the schema was processed as a union, false otherwise
-   *
-   * @remarks
-   * This method handles three types of unions:
-   * - allOf: Generates intersection types (&)
-   * - anyOf: Generates union types (|)
-   * - oneOf: Generates union types (|)
-   */
-  processUnion(e, n, t) {
-    let o = null;
-    if (t.allOf ? o = t.allOf.map((a) => this.resolveType(e, n, a)).join(" & ") : t.anyOf ? o = t.anyOf.map((a) => this.resolveType(e, n, a)).join(" | ") : t.oneOf && (o = t.oneOf.map((a) => this.resolveType(e, n, a)).join(" | ")), !!o)
-      return n.addTypeAlias({
-        name: e.name,
-        type: o,
-        isExported: !0,
-        docs: D(t.title, t.description)
-      });
-  }
-  /**
-   * Processes type alias schemas and generates TypeScript type aliases.
-   *
-   * @param modelInfo - The model information
-   * @param sourceFile - The source file to add the type alias to
-   * @param schema - The schema to process
-   *
-   * @remarks
-   * This method is used as a fallback for schemas that don't match
-   * enum, object, or union patterns. It resolves the type and creates
-   * a simple type alias.
-   */
-  processTypeAlias(e, n, t) {
-    const o = this.resolveType(e, n, t);
-    return n.addTypeAlias({
-      name: e.name,
-      type: o,
-      isExported: !0,
-      docs: D(t.title, t.description)
-    });
-  }
-  /**
-   * Resolves the TypeScript type for a given schema or reference.
-   * Handles arrays, objects, primitives, and references.
-   *
-   * @param modelInfo - The model information
-   * @param sourceFile - The source file for import management
-   * @param schema - The schema or reference to resolve
-   * @returns The resolved TypeScript type as a string
-   *
-   * @remarks
-   * This method handles various schema types:
-   * - References: Resolves to imported types
-   * - Arrays: Resolves item types and adds array notation
-   * - Objects: Resolves to Record<string, any> for generic objects
-   * - Primitives: Maps to TypeScript primitives
-   * - Nullable: Adds null union type
-   */
-  resolveType(e, n, t) {
-    if (l(t))
-      return this.resolveReference(e, n, t);
-    if (t.type === "array")
-      return `${t.items ? this.resolveType(e, n, t.items) : "any"}[]`;
-    if (t.type === "object" && !t.properties)
-      return "Record<string, any>";
-    let o;
-    return t.type ? o = $(t.type) : o = "any", t.nullable && (o = `${o} | null`), o;
-  }
-  /**
-   * Resolves a reference to another schema.
-   * Handles mapped types and imports.
-   *
-   * @param modelInfo - The current model information
-   * @param sourceFile - The source file for import management
-   * @param ref - The reference to resolve
-   * @returns The resolved type name
-   *
-   * @remarks
-   * This method checks for mapped types first (WOW_TYPE_MAPPING).
-   * If not found, it adds an import for the referenced model.
-   */
-  resolveReference(e, n, t) {
-    const o = h(t), a = g(o);
-    return te(e, n, this.outputDir, a), a.name;
-  }
-}
-function ue(r) {
+function Ce(t) {
   let e = 0, n = 0;
-  return r.commands.forEach((t) => {
-    t.path.startsWith(R.TENANT) && (e += 1), t.path.startsWith(R.OWNER) && (n += 1);
+  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 W(r, e, n, t) {
-  const o = `${n.contextAlias}/${n.aggregateName}/${t}.ts`;
-  return T(r, e, o);
+function F(t, e, n, r) {
+  const o = `${n.contextAlias}/${n.aggregateName}/${r}.ts`;
+  return v(t, e, o);
 }
-function le(r, e) {
-  return `${O(r.aggregateName)}${e}`;
+function we(t, e) {
+  return `${P(t.aggregateName)}${e}`;
 }
-class ge extends C {
+class Pe extends O {
   /**
    * Creates a new QueryClientGenerator instance.
    * @param context - The generation context containing OpenAPI spec and project details
@@ -638,16 +610,16 @@ class ge extends C {
    */
   generate() {
     const e = Array.from(this.contextAggregates.values()).flat().length;
-    this.logger?.progress(
+    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);
+      n.forEach((r) => {
+        this.logger.progress(
+          `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.
@@ -656,7 +628,7 @@ class ge extends C {
    * @returns The source file for the client
    */
   createClientFilePath(e, n) {
-    return W(
+    return F(
       this.project,
       this.outputDir,
       e,
@@ -673,53 +645,53 @@ class ge extends C {
       "queryClient"
     );
     n.addImportDeclaration({
-      moduleSpecifier: v,
+      moduleSpecifier: E,
       namedImports: [
         "QueryClientFactory",
         "QueryClientOptions",
         "ResourceAttributionPathSpec"
       ]
     });
-    const t = "DEFAULT_QUERY_CLIENT_OPTIONS";
+    const r = "DEFAULT_QUERY_CLIENT_OPTIONS";
     n.addVariableStatement({
       declarationKind: S.Const,
       declarations: [
         {
-          name: t,
+          name: r,
           type: "QueryClientOptions",
           initializer: `{
         contextAlias: '${e.aggregate.contextAlias}',
         aggregateName: '${e.aggregate.aggregateName}',
-        resourceAttribution: ${ue(e)},
+        resourceAttribution: ${Ce(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);
+    for (const m of e.events.values()) {
+      const g = l(m.schema.key);
+      h(n, this.outputDir, g), o.push(g);
     }
     const a = "DOMAIN_EVENT_TYPES";
     n.addTypeAlias({
       name: a,
-      type: o.map((p) => p.name).join(" | ")
+      type: o.map((m) => m.name).join(" | ")
     });
-    const s = `${M(e.aggregate.aggregateName)}QueryClientFactory`, c = g(e.state.key), i = g(e.fields.key);
-    f(n, this.outputDir, c), f(n, this.outputDir, i), n.addVariableStatement({
+    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,
       declarations: [
         {
           name: s,
-          initializer: `new QueryClientFactory<${c.name}, ${i.name} | string, ${a}>(${t})`
+          initializer: `new QueryClientFactory<${c.name}, ${i.name} | string, ${a}>(${r})`
         }
       ],
       isExported: !0
     });
   }
 }
-class de extends C {
+class Ee extends O {
   commandEndpointPathsName = "COMMAND_ENDPOINT_PATHS";
   defaultCommandClientOptionsName = "DEFAULT_COMMAND_CLIENT_OPTIONS";
   /**
@@ -734,23 +706,23 @@ class de extends C {
    */
   generate() {
     const e = Array.from(this.contextAggregates.values()).flat().length;
-    this.logger?.progress(
+    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);
+      n.forEach((r) => {
+        this.logger.progress(
+          `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(
+    const n = F(
       this.project,
       this.outputDir,
       e.aggregate,
@@ -769,7 +741,7 @@ class de extends C {
       ],
       isExported: !1
     }), n.addImportDeclaration({
-      moduleSpecifier: v,
+      moduleSpecifier: E,
       namedImports: [
         "CommandRequest",
         "CommandResult",
@@ -781,12 +753,13 @@ class de extends C {
     }), n.addImportDeclaration({
       moduleSpecifier: "@ahoo-wang/fetcher-eventstream",
       namedImports: ["JsonEventStreamResultExtractor"]
-    }), N(n, "@ahoo-wang/fetcher", ["ContentTypeValues"]), N(n, "@ahoo-wang/fetcher-decorator", [
+    }), w(n, "@ahoo-wang/fetcher", ["ContentTypeValues"]), w(n, "@ahoo-wang/fetcher-decorator", [
       "type ApiMetadata",
       "type ApiMetadataCapable",
       "api",
       "post",
       "put",
+      "patch",
       "del",
       "request",
       "attribute",
@@ -795,11 +768,11 @@ class de extends C {
     ]), this.processCommandClient(n, e), this.processCommandClient(n, e, !0);
   }
   processCommandEndpointPaths(e, n) {
-    const t = e.addEnum({
+    const r = e.addEnum({
       name: this.commandEndpointPathsName
     });
     n.commands.forEach((o) => {
-      t.addMember({
+      r.addMember({
         name: o.name.toUpperCase(),
         initializer: `'${o.path}'`
       });
@@ -808,12 +781,12 @@ class de extends C {
   getEndpointPath(e) {
     return `${this.commandEndpointPathsName}.${e.name.toUpperCase()}`;
   }
-  processCommandClient(e, n, t = !1) {
+  processCommandClient(e, n, r = !1) {
     let o = "CommandClient", a = {
       name: "api",
       arguments: []
     }, s = "Promise<CommandResult>";
-    t && (o = "Stream" + o, a = {
+    r && (o = "Stream" + o, a = {
       name: "api",
       arguments: [
         "''",
@@ -823,7 +796,7 @@ class de extends C {
 }`
       ]
     }, s = "Promise<CommandResultEventStream>");
-    const c = le(
+    const c = we(
       n.aggregate,
       o
     ), i = e.addClass({
@@ -837,13 +810,13 @@ class de extends C {
         {
           name: "apiMetadata",
           type: "ApiMetadata",
-          scope: F.Public,
+          scope: k.Public,
           isReadonly: !0,
           initializer: `${this.defaultCommandClientOptionsName}`
         }
       ]
-    }), n.commands.forEach((p) => {
-      this.processCommandMethod(e, i, p, s);
+    }), n.commands.forEach((m) => {
+      this.processCommandMethod(e, i, m, s);
     });
   }
   methodToDecorator(e) {
@@ -855,10 +828,10 @@ 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) => ({
+  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,
       type: "string",
       decorators: [
@@ -888,11 +861,11 @@ class de extends C {
       ]
     });
     const c = n.addMethod({
-      name: M(t.name),
+      name: q(r.name),
       decorators: [
         {
-          name: this.methodToDecorator(t.method),
-          arguments: [`${this.getEndpointPath(t)}`]
+          name: this.methodToDecorator(r.method),
+          arguments: [`${this.getEndpointPath(r)}`]
         }
       ],
       parameters: s,
@@ -901,10 +874,10 @@ class de extends C {
         `throw autoGeneratedError(${s.map((i) => i.name).join(",")});`
       ]
     });
-    G(c, t.summary, t.description);
+    A(c, r.summary, r.description);
   }
 }
-class fe extends C {
+class Oe extends O {
   queryClientGenerator;
   commandClientGenerator;
   /**
@@ -912,18 +885,18 @@ 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 Pe(e), this.commandClientGenerator = new Ee(e);
   }
   /**
    * Generates client classes for all aggregates.
    */
   generate() {
-    this.logger?.progress(
+    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");
+      this.logger.progress(`Processing bounded context: ${e}`), this.processBoundedContext(e);
+    this.queryClientGenerator.generate(), this.commandClientGenerator.generate(), this.logger.success("Client generation completed");
   }
   /**
    * Processes a bounded context by creating a file with the context alias constant.
@@ -931,12 +904,12 @@ class fe extends C {
    */
   processBoundedContext(e) {
     const n = `${e}/boundedContext.ts`;
-    T(this.project, this.outputDir, n).addStatements(
+    v(this.project, this.outputDir, n).addStatements(
       `export const BOUNDED_CONTEXT_ALIAS = '${e}';`
     );
   }
 }
-class Se {
+class xe {
   /**
    * Creates a new CodeGenerator instance.
    * @param options - Configuration options for code generation
@@ -951,18 +924,19 @@ class Se {
    * and formats the output files.
    */
   async generate() {
-    const e = await z(this.options.inputPath), t = new ce(e).resolve(), o = {
+    const e = await Y(this.options.inputPath), r = new Ae(e).resolve(), o = {
       openAPI: e,
       project: this.project,
       outputDir: this.options.outputDir,
-      contextAggregates: t,
+      contextAggregates: r,
       logger: this.options.logger
     };
-    new me(o).generate(), new fe(o).generate(), this.project.getSourceFiles().forEach((c) => {
+    new ue(o).generate(), new Oe(o).generate(), this.project.getSourceFiles().forEach((c) => {
       c.formatText(), c.organizeImports(), c.fixMissingImports();
     }), await this.project.save();
   }
 }
 export {
-  Se as CodeGenerator
+  xe as CodeGenerator
 };
+//# sourceMappingURL=index.js.map