@r0hitsharma/http-client-core 0.12.0-rohit-fork-ci.1

package/README.md

@@ -0,0 +1,81 @@
+# @r0hitsharma/http-client-core
+
+Typed HTTP client utilities built on OpenAPI and Zod: an `openapi-fetch` client
+factory, the OpenAPI helper types the rest of the toolkit shares, and helpers
+that turn a document's component schemas into zod validators.
+
+## Installation
+
+```bash
+npm install @r0hitsharma/http-client-core
+npm install --save-dev openapi-typescript
+```
+
+## Usage
+
+### Generate types from an OpenAPI document
+
+```bash
+npx uikit-openapi-generate --schema openapi.json --output src/api.types.ts
+```
+
+### Create a typed client
+
+```typescript
+import { createApiClient } from '@r0hitsharma/http-client-core';
+
+import type { paths } from './api.types';
+
+const client = createApiClient<paths>('https://api.example.com');
+
+// Fully typed request and response
+const { data, error } = await client.GET('/users/{id}', {
+  params: { path: { id: '123' } },
+});
+```
+
+The second argument is the rest of the `openapi-fetch` client config (everything
+except `baseUrl`), which is how a test or a mock layer injects its own `fetch`:
+
+```typescript
+const client = createApiClient<paths>('https://api.example.com', {
+  fetch: myFetch,
+  headers: { 'X-Tenant': tenantId },
+});
+```
+
+### Build a zod validator from a component schema
+
+```typescript
+import { getComponentSchemaFromOpenApi } from '@r0hitsharma/http-client-core';
+
+import openApiDocument from '../openapi.json';
+
+const userSchema = getComponentSchemaFromOpenApi(openApiDocument, 'User');
+const result = userSchema.safeParse(await response.json());
+```
+
+`normalizeOpenApiRefs` is exported for documents that need their
+`#/components/schemas/...` refs rewritten to zod's `#/$defs/...` form ahead of
+time; `getComponentSchemaFromOpenApi` applies it internally.
+
+For response validation wired into TanStack Query, use
+`createZodResponseMiddleware` from
+[http-client-react](../http-client-react) rather than calling this directly.
+
+### Shared OpenAPI types
+
+The `openapi-fetch` and `openapi-typescript-helpers` types that anything built on
+this client needs are re-exported here — `ApiClient`, `ApiClientOptions`,
+`FetchResponse`, `MaybeOptionalInit`, `HttpMethod`, `MediaType`,
+`PathsWithMethod`, `RequiredKeysOf` — so downstream packages type against one
+pinned copy of the OpenAPI toolchain instead of each declaring their own
+dependency on it.
+
+## Peer dependencies
+
+- `openapi-typescript`: for generating types from OpenAPI documents
+
+## See also
+
+- [http-client-react](../http-client-react) for the TanStack Query layer

package/bin/generate-openapi.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+function parseArg(name: string, fallback?: string): string | undefined {
+  const prefix = `--${name}=`;
+  const inline = process.argv.find((arg) => arg.startsWith(prefix));
+  if (inline) {
+    return inline.slice(prefix.length);
+  }
+
+  const idx = process.argv.indexOf(`--${name}`);
+  if (idx >= 0 && process.argv[idx + 1]) {
+    return process.argv[idx + 1];
+  }
+
+  return fallback;
+}
+
+const schema = parseArg('schema', process.env.OPENAPI_FILE);
+const output = parseArg('output', 'generated/openapi-types.ts') ?? 'generated/openapi-types.ts';
+
+if (!schema) {
+  console.error('Missing schema path. Use --schema <path-to-openapi-json>.');
+  process.exit(1);
+}
+
+const absoluteSchema = path.resolve(process.cwd(), schema);
+const absoluteOutput = path.resolve(process.cwd(), output);
+
+if (!existsSync(absoluteSchema)) {
+  console.error(`OpenAPI schema file does not exist: ${absoluteSchema}`);
+  process.exit(1);
+}
+
+mkdirSync(path.dirname(absoluteOutput), { recursive: true });
+
+// openapi-typescript builds its output with the classic TypeScript compiler API, which
+// TypeScript 7.0 does not ship (openapi-ts/openapi-typescript#2841). Running from an empty
+// directory makes npx resolve it in an isolated tree alongside a TypeScript that still has that
+// API, instead of picking up the host project's compiler. Exact pins: the
+// isolated tree resolves outside any project .npmrc, so range specifiers
+// would float past consumer supply-chain guards (min-release-age).
+const isolatedCwd = mkdtempSync(path.join(os.tmpdir(), 'openapi-typescript-'));
+
+try {
+  execSync(
+    `npx --yes --package=openapi-typescript@7.13.0 --package=typescript@5.9.3 openapi-typescript "${absoluteSchema}" --output "${absoluteOutput}"`,
+    { cwd: isolatedCwd, stdio: 'inherit' },
+  );
+} finally {
+  rmSync(isolatedCwd, { force: true, recursive: true });
+}
+
+console.log(`Generated: ${absoluteOutput}`);

