react-query-lightbase-codegen 0.3.0 → 1.0.1

package/lib/src/utils.js

@@ -0,0 +1,172 @@
+"use strict";
+exports.__esModule = true;
+exports.getResReqTypes = exports.formatDescription = exports.resolveValue = exports.getScalar = exports.isReference = exports.getDocs = void 0;
+var lodash_1 = require("lodash");
+var uniq = lodash_1["default"].uniq, isEmpty = lodash_1["default"].isEmpty;
+var case_1 = require("case");
+var pascal = case_1["default"].pascal;
+var getDocs = function (data) {
+    return (0, exports.isReference)(data) ? '' : (0, exports.formatDescription)(data.description);
+};
+exports.getDocs = getDocs;
+/**
+ * Discriminator helper for `ReferenceObject`
+ */
+var isReference = function (property) {
+    return Boolean(property.$ref);
+};
+exports.isReference = isReference;
+/**
+ * Return the typescript equivalent of open-api data type
+ */
+var getScalar = function (item) {
+    var 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"] ? "\"".concat(item["enum"].join("\" | \""), "\"") : 'string') + nullable;
+        case 'object':
+        default:
+            return getObject(item) + nullable;
+    }
+};
+exports.getScalar = getScalar;
+/**
+ * Return the output type from the $ref
+ */
+var getRef = function ($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
+ */
+var getArray = function (item) {
+    if (item.items) {
+        if (!(0, exports.isReference)(item.items) && (item.items.oneOf || item.items.allOf || item.items["enum"])) {
+            return "(".concat((0, exports.resolveValue)(item.items), ")[]");
+        }
+        else {
+            return "".concat((0, exports.resolveValue)(item.items), "[]");
+        }
+    }
+    else {
+        throw new Error('All arrays must have an `items` key define');
+    }
+};
+/**
+ * Return the output type from an object
+ */
+var getObject = function (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}';
+    }
+    var IdentifierRegexp = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+    // Consolidation of item.properties & item.additionalProperties
+    var output = '{\n';
+    if (item.properties) {
+        output += Object.entries(item.properties)
+            .map(function (_a) {
+            var key = _a[0], prop = _a[1];
+            var doc = (0, exports.getDocs)(prop);
+            var isRequired = (item.required || []).includes(key);
+            var processedKey = IdentifierRegexp.test(key) ? key : "\"".concat(key, "\"");
+            return "".concat(doc, "\n").concat(processedKey).concat(isRequired ? '' : '?', ": ").concat((0, exports.resolveValue)(prop), ";");
+        })
+            .join('');
+    }
+    if (item.additionalProperties) {
+        if (item.properties) {
+            output += '\n';
+        }
+        output += "} & { [key: string]: ".concat(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.
+ */
+var resolveValue = function (schema) {
+    return (0, exports.isReference)(schema) ? getRef(schema.$ref) : (0, exports.getScalar)(schema);
+};
+exports.resolveValue = resolveValue;
+/**
+ * Format a description to code documentation.
+ */
+var formatDescription = function (description) {
+    if (!description) {
+        return '';
+    }
+    return "\n/**\n".concat(description
+        .split('\n')
+        .map(function (i) { return "*  ".concat(i); })
+        .join('\n'), "\n */");
+};
+exports.formatDescription = formatDescription;
+/**
+ * Extract responses / request types from open-api specs
+ */
+var getResReqTypes = function (responsesOrRequests) {
+    return uniq(responsesOrRequests.map(function (_a) {
+        var _ = _a[0], res = _a[1];
+        if (!res) {
+            return;
+        }
+        if ((0, exports.isReference)(res)) {
+            return getRef(res.$ref);
+        }
+        if (res.content) {
+            for (var _i = 0, _b = Object.keys(res.content); _i < _b.length; _i++) {
+                var contentType = _b[_i];
+                if (contentType.startsWith('application/json') ||
+                    contentType.startsWith('application/octet-stream')) {
+                    var schema = res.content[contentType].schema;
+                    return (0, exports.resolveValue)(schema);
+                }
+            }
+            return;
+        }
+        return;
+    })).join(' | ');
+};
+exports.getResReqTypes = getResReqTypes;

package/lib/typescript/convertSwaggerFile.d.ts

@@ -0,0 +1,5 @@
+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/lib/typescript/generateHooks.d.ts

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

package/lib/typescript/generateImports.d.ts

@@ -0,0 +1,7 @@
+export declare const generateImports: ({ schemaName, apiDirectory, queryClientDir, schemaImports, queryImports, }: {
+    apiDirectory: string;
+    queryClientDir: string;
+    schemaName: string;
+    schemaImports: string[];
+    queryImports: ('query' | 'mutation' | 'infiniteQuery')[];
+}) => string;

package/lib/typescript/generateSchemas.d.ts

@@ -0,0 +1,7 @@
+import { OpenAPIObject } from 'openapi3-ts';
+/**
+ * Extract all types from #/components/schemas
+ */
+export declare const generateSchemas: ({ spec }: {
+    spec: OpenAPIObject;
+}) => string;

package/lib/typescript/importSpecs.d.ts

@@ -0,0 +1,15 @@
+export declare 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;
+    }>;
+}): void;

