react-query-lightbase-codegen 0.2.0 → 0.5.0

package/lib/esm/importSpecs.js

@@ -0,0 +1,80 @@
+import chalk from 'chalk';
+import { readFileSync, writeFileSync, readdir, mkdirSync } from 'fs';
+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, }) {
+    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 = [];
+                let hooks = '';
+                let schemaImportsArray = [];
+                let collectedQueryImports = [];
+                Object.entries(spec.paths).forEach(([route, verbs]) => {
+                    Object.entries(verbs).forEach(([verb, operation]) => {
+                        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.code === 'EISDIR') {
+                    console.log(chalk.red('nested folder structure not supported'));
+                    return;
+                }
+                console.log(chalk.red(`[${filename}]:`), chalk.red(error));
+            }
+        });
+    });
+}

package/lib/esm/index.js

@@ -1,2 +1,3 @@
-import { importSpecs } from './react-query-codegen-import';
-export { importSpecs };
+import { convertSwaggerFile } from './convertSwaggerFile.js';
+import { importSpecs } from './importSpecs.js';
+export { importSpecs, convertSwaggerFile };

package/lib/esm/react-query-codegen-import.js

@@ -1,12 +1,13 @@
 import chalk from 'chalk';
-import { readFileSync, writeFileSync, readdir } from 'fs';
+import { readFileSync, writeFileSync, readdir, mkdirSync } from 'fs';
 import { join, parse } from 'path';