package/dist/bin/generate-openapi.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/generate-openapi.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+function parseArg(name, fallback) {
+    const prefix = `--${name}=`;
+    const inline = process.argv.find((arg) => arg.startsWith(prefix));
+    if (inline) {
+        return inline.slice(prefix.length);
+    }
+    const idx = process.argv.indexOf(`--${name}`);
+    if (idx >= 0 && process.argv[idx + 1]) {
+        return process.argv[idx + 1];
+    }
+    return fallback;
+}
+const schema = parseArg('schema', process.env.OPENAPI_FILE);
+const output = parseArg('output', 'generated/openapi-types.ts') ?? 'generated/openapi-types.ts';
+if (!schema) {
+    console.error('Missing schema path. Use --schema <path-to-openapi-json>.');
+    process.exit(1);
+}
+const absoluteSchema = path.resolve(process.cwd(), schema);
+const absoluteOutput = path.resolve(process.cwd(), output);
+if (!existsSync(absoluteSchema)) {
+    console.error(`OpenAPI schema file does not exist: ${absoluteSchema}`);
+    process.exit(1);
+}
+mkdirSync(path.dirname(absoluteOutput), { recursive: true });
+// openapi-typescript builds its output with the classic TypeScript compiler API, which
+// TypeScript 7.0 does not ship (openapi-ts/openapi-typescript#2841). Running from an empty
+// directory makes npx resolve it in an isolated tree alongside a TypeScript that still has that
+// API, instead of picking up the host project's compiler. Exact pins: the
+// isolated tree resolves outside any project .npmrc, so range specifiers
+// would float past consumer supply-chain guards (min-release-age).
+const isolatedCwd = mkdtempSync(path.join(os.tmpdir(), 'openapi-typescript-'));
+try {
+    execSync(`npx --yes --package=openapi-typescript@7.13.0 --package=typescript@5.9.3 openapi-typescript "${absoluteSchema}" --output "${absoluteOutput}"`, { cwd: isolatedCwd, stdio: 'inherit' });
+}
+finally {
+    rmSync(isolatedCwd, { force: true, recursive: true });
+}
+console.log(`Generated: ${absoluteOutput}`);

package/dist/src/index.d.ts

@@ -0,0 +1,20 @@
+import type { ClientOptions } from 'openapi-fetch';
+import { z } from 'zod';
+/**
+ * The `openapi-fetch` / `openapi-typescript` helper types that anything built
+ * on this client needs. They are re-exported here so downstream packages
+ * (`http-client-react` and `http-client-msw`) type against the same helper
+ * versions this package is pinned to, rather than each declaring its own
+ * dependency on the OpenAPI toolchain.
+ */
+export type { Client as ApiClient, ClientOptions as ApiClientOptions, FetchResponse, MaybeOptionalInit, } from 'openapi-fetch';
+export type { HttpMethod, MediaType, PathsWithMethod, RequiredKeysOf, } from 'openapi-typescript-helpers';
+export type JsonSchema = z.core.JSONSchema.JSONSchema;
+/**
+ * `options` is the full `openapi-fetch` client config minus `baseUrl`, which
+ * stays the first positional argument for backwards compatibility. It is what
+ * lets a test or a mock layer inject its own `fetch`.
+ */
+export declare const createApiClient: <TPaths extends {}>(baseUrl?: string, options?: Omit<ClientOptions, 'baseUrl'>) => import("openapi-fetch").Client<TPaths, `${string}/${string}`>;
+export declare function normalizeOpenApiRefs(value: unknown): unknown;
+export declare function getComponentSchemaFromOpenApi(openApi: unknown, name: string): z.ZodType;

package/dist/src/index.js

@@ -0,0 +1,37 @@
+import createClient from 'openapi-fetch';
+import { z } from 'zod';
+/**
+ * `options` is the full `openapi-fetch` client config minus `baseUrl`, which
+ * stays the first positional argument for backwards compatibility. It is what
+ * lets a test or a mock layer inject its own `fetch`.
+ */
+export const createApiClient = (baseUrl = '/', options) => {
+    return createClient({ ...options, baseUrl });
+};
+export function normalizeOpenApiRefs(value) {
+    if (Array.isArray(value)) {
+        return value.map(normalizeOpenApiRefs);
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        const normalized = {};
+        for (const [key, entryValue] of Object.entries(record)) {
+            if (key === '$ref' && typeof entryValue === 'string') {
+                normalized[key] = entryValue.replace('#/components/schemas/', '#/$defs/');
+            }
+            else {
+                normalized[key] = normalizeOpenApiRefs(entryValue);
+            }
+        }
+        return normalized;
+    }
+    return value;
+}
+export function getComponentSchemaFromOpenApi(openApi, name) {
+    const schema = openApi;
+    const defs = normalizeOpenApiRefs(schema.components?.schemas ?? {});
+    return z.fromJSONSchema({
+        $ref: `#/$defs/${name}`,
+        $defs: defs,
+    });
+}

