react-query-lightbase-codegen 1.0.2 → 1.0.5

package/src/importSpecs.ts

@@ -0,0 +1,110 @@
+import chalk from 'chalk';
+import { readFileSync, writeFileSync, readdir, mkdirSync } from 'fs';
+import { OperationObject, PathItemObject } from 'openapi3-ts';
+import { join, parse } from 'path';
+import { convertSwaggerFile } from './convertSwaggerFile.js';
+import { createHook } from './generateHooks.js';
+import { generateImports } from './generateImports.js';
+import { generateSchemas } from './generateSchemas.js';
+
+export function importSpecs({
+  sourceDirectory,
+  exportDirectory,
+  apiDirectory,
+  queryClientDir,
+  headerFilters,
+  overrides,
+}: {
+  sourceDirectory: string;
+  exportDirectory: string;
+  apiDirectory: string;
+  queryClientDir: string;
+  headerFilters?: string[];
+  overrides?: Record<
+    string,
+    { type: 'query' } | { type: 'mutation' } | { type: 'infiniteQuery'; infiniteQueryParm: string }
+  >;
+}) {
+  readdir(sourceDirectory, function (err, filenames) {
+    if (err) {
+      console.log(err);
+      throw err;
+    }
+    filenames.map(async (filename) => {
+      try {
+        const data = readFileSync(join(process.cwd(), sourceDirectory + '/' + filename), 'utf-8');
+        const { ext } = parse(sourceDirectory + '/' + filename);
+        const format = ['.yaml', '.yml'].includes(ext.toLowerCase()) ? 'yaml' : 'json';
+        let spec = await convertSwaggerFile(data, format);
+
+        const schemaName = `useQueries${filename.split('.')[0]}.schema`;
+        const hooksName = `useQueries${filename.split('.')[0]}`;
+        const name = filename.split('.')[0];
+        mkdirSync(join(process.cwd(), `${exportDirectory}/${name}`), { recursive: true });
+
+        const operationIds: string[] = [];
+
+        let hooks = '';
+        let schemaImportsArray = [] as string[];
+        let collectedQueryImports = [] as ('query' | 'mutation' | 'infiniteQuery')[];
+        Object.entries(spec.paths).forEach(([route, verbs]: [string, PathItemObject]) => {
+          Object.entries(verbs).forEach(([verb, operation]: [string, OperationObject]) => {
+            if (['get', 'post', 'patch', 'put', 'delete'].includes(verb) && !operation.deprecated) {
+              const { implementation, imports, queryImports } = createHook({
+                operation,
+                verb,
+                route: (spec.basePath || '') + route,
+                operationIds,
+                parameters: verbs.parameters,
+                schemasComponents: spec.components,
+                headerFilters,
+                overrides,
+              });
+
+              hooks += implementation;
+              imports.forEach((element) => {
+                const formattedImport = element.replace('[]', '');
+                if (
+                  !schemaImportsArray.includes(formattedImport) &&
+                  element !== 'void' &&
+                  element !== 'string' &&
+                  !element.includes('{')
+                ) {
+                  schemaImportsArray.push(formattedImport);
+                }
+              });
+              queryImports.forEach((element) => {
+                if (!schemaImportsArray.includes(element)) {
+                  collectedQueryImports.push(element);
+                }
+              });
+            }
+          });
+        });
+
+        const imports = generateImports({
+          apiDirectory,
+          queryClientDir,
+          schemaName,
+          schemaImports: schemaImportsArray,
+          queryImports: collectedQueryImports,
+        });
+
+        writeFileSync(join(process.cwd(), `${exportDirectory}/${name}/${hooksName}.tsx`), imports + hooks);
+
+        const schemas = generateSchemas({ spec });
+        writeFileSync(join(process.cwd(), `${exportDirectory}/${name}/${schemaName}.tsx`), schemas);
+
+        console.log(
+          chalk.green(`🎉 [${filename}] Your OpenAPI spec has been converted into react query hooks`)
+        );
+      } catch (error) {
+        if ((error as any).code === 'EISDIR') {
+          console.log(chalk.red('nested folder structure not supported'));
+          return;
+        }
+        console.log(chalk.red(`[${filename}]:`), chalk.red(error));
+      }
+    });
+  });
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+import { convertSwaggerFile } from './convertSwaggerFile.js';
+import { importSpecs } from './importSpecs.js';
+export { importSpecs, convertSwaggerFile };

package/src/utils.ts

@@ -0,0 +1,190 @@
+import lodash from 'lodash';
+const { uniq, isEmpty } = lodash;
+import pasCase from 'case';
+
+const { pascal } = pasCase;
+
+import { ReferenceObject, RequestBodyObject, ResponseObject, SchemaObject } from 'openapi3-ts';
+
+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':
+      return (item.enum ? `"${item.enum.join(`" | "`)}"` : 'string') + nullable;
+
+    case 'object':
+    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 => {
+  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)}[]`;
+    }
+  } else {
+    throw new Error('All arrays must have an `items` key define');
+  }
+};
+
+/**
+ * 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.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 = '{\n';
+  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) =>
+  isReference(schema) ? getRef(schema.$ref) : 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)) {
+        return getRef(res.$ref);
+      }
+
+      if (res.content) {
+        for (let contentType of Object.keys(res.content)) {
+          if (
+            contentType.startsWith('application/json') ||
+            contentType.startsWith('application/octet-stream')
+          ) {
+            const schema = res.content[contentType].schema!;
+
+            return resolveValue(schema);
+          }
+        }
+        return;
+      }
+
+      return;
+    })
+  ).join(' | ');
+};