react-query-lightbase-codegen 0.2.0 → 0.5.0

package/lib/cjs/generateSchemasDefinition.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchemasDefinition = void 0;
+const case_1 = require("case");
+const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
+const getResReqTypes_1 = require("./getResReqTypes");
+/**
+ * Generate the interface string
+ */
+const generateInterface = (name, schema) => {
+    const scalar = (0, getResReqTypes_1.getScalar)(schema);
+    return `
+       ${(0, getResReqTypes_1.formatDescription)(schema.description)}
+       export type ${(0, case_1.pascal)(name)} = ${scalar}
+     `;
+};
+/**
+ * Extract all types from #/components/schemas
+ */
+const generateSchemasDefinition = (schemas = {}) => {
+    if ((0, isEmpty_1.default)(schemas)) {
+        return '';
+    }
+    return ('\n // SCEHMAS' +
+        Object.entries(schemas)
+            .map(([name, schema]) => !(0, getResReqTypes_1.isReference)(schema) &&
+            (!schema.type || schema.type === 'object') &&
+            !schema.allOf &&
+            !schema.oneOf &&
+            !(0, getResReqTypes_1.isReference)(schema) &&
+            !schema.nullable
+            ? generateInterface(name, schema)
+            : `${(0, getResReqTypes_1.formatDescription)((0, getResReqTypes_1.isReference)(schema) ? undefined : schema.description)} type ${(0, case_1.pascal)(name)} = ${(0, getResReqTypes_1.resolveValue)(schema)};`)
+            .join('\n\n') +
+        '\n');
+};
+exports.generateSchemasDefinition = generateSchemasDefinition;

package/lib/cjs/getResReqTypes.js

@@ -0,0 +1,162 @@
+"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 case_1 = require("case");
+const lodash_1 = require("lodash");
+const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
+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 (0, case_1.pascal)($ref.replace('#/components/schemas/', ''));
+    }
+    else if ($ref.startsWith('#/components/responses')) {
+        return (0, case_1.pascal)($ref.replace('#/components/responses/', '')) + 'Response';
+    }
+    else if ($ref.startsWith('#/components/parameters')) {
+        return (0, case_1.pascal)($ref.replace('#/components/parameters/', '')) + 'Parameter';
+    }
+    else if ($ref.startsWith('#/components/requestBodies')) {
+        return (0, case_1.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 || (0, isEmpty_1.default)(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('\n');
+    }
+    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, tabSize = 0) => description
+    ? `/**\n${description
+        .split('\n')
+        .map((i) => `${' '.repeat(tabSize)} *  ${i}`)
+        .join('\n')}\n${' '.repeat(tabSize)} */${' '.repeat(tabSize)}`
+    : '';
+exports.formatDescription = formatDescription;
+/**
+ * Extract responses / request types from open-api specs
+ */
+const getResReqTypes = (responsesOrRequests) => (0, lodash_1.uniq)(responsesOrRequests.map(([_, res]) => {
+    if (!res) {
+        return 'void';
+    }
+    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 'void';
+    }
+    return 'void';
+})).join(' | ');
+exports.getResReqTypes = getResReqTypes;