react-query-lightbase-codegen 1.6.3 → 2.0.0

package/src/utils.ts

@@ -1,213 +1,56 @@
-import lodash from 'lodash';
-const { uniq, isEmpty } = lodash;
-import pasCase from 'case';
-import chalk from 'chalk';
-
-const { pascal } = pasCase;
-
-import type { ReferenceObject, RequestBodyObject, ResponseObject, SchemaObject } from 'openapi3-ts';
-import { imports } from './generateHooks.js';
-
-export const getDocs = (data: ReferenceObject | { description?: string }) =>
-  isReference(data) ? '' : formatDescription(data.description);
-/**
- * Discriminator helper for `ReferenceObject`
- */
-export const isReference = (property: any): property is ReferenceObject => {
-  return Boolean(property.$ref);
-};
-
-/**
- * Return the typescript equivalent of open-api data type
- */
-export const getScalar = (item: SchemaObject) => {
-  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: ReferenceObject['$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: SchemaObject): string | undefined => {
-  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: SchemaObject): string => {
-  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]: [string, ReferenceObject | SchemaObject]) => {
-        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: SchemaObject) => {
-  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?: string) => {
-  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: Array<[string, ResponseObject | ReferenceObject | RequestBodyObject]>
-) => {
-  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(' | ');
-};
+import type { OpenAPIV3 } from "openapi-types";
+
+export function camelCase(str: string): string {
+	return str
+		.toLowerCase()
+		.replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase())
+		.replace(/^[A-Z]/, (c) => c.toLowerCase());
+}
+
+export function pascalCase(str: string): string {
+	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
+ */
+export function sanitizePropertyName(name: string): string {
+	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
+ */
+export function sanitizeTypeName(name: string): string {
+	return name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/_+$/, "");
+}
+
+export function specTitle(spec: OpenAPIV3.Document): string {
+	return camelCase(spec.info.title.toLowerCase().replace(/\s+/g, "-"));
+}

package/README.md

@@ -1,77 +0,0 @@
-# React Query Code Generation
-
-Generate fully typed react query hooks from OpenAPI specifications.
-
-- GET requests will automatically generate `useQuery` hooks together with helper functions
-  - getQueryState
-  - getQueryData
-  - prefetch
-  - cancelQueries
-  - invalidate
-  - refetchStale
-
-- Override default generation forcing query, mutation or infiniteQuery output
-
-## Installation
-
-You can install react-query-lightbase-codegen with NPM or Yarn.
-
-Using NPM:
-
-```bash
-$ npm i -D react-query-lightbase-codegen 
-```
-
-Using Yarn:
-
-```
-$ yarn add -D react-query-lightbase-codegen
-```
-
-## Configuration
-
-create a generateQueries.mjs file in project root folder
-
-```javascript
-// generateQueries.mjs
-import { importSpecs } from 'react-query-lightbase-codegen';
-
-importSpecs({
-  // folder location of the openapi/swagger documents (yaml or JSON)
-  sourceDirectory: './specs',
-  // export folder for hooks and schema code generated files
-  exportDirectory: './src/generated',
-  // api client - as named export labelled 'api'
-  apiDirectory: './src/api',
-  // React query client directory - names export 'queryClient'
-  queryClientDir: './src/api',
-});
-```
-
-## Code generation
-
-To generate the code generated scheme and react query hooks run the above script
-
-```bash
-node scripts/generateQueries.mjs
-```
-
-## Configuration Options
-
-```javascript
-// generateQueries.mjs
-import { importSpecs } from 'react-query-lightbase-codegen';
-
-importSpecs({
-  ...
-  // Filter out any headers from individual queries (these might be applied globally in the axios instance)
-  headerFilters: ['X-Session-Token'],
-  overrides: {
-    // operationId listed in the openApi spec
-    findPetsByStatus: {
-      // Override the default query code generation type ('query' | 'mutation' | 'infiniteQuery')
-      type: 'query',
-    },
-  },
-});
-```

package/dist/convertSwaggerFile.d.ts

@@ -1,5 +0,0 @@
-import { OpenAPIObject } from 'openapi3-ts';
-/**
- * Import and parse the openapi spec from a yaml/json
- */
-export declare const convertSwaggerFile: (data: string, extension: 'yaml' | 'json') => Promise<OpenAPIObject>;

package/dist/convertSwaggerFile.js

@@ -1,26 +0,0 @@
-import swagger2openapi from 'swagger2openapi';
-import yaml from 'js-yaml';
-/**
- * Import and parse the openapi spec from a yaml/json
- */
-export const convertSwaggerFile = (data, extension) => {
-    const schema = extension === 'yaml' ? yaml.load(data) : JSON.parse(data);
-    return new Promise((resolve, reject) => {
-        if (!schema.openapi || !schema.openapi.startsWith('3.')) {
-            swagger2openapi.convertObj(schema, {}, (err, convertedObj) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    // @ts-ignore
-                    convertedObj.openapi.basePath = convertedObj.original.basePath;
-                    resolve(convertedObj.openapi);
-                }
-            });
-        }
-        else {
-            resolve(schema);
-        }
-    });
-};
-//# sourceMappingURL=convertSwaggerFile.js.map

package/dist/convertSwaggerFile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"convertSwaggerFile.js","sourceRoot":"","sources":["../src/convertSwaggerFile.ts"],"names":[],"mappings":"AACA,OAAO,eAAe,MAAM,iBAAiB,CAAC;AAC9C,OAAO,IAAI,MAAM,SAAS,CAAC;AAE3B;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,IAAY,EAAE,SAA0B,EAA0B,EAAE;IACrG,MAAM,MAAM,GAAG,SAAS,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACzE,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;YACxD,eAAe,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,YAAY,EAAE,EAAE;gBAC3D,IAAI,GAAG,EAAE,CAAC;oBACR,MAAM,CAAC,GAAG,CAAC,CAAC;gBACd,CAAC;qBAAM,CAAC;oBACN,aAAa;oBACb,YAAY,CAAC,OAAO,CAAC,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC;oBAC/D,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;gBAChC,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,MAAM,CAAC,CAAC;QAClB,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC"}

package/dist/generateHooks.d.ts

@@ -1,18 +0,0 @@
-import { ComponentsObject, OperationObject, ParameterObject, ReferenceObject } from 'openapi3-ts';
-export declare let imports: string[];
-/**
- * Generate a react-query component from openapi operation specs
- */
-export declare const createHook: ({ operation, verb, route, operationIds, parameters, schemasComponents, headerFilters, }: {
-    operation: OperationObject;
-    verb: string;
-    route: string;
-    operationIds: string[];
-    parameters: (ReferenceObject | ParameterObject)[] | undefined;
-    schemasComponents?: ComponentsObject | undefined;
-    headerFilters?: string[] | undefined;
-}) => {
-    implementation: string;
-    imports: string[];
-    queryImports: ("mutation" | "query" | "infiniteQuery")[];
-};