package/oxfmt.config.ts

@@ -0,0 +1,5 @@
+import formatConfig from '@r0hitsharma/oxfmt-config';
+
+export default {
+  ...formatConfig,
+};

package/oxlint.config.ts

@@ -0,0 +1,7 @@
+export default {
+  plugins: ['typescript'],
+  categories: {
+    correctness: 'warn',
+    suspicious: 'warn',
+  },
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@r0hitsharma/http-client-core",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "bin": {
+    "uikit-openapi-generate": "./dist/bin/generate-openapi.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "prepare": "npm run build",
+    "type:check": "tsc -p tsconfig.json --noEmit",
+    "lint": "oxlint -c oxlint.config.ts --max-warnings=0 src",
+    "lint:fix": "oxlint -c oxlint.config.ts --fix src",
+    "format": "oxfmt -c oxfmt.config.ts --write src",
+    "format:check": "oxfmt -c oxfmt.config.ts --check src"
+  },
+  "dependencies": {
+    "openapi-fetch": "0.17.0",
+    "openapi-typescript-helpers": "0.1.0",
+    "zod": "4.5.4"
+  },
+  "peerDependencies": {
+    "openapi-typescript": "^7.13.0"
+  },
+  "devDependencies": {
+    "@r0hitsharma/oxfmt-config": "*",
+    "@r0hitsharma/tsconfig": "*",
+    "@types/node": "24.13.3",
+    "oxfmt": "0.67.0",
+    "oxlint": "1.82.0"
+  },
+  "version": "0.12.0-rohit-fork-ci.1",
+  "repository": {
+    "url": "https://github.com/r0hitsharma/uikit"
+  }
+}

package/src/index.ts

@@ -0,0 +1,81 @@
+import createClient from 'openapi-fetch';
+import type { ClientOptions } from 'openapi-fetch';
+import { z } from 'zod';
+
+/**
+ * The `openapi-fetch` / `openapi-typescript` helper types that anything built
+ * on this client needs. They are re-exported here so downstream packages
+ * (`http-client-react` and `http-client-msw`) type against the same helper
+ * versions this package is pinned to, rather than each declaring its own
+ * dependency on the OpenAPI toolchain.
+ */
+export type {
+  Client as ApiClient,
+  ClientOptions as ApiClientOptions,
+  FetchResponse,
+  MaybeOptionalInit,
+} from 'openapi-fetch';
+export type {
+  HttpMethod,
+  MediaType,
+  PathsWithMethod,
+  RequiredKeysOf,
+} from 'openapi-typescript-helpers';
+
+export type JsonSchema = z.core.JSONSchema.JSONSchema;
+
+/**
+ * `options` is the full `openapi-fetch` client config minus `baseUrl`, which
+ * stays the first positional argument for backwards compatibility. It is what
+ * lets a test or a mock layer inject its own `fetch`.
+ */
+export const createApiClient = <TPaths extends {}>(
+  baseUrl: string = '/',
+  options?: Omit<ClientOptions, 'baseUrl'>,
+) => {
+  return createClient<TPaths>({ ...options, baseUrl });
+};
+
+export function normalizeOpenApiRefs(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(normalizeOpenApiRefs);
+  }
+
+  if (value && typeof value === 'object') {
+    const record = value as Record<string, unknown>;
+    const normalized: Record<string, unknown> = {};
+
+    for (const [key, entryValue] of Object.entries(record)) {
+      if (key === '$ref' && typeof entryValue === 'string') {
+        normalized[key] = entryValue.replace(
+          '#/components/schemas/',
+          '#/$defs/',
+        );
+      } else {
+        normalized[key] = normalizeOpenApiRefs(entryValue);
+      }
+    }
+
+    return normalized;
+  }
+
+  return value;
+}
+
+export function getComponentSchemaFromOpenApi(
+  openApi: unknown,
+  name: string,
+): z.ZodType {
+  const schema = openApi as {
+    components?: { schemas?: Record<string, unknown> };
+  };
+  const defs = normalizeOpenApiRefs(schema.components?.schemas ?? {}) as Record<
+    string,
+    JsonSchema
+  >;
+
+  return z.fromJSONSchema({
+    $ref: `#/$defs/${name}`,
+    $defs: defs,
+  } satisfies JsonSchema);
+}

package/tsconfig.build.json

@@ -0,0 +1,14 @@
+{
+  "extends": "@r0hitsharma/tsconfig/node",
+  "compilerOptions": {
+    "allowImportingTsExtensions": false,
+    "types": ["node"],
+    "noEmit": false,
+    "emitDeclarationOnly": false,
+    "declaration": true,
+    "declarationMap": false,
+    "rootDir": ".",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*.ts", "bin/**/*.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "@r0hitsharma/tsconfig/node",
+  "compilerOptions": {
+    "allowImportingTsExtensions": false,
+    "types": ["node"]
+  },
+  "include": [
+    "src/**/*.ts",
+    "bin/**/*.ts"
+  ]
+}