@blimu/codegen 0.2.1 → 0.3.1

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

@@ -21,14 +21,12 @@ const client = new {{pascal Client.name}}Client({
   timeoutMs: 10000,
   retry: { retries: 2, strategy: 'exponential', backoffMs: 300, retryOn: [429, 500, 502, 503, 504] },
   // Auth configuration
-  auth: {
-    strategies: [
-      {
-        type: 'bearer',
-        token: process.env.API_TOKEN,
-      },
-    ],
-  },
+  authStrategies: [
+    {
+      type: 'bearer',
+      token: process.env.API_TOKEN,
+    },
+  ],
 });
 
 {{#each IR.services}}

package/dist/generator/typescript/templates/auth-strategies.ts.hbs

@@ -0,0 +1,64 @@
+import type { AuthStrategy } from '@blimu/fetch';
+import type { ClientOption } from './client';
+
+export function buildAuthStrategies(cfg: ClientOption): AuthStrategy[] {
+  const authStrategies: AuthStrategy[] = [...(cfg?.authStrategies || [])];
+  
+  {{~#each IR.securitySchemes~}}
+  {{~#if (eq this.type "http")~}}
+    {{~#if (eq this.scheme "bearer")~}}
+  if (cfg.{{camel this.key}}) {
+    authStrategies.push({
+      type: 'bearer',
+      token: cfg.{{camel this.key}},
+    });
+  }
+    {{~/if~}}
+  {{~/if~}}
+  {{~/each~}}
+  
+  {{~#each IR.securitySchemes~}}
+  {{~#if (eq this.type "http")~}}
+    {{~#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")~}}
+    {{~#if (eq this.in "header")~}}
+  if (cfg.{{camel this.key}}) {
+    authStrategies.push({
+      type: 'apiKey',
+      key: cfg.{{camel this.key}},
+      location: 'header',
+      name: '{{this.name}}',
+    });
+  }
+    {{~else if (eq this.in "query")~}}
+  if (cfg.{{camel this.key}}) {
+    authStrategies.push({
+      type: 'apiKey',
+      key: cfg.{{camel this.key}},
+      location: 'query',
+      name: '{{this.name}}',
+    });
+  }
+    {{~else if (eq this.in "cookie")~}}
+  if (cfg.{{camel this.key}}) {
+    authStrategies.push({
+      type: 'apiKey',
+      key: cfg.{{camel this.key}},
+      location: 'cookie',
+      name: '{{this.name}}',
+    });
+  }
+    {{~/if~}}
+  {{~/if~}}
+  {{~/each~}}
+
+  return authStrategies;
+}

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

@@ -1,146 +1,89 @@
-import { FetchClient, FetchError, type FetchClientConfig, type AuthStrategy } from "@blimu/fetch";
+import { FetchClient, FetchError } from '@blimu/fetch';
+import {
+  type FetchClientConfig{{~#if (hasBearerScheme IR.securitySchemes)}}, 
+  type BearerAuthStrategy{{~/if~}}{{~#if (hasApiKeyScheme IR.securitySchemes)}},
+  type ApiKeyAuthStrategy{{~/if~}}
+} from '@blimu/fetch';
+import { buildAuthStrategies } from './auth-strategies';
+{{~#each IR.services~}}
+import { {{serviceName tag}} } from './services/{{fileBase tag}}';
+{{~/each~}}
+
 
 export type ClientOption = FetchClientConfig & {
   {{~#each IR.securitySchemes~}}
   {{~#if (eq this.type "http")~}}
     {{~#if (eq this.scheme "bearer")~}}
-  {{camel this.key}}?: string | (() => string | undefined | Promise<string | undefined>);
+  {{camel this.key}}?: BearerAuthStrategy['token'];
     {{~else if (eq this.scheme "basic")~}}
   {{camel this.key}}?: { username: string; password: string };
     {{~/if~}}
-  {{~else if (eq this.type "apiKey")~}}
-  {{camel this.key}}?: string;
+    {{~else if (eq this.type "apiKey")~}}
+  {{camel this.key}}?: ApiKeyAuthStrategy['key'];
   {{~/if~}}
   {{~/each~}}
 };
 
-// Re-export FetchError for backward compatibility
-export { FetchError };
+{{~setVar "grouped" (groupByNamespace IR.services)~}}
 
-export class CoreClient extends FetchClient {
-  constructor(cfg: ClientOption = {}) {
-    // Build auth strategies from OpenAPI security schemes
-    const authStrategies: AuthStrategy[] = [];
+{{~! Generate namespace classes for non-root services ~}}
+{{~#each (groupByNamespace IR.services) as |services namespace|~}}
+  {{~#if (ne namespace "")~}}
+class {{pascal namespace}}Namespace {
+    {{~#each services~}}
+  readonly {{serviceProp (getServiceName tag)}}: {{serviceName tag}};
+    {{~/each~}}
 
-    // Extract auth and security scheme properties to avoid passing them to FetchClient
+  constructor(core: FetchClient) {
+    {{~#each services~}}
+    this.{{serviceProp (getServiceName tag)}} = new {{serviceName tag}}(core);
+    {{~/each~}}
+  }
+}
+
+  {{~/if~}}
+{{~/each~}}
+
+export class {{Client.name}} {
+  {{~! Root level services (no namespace) ~}}
+  {{~#each (getRootServices IR.services)~}}
+  readonly {{serviceProp tag}}: {{serviceName tag}};
+  {{~/each~}}
+  {{~! Namespace properties ~}}
+  {{~#each (groupByNamespace IR.services) as |services namespace|~}}
+    {{~#if (ne namespace "")~}}
+  readonly {{serviceProp namespace}}: {{pascal namespace}}Namespace;
+    {{~/if~}}
+  {{~/each~}}
+
+  constructor(options?: ClientOption) {
     const { 
-      auth: _existingAuth{{~#each IR.securitySchemes~}},
-      {{camel this.key}}{{~/each~}},
+      {{~#each IR.securitySchemes~}}
+      {{camel this.key}},{{~/each~}}
       ...restCfg 
-    } = cfg;
+    } = options || {};
+
+    const authStrategies = buildAuthStrategies(options || {});
     
-    {{~#each IR.securitySchemes~}}
-    {{~#if (eq this.type "http")~}}
-      {{~#if (eq this.scheme "bearer")~}}
-    if (cfg.{{camel this.key}}) {
-      const {{camel this.key}}Value = cfg.{{camel this.key}};
-      if (typeof {{camel this.key}}Value === "string") {
-        authStrategies.push({
-          type: "bearer",
-          token: () => {{camel this.key}}Value,
-        });
-      } else if (typeof {{camel this.key}}Value === "function") {
-        authStrategies.push({
-          type: "bearer",
-          token: {{camel this.key}}Value as () => string | undefined | Promise<string | undefined>,
-        });
-      }
-    }
-      {{~/if~}}
-    {{~/if~}}
-    {{~/each~}}
+    const core = new FetchClient({
+      ...restCfg,
+      baseURL: options?.baseURL ?? '{{Client.defaultBaseURL}}',
+      ...(authStrategies.length > 0 ? { authStrategies } : {}),
+    });
     
-    {{~#each IR.securitySchemes~}}
-    {{~#if (eq this.type "http")~}}
-      {{~#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")~}}
-      {{~#if (eq this.in "header")~}}
-    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 (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}}",
-      });
-    }
+    {{~! Initialize root services ~}}
+    {{~#each (getRootServices IR.services)~}}
+    this.{{serviceProp tag}} = new {{serviceName tag}}(core);
+    {{~/each~}}
+    {{~! Initialize namespaces ~}}
+    {{~#each (groupByNamespace IR.services) as |services namespace|~}}
+      {{~#if (ne namespace "")~}}
+    this.{{serviceProp namespace}} = new {{pascal namespace}}Namespace(core);
       {{~/if~}}
-    {{~/if~}}
     {{~/each~}}
-
-
-    // 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,
-            },
-          }
-        : {}),
-      // Hooks are passed through directly from FetchClientConfig (no mapping needed)
-    };
-
-    super(fetchConfig);
-  }
-
-  async request(
-    init: RequestInit & {
-      path: string;
-      method: string;
-      query?: Record<string, any>;
-    }
-  ) {
-    return await super.request(init);
-  }
-
-  async *requestStream<T = any>(
-    init: RequestInit & {
-      path: string;
-      method: string;
-      query?: Record<string, any>;
-      contentType: string;
-      streamingFormat?: "sse" | "ndjson" | "chunked";
-    }
-  ): AsyncGenerator<T, void, unknown> {
-    yield* super.requestStream(init);
   }
 }
+
+// Re-export FetchError for backward compatibility
+export { FetchError };
+export const {{Client.name}}Error = FetchError;

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

@@ -1,69 +1,19 @@
+/**
+ * This file is generated only once. If it already exists, it will not be overwritten.
+ * You can safely add custom exports, re-exports, or any other code here as needed.
+ * Your customizations will be preserved across SDK regenerations.
+ */
 
-import { CoreClient, FetchError, type ClientOption } from "./client";
-{{~#each IR.services~}}
-import { {{serviceName tag}} } from "./services/{{fileBase tag}}";
-{{~/each~}}
-
-{{~setVar "grouped" (groupByNamespace IR.services)~}}
-
-{{~! Generate namespace classes for non-root services ~}}
-{{~#each (groupByNamespace IR.services) as |services namespace|~}}
-  {{~#if (ne namespace "")~}}
-class {{pascal namespace}}Namespace {
-    {{~#each services~}}
-  readonly {{serviceProp (getServiceName tag)}}: {{serviceName tag}};
-    {{~/each~}}
-
-  constructor(core: CoreClient) {
-    {{~#each services~}}
-    this.{{serviceProp (getServiceName tag)}} = new {{serviceName tag}}(core);
-    {{~/each~}}
-  }
-}
-
-  {{~/if~}}
-{{~/each~}}
-
-export class {{Client.name}} {
-  {{~! Root level services (no namespace) ~}}
-  {{~#each (getRootServices IR.services)~}}
-  readonly {{serviceProp tag}}: {{serviceName tag}};
-  {{~/each~}}
-  {{~! Namespace properties ~}}
-  {{~#each (groupByNamespace IR.services) as |services namespace|~}}
-    {{~#if (ne namespace "")~}}
-  readonly {{serviceProp namespace}}: {{pascal namespace}}Namespace;
-    {{~/if~}}
-  {{~/each~}}
-
-  constructor(options?: ClientOption) {
-    const core = new CoreClient(options);
-    
-    {{~! Initialize root services ~}}
-    {{~#each (getRootServices IR.services)~}}
-    this.{{serviceProp tag}} = new {{serviceName tag}}(core);
-    {{~/each~}}
-    {{~! Initialize namespaces ~}}
-    {{~#each (groupByNamespace IR.services) as |services namespace|~}}
-      {{~#if (ne namespace "")~}}
-    this.{{serviceProp namespace}} = new {{pascal namespace}}Namespace(core);
-      {{~/if~}}
-    {{~/each~}}
-  }
-}
-
-export type { ClientOption };
+// Re-export everything from client
+export * from './client';
 
-// 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;
+export * from '@blimu/fetch';
 
 // Re-exports for better ergonomics
-export * from "./utils";
-export * as Schema from "./schema";
-export * as ZodSchema from "./schema.zod";
+export * from './utils';
+export * as Schema from './schema';
+export * as ZodSchema from './schema.zod';
 {{~#each IR.services~}}
-export { {{serviceName tag}} } from "./services/{{fileBase tag}}";
+export { {{serviceName tag}} } from './services/{{fileBase tag}}';
 {{~/each~}}

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

@@ -1,5 +1,10 @@
-import { CoreClient } from "../client";
+import { FetchClient } from '@blimu/fetch';
+{{#if (serviceUsesSchema Service)}}
 import * as Schema from "../schema";
+{{/if}}
+{{#if Client.includeQueryKeys}}
+import { isNotUndefined } from "../utils";
+{{/if}}
 {{! Generate import statements for predefined types used in this specific service }}
 {{#if (getServicePredefinedTypes Service)}}
 {{#each (groupByPackage (getServicePredefinedTypes Service))}}
@@ -8,7 +13,7 @@ import type { {{joinTypes this.types}} } from '{{this.package}}';
 {{/if}}
 
 export class {{serviceName Service.tag}} {
-  constructor(private core: CoreClient) {}
+  constructor(private core: FetchClient) {}
   {{#each Service.operations}}
 
   /**
@@ -38,7 +43,7 @@ export class {{serviceName Service.tag}} {
       query,
       {{/if}}
       {{#if requestBody}}
-      body: body as any,
+      body,
       {{/if}}
       contentType: "{{response.contentType}}",
       streamingFormat: "{{response.streamingFormat}}",
@@ -58,7 +63,7 @@ export class {{serviceName Service.tag}} {
       query,
       {{/if}}
       {{#if requestBody}}
-      body: body as any,
+      body,
       {{/if}}
       ...(init || {}),
     });
@@ -74,7 +79,8 @@ export class {{serviceName Service.tag}} {
     {{param}}{{#unless @last}},{{/unless}}
     {{~/each~}}
   ) {
-    return [{{queryKeyBase this}}{{#each (queryKeyArgs this)}}, {{this}}{{/each}}] as const;
+    const keys = [{{queryKeyBase this}}{{#each (queryKeyArgs this)}}, {{this}}{{/each}}] as const;
+    return isNotUndefined(keys);
   }
   {{/if}}
   {{/each}}

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

@@ -32,5 +32,13 @@ export async function listAll<T>(
   return out;
 }
 
+/**
+ * Filters out undefined values from an array while preserving type safety
+ * Useful for query keys where optional parameters might be undefined
+ */
+export function isNotUndefined<T>(arr: readonly (T | undefined)[]): T[] {
+  return arr.filter((item): item is T => item !== undefined);
+}
+
 // Re-export streaming parsers from @blimu/fetch
 export { parseSSEStream, parseNDJSONStream };

package/dist/index.d.mts

@@ -291,6 +291,7 @@ declare class TypeScriptGeneratorService implements Generator<TypeScriptClient>
     private registerHandlebarsHelpers;
     private renderTemplate;
     private generateClient;
+    private generateAuthStrategies;
     private generateIndex;
     private generateUtils;
     private generateServices;

package/dist/index.d.ts

@@ -291,6 +291,7 @@ declare class TypeScriptGeneratorService implements Generator<TypeScriptClient>
     private registerHandlebarsHelpers;
     private renderTemplate;
     private generateClient;
+    private generateAuthStrategies;
     private generateIndex;
     private generateUtils;
     private generateServices;