react-query-lightbase-codegen 1.6.4 → 2.0.0

package/dist/utils.d.ts

@@ -1,24 +1,35 @@
-import type { ReferenceObject, RequestBodyObject, ResponseObject, SchemaObject } from 'openapi3-ts';
-export declare const getDocs: (data: ReferenceObject | {
-    description?: string;
-}) => string;
+import type { OpenAPIV3 } from "openapi-types";
+export declare function camelCase(str: string): string;
+export declare function pascalCase(str: string): string;
 /**
- * Discriminator helper for `ReferenceObject`
+ * Sanitizes a property name to ensure it's a valid JavaScript identifier.
+ * If the name is already a valid identifier (starts with letter/underscore/$ and contains only letters/numbers/underscore/$),
+ * returns it as-is. Otherwise wraps it in quotes to make it a valid property accessor.
+ *
+ * For example:
+ * - sanitizePropertyName("validName") => "validName"
+ * - sanitizePropertyName("invalid-name") => "'invalid-name'"
+ * - sanitizePropertyName("123invalid") => "'123invalid'"
+ *
+ * @param name The property name to sanitize
+ * @returns The sanitized property name, quoted if needed
  */
-export declare const isReference: (property: any) => property is ReferenceObject;
+export declare function sanitizePropertyName(name: string): string;
 /**
- * Return the typescript equivalent of open-api data type
+ * Sanitizes a type name to ensure it's a valid TypeScript type identifier.
+ * Replaces any characters that aren't alphanumeric or underscore with an underscore.
+ *
+ * For example:
+ * - sanitizeTypeName("ValidType") => "ValidType"
+ * - sanitizeTypeName("invalid-type") => "invalid_type"
+ * - sanitizeTypeName("type.name") => "type_name"
+ * - sanitizeTypeName("type/name") => "type_name"
+ *
+ * This is used to convert operation IDs and response names from the OpenAPI spec
+ * into valid TypeScript type names.
+ *
+ * @param name The type name to sanitize
+ * @returns The sanitized type name with invalid characters replaced by underscores
  */
-export declare const getScalar: (item: SchemaObject) => string;
-/**
- * Resolve the value of a schema object to a proper type definition.
- */
-export declare const resolveValue: (schema: SchemaObject) => string;
-/**
- * Format a description to code documentation.
- */
-export declare const formatDescription: (description?: string) => string;
-/**
- * Extract responses / request types from open-api specs
- */
-export declare const getResReqTypes: (responsesOrRequests: Array<[string, ResponseObject | ReferenceObject | RequestBodyObject]>) => string;
+export declare function sanitizeTypeName(name: string): string;
+export declare function specTitle(spec: OpenAPIV3.Document): string;

package/dist/utils.js

