@tetrascience-npm/request 0.2.0-beta.106.2

package/README.md

@@ -0,0 +1,169 @@
+# @tetrascience-npm/request <!-- omit in toc -->
+
+Request middleware for TetraScience services and data apps. End-to-end tracing, auth, validation, and typed OpenAPI client generation — zero-config where possible.
+
+## Table of Contents <!-- omit in toc -->
+
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [Auth](#auth)
+- [Middleware pipeline](#middleware-pipeline)
+- [Client SDK generation](#client-sdk-generation)
+- [Entrypoints](#entrypoints)
+- [API reference](#api-reference)
+
+## Installation
+
+```sh
+yarn add @tetrascience-npm/request
+```
+
+## Quick start
+
+**Server** — reads tracing + auth from headers/cookies, stores in AsyncLocalStorage:
+
+```typescript
+import cookieParser from 'cookie-parser'
+import { createRequestMiddleware } from '@tetrascience-npm/request/server'
+
+app.use(cookieParser())
+app.use(createRequestMiddleware())
+```
+
+**Browser** — patches `fetch()`, auto-manages request ID + session cookie:
+
+```typescript
+import { installRequestMiddleware } from '@tetrascience-npm/request/client'
+
+installRequestMiddleware()
+```
+
+**Using a generated client** — auth and tracing auto-resolve:
+
+```typescript
+import { createDataAppsClient } from '@tetrascience/data-apps-client'
+
+// Browser — auth from cookies, tracing from installRequestMiddleware
+const client = createDataAppsClient({ auth: 'direct' })
+
+// Server (service-to-service) — reads INTERNAL_API_KEY env var, rest from context
+const client = createDataAppsClient({
+  baseUrl: process.env.TDP_API_URL,
+  auth: 'internal',
+})
+
+// Fully typed
+const { data } = await client.GET('/v1/dataapps/kv/{appSlug}', {
+  params: { path: { appSlug: 'my-app' } },
+})
+```
+
+## Auth
+
+Both auth modes auto-resolve values from `RequestContext` (server) or cookies (browser) when not explicitly provided.
+
+```typescript
+// Zero-config shorthands
+auth: 'direct'    // user/browser
+auth: 'internal'  // service-to-service (reads INTERNAL_API_KEY env var)
+
+// Explicit values
+auth: { authToken: jwt, orgSlug: 'my-org' }
+auth: { internalApiKey: env.KEY, orgSlug: 'my-org', authToken: 'tok' }
+```
+
+Headers injected by each mode:
+
+| Mode | Headers |
+|------|---------|
+| Direct | `ts-auth-token`, `x-org-slug` |
+| Internal | `ts-internal-api-key`, `x-org-slug`, `ts-auth-token` |
+
+## Middleware pipeline
+
+`applyDefaultMiddleware(client, options, schemas)` wires the standard pipeline:
+
+| Order | Middleware | Headers / Purpose |
+|-------|-----------|-------------------|
+| 1 | Tracing | `ts-request-id`, `ts-session-id`, `ts-initiating-service-name`, logging |
+| 2 | Auth | `ts-internal-api-key` / `ts-auth-token` / `x-org-slug` |
+| 3 | Validation | Zod request body validation |
+| 4 | Safe response | Wraps non-JSON success responses |
+
+On Node servers, request ID, session ID, orgSlug, and authToken auto-propagate from `createRequestMiddleware` context. New middleware added here is picked up by existing clients on dependency update — no regeneration needed.
+
+## Client SDK generation
+
+Add to `package.json`:
+
+```json
+"serviceClient": {
+  "packageName": "@tetrascience/data-apps-client",
+  "spec": "openapi/dataapps.yaml",
+  "version": "2.0.0"
+}
+```
+
+Run `generate-service-client` — produces a typed client directory. Multi-spec support:
+
+```json
+"spec": { "internal": "openapi/internal.yaml", "public": "openapi/public.yaml" }
+```
+
+## Entrypoints
+
+| Entrypoint | Environment | Purpose |
+|-----------|-------------|---------|
+| Root | Any | Middleware, types, constants, `createClient`, `applyDefaultMiddleware` |
+| `/server` | Node only | `createRequestMiddleware`, `runWithRequestContext`, `getRequestId` |
+| `/client` | Browser only | `installRequestMiddleware`, `createConsoleLogger` |
+
+Independent — `/server` and `/client` do not re-export the root.
+
+## API reference
+
+### Root
+
+**Middleware:**
+
+| Export | Description |
+|--------|-------------|
+| `createClient` | Re-exported from `openapi-fetch` |
+| `applyDefaultMiddleware(client, options, schemas?)` | Standard pipeline with auto-resolve |
+| `createTracingMiddleware(options?)` | `ts-request-id`, `ts-session-id`, `ts-initiating-service-name`, logging |
+| `createInternalAuthMiddleware(auth)` | Service-to-service auth (`'internal'` or explicit) |
+| `createDirectAuthMiddleware(auth)` | User auth (`'direct'` or explicit) |
+| `createRequestValidationMiddleware(opts)` | Zod request body validation |
+| `createSafeResponseMiddleware()` | Wraps non-JSON responses |
+
+**Types:**
+
+| Export | Description |
+|--------|-------------|
+| `ServiceClientOptions` | `{ baseUrl?, auth, headers?, skipValidation? }` extends `TracingOptions` |
+| `InternalAuth` | `InternalAuthExplicit \| 'internal'` |
+| `DirectAuth` | `AuthBase \| 'direct'` |
+| `AuthBase` | `{ authToken?, orgSlug? }` — auto-resolves from context/cookies |
+| `InternalAuthExplicit` | `AuthBase & { internalApiKey }` |
+| `TracingOptions` | `{ requestId?, sessionId?, serviceName?, logger? }` |
+| `HeaderValue` | `string \| (() => string \| undefined)` |
+| `RequestContext` | `{ requestId, sessionId, orgSlug?, authToken? }` |
+
+**Constants:** `REQUEST_ID_HEADER`, `SESSION_ID_HEADER`, `ORG_SLUG_HEADER`, `AUTH_TOKEN_HEADER`, `INTERNAL_API_KEY_HEADER`, `INITIATING_SERVICE_NAME_HEADER`
+
+### `/server`
+
+| Export | Description |
+|--------|-------------|
+| `createRequestMiddleware()` | Express middleware — reads headers/cookies, sets context + session cookie |
+| `runWithRequestContext(ctx, fn)` | Scoped context via `AsyncLocalStorage.run()` |
+| `runWithoutRequestContext(fn)` | No context (testing) |
+| `getRequestContext()` | Read current context |
+| `getRequestId()` | Request ID from context or new UUID |
+
+### `/client`
+
+| Export | Description |
+|--------|-------------|
+| `installRequestMiddleware(opts?)` | Patches global `fetch()` — request ID + session cookie |
+| `createConsoleLogger(opts?)` | Console logger with level filtering and prefix |

package/client.d.ts

@@ -0,0 +1 @@
+export * from './dist/client/index';

package/client.js

@@ -0,0 +1 @@
+module.exports = require('./dist/client/index.js');

package/dist/cli/generate-client.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=generate-client.d.ts.map

package/dist/cli/generate-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-client.d.ts","sourceRoot":"","sources":["../../src/cli/generate-client.ts"],"names":[],"mappings":""}

package/dist/cli/generate-client.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Generates a complete, publishable typed OpenAPI client SDK for a TetraScience service.
+ *
+ * Reads configuration from the service's package.json `serviceClient` field:
+ *
+ *   // Single spec
+ *   "serviceClient": {
+ *     "packageName": "@tetrascience/data-apps-client",
+ *     "spec": "openapi/dataapps.yaml",
+ *     "version": "2.0.0"
+ *   }
+ *
+ *   // Multiple specs (internal/external API surfaces)
+ *   "serviceClient": {
+ *     "packageName": "@tetrascience/data-acq-client",
+ *     "spec": {
+ *       "internal": "openapi/internal.yaml",
+ *       "public": "openapi/public.yaml"
+ *     },
+ *     "version": "2.0.0"
+ *   }
+ *
+ * Usage:
+ *   generate-service-client
+ */
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const generate_schemas_1 = require("./generate-schemas");
+const templates_1 = require("./templates");
+function readConfig() {
+    const args = process.argv.slice(2);
+    let configPath = path.join(process.cwd(), 'package.json');
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--config' && args[i + 1]) {
+            configPath = path.resolve(args[++i]);
+        }
+    }
+    if (!fs.existsSync(configPath)) {
+        console.error(`Error: ${configPath} not found`);
+        process.exit(1);
+    }
+    const pkg = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    const config = pkg.serviceClient;
+    if (!config) {
+        console.error('Error: no "serviceClient" field found in package.json');
+        console.error('');
+        console.error('Add configuration like:');
+        console.error('  "serviceClient": {');
+        console.error('    "packageName": "@tetrascience/my-service-client",');
+        console.error('    "spec": "openapi/spec.yaml",');
+        console.error('    "version": "1.0.0"');
+        console.error('  }');
+        process.exit(1);
+    }
+    if (!config.packageName) {
+        console.error('Error: serviceClient.packageName is required');
+        process.exit(1);
+    }
+    if (!config.spec) {
+        console.error('Error: serviceClient.spec is required');
+        process.exit(1);
+    }
+    if (!config.version) {
+        console.error('Error: serviceClient.version is required');
+        process.exit(1);
+    }
+    config.outDir = config.outDir || 'client';
+    return config;
+}
+/**
+ * Clean previously generated files from the output directory,
+ * but preserve node_modules/, .yarn/, and yarn.lock for install cache.
+ */
+function cleanOutDir(outDir) {
+    const preserve = new Set(['node_modules', '.yarn', 'yarn.lock']);
+    if (!fs.existsSync(outDir))
+        return;
+    for (const entry of fs.readdirSync(outDir)) {
+        if (preserve.has(entry))
+            continue;
+        fs.rmSync(path.join(outDir, entry), { recursive: true, force: true });
+    }
+}
+/**
+ * Detect the installed version of @tetrascience-npm/request
+ * and return it as a dependency specifier for the generated client.
+ */
+function getMiddlewareVersion() {
+    const ownPkgPath = path.resolve(__dirname, '..', '..', 'package.json');
+    try {
+        const pkg = JSON.parse(fs.readFileSync(ownPkgPath, 'utf-8'));
+        return pkg.version;
+    }
+    catch {
+        return '^0.2.0';
+    }
+}
+/**
+ * Normalize the spec config into a list of { name, specPath } entries.
+ * Single string → one unnamed entry. Object → named variants.
+ */
+function resolveSpecs(spec) {
+    if (typeof spec === 'string') {
+        const resolved = path.resolve(spec);
+        if (!fs.existsSync(resolved)) {
+            console.error(`Error: spec file not found: ${resolved}`);
+            process.exit(1);
+        }
+        return [{ name: null, specPath: resolved }];
+    }
+    const entries = Object.entries(spec);
+    if (entries.length === 0) {
+        console.error('Error: spec object is empty — provide at least one named spec');
+        process.exit(1);
+    }
+    return entries.map(([name, specFile]) => {
+        const resolved = path.resolve(specFile);
+        if (!fs.existsSync(resolved)) {
+            console.error(`Error: spec file not found for "${name}": ${resolved}`);
+            process.exit(1);
+        }
+        return { name, specPath: resolved };
+    });
+}
+function main() {
+    const config = readConfig();
+    const outDir = path.resolve(config.outDir);
+    const serviceName = (0, templates_1.deriveServiceName)(config.packageName);
+    const specs = resolveSpecs(config.spec);
+    const isMultiSpec = specs[0].name !== null;
+    const middlewareVersion = getMiddlewareVersion();
+    console.log(`Generating ${config.packageName} v${config.version}`);
+    console.log(`Using @tetrascience-npm/request@${middlewareVersion}\n`);
+    // 1. Clean and prepare output directory
+    cleanOutDir(outDir);
+    fs.mkdirSync(path.join(outDir, 'generated'), { recursive: true });
+    const openapiTsBin = (0, generate_schemas_1.findBin)('openapi-typescript');
+    const generatedDir = path.join(outDir, 'generated');
+    for (const { name, specPath } of specs) {
+        const prefix = name ? `${name}.` : '';
+        console.log(`  spec: ${path.relative(process.cwd(), specPath)}${name ? ` (${name})` : ''}`);
+        // 2. Generate OpenAPI TypeScript types
+        const schemaOut = path.join(generatedDir, `${prefix}schema.ts`);
+        (0, child_process_1.execSync)(`"${openapiTsBin}" "${specPath}" -o "${schemaOut}"`, { stdio: 'inherit' });
+        // 3. Generate Zod request-body schemas
+        (0, generate_schemas_1.generateRequestSchemas)(specPath, generatedDir, `${prefix}request-schemas.ts`);
+    }
+    // 4. Write template files
+    const specVariants = isMultiSpec ? specs.map((s) => s.name) : null;
+    const files = {
+        'package.json': (0, templates_1.generateClientPackageJson)({
+            packageName: config.packageName,
+            version: config.version,
+            description: config.description,
+            serviceName,
+            middlewareVersion,
+        }),
+        'tsconfig.build.json': (0, templates_1.generateTsConfig)(),
+        'index.ts': (0, templates_1.generateIndexTs)(serviceName, specVariants),
+        '.gitignore': (0, templates_1.generateClientGitIgnore)(),
+        '.yarnrc.yml': (0, templates_1.generateYarnRc)(),
+    };
+    for (const [name, content] of Object.entries(files)) {
+        fs.writeFileSync(path.join(outDir, name), content);
+    }
+    console.log(`\nGenerated ${config.packageName} in ${path.relative(process.cwd(), outDir)}/`);
+    console.log('For local testing: cd ' + path.relative(process.cwd(), outDir) + ' && yarn install && yarn build');
+}
+if (require.main === module) {
+    main();
+}

package/dist/cli/generate-schemas.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * Walk up from cwd looking for a binary in node_modules/.bin.
+ */
+export declare function findBin(name: string): string;
+export declare function generateRequestSchemas(specPath: string, outDir: string, outFileName?: string): void;
+//# sourceMappingURL=generate-schemas.d.ts.map

package/dist/cli/generate-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-schemas.d.ts","sourceRoot":"","sources":["../../src/cli/generate-schemas.ts"],"names":[],"mappings":";AA8DA;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAS5C;AAMD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CA6GnG"}

package/dist/cli/generate-schemas.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findBin = findBin;
+exports.generateRequestSchemas = generateRequestSchemas;
+/**
+ * Generates Zod request-body schemas from an OpenAPI spec.
+ *
+ * 1. Runs openapi-zod-client to get Zod schemas for all components
+ * 2. Parses the OpenAPI spec to find which path+method has a request body
+ * 3. Outputs a validation map: "METHOD /path" -> Zod schema
+ *
+ * Usage:
+ *   generate-request-schemas --spec <path-to-openapi-yaml> --out <output-dir>
+ */
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let specPath;
+    let outDir;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--spec' && args[i + 1]) {
+            specPath = path.resolve(args[++i]);
+        }
+        else if (args[i] === '--out' && args[i + 1]) {
+            outDir = path.resolve(args[++i]);
+        }
+    }
+    if (!specPath) {
+        console.error('Error: --spec <path-to-openapi-yaml> is required');
+        process.exit(1);
+    }
+    if (!outDir) {
+        console.error('Error: --out <output-directory> is required');
+        process.exit(1);
+    }
+    if (!fs.existsSync(specPath)) {
+        console.error(`Error: spec file not found: ${specPath}`);
+        process.exit(1);
+    }
+    return { specPath, outDir };
+}
+function loadYaml(filePath) {
+    let yaml;
+    try {
+        yaml = require('js-yaml');
+    }
+    catch {
+        console.error('Error: js-yaml is required for client generation. Install it as a devDependency: yarn add -D js-yaml');
+        process.exit(1);
+    }
+    return yaml.load(fs.readFileSync(filePath, 'utf-8'));
+}
+/**
+ * Walk up from cwd looking for a binary in node_modules/.bin.
+ */
+function findBin(name) {
+    let dir = process.cwd();
+    while (dir !== path.dirname(dir)) {
+        const candidate = path.join(dir, 'node_modules', '.bin', name);
+        if (fs.existsSync(candidate))
+            return candidate;
+        dir = path.dirname(dir);
+    }
+    console.error(`Error: ${name} not found. Install it as a devDependency: yarn add -D ${name}`);
+    process.exit(1);
+}
+function findZodClientBin() {
+    return findBin('openapi-zod-client');
+}
+function generateRequestSchemas(specPath, outDir, outFileName) {
+    const tmpFile = path.join(outDir, '.zod-raw.ts');
+    const outFile = path.join(outDir, outFileName || 'request-schemas.ts');
+    fs.mkdirSync(outDir, { recursive: true });
+    // 1. Generate full zodios output to a temp file
+    const zodClientBin = findZodClientBin();
+    (0, child_process_1.execSync)(`"${zodClientBin}" "${specPath}" -o "${tmpFile}" --export-schemas`, { stdio: 'inherit' });
+    let raw;
+    try {
+        raw = fs.readFileSync(tmpFile, 'utf-8');
+    }
+    catch {
+        throw new Error(`Failed to read generated file: ${tmpFile}`);
+    }
+    // Extract schema section (everything before `const endpoints = makeApi(`)
+    const endpointsIdx = raw.indexOf('const endpoints = makeApi(');
+    if (endpointsIdx === -1) {
+        fs.unlinkSync(tmpFile);
+        throw new Error('Could not find endpoints definition in generated file');
+    }
+    const schemaSection = raw
+        .substring(0, endpointsIdx)
+        .split('\n')
+        .filter((l) => !l.startsWith('import '))
+        .join('\n')
+        .trim();
+    // 2. Parse the OpenAPI spec to find request body -> schema name mappings
+    const spec = loadYaml(specPath);
+    const bodyMap = {};
+    for (const [pathStr, methods] of Object.entries(spec.paths || {})) {
+        for (const [method, operation] of Object.entries(methods)) {
+            if (method === 'parameters')
+                continue;
+            const op = operation;
+            const requestBody = op.requestBody;
+            if (!requestBody?.content?.['application/json']?.schema)
+                continue;
+            const schema = requestBody.content['application/json'].schema;
+            const key = `${method.toUpperCase()} ${pathStr}`;
+            if (schema.$ref) {
+                const schemaName = schema.$ref.split('/').pop();
+                bodyMap[key] = schemaName;
+            }
+            else if (schema.type === 'array' && schema.items?.$ref) {
+                const opId = op.operationId?.replace(/-/g, '_');
+                if (opId)
+                    bodyMap[key] = `${opId}_Body`;
+            }
+            else {
+                const opId = op.operationId?.replace(/-/g, '_');
+                if (opId)
+                    bodyMap[key] = `${opId}_Body`;
+            }
+        }
+    }
+    // 3. Verify all referenced schema names exist in the generated code
+    const exportedSchemaNames = [...raw.matchAll(/^const (\w+)\s*=\s*z[.\s]/gm)].map((m) => m[1]);
+    for (const [key, schemaName] of Object.entries(bodyMap)) {
+        if (raw.includes(`const ${schemaName} =`) || raw.includes(`const ${schemaName}=`)) {
+            continue;
+        }
+        // Try to find a schema with matching suffix
+        const parts = schemaName.split('_');
+        const resourceHint = parts.slice(1, -1).join('_');
+        const fallback = exportedSchemaNames.find((name) => name.endsWith('_Body') && name.includes(resourceHint));
+        if (fallback) {
+            console.log(`  info: ${key}: "${schemaName}" -> "${fallback}" (shared schema)`);
+            bodyMap[key] = fallback;
+        }
+        else {
+            console.warn(`  warn: Schema "${schemaName}" for ${key} not found — skipping`);
+            delete bodyMap[key];
+        }
+    }
+    // 4. Build output file
+    const lines = [
+        '// AUTO-GENERATED — do not edit. Run `generate-request-schemas` to regenerate.',
+        "import { z } from 'zod'",
+        '',
+        schemaSection,
+        '',
+        '/**',
+        ' * Map of "METHOD /path" -> Zod schema for request body validation.',
+        ' * Used by the request validation middleware.',
+        ' */',
+        'export const requestBodySchemas: Record<string, z.ZodTypeAny> = {',
+    ];
+    for (const [key, schemaName] of Object.entries(bodyMap)) {
+        lines.push(`  '${key}': ${schemaName},`);
+    }
+    lines.push('}');
+    lines.push('');
+    fs.writeFileSync(outFile, lines.join('\n'));
+    fs.unlinkSync(tmpFile);
+    console.log(`\nGenerated ${outFile}`);
+    console.log(`  ${Object.keys(bodyMap).length} request body schemas mapped:`);
+    for (const [key, schemaName] of Object.entries(bodyMap)) {
+        console.log(`  ${key} -> ${schemaName}`);
+    }
+}
+// Run as CLI
+if (require.main === module) {
+    const { specPath, outDir } = parseArgs();
+    generateRequestSchemas(specPath, outDir);
+}

