@blimu/codegen 0.1.0 → 0.2.0

package/README.md

@@ -135,7 +135,6 @@ const config = await loadConfig("./chunkflow-codegen.config.mjs");
 - `postCommand` (optional): Commands to run after SDK generation
 - `defaultBaseURL` (optional): Default base URL for the client
 - `exclude` (optional): Array of file paths to exclude from generation
-- `typeAugmentation` (optional): Options for type augmentation generators
 
 ## License
 

package/dist/generator/typescript/templates/.prettierrc.hbs

@@ -0,0 +1,8 @@
+{
+  "semi": true,
+  "trailingComma": "es5",
+  "singleQuote": true,
+  "printWidth": 80,
+  "tabWidth": 2,
+  "useTabs": false
+}

package/dist/generator/typescript/templates/README.md.hbs

@@ -19,13 +19,16 @@ import { {{pascal Client.name}}Client } from '{{Client.packageName}}';
 const client = new {{pascal Client.name}}Client({
   baseURL: '{{Client.defaultBaseURL}}',
   timeoutMs: 10000,
-  retry: { retries: 2, backoffMs: 300, retryOn: [429, 500, 502, 503, 504] },
-  // Environment-based baseURL (optional)
-  env: 'sandbox',
-  envBaseURLs: { sandbox: 'https://api-sandbox.example.com', production: 'https://api.example.com' },
-  // Auth (generic API Key or Bearer header)
-  accessToken: process.env.API_TOKEN,
-  headerName: 'access_token', // or 'Authorization' (defaults to Authorization: Bearer <token>)
+  retry: { retries: 2, strategy: 'exponential', backoffMs: 300, retryOn: [429, 500, 502, 503, 504] },
+  // Auth configuration
+  auth: {
+    strategies: [
+      {
+        type: 'bearer',
+        token: process.env.API_TOKEN,
+      },
+    ],
+  },
 });
 
 {{#each IR.services}}

package/dist/generator/typescript/templates/client.ts.hbs

@@ -1,17 +1,6 @@
-{{~#if IR.securitySchemes~}}
-export type ClientOption = {
-  baseURL?: string;
-  headers?: Record<string, string>;
-  timeoutMs?: number;
-  retry?: { retries: number; backoffMs: number; retryOn?: number[] };
-  onRequest?: (ctx: { url: string; init: RequestInit & { path: string; method: string; query?: Record<string, any>; headers: Headers }; attempt: number }) => void | Promise<void>;
-  onResponse?: (ctx: { url: string; init: RequestInit & { path: string; method: string; query?: Record<string, any>; headers: Headers }; attempt: number; response: Response }) => void | Promise<void>;
-  onError?: (err: unknown, ctx: { url: string; init: RequestInit & { path: string; method: string; query?: Record<string, any> }; attempt: number }) => void | Promise<void>;
-  // Environment & Auth
-  env?: 'sandbox' | 'production';
-  envBaseURLs?: { sandbox: string; production: string };
-  accessToken?: string | undefined | (() => string | undefined | Promise<string | undefined>);
-  headerName?: string;
+import { FetchClient, FetchError, type FetchClientConfig, type AuthStrategy } from "@blimu/fetch";
+
+export type ClientOption = FetchClientConfig & {
   {{~#each IR.securitySchemes~}}
   {{~#if (eq this.type "http")~}}
     {{~#if (eq this.scheme "bearer")~}}
@@ -23,200 +12,134 @@ export type ClientOption = {
   {{camel this.key}}?: string;
   {{~/if~}}
   {{~/each~}}
-  fetch?: typeof fetch;
-  credentials?: RequestCredentials;
+  // Generic accessToken support (alias for bearer auth)
+  accessToken?: string | (() => string | undefined | Promise<string | undefined>);
 };
 
-export class FetchError<T = unknown> extends Error {
-  constructor(
-    message: string,
-    readonly status: number,
-    readonly data?: T,
-    readonly headers?: Headers,
-  ) {
-    super(message);
-    this.name = "FetchError";
-  }
-}
+// Re-export FetchError for backward compatibility
+export { FetchError };
 
-export class CoreClient {
-  constructor(private cfg: ClientOption = {}) {
-    // Set default base URL if not provided
-    if (!this.cfg.baseURL) {
-      if (this.cfg.env && this.cfg.envBaseURLs) {
-        this.cfg.baseURL = this.cfg.env === 'production' ? this.cfg.envBaseURLs.production : this.cfg.envBaseURLs.sandbox;
-      } else {
-        this.cfg.baseURL = "{{Client.defaultBaseURL}}";
-      }
-    }
-  }
-  setAccessToken(token: string | undefined | (() => string | undefined | Promise<string | undefined>)) {
-    this.cfg.accessToken = token;
-  }
-  async request(
-    init: RequestInit & {
-      path: string;
-      method: string;
-      query?: Record<string, any>;
-    }
-  ) {
-    let normalizedPath = init.path || "";
-    if (normalizedPath.length > 1 && normalizedPath.endsWith('/')) {
-      normalizedPath = normalizedPath.slice(0, -1);
-    }
-    const url = new URL((this.cfg.baseURL || "") + normalizedPath);
-    if (init.query) {
-      Object.entries(init.query).forEach(([k, v]) => {
-        if (v === undefined || v === null) return;
-        if (Array.isArray(v))
-          v.forEach((vv) => url.searchParams.append(k, String(vv)));
-        else url.searchParams.set(k, String(v));
-      });
-    }
+export class CoreClient extends FetchClient {
+  constructor(cfg: ClientOption = {}) {
+    // Build auth strategies from OpenAPI security schemes
+    const authStrategies: AuthStrategy[] = [];
+    
     {{~#each IR.securitySchemes~}}
-    {{~#if (and (eq this.type "apiKey") (eq this.in "query"))~}}
-    if (this.cfg.{{camel this.key}}) {
-      url.searchParams.set("{{this.name}}", String(this.cfg.{{camel this.key}}));
+    {{~#if (eq this.type "http")~}}
+      {{~#if (eq this.scheme "bearer")~}}
+    if (cfg.{{camel this.key}}) {
+      const {{camel this.key}}Value = cfg.{{camel this.key}};
+      authStrategies.push({
+        type: "bearer",
+        token: () => {{camel this.key}}Value,
+      });
     }
+      {{~/if~}}
     {{~/if~}}
     {{~/each~}}
-    const headers = new Headers({
-      ...(this.cfg.headers || {}),
-      ...(init.headers as any),
-    });
-    // Generic access token support (optional)
-    if (this.cfg.accessToken) {
-      const token = typeof this.cfg.accessToken === 'function' ? await this.cfg.accessToken() : this.cfg.accessToken;
-      // Only set header if token is not nullish
-      if (token != null) {
-        const name = this.cfg.headerName || 'Authorization';
-        if (name.toLowerCase() === 'authorization') headers.set(name, `Bearer ${String(token)}`);
-        else headers.set(name, String(token));
+    // Support accessToken as an alias for bearer auth (only if no bearer auth was already added)
+    if (!authStrategies.some((s: any) => s.type === "bearer") && cfg.accessToken) {
+      const accessTokenValue = cfg.accessToken;
+      if (typeof accessTokenValue === "string") {
+        authStrategies.push({
+          type: "bearer",
+          token: () => accessTokenValue,
+        });
+      } else if (typeof accessTokenValue === "function") {
+        authStrategies.push({
+          type: "bearer",
+          token: accessTokenValue as () => string | undefined | Promise<string | undefined>,
+        });
       }
     }
+    
     {{~#each IR.securitySchemes~}}
     {{~#if (eq this.type "http")~}}
-      {{~#if (eq this.scheme "bearer")~}}
-    const {{camel this.key}}Key = "{{camel this.key}}";
-    if (this.cfg[{{camel this.key}}Key])
-      headers.set("Authorization", `Bearer ${this.cfg[{{camel this.key}}Key]}`);
-      {{~else if (eq this.scheme "basic")~}}
-    const {{camel this.key}}Key = "{{camel this.key}}";
-    if (this.cfg[{{camel this.key}}Key]) {
-      const u = this.cfg[{{camel this.key}}Key].username;
-      const p = this.cfg[{{camel this.key}}Key].password;
-      const encoded = typeof btoa !== 'undefined' ? btoa(`${u}:${p}`) : (typeof Buffer !== 'undefined' ? Buffer.from(`${u}:${p}`).toString('base64') : '' );
-      if (encoded) headers.set("Authorization", `Basic ${encoded}`);
+      {{~#if (eq this.scheme "basic")~}}
+    if (cfg.{{camel this.key}}) {
+      authStrategies.push({
+        type: "basic",
+        username: cfg.{{camel this.key}}.username,
+        password: cfg.{{camel this.key}}.password,
+      });
     }
       {{~/if~}}
-    {{~else if (eq this.type "apiKey")~}}
+      {{~else if (eq this.type "apiKey")~}}
       {{~#if (eq this.in "header")~}}
-    if (this.cfg?.{{camel this.key}})
-      headers.set("{{this.name}}", String(this.cfg?.{{camel this.key}}));
+    if (cfg?.{{camel this.key}}) {
+      const {{camel this.key}}Value = cfg.{{camel this.key}};
+      authStrategies.push({
+        type: "apiKey",
+        key: () => {{camel this.key}}Value,
+        location: "header",
+        name: "{{this.name}}",
+      });
+    }
+      {{~else if (eq this.in "query")~}}
+    if (cfg?.{{camel this.key}}) {
+      const {{camel this.key}}Value = cfg.{{camel this.key}};
+      authStrategies.push({
+        type: "apiKey",
+        key: () => {{camel this.key}}Value,
+        location: "query",
+        name: "{{this.name}}",
+      });
+    }
       {{~else if (eq this.in "cookie")~}}
-    if (this.cfg?.{{camel this.key}})
-      headers.set("Cookie", `${"{{this.name}}"}=${String(this.cfg?.{{camel this.key}})}`);
+    if (cfg?.{{camel this.key}}) {
+      const {{camel this.key}}Value = cfg.{{camel this.key}};
+      authStrategies.push({
+        type: "apiKey",
+        key: () => {{camel this.key}}Value,
+        location: "cookie",
+        name: "{{this.name}}",
+      });
+    }
       {{~/if~}}
     {{~/if~}}
     {{~/each~}}
 
-    const doFetch = async (attempt: number) => {
-      // Clone init to prevent mutations from affecting concurrent requests
-      // Create a new Headers object for each request to avoid sharing references
-      const requestHeaders = new Headers(headers);
-      const fetchInit: RequestInit & {
-        path: string;
-        method: string;
-        query?: Record<string, any>;
-        headers: Headers;
-      } = {
-        ...init,
-        headers: requestHeaders,
-      };
-      // Set credentials from config if provided (can be overridden by onRequest)
-      if (this.cfg.credentials !== undefined) {
-        fetchInit.credentials = this.cfg.credentials;
-      }
-      if (this.cfg.onRequest) await this.cfg.onRequest({ url: url.toString(), init: fetchInit, attempt });
-      let controller: AbortController | undefined;
-      let timeoutId: any;
-      const existingSignal = fetchInit.signal;
-
-      if (this.cfg.timeoutMs && typeof AbortController !== 'undefined') {
-        controller = new AbortController();
-
-        // If there's an existing signal, combine it with the timeout signal
-        // The combined controller will abort when either signal aborts
-        if (existingSignal) {
-          // If existing signal is already aborted, abort the new controller immediately
-          if (existingSignal.aborted) {
-            controller.abort();
-          } else {
-            // Listen to the existing signal and abort the combined controller when it aborts
-            existingSignal.addEventListener('abort', () => {
-              controller?.abort();
-            });
+    // Extract accessToken, auth, and security scheme properties to avoid passing them to FetchClient
+    const { 
+      accessToken, 
+      auth: _existingAuth{{~#each IR.securitySchemes~}},
+      {{camel this.key}}{{~/each~}},
+      ...restCfg 
+    } = cfg;
+
+    // Build final auth config (merge existing with new strategies)
+    const finalAuthStrategies = [
+      ...(_existingAuth?.strategies || []),
+      ...authStrategies,
+    ];
+
+    // Build fetchConfig, ensuring auth comes after restCfg spread to override any existing auth
+    const fetchConfig: FetchClientConfig = {
+      ...restCfg,
+      baseURL: cfg.baseURL ?? "{{Client.defaultBaseURL}}",
+      // Explicitly set auth after restCfg to ensure it's not overwritten
+      // (restCfg might have an auth property that we want to replace)
+      ...(finalAuthStrategies.length > 0
+        ? {
+            auth: {
+              strategies: finalAuthStrategies,
+            },
           }
-        }
-
-        fetchInit.signal = controller.signal;
-        timeoutId = setTimeout(() => controller?.abort(), this.cfg.timeoutMs);
-      }
-      try {
-        const res = await (this.cfg.fetch || fetch)(url.toString(), fetchInit);
-        if (this.cfg.onResponse) await this.cfg.onResponse({ url: url.toString(), init: fetchInit, attempt, response: res });
-        const ct = res.headers.get("content-type") || "";
-        let parsed: any;
-        if (ct.includes("application/json")) {
-          parsed = await res.json();
-        } else if (ct.startsWith("text/")) {
-          parsed = await res.text();
-        } else {
-          // binary or unknown -> ArrayBuffer
-          parsed = await res.arrayBuffer();
-        }
-        if (!res.ok) {
-          throw new FetchError(
-            parsed?.message || `HTTP ${res.status}`,
-            res.status,
-            parsed,
-            res.headers,
-          );
-        }
-        return parsed as any;
-      } catch (err) {
-        if (this.cfg.onError) await this.cfg.onError(err, { url: url.toString(), init, attempt });
-        throw err;
-      } finally {
-        if (timeoutId) clearTimeout(timeoutId);
-      }
+        : {}),
+      // Hooks are passed through directly from FetchClientConfig (no mapping needed)
     };
 
-    const retries = this.cfg.retry?.retries ?? 0;
-    const baseBackoff = this.cfg.retry?.backoffMs ?? 300;
-    const retryOn = this.cfg.retry?.retryOn ?? [429, 500, 502, 503, 504];
+    super(fetchConfig);
+  }
 
-    let lastError: unknown;
-    for (let attempt = 0; attempt <= retries; attempt++) {
-      try {
-        return await doFetch(attempt);
-      } catch (err: any) {
-        // Retry on network errors or configured status errors
-        const status = err?.status as number | undefined;
-        const shouldRetry = status ? retryOn.includes(status) : true;
-        if (attempt < retries && shouldRetry) {
-          const delay = baseBackoff * Math.pow(2, attempt);
-          await new Promise((r) => setTimeout(r, delay));
-          lastError = err;
-          continue;
-        }
-        if (err instanceof DOMException) throw err;
-        if (err instanceof FetchError) throw err;
-        if (typeof err === 'string') throw new FetchError(err, status ?? 0);
-        throw new FetchError((err as Error)?.message || 'Network error', status ?? 0);
-      }
+  async request(
+    init: RequestInit & {
+      path: string;
+      method: string;
+      query?: Record<string, any>;
     }
-    throw lastError as any;
+  ) {
+    return await super.request(init);
   }
 
   async *requestStream<T = any>(
@@ -228,153 +151,6 @@ export class CoreClient {
       streamingFormat?: "sse" | "ndjson" | "chunked";
     }
   ): AsyncGenerator<T, void, unknown> {
-    let normalizedPath = init.path || "";
-    if (normalizedPath.length > 1 && normalizedPath.endsWith('/')) {
-      normalizedPath = normalizedPath.slice(0, -1);
-    }
-    const url = new URL((this.cfg.baseURL || "") + normalizedPath);
-    if (init.query) {
-      Object.entries(init.query).forEach(([k, v]) => {
-        if (v === undefined || v === null) return;
-        if (Array.isArray(v))
-          v.forEach((vv) => url.searchParams.append(k, String(vv)));
-        else url.searchParams.set(k, String(v));
-      });
-    }
-    {{~#each IR.securitySchemes~}}
-    {{~#if (and (eq this.type "apiKey") (eq this.in "query"))~}}
-    if (this.cfg.{{camel this.key}}) {
-      url.searchParams.set("{{this.name}}", String(this.cfg.{{camel this.key}}));
-    }
-    {{~/if~}}
-    {{~/each~}}
-    const headers = new Headers({
-      ...(this.cfg.headers || {}),
-      ...(init.headers as any),
-    });
-    // Generic access token support (optional)
-    if (this.cfg.accessToken) {
-      const token = typeof this.cfg.accessToken === 'function' ? await this.cfg.accessToken() : this.cfg.accessToken;
-      // Only set header if token is not nullish
-      if (token != null) {
-        const name = this.cfg.headerName || 'Authorization';
-        if (name.toLowerCase() === 'authorization') headers.set(name, `Bearer ${String(token)}`);
-        else headers.set(name, String(token));
-      }
-    }
-    {{~#each IR.securitySchemes~}}
-    {{~#if (eq this.type "http")~}}
-      {{~#if (eq this.scheme "bearer")~}}
-    const {{camel this.key}}Key = "{{camel this.key}}";
-    if (this.cfg[{{camel this.key}}Key])
-      headers.set("Authorization", `Bearer ${this.cfg[{{camel this.key}}Key]}`);
-      {{~else if (eq this.scheme "basic")~}}
-    const {{camel this.key}}Key = "{{camel this.key}}";
-    if (this.cfg[{{camel this.key}}Key]) {
-      const u = this.cfg[{{camel this.key}}Key].username;
-      const p = this.cfg[{{camel this.key}}Key].password;
-      const encoded = typeof btoa !== 'undefined' ? btoa(`${u}:${p}`) : (typeof Buffer !== 'undefined' ? Buffer.from(`${u}:${p}`).toString('base64') : '' );
-      if (encoded) headers.set("Authorization", `Basic ${encoded}`);
-    }
-      {{~/if~}}
-    {{~else if (eq this.type "apiKey")~}}
-      {{~#if (eq this.in "header")~}}
-    if (this.cfg?.{{camel this.key}})
-      headers.set("{{this.name}}", String(this.cfg?.{{camel this.key}}));
-      {{~else if (eq this.in "cookie")~}}
-    if (this.cfg?.{{camel this.key}})
-      headers.set("Cookie", `${"{{this.name}}"}=${String(this.cfg?.{{camel this.key}})}`);
-      {{~/if~}}
-    {{~/if~}}
-    {{~/each~}}
-
-    const fetchInit: RequestInit & {
-      path: string;
-      method: string;
-      query?: Record<string, any>;
-      headers: Headers;
-    } = {
-      ...init,
-      headers,
-    };
-    // Set credentials from config if provided
-    if (this.cfg.credentials !== undefined) {
-      fetchInit.credentials = this.cfg.credentials;
-    }
-
-    if (this.cfg.onRequest) await this.cfg.onRequest({ url: url.toString(), init: fetchInit, attempt: 0 });
-
-    let controller: AbortController | undefined;
-    let timeoutId: any;
-    const existingSignal = fetchInit.signal;
-
-    if (this.cfg.timeoutMs && typeof AbortController !== 'undefined') {
-      controller = new AbortController();
-      if (existingSignal) {
-        if (existingSignal.aborted) {
-          controller.abort();
-        } else {
-          existingSignal.addEventListener('abort', () => {
-            controller?.abort();
-          });
-        }
-      }
-      fetchInit.signal = controller.signal;
-      timeoutId = setTimeout(() => controller?.abort(), this.cfg.timeoutMs);
-    }
-
-    try {
-      const res = await (this.cfg.fetch || fetch)(url.toString(), fetchInit);
-      if (this.cfg.onResponse) await this.cfg.onResponse({ url: url.toString(), init: fetchInit, attempt: 0, response: res });
-
-      if (!res.ok) {
-        const ct = res.headers.get("content-type") || "";
-        let parsed: any;
-        if (ct.includes("application/json")) {
-          parsed = await res.json();
-        } else if (ct.startsWith("text/")) {
-          parsed = await res.text();
-        } else {
-          parsed = await res.arrayBuffer();
-        }
-        throw new FetchError(
-          parsed?.message || `HTTP ${res.status}`,
-          res.status,
-          parsed,
-          res.headers,
-        );
-      }
-
-      // Import streaming parsers
-      const { parseSSEStream, parseNDJSONStream } = await import("./utils");
-
-      // Route to appropriate parser based on streaming format
-      if (init.streamingFormat === "sse") {
-        yield* parseSSEStream(res) as AsyncGenerator<T, void, unknown>;
-      } else if (init.streamingFormat === "ndjson") {
-        yield* parseNDJSONStream<T>(res);
-      } else {
-        // Generic chunked streaming - yield raw chunks as strings
-        if (!res.body) return;
-        const reader = res.body.getReader();
-        const decoder = new TextDecoder();
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            const chunk = decoder.decode(value, { stream: true });
-            yield chunk as T;
-          }
-        } finally {
-          reader.releaseLock();
-        }
-      }
-    } catch (err) {
-      if (this.cfg.onError) await this.cfg.onError(err, { url: url.toString(), init, attempt: 0 });
-      throw err;
-    } finally {
-      if (timeoutId) clearTimeout(timeoutId);
-    }
+    yield* super.requestStream(init);
   }
 }
-{{~/if~}}

package/dist/generator/typescript/templates/index.ts.hbs

@@ -54,8 +54,10 @@ export class {{Client.name}} {
 
 export type { ClientOption };
 
-// Export FetchError for error handling
-export { FetchError };
+// Export FetchError and CoreClient for error handling and advanced usage
+export { FetchError, CoreClient };
+// Re-export all error types from @blimu/fetch for instanceof checks
+export * from "@blimu/fetch";
 export const {{Client.name}}Error = FetchError;
 
 // Re-exports for better ergonomics

package/dist/generator/typescript/templates/package.json.hbs

@@ -3,46 +3,55 @@
   "version": "0.1.0",
   "description": "TypeScript SDK for {{Client.name}} API (auto-generated)",
   "main": "dist/index.js",
+  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
-  "files": ["dist/**"],
+  "files": ["dist/**", "src/**"],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./services/*": {
       "types": "./dist/services/*.d.ts",
       "import": "./dist/services/*.mjs",
-      "require": "./dist/services/*.js"
+      "require": "./dist/services/*.js",
+      "default": "./dist/services/*.js"
     },
     "./schema": {
       "types": "./dist/schema.d.ts",
       "import": "./dist/schema.mjs",
-      "require": "./dist/schema.js"
+      "require": "./dist/schema.js",
+      "default": "./dist/schema.js"
     },
     "./client": {
       "types": "./dist/client.d.ts",
       "import": "./dist/client.mjs",
-      "require": "./dist/client.js"
+      "require": "./dist/client.js",
+      "default": "./dist/client.js"
     },
     "./utils": {
       "types": "./dist/utils.d.ts",
       "import": "./dist/utils.mjs",
-      "require": "./dist/utils.js"
+      "require": "./dist/utils.js",
+      "default": "./dist/utils.js"
     }
   },
   "scripts": {
-    "build": "tsup src/index.ts src/services/*.ts src/schema.ts src/schema.zod.ts src/client.ts src/utils.ts --format cjs,esm --dts",
+    "build": "tsup src/index.ts src/services/*.ts src/schema.ts src/schema.zod.ts src/client.ts src/utils.ts --format cjs,esm --dts --no-splitting",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "lint": "eslint .",
     "format": "eslint --fix . && prettier --write .",
     "prepublishOnly": "npm run build && npm run typecheck || true"
   },
   "dependencies": {
-    "zod": "^4.3.5"
+{{#each (getAllDependencies Client)}}
+    "{{@key}}": "{{this}}"{{#unless @last}},{{/unless}}
+{{/each}}
   },
   "devDependencies": {
-    "tsup": "^8.5.1"
+    "tsup": "^8.5.1"{{#if Client.devDependencies}}{{#each Client.devDependencies}},
+    "{{@key}}": "{{this}}"{{/each}}{{/if}}
   }
 }