@blimu/codegen 0.2.0 → 0.3.0

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,68 @@
+import type {
+  AuthStrategy{{~#if (hasBearerScheme IR.securitySchemes)}}, 
+  BearerAuthStrategy{{~/if~}}{{~#if (hasApiKeyScheme IR.securitySchemes)}}, 
+  ApiKeyAuthStrategy{{~/if~}}
+} 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,156 +1,88 @@
-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;
+  {{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~}}
-  // Generic accessToken support (alias for bearer auth)
-  accessToken?: string | (() => string | undefined | Promise<string | undefined>);
 };
 
-// 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[] = [];
-    
-    {{~#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}};
-      authStrategies.push({
-        type: "bearer",
-        token: () => {{camel this.key}}Value,
-      });
-    }
-      {{~/if~}}
-    {{~/if~}}
+{{~! 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~}}
-    // 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 "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}}",
-      });
-    }
-      {{~/if~}}
-    {{~/if~}}
+
+  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~}}
 
-    // Extract accessToken, auth, and security scheme properties to avoid passing them to FetchClient
+  constructor(options?: ClientOption) {
     const { 
-      accessToken, 
-      auth: _existingAuth{{~#each IR.securitySchemes~}},
-      {{camel this.key}}{{~/each~}},
+      {{~#each IR.securitySchemes~}}
+      {{camel this.key}},{{~/each~}}
       ...restCfg 
-    } = cfg;
+    } = options || {};
 
-    // 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 = {
+    const authStrategies = buildAuthStrategies(options || {});
+    
+    const core = new FetchClient({
       ...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);
+      baseURL: options?.baseURL ?? '{{Client.defaultBaseURL}}',
+      ...(authStrategies.length > 0 ? { authStrategies } : {}),
+    });
+    
+    {{~! 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~}}
   }
 }
+
+// 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/package.json.hbs

@@ -39,7 +39,7 @@
     }
   },
   "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 --no-splitting",
+    "build": "tsup",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "lint": "eslint .",
     "format": "eslint --fix . && prettier --write .",

package/dist/generator/typescript/templates/schema.zod.ts.hbs

@@ -2,7 +2,6 @@
 // Use these schemas for runtime validation in forms, API requests, etc.
 
 import { z } from 'zod';
-import * as Schema from './schema';
 
 {{! Simple types: generate as regular Zod schema exports (not in namespace) }}
 {{#each IR.modelDefs}}
@@ -54,7 +53,7 @@ export const {{this.name}}Schema = z.object({
 /**
  * Zod schema for {{this.name}}
  */
-export const {{this.name}}Schema = Schema.{{this.schema.ref}}Schema;
+export const {{this.name}}Schema = {{zodSchema this.schema}};
 
   {{~else if (eq this.schema.kind "oneOf")~}}
 /**

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

@@ -1,5 +1,8 @@
-import { CoreClient } from "../client";
+import { FetchClient } from '@blimu/fetch';
 import * as Schema from "../schema";
+{{#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 +11,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 +41,7 @@ export class {{serviceName Service.tag}} {
       query,
       {{/if}}
       {{#if requestBody}}
-      body: body as any,
+      body,
       {{/if}}
       contentType: "{{response.contentType}}",
       streamingFormat: "{{response.streamingFormat}}",
@@ -58,7 +61,7 @@ export class {{serviceName Service.tag}} {
       query,
       {{/if}}
       {{#if requestBody}}
-      body: body as any,
+      body,
       {{/if}}
       ...(init || {}),
     });
@@ -74,7 +77,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/tsconfig.json.hbs

@@ -1,26 +1,27 @@
 {
-  "rootDir": "./src",
   "compilerOptions": {
-    "module": "commonjs",
-    "moduleResolution": "node",
+    "rootDir": "./src",
+    "module": "ES2022",
+    "moduleResolution": "Bundler",
+    "target": "ES2022",
     "esModuleInterop": true,
     "isolatedModules": true,
     "declaration": true,
+    "declarationMap": true,
     "removeComments": true,
     "allowSyntheticDefaultImports": true,
-    "target": "ES2023",
     "sourceMap": true,
     "outDir": "./dist",
     "baseUrl": "./src",
     "incremental": true,
     "tsBuildInfoFile": "./dist/tsconfig.tsbuildinfo",
     "skipLibCheck": true,
-    "strictNullChecks": true,
     "forceConsistentCasingInFileNames": true,
-    "noImplicitAny": false,
-    "strictBindCallApply": false,
-    "noFallthroughCasesInSwitch": false,
-    "useDefineForClassFields": false
+    "strict": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "useDefineForClassFields": true
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]

package/dist/generator/typescript/templates/tsup.config.ts.hbs

@@ -0,0 +1,15 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/**/*.ts"],
+  format: ["cjs", "esm"],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+  outDir: "dist",
+  tsconfig: "./tsconfig.json",
+  // External dependencies should not be bundled
+  // This ensures proper type resolution and smaller bundle sizes
+  external: [],
+});

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;
@@ -298,6 +299,7 @@ declare class TypeScriptGeneratorService implements Generator<TypeScriptClient>
     private generateZodSchema;
     private generatePackageJson;
     private generateTsConfig;
+    private generateTsupConfig;
     private generateReadme;
     private generatePrettierConfig;
 }

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;
@@ -298,6 +299,7 @@ declare class TypeScriptGeneratorService implements Generator<TypeScriptClient>
     private generateZodSchema;
     private generatePackageJson;
     private generateTsConfig;
+    private generateTsupConfig;
     private generateReadme;
     private generatePrettierConfig;
 }