react-query-lightbase-codegen 0.3.0 → 0.5.0

package/lib/cjs/importSpecs.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importSpecs = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const convertSwaggerFile_js_1 = require("./convertSwaggerFile.js");
+const generateHooks_js_1 = require("./generateHooks.js");
+const generateImports_js_1 = require("./generateImports.js");
+const generateSchemas_js_1 = require("./generateSchemas.js");
+function importSpecs({ sourceDirectory, exportDirectory, apiDirectory, queryClientDir, headerFilters, overrides, }) {
+    (0, fs_1.readdir)(sourceDirectory, function (err, filenames) {
+        if (err) {
+            console.log(err);
+            throw err;
+        }
+        filenames.map(async (filename) => {
+            try {
+                const data = (0, fs_1.readFileSync)((0, path_1.join)(process.cwd(), sourceDirectory + '/' + filename), 'utf-8');
+                const { ext } = (0, path_1.parse)(sourceDirectory + '/' + filename);
+                const format = ['.yaml', '.yml'].includes(ext.toLowerCase()) ? 'yaml' : 'json';
+                let spec = await (0, convertSwaggerFile_js_1.convertSwaggerFile)(data, format);
+                const schemaName = `useQueries${filename.split('.')[0]}.schema`;
+                const hooksName = `useQueries${filename.split('.')[0]}`;
+                const name = filename.split('.')[0];
+                (0, fs_1.mkdirSync)((0, path_1.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 } = (0, generateHooks_js_1.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 = (0, generateImports_js_1.generateImports)({
+                    apiDirectory,
+                    queryClientDir,
+                    schemaName,
+                    schemaImports: schemaImportsArray,
+                    queryImports: collectedQueryImports,
+                });
+                (0, fs_1.writeFileSync)((0, path_1.join)(process.cwd(), `${exportDirectory}/${name}/${hooksName}.tsx`), imports + hooks);
+                const schemas = (0, generateSchemas_js_1.generateSchemas)({ spec });
+                (0, fs_1.writeFileSync)((0, path_1.join)(process.cwd(), `${exportDirectory}/${name}/${schemaName}.tsx`), schemas);
+                console.log(chalk_1.default.green(`🎉 [${filename}] Your OpenAPI spec has been converted into react query hooks`));
+            }
+            catch (error) {
+                if (error.code === 'EISDIR') {
+                    console.log(chalk_1.default.red('nested folder structure not supported'));
+                    return;
+                }
+                console.log(chalk_1.default.red(`[${filename}]:`), chalk_1.default.red(error));
+            }
+        });
+    });
+}
+exports.importSpecs = importSpecs;

package/lib/cjs/index.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.importSpecs = void 0;
-const react_query_codegen_import_1 = require("./react-query-codegen-import");
-Object.defineProperty(exports, "importSpecs", { enumerable: true, get: function () { return react_query_codegen_import_1.importSpecs; } });
+exports.convertSwaggerFile = exports.importSpecs = void 0;
+const convertSwaggerFile_js_1 = require("./convertSwaggerFile.js");
+Object.defineProperty(exports, "convertSwaggerFile", { enumerable: true, get: function () { return convertSwaggerFile_js_1.convertSwaggerFile; } });
+const importSpecs_js_1 = require("./importSpecs.js");
+Object.defineProperty(exports, "importSpecs", { enumerable: true, get: function () { return importSpecs_js_1.importSpecs; } });

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

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

package/lib/cjs/resolveDiscriminator.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDiscriminator = void 0;
+const set_1 = __importDefault(require("lodash/set"));
+const getResReqTypes_1 = require("./getResReqTypes");
+/**
+ * Propagate every `discriminator.propertyName` mapping to the original ref
+ *
+ * Note: This method directly mutate the `specs` object.
+ */
+const resolveDiscriminator = (specs) => {
+    if (specs.components && specs.components.schemas) {
+        Object.values(specs.components.schemas).forEach((schema) => {
+            if ((0, getResReqTypes_1.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');
+                (0, set_1.default)(specs, `components.schemas.${ref.slice('#/components/schemas/'.length)}.properties.${propertyName}.enum`, [name]);
+            });
+        });
+    }
+};
+exports.resolveDiscriminator = resolveDiscriminator;

package/lib/cjs/utils.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResReqTypes = exports.formatDescription = exports.resolveValue = exports.getScalar = exports.isReference = exports.getDocs = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const { uniq, isEmpty } = lodash_1.default;
+const case_1 = __importDefault(require("case"));
+const { pascal } = case_1.default;
+const getDocs = (data) => (0, exports.isReference)(data) ? '' : (0, exports.formatDescription)(data.description);
+exports.getDocs = getDocs;
+/**
+ * Discriminator helper for `ReferenceObject`
+ */
+const isReference = (property) => {
+    return Boolean(property.$ref);
+};
+exports.isReference = isReference;
+/**
+ * Return the typescript equivalent of open-api data type
+ */
+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;
+    }
+};
+exports.getScalar = getScalar;
+/**
+ * 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 (!(0, exports.isReference)(item.items) && (item.items.oneOf || item.items.allOf || item.items.enum)) {
+            return `(${(0, exports.resolveValue)(item.items)})[]`;
+        }
+        else {
+            return `${(0, exports.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 ((0, exports.isReference)(item)) {
+        return getRef(item.$ref);
+    }
+    if (item.allOf) {
+        return item.allOf.map(exports.resolveValue).join(' & ');
+    }
+    if (item.oneOf) {
+        return item.oneOf.map(exports.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 = (0, exports.getDocs)(prop);
+            const isRequired = (item.required || []).includes(key);
+            const processedKey = IdentifierRegexp.test(key) ? key : `"${key}"`;
+            return `${doc}\n${processedKey}${isRequired ? '' : '?'}: ${(0, exports.resolveValue)(prop)};`;
+        })
+            .join('');
+    }
+    if (item.additionalProperties) {
+        if (item.properties) {
+            output += '\n';
+        }
+        output += `} & { [key: string]: ${item.additionalProperties === true ? 'any' : (0, exports.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.
+ */
+const resolveValue = (schema) => (0, exports.isReference)(schema) ? getRef(schema.$ref) : (0, exports.getScalar)(schema);
+exports.resolveValue = resolveValue;
+/**
+ * Format a description to code documentation.
+ */
+const formatDescription = (description) => {
+    if (!description) {
+        return '';
+    }
+    return `\n/**\n${description
+        .split('\n')
+        .map((i) => `*  ${i}`)
+        .join('\n')}\n */`;
+};
+exports.formatDescription = formatDescription;
+/**
+ * Extract responses / request types from open-api specs
+ */
+const getResReqTypes = (responsesOrRequests) => {
+    return uniq(responsesOrRequests.map(([_, res]) => {
+        if (!res) {
+            return;
+        }
+        if ((0, exports.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 (0, exports.resolveValue)(schema);
+                }
+            }
+            return;
+        }
+        return;
+    })).join(' | ');
+};
+exports.getResReqTypes = getResReqTypes;

package/lib/esm/convertSwaggerFile.js

@@ -0,0 +1,25 @@
+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);
+        }
+    });
+};