@@ -1,179 +1,57 @@
-import lodash from 'lodash';
-const { uniq, isEmpty } = lodash;
-import pasCase from 'case';
-import chalk from 'chalk';
-const { pascal } = pasCase;
-import { imports } from './generateHooks.js';
-export const getDocs = (data) => isReference(data) ? '' : formatDescription(data.description);
-/**
- * Discriminator helper for `ReferenceObject`
- */
-export const isReference = (property) => {
-    return Boolean(property.$ref);
-};
-/**
- * Return the typescript equivalent of open-api data type
- */
-export const getScalar = (item) => {
-    const nullable = item.nullable ? ' | null' : '';
-    switch (item.type) {
-        case 'number':
-        case 'integer':
-            return 'number' + nullable;
-        case 'boolean':
-            return 'boolean' + nullable;
-        case 'array':
-            return getArray(item) + nullable;
-        case 'string':
-            if (item.format === 'binary') {
-                return 'string | { name?: string; type?: string; uri: string }' + nullable;
-            }
-            if (item.enum) {
-                return `"${item.enum.join(`" | "`)}"` + nullable;
-            }
-            return 'string' + nullable;
-        case 'object':
-            return getObject(item) + nullable;
-        default:
-            return getObject(item) + nullable;
-    }
-};
-/**
- * Return the output type from the $ref
- */
-const getRef = ($ref) => {
-    if ($ref.startsWith('#/components/schemas')) {
-        return pascal($ref.replace('#/components/schemas/', ''));
-    }
-    else if ($ref.startsWith('#/components/responses')) {
-        return pascal($ref.replace('#/components/responses/', '')) + 'Response';
-    }
-    else if ($ref.startsWith('#/components/parameters')) {
-        return pascal($ref.replace('#/components/parameters/', '')) + 'Parameter';
-    }
-    else if ($ref.startsWith('#/components/requestBodies')) {
-        return pascal($ref.replace('#/components/requestBodies/', '')) + 'RequestBody';
-    }
-    else {
-        throw new Error('This library only resolve $ref that are include into `#/components/*` for now');
-    }
-};
-/**
- * Return the output type from an array
- */
-const getArray = (item) => {
-    if (item.items) {
-        if (!isReference(item.items) && (item.items.oneOf || item.items.allOf || item.items.enum)) {
-            return `(${resolveValue(item.items)})[]`;
-        }
-        else {
-            return `${resolveValue(item.items)}[]`;
-        }
-    }
-    console.log(chalk.red(`Skipped(${item.title}): All arrays must have an 'items' key define`));
-    return 'unknown[]';
-};
-/**
- * Return the output type from an object
- */
-const getObject = (item) => {
-    if (isReference(item)) {
-        return getRef(item.$ref);
-    }
-    if (item.allOf) {
-        return item.allOf.map(resolveValue).join(' & ');
-    }
-    if (item.oneOf) {
-        return item.oneOf.map(resolveValue).join(' | ');
-    }
-    if (item.anyOf) {
-        return item.anyOf.map(resolveValue).join(' | ');
-    }
-    if (!item.type && !item.properties && !item.additionalProperties) {
-        return '{}';
-    }
-    // Free form object (https://swagger.io/docs/specification/data-models/data-types/#free-form)
-    if (item.type === 'object' &&
-        !item.properties &&
-        (!item.additionalProperties || item.additionalProperties === true || isEmpty(item.additionalProperties))) {
-        return '{[key: string]: any}';
-    }
-    const IdentifierRegexp = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-    // Consolidation of item.properties & item.additionalProperties
-    let output = '{';
-    if (item.properties) {
-        output += Object.entries(item.properties)
-            .map(([key, prop]) => {
-            const doc = getDocs(prop);
-            const isRequired = (item.required || []).includes(key);
-            const processedKey = IdentifierRegexp.test(key) ? key : `"${key}"`;
-            return `${doc}\n${processedKey}${isRequired ? '' : '?'}: ${resolveValue(prop)}`;
-        })
-            .join('');
-    }
-    if (item.additionalProperties) {
-        if (item.properties) {
-            output += '\n';
-        }
-        output += `} & { [key: string]: ${item.additionalProperties === true ? 'any' : resolveValue(item.additionalProperties)}`;
-    }
-    if (item.properties || item.additionalProperties) {
-        if (output === '{\n') {
-            return '{}';
-        }
-        return output + '\n}';
-    }
-    return item.type === 'object' ? '{[key: string]: any}' : 'any';
-};
-/**
- * Resolve the value of a schema object to a proper type definition.
- */
-export const resolveValue = (schema) => {
-    if (isReference(schema)) {
-        const ref = getRef(schema.$ref);
-        imports?.push(ref);
-        return ref;
-    }
-    return getScalar(schema);
-};
-/**
- * Format a description to code documentation.
- */
-export const formatDescription = (description) => {
-    if (!description) {
-        return '';
-    }
-    return `\n/**\n${description
-        .split('\n')
-        .map((i) => `*  ${i}`)
-        .join('\n')}\n */`;
-};
-/**
- * Extract responses / request types from open-api specs
- */
-export const getResReqTypes = (responsesOrRequests) => {
-    return uniq(responsesOrRequests.map(([_, res]) => {
-        if (!res) {
-            return;
-        }
-        if (isReference(res)) {
-            const ref = getRef(res.$ref);
-            imports.push(ref);
-            return ref;
-        }
-        if (res.content) {
-            for (const contentType of Object.keys(res.content)) {
-                if (contentType.startsWith('application/json') ||
-                    contentType.startsWith('application/ld+json') ||
-                    contentType.startsWith('application/octet-stream') ||
-                    contentType.startsWith('multipart/form-data')) {
-                    const schema = res.content[contentType].schema;
-                    return resolveValue(schema);
-                }
-            }
-            return;
-        }
-        return;
-    })).join(' | ');
-};
-//# sourceMappingURL=utils.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.camelCase = camelCase;
+exports.pascalCase = pascalCase;
+exports.sanitizePropertyName = sanitizePropertyName;
+exports.sanitizeTypeName = sanitizeTypeName;
+exports.specTitle = specTitle;
+function camelCase(str) {
+    return str
+        .toLowerCase()
+        .replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase())
+        .replace(/^[A-Z]/, (c) => c.toLowerCase());
+}
+function pascalCase(str) {
+    return str
+        .toLowerCase()
+        .replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase())
+        .replace(/^[a-z]/, (c) => c.toUpperCase());
+}
+/**
+ * Sanitizes a property name to ensure it's a valid JavaScript identifier.
+ * If the name is already a valid identifier (starts with letter/underscore/$ and contains only letters/numbers/underscore/$),
+ * returns it as-is. Otherwise wraps it in quotes to make it a valid property accessor.
+ *
+ * For example:
+ * - sanitizePropertyName("validName") => "validName"
+ * - sanitizePropertyName("invalid-name") => "'invalid-name'"
+ * - sanitizePropertyName("123invalid") => "'123invalid'"
+ *
+ * @param name The property name to sanitize
+ * @returns The sanitized property name, quoted if needed
+ */
+function sanitizePropertyName(name) {
+    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `'${name}'`;
+}
+/**
+ * Sanitizes a type name to ensure it's a valid TypeScript type identifier.
+ * Replaces any characters that aren't alphanumeric or underscore with an underscore.
+ *
+ * For example:
+ * - sanitizeTypeName("ValidType") => "ValidType"
+ * - sanitizeTypeName("invalid-type") => "invalid_type"
+ * - sanitizeTypeName("type.name") => "type_name"
+ * - sanitizeTypeName("type/name") => "type_name"
+ *
+ * This is used to convert operation IDs and response names from the OpenAPI spec
+ * into valid TypeScript type names.
+ *
+ * @param name The type name to sanitize
+ * @returns The sanitized type name with invalid characters replaced by underscores
+ */
+function sanitizeTypeName(name) {
+    return name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/_+$/, "");
+}
+function specTitle(spec) {
+    return camelCase(spec.info.title.toLowerCase().replace(/\s+/g, "-"));
+}