package/dist/cli/templates.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared template functions used by init-client and generate-client CLIs.
+ */
+/**
+ * Derive a PascalCase service name from the npm package name.
+ * @example "@tetrascience/data-apps-client" -> "DataApps"
+ * @example "@tetrascience/pipeline-client" -> "Pipeline"
+ */
+export declare function deriveServiceName(packageName: string): string;
+export declare function generateTsConfig(): string;
+/**
+ * Generate index.ts for a client package.
+ *
+ * @param serviceName - PascalCase service name (e.g. "DataApps")
+ * @param specVariants - null for single-spec, or an array of variant names (e.g. ["internal", "public"])
+ */
+export declare function generateIndexTs(serviceName: string, specVariants?: string[] | null): string;
+export declare function generateClientPackageJson(config: {
+    packageName: string;
+    version: string;
+    description?: string;
+    serviceName: string;
+    middlewareVersion: string;
+}): string;
+export declare function generateClientGitIgnore(): string;
+export declare function generateYarnRc(): string;
+//# sourceMappingURL=templates.d.ts.map

package/dist/cli/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../src/cli/templates.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAM7D;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAkBzC;AAaD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,MAAM,CA4E3F;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE;IACjD,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;CAC1B,GAAG,MAAM,CAsBT;AAED,wBAAgB,uBAAuB,IAAI,MAAM,CAKhD;AAED,wBAAgB,cAAc,IAAI,MAAM,CAOvC"}