package/lib/typescript/index.d.ts

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

package/lib/typescript/utils.d.ts

@@ -0,0 +1,24 @@
+import { ReferenceObject, RequestBodyObject, ResponseObject, SchemaObject } from 'openapi3-ts';
+export declare const getDocs: (data: ReferenceObject | {
+    description?: string;
+}) => string;
+/**
+ * Discriminator helper for `ReferenceObject`
+ */
+export declare const isReference: (property: any) => property is ReferenceObject;
+/**
+ * Return the typescript equivalent of open-api data type
+ */
+export declare const getScalar: (item: SchemaObject) => string;
+/**
+ * Resolve the value of a schema object to a proper type definition.
+ */
+export declare const resolveValue: (schema: SchemaObject) => string;
+/**
+ * Format a description to code documentation.
+ */
+export declare const formatDescription: (description?: string) => string;
+/**
+ * Extract responses / request types from open-api specs
+ */
+export declare const getResReqTypes: (responsesOrRequests: Array<[string, ResponseObject | ReferenceObject | RequestBodyObject]>) => string;

package/package.json

@@ -1,43 +1,97 @@
 {
   "name": "react-query-lightbase-codegen",
-  "version": "0.3.0",
+  "description": "Fully typed react query code generation tool based on openApi specifications",
+  "version": "1.0.1",
   "license": "MIT",
-  "main": "./lib/cjs/index.js",
-  "module": "./lib/esm/index.js",
+  "type": "module",
+  "exports": "./src/index.js",
   "files": [
-    "lib/"
+    "src",
+    "lib",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__"
+  ],
+  "keywords": [
+    "rest",
+    "client",
+    "swagger",
+    "open-api",
+    "fetch",
+    "data fetching",
+    "code-generation",
+    "react",
+    "react-query",
+    "axios",
+    "vue-query",
+    "tanstack"
   ],
+  "author": {
+    "name": "Oliver Winter",
+    "email": "owinter86@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/owinter86/react-query-codegen"
+  },
+  "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": "node test/script.mjs && prettier --check ./test/generated/**/*.tsx --write && eslint ./test/generated/**/*.tsx --fix",
+    "prepare": "bob build"
   },
   "dependencies": {
-    "@tanstack/react-query": "^4.0.9",
     "axios": "0.27.2",
     "case": "1.6.3",
-    "chalk": "4.1.0",
+    "chalk": "4.1.2",
     "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",
+    "@commitlint/cli": "^17.0.3",
+    "@commitlint/config-conventional": "^17.0.3",
+    "@react-native-community/eslint-config": "3.1.0",
+    "@semantic-release/changelog": "^6.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^8.0.5",
+    "@semantic-release/npm": "^9.0.1",
+    "@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",
+    "husky": "^8.0.1",
+    "prettier": "2.7.1",
     "react": "17.0.2",
-    "typescript": "4.6.4"
-  }
+    "react-native-builder-bob": "^0.18.3",
+    "semantic-release": "^19.0.3",
+    "typescript": "4.7.4"
+  },
+  "main": "lib/commonjs/index.js",
+  "react-native": "src/index.ts",
+  "types": "lib/typescript/src/index.d.ts",
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "typescript"
+    ]
+  },
+  "eslintIgnore": [
+    "node_modules/",
+    "lib/"
+  ]
 }

package/src/convertSwaggerFile.ts

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