package/package.json

@@ -1,84 +1,56 @@
 {
-  "name": "react-query-lightbase-codegen",
-  "description": "Fully typed react query code generation tool based on openApi specifications",
-  "version": "1.6.4",
-  "license": "MIT",
-  "type": "module",
-  "exports": "./dist/index.js",
-  "files": [
-    "src",
-    "dist"
-  ],
-  "keywords": [
-    "rest",
-    "client",
-    "swagger",
-    "open-api",
-    "fetch",
-    "data fetching",
-    "code-generation",
-    "react",
-    "react-query",
-    "axios",
-    "vue-query",
-    "tanstack"
-  ],
-  "author": {
-    "name": "Oliver Winter",
-    "email": "owinter86@gmail.com"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/lightbasenl/react-query-codegen"
-  },
-  "engines": {
-    "node": ">=14.16"
-  },
-  "scripts": {
-    "lint": "eslint . --ext .js,.jsx,.ts,.tsx",
-    "tsc": "tsc -p tsconfig.json",
-    "test": "npm run tsc && node test/script.mjs",
-    "deploy": "tsc && semantic-release --no-ci",
-    "updates": "npx npm-check-updates -i",
-    "prepare": "husky install"
-  },
-  "dependencies": {
-    "case": "1.6.3",
-    "chalk": "5.3.0",
-    "js-yaml": "4.1.0",
-    "lodash": "4.17.21",
-    "openapi3-ts": "2.0.2",
-    "swagger2openapi": "7.0.8",
-    "yamljs": "0.3.0"
-  },
-  "devDependencies": {
-    "@babel/core": "7.24.3",
-    "@babel/eslint-parser": "7.24.1",
-    "@commitlint/cli": "^19.2.1",
-    "@commitlint/config-conventional": "^19.1.0",
-    "@react-native-community/eslint-config": "3.2.0",
-    "@semantic-release/changelog": "^6.0.3",
-    "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^10.0.2",
-    "@semantic-release/npm": "^12.0.0",
-    "@tanstack/react-query": "5.51.23",
-    "@types/js-yaml": "4.0.9",
-    "@types/lodash": "4.17.0",
-    "@types/node": "20.11.30",
-    "@types/qs": "6.9.14",
-    "@types/query-string": "6.3.0",
-    "@types/yamljs": "0.2.34",
-    "axios": "1.7.3",
-    "eslint": "8.57.0",
-    "eslint-plugin-prettier": "5.1.3",
-    "husky": "^9.0.11",
-    "prettier": "3.3.3",
-    "react": "18.2.0",
-    "semantic-release": "^23.0.6",
-    "typescript": "5.4.3"
-  },
-  "peerDependencies": {
-    "@tanstack/react-query": ">= 5.20.0",
-    "axios": "*"
-  }
+	"name": "react-query-lightbase-codegen",
+	"version": "2.0.0",
+	"license": "MIT",
+	"description": "Generate Axios API clients and React Query options from OpenAPI specifications",
+	"exports": "./dist/index.js",
+	"files": [
+		"src",
+		"dist"
+	],
+	"author": {
+		"name": "Oliver Winter",
+		"email": "owinter86@gmail.com"
+	},
+	"keywords": [
+		"rest",
+		"client",
+		"swagger",
+		"open-api",
+		"fetch",
+		"data fetching",
+		"code-generation",
+		"react",
+		"react-query",
+		"axios",
+		"tanstack"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/lightbasenl/react-query-codegen"
+	},
+	"scripts": {
+		"build": "tsc -p tsconfig.json",
+		"example": "ts-node example/index.ts && biome check --fix --unsafe",
+		"check": "biome check --write .",
+		"updates": "npx npm-check-updates -i",
+		"release": "release-it"
+	},
+	"dependencies": {
+		"axios": "^1.7.9",
+		"openapi-types": "^12.1.3",
+		"yaml": "^2.7.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "1.9.4",
+		"@tanstack/react-query": "^5.66.9",
+		"@types/node": "^22.13.5",
+		"release-it": "^17.0.0",
+		"ts-node": "^10.9.2",
+		"typescript": "^5.7.3"
+	},
+	"peerDependencies": {
+		"@tanstack/react-query": ">= 5.50.0",
+		"axios": "^1.7.0"
+	}
 }