-import { importOpenApi } from './import-open-api';
-const log = console.log; // tslint:disable-line:no-console
-const createSuccessMessage = (backend) => chalk.green(`🎉 ${backend ? `[${backend}] ` : ''} Your OpenAPI spec has been converted into react query hooks`);
+import { convertSwaggerFile } from './convertSwaggerFile';
+import { generateQueryHooks } from './generateHooks';
+import { generateSchemas } from './generateSchemas';
 export function importSpecs({ sourceDirectory, exportDirectory, apiDirectory, queryClientDir, headerFilters, }) {
     readdir(sourceDirectory, function (err, filenames) {
         if (err) {
+            console.log(err);
             throw err;
         }
         filenames.map(async (filename) => {
@@ -14,20 +15,27 @@ export function importSpecs({ sourceDirectory, exportDirectory, apiDirectory, qu
             const { ext } = parse(sourceDirectory + '/' + filename);
             const format = ['.yaml', '.yml'].includes(ext.toLowerCase()) ? 'yaml' : 'json';
             try {
-                const name = `useQueries${filename.split('.')[0]}.tsx`;
-                const fileExports = await importOpenApi({
-                    data,
-                    format,
-                    apiDirectory,
+                const name = filename.split('.')[0];
+                const hooksName = `useQueries${filename.split('.')[0]}`;
+                const schemaName = `useQueries${filename.split('.')[0]}.schema`;
+                let spec = await convertSwaggerFile(data, format);
+                const operationIds = [];
+                mkdirSync(join(process.cwd(), `${exportDirectory}/${name}`), { recursive: true });
+                const hooks = generateQueryHooks({
+                    spec,
+                    schemaName,
+                    operationIds,
                     headerFilters,
+                    apiDirectory,
                     queryClientDir,
                 });
-                writeFileSync(join(process.cwd(), `${exportDirectory}/${name}`), fileExports);
-                log(createSuccessMessage(filename));
+                writeFileSync(join(process.cwd(), `${exportDirectory}/${name}/${hooksName}.tsx`), 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) {
-                log(chalk.red(`[${filename}]:`), chalk.red(error));
-                // process.exit(1);
+                console.log(chalk.red(`[${filename}]:`), chalk.red(error));
             }
         });
     });

package/lib/esm/resolveDiscriminator.js

@@ -0,0 +1,24 @@
+import set from 'lodash/set';
+import { isReference } from './getResReqTypes';
+/**
+ * Propagate every `discriminator.propertyName` mapping to the original ref
+ *
+ * Note: This method directly mutate the `specs` object.
+ */
+export const resolveDiscriminator = (specs) => {
+    if (specs.components && specs.components.schemas) {
+        Object.values(specs.components.schemas).forEach((schema) => {
+            if (isReference(schema) || !schema.discriminator || !schema.discriminator.mapping) {
+                return;
+            }
+            const { mapping, propertyName } = schema.discriminator;
+            Object.entries(mapping).forEach(([name, ref]) => {
+                if (!ref.startsWith('#/components/schemas/')) {
+                    throw new Error('Discriminator mapping outside of `#/components/schemas` is not supported');
+                }
+                console.log('HELLO');
+                set(specs, `components.schemas.${ref.slice('#/components/schemas/'.length)}.properties.${propertyName}.enum`, [name]);
+            });
+        });
+    }
+};

package/lib/esm/utils.js

@@ -0,0 +1,156 @@
+import lodash from 'lodash';
+const { uniq, isEmpty } = lodash;
+import pasCase from 'case';
+const { pascal } = pasCase;
+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':
+            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) => {
+    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)}[]`;
+        }
+    }
+    else {
+        throw new Error('All arrays must have an `items` key define');
+    }
+};
+/**
+ * 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.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]) => {
+            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) => isReference(schema) ? getRef(schema.$ref) : 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)) {
+            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(' | ');
+};

package/package.json

@@ -1,43 +1,45 @@
 {
   "name": "react-query-lightbase-codegen",
-  "version": "0.2.0",
+  "version": "0.5.0",
   "license": "MIT",
-  "main": "./lib/cjs/index.js",
-  "module": "./lib/esm/index.js",
+  "type": "module",
+  "exports": "./src/index.js",
   "files": [
     "lib/"
   ],
+  "engines": {
+    "node": ">=14.16"
+  },
   "scripts": {
     "lint": "eslint . --ext .js,.jsx,.ts,.tsx",
     "tsc": "tsc -p tsconfig.json && tsc -p tsconfig-cjs.json",
-    "test": "yarn tsc && node test/script.mjs && eslint . --ext .js,.jsx,.ts,.tsx --fix"
+    "test": "yarn tsc && node test/script.mjs && prettier --check ./test/generated/**/*.tsx --write && eslint ./test/generated/**/*.tsx --fix"
   },
   "dependencies": {
-    "@tanstack/react-query": "^4.0.9",
     "axios": "0.27.2",
     "case": "1.6.3",
-    "chalk": "4.1.0",
+    "chalk": "5.0.1",
     "js-yaml": "4.1.0",
     "lodash": "4.17.21",
     "openapi3-ts": "2.0.2",
-    "qs": "6.10.3",
-    "query-string": "7.1.1",
     "swagger2openapi": "7.0.8",
     "yamljs": "0.3.0"
   },
   "devDependencies": {
-    "@babel/core": "7.17.10",
+    "@babel/core": "7.18.10",
     "@babel/eslint-parser": "7.17.0",
-    "@react-native-community/eslint-config": "3.0.2",
+    "@react-native-community/eslint-config": "3.1.0",
+    "@tanstack/react-query": "4.0.10",
+    "@types/js-yaml": "4.0.5",
     "@types/lodash": "4.14.182",
-    "@types/node": "17.0.32",
+    "@types/node": "18.6.3",
     "@types/qs": "6.9.7",
     "@types/query-string": "6.3.0",
     "@types/yamljs": "0.2.31",
-    "eslint": "8.15.0",
-    "eslint-plugin-prettier": "4.0.0",
-    "prettier": "2.6.2",
+    "eslint": "8.21.0",
+    "eslint-plugin-prettier": "4.2.1",
+    "prettier": "2.7.1",
     "react": "17.0.2",
-    "typescript": "4.6.4"
+    "typescript": "4.7.4"
   }
 }