package/readme.md

@@ -0,0 +1,94 @@
+# react-query-lightbase-codegen
+
+Generate type-safe Axios API clients and React Query hooks from OpenAPI specifications.
+
+## Features
+
+- 🔄 Automatic code generation from OpenAPI/Swagger specs
+- 📝 Type-safe API client functions
+- 🎣 React Query integration with query options
+- 📦 Support for multiple API specifications
+- 📤 Handle multipart/form-data uploads
+- 💪 Full TypeScript support
+- 🔒 Type-safe request/response handling
+
+## Installation
+
+```bash
+npm install react-query-lightbase-codegen
+```
+
+## Quick Start
+
+### 1. Configure Generation
+
+Create a script to generate your API code (e.g., `scripts/generate.ts`):
+
+```typescript
+import { codegenerate } from 'react-query-lightbase-codegen';
+await codegenerate({
+  specSource: './specs/api.yaml', // or array of specs
+  exportDir: './src/generated'
+});
+```
+
+### 2. Configure API Instance
+
+```typescript
+import axios from "axios";
+import { setApiClient } from "./src/generated/apiClient";
+
+const api = axios.create({ baseURL: "https://api.example.com" });
+// Set the API client instance to be used by the generated client functions
+setApiClient(api);
+
+```
+
+### 3. Use Generated Query Options
+
+```typescript
+import { useQuery } from '@tanstack/react-query';
+import { characteristicListQueryOptions } from './src/generated/pokiApi.queryOptions';
+
+const { data, isLoading, error } = useQuery(characteristicListQueryOptions());
+```
+
+and more complex queries: 
+```typescript
+import { useQuery } from '@tanstack/react-query';
+import { characteristicListQueryOptions } from './src/generated/pokiApi.queryOptions';
+
+const { data, isLoading, error } = useQuery({
+  ...characteristicListQueryOptions(),
+  select: (data) => data.results.find(item => item.id === itemId),
+});
+```
+
+easier query invalidation:
+```typescript
+queryClient.invalidateQueries(characteristicListQueryOptions());
+```
+
+
+## Generated Files
+
+A single `apiClient.ts` file is generated to be used as a global Axios instance for all generated clients.
+
+For each API specification, the following files are generated:
+
+- `{api}.schema.ts` - TypeScript types for requests/responses
+- `{api}.client.ts` - Type-safe API client functions
+- `{api}.queryOptions.ts` - React Query integration
+
+### Multiple API Specifications
+
+```typescript
+await codegenerate({
+specSource: [
+  './specs/auth-api.yaml',
+  './specs/user-api.json',
+  'https://api.example.com/openapi.yaml'
+],
+exportDir: './src/generated'
+});
+```

package/src/config/loadConfig.ts

@@ -0,0 +1,25 @@
+import { readFile } from "node:fs/promises";
+import type { OpenAPIConfig } from "../types/config";
+
+export async function loadConfig(configPath: string): Promise<OpenAPIConfig> {
+	try {
+		const configContent = await readFile(configPath, "utf-8");
+		const config = JSON.parse(configContent) as OpenAPIConfig;
+
+		// Validate required fields
+		if (!config.specSource) {
+			throw new Error("specSource is required in configuration");
+		}
+
+		if (!config.exportDir) {
+			throw new Error("exportDir is required in configuration");
+		}
+
+		return config;
+	} catch (error) {
+		if (error instanceof Error) {
+			throw new Error(`Failed to load configuration: ${error.message}`);
+		}
+		throw new Error("Failed to load configuration: Unknown error");
+	}
+}