ts-openapi-codegen 1.0.0-beta.1 → 1.0.0-beta.2

package/dist/core/utils/stripNamespace.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Strip (OpenAPI) namespaces fom values.
+ * @param value
+ */
+export declare function stripNamespace(value: string): string;
+//# sourceMappingURL=stripNamespace.d.ts.map

package/dist/core/utils/stripNamespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripNamespace.d.ts","sourceRoot":"","sources":["../../../src/core/utils/stripNamespace.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA+BpD"}

package/dist/core/utils/stripNamespace.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripNamespace = stripNamespace;
+const path_1 = require("path");
+const pathHelpers_1 = require("../utils/pathHelpers");
+const getClassName_1 = require("./getClassName");
+const getMappedType_1 = require("./getMappedType");
+/**
+ * Strip (OpenAPI) namespaces fom values.
+ * @param value
+ */
+function stripNamespace(value) {
+    if (!value || (0, getMappedType_1.hasMappedType)(value)) {
+        return value;
+    }
+    if (!value.match(/^(http:\/\/|https:\/\/|#\/)/g) && !(0, getMappedType_1.hasMappedType)(value) && !value.match(/^array\[[a-z]+\]$/g)) {
+        const foundFile = value.match(/^(.*)#/);
+        const directoryName = foundFile ? (0, pathHelpers_1.dirName)(foundFile[1]) : (0, pathHelpers_1.dirName)(value);
+        const extName = (0, path_1.extname)(value);
+        const baseName = extName.toLowerCase().match(/(\.json|\.yaml|\.yml)$/g) ? (0, getClassName_1.getClassName)((0, path_1.basename)(value, extName)) : (0, getClassName_1.getClassName)((0, path_1.basename)(value));
+        return directoryName ? (0, pathHelpers_1.join)(directoryName, baseName) : baseName;
+    }
+    const clearValue = value
+        .trim()
+        .replace(/^#\/components\/schemas\//, '')
+        .replace(/^#\/components\/responses\//, '')
+        .replace(/^#\/components\/parameters\//, '')
+        .replace(/^#\/components\/examples\//, '')
+        .replace(/^#\/components\/requestBodies\//, '')
+        .replace(/^#\/components\/headers\//, '')
+        .replace(/^#\/components\/securitySchemes\//, '')
+        .replace(/^#\/components\/links\//, '')
+        .replace(/^#\/components\/callbacks\//, '')
+        .replace(/^#\/definitions\//, '')
+        .replace(/^#\/parameters\//, '')
+        .replace(/^#\/responses\//, '')
+        .replace(/^#\/securityDefinitions\//, '');
+    const directoryName = (0, pathHelpers_1.dirName)(clearValue);
+    const baseName = (0, getClassName_1.getClassName)((0, path_1.basename)(clearValue));
+    return directoryName ? (0, pathHelpers_1.join)(directoryName, baseName) : baseName;
+}

package/dist/core/utils/unique.d.ts

@@ -0,0 +1,2 @@
+export declare function unique<T>(val: T, index: number, arr: T[]): boolean;
+//# sourceMappingURL=unique.d.ts.map

package/dist/core/utils/unique.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique.d.ts","sourceRoot":"","sources":["../../../src/core/utils/unique.ts"],"names":[],"mappings":"AAEA,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,OAAO,CAElE"}

package/dist/core/utils/unique.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unique = unique;
+const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+function unique(val, index, arr) {
+    return deepUnique(val, index, arr);
+}
+function deepUnique(val, index, arr) {
+    for (let i = 0; i < arr.length; ++i) {
+        if ((0, fast_deep_equal_1.default)(val, arr[i])) {
+            return index === i;
+        }
+    }
+    return false;
+}

package/dist/core/utils/writeClient.d.ts

@@ -0,0 +1,85 @@
+import { HttpClient } from '../types/Enums';
+import { IOutput } from '../types/Models';
+import type { Client } from '../types/shared/Client.model';
+import { Templates } from './registerHandlebarTemplates';
+/**
+ * @param client Client object with all the models, services, etc.
+ * @param templates Templates wrapper with all loaded Handlebars templates
+ * @param outputPaths The relative location of the output directory
+ * @param httpClient The selected httpClient (fetch, xhr or node)
+ * @param useOptions Use options or arguments functions
+ * @param useUnionTypes Use union types instead of enums
+ * @param exportCore: Generate core client classes
+ * @param exportServices: Generate services
+ * @param exportModels: Generate models
+ * @param exportSchemas: Generate schemas
+ * @param clean: Clean a directory before generation
+ * @param request: Path to custom request file
+ * @param useCancelableRequest Use cancelable request type.
+ */
+interface IWriteClient {
+    client: Client;
+    templates: Templates;
+    outputPaths: IOutput;
+    httpClient: HttpClient;
+    useOptions: boolean;
+    useUnionTypes: boolean;
+    exportCore: boolean;
+    exportServices: boolean;
+    exportModels: boolean;
+    exportSchemas: boolean;
+    clean: boolean;
+    request?: string;
+    useCancelableRequest?: boolean;
+}
+/**
+ * @param client Client object with all the models, services, etc.
+ * @param templates The loaded handlebar templates
+ * @param outputPaths Directory to write the generated files to
+ * @param useUnionTypes Use union types instead of enums
+ * @param exportCore: Generate core
+ * @param exportServices: Generate services
+ * @param exportModels: Generate models
+ * @param exportSchemas: Generate schemas
+ */
+export interface IWriteClientIndex {
+    client: Client;
+    templates: Templates;
+    outputPaths: IOutput;
+    useUnionTypes: boolean;
+    exportCore: boolean;
+    exportServices: boolean;
+    exportModels: boolean;
+    exportSchemas: boolean;
+}
+/**
+ * The client which is writing all items and keep the parameters to write index file
+ */
+export declare class WriteClient {
+    private options;
+    /**
+     * Write our OpenAPI client, using the given templates at the given output
+     * @param client Client object with all the models, services, etc.
+     * @param templates Templates wrapper with all loaded Handlebars templates
+     * @param outputPaths A set of parameters with paths for generating main sections (folders)
+     * @param httpClient The selected httpClient (fetch, xhr or node)
+     * @param useOptions Use options or arguments functions
+     * @param useUnionTypes Use union types instead of enums
+     * @param exportCore: Generate core client classes
+     * @param exportServices: Generate services
+     * @param exportModels: Generate models
+     * @param exportSchemas: Generate schemas
+     * @param clean: Clean a directory before generation
+     * @param request: Path to custom request file
+     * @param useCancelableRequest Use cancelable request type.
+     */
+    writeClient(options: IWriteClient): Promise<void>;
+    /**
+     * Method keeps all options that is need to create index file
+     * @param options
+     */
+    writeClientIndex(options: IWriteClientIndex): Promise<void>;
+    combineAndWrite(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=writeClient.d.ts.map

package/dist/core/utils/writeClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeClient.d.ts","sourceRoot":"","sources":["../../../src/core/utils/writeClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAG3D,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAoCzD;;;;;;;;;;;;;;GAcG;AACH,UAAU,YAAY;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,UAAU,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;IACvB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,iBAAiB;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;CAC1B;AAED;;GAEG;AACH,qBAAa,WAAW;IACpB,OAAO,CAAC,OAAO,CAA+C;IAE9D;;;;;;;;;;;;;;;OAeG;IACG,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IA+DvD;;;OAGG;IACG,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAU3D,eAAe;CAsFxB"}

package/dist/core/utils/writeClient.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriteClient = void 0;
+const pathHelpers_1 = require("../utils/pathHelpers");
+const fileSystem_1 = require("./fileSystem");
+const unique_1 = require("./unique");
+const writeClientCore_1 = require("./writeClientCore");
+const writeClientIndex_1 = require("./writeClientIndex");
+const writeClientModels_1 = require("./writeClientModels");
+const writeClientSchemas_1 = require("./writeClientSchemas");
+const writeClientServices_1 = require("./writeClientServices");
+function sortModelByName(a, b) {
+    if (a.name > b.name) {
+        return 1;
+    }
+    if (a.name < b.name) {
+        return -1;
+    }
+    return 0;
+}
+function prepareAlias(models) {
+    let modelPrevious = undefined;
+    let index = 1;
+    for (const model of models) {
+        if (modelPrevious && model.name === modelPrevious.name) {
+            model.alias = `${model.name}$${index}`;
+            if (!modelPrevious.alias) {
+                modelPrevious.alias = `${modelPrevious.name}$${index - 1}`;
+            }
+            index++;
+        }
+        else if (modelPrevious && model.name !== modelPrevious.name) {
+            index = 1;
+        }
+        modelPrevious = model;
+    }
+}
+/**
+ * The client which is writing all items and keep the parameters to write index file
+ */
+class WriteClient {
+    options = new Map();
+    /**
+     * Write our OpenAPI client, using the given templates at the given output
+     * @param client Client object with all the models, services, etc.
+     * @param templates Templates wrapper with all loaded Handlebars templates
+     * @param outputPaths A set of parameters with paths for generating main sections (folders)
+     * @param httpClient The selected httpClient (fetch, xhr or node)
+     * @param useOptions Use options or arguments functions
+     * @param useUnionTypes Use union types instead of enums
+     * @param exportCore: Generate core client classes
+     * @param exportServices: Generate services
+     * @param exportModels: Generate models
+     * @param exportSchemas: Generate schemas
+     * @param clean: Clean a directory before generation
+     * @param request: Path to custom request file
+     * @param useCancelableRequest Use cancelable request type.
+     */
+    async writeClient(options) {
+        const { client, templates, outputPaths, httpClient, useOptions, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas, request, useCancelableRequest = false } = options;
+        if (exportCore) {
+            await fileSystem_1.fileSystem.mkdir(outputPaths.outputCore);
+            await (0, writeClientCore_1.writeClientCore)({ client, templates, outputCorePath: outputPaths.outputCore, httpClient, request, useCancelableRequest });
+        }
+        if (exportServices) {
+            const { outputCore, outputServices, outputModels } = outputPaths;
+            await fileSystem_1.fileSystem.mkdir(outputPaths.outputServices);
+            await (0, writeClientServices_1.writeClientServices)({
+                services: client.services,
+                templates,
+                outputPaths: {
+                    outputServices,
+                    outputCore: exportCore ? `${(0, pathHelpers_1.relative)(outputServices, outputCore)}` : '../core/',
+                    outputModels: exportModels ? `${(0, pathHelpers_1.relative)(outputServices, outputModels)}` : '../models/',
+                },
+                httpClient,
+                useUnionTypes,
+                useOptions,
+                useCancelableRequest,
+            });
+        }
+        if (exportSchemas) {
+            await fileSystem_1.fileSystem.mkdir(outputPaths.outputSchemas);
+            await (0, writeClientSchemas_1.writeClientSchemas)({
+                models: client.models,
+                templates,
+                outputSchemasPath: outputPaths.outputSchemas,
+                httpClient,
+                useUnionTypes,
+            });
+        }
+        if (exportModels) {
+            await fileSystem_1.fileSystem.mkdir(outputPaths.outputModels);
+            await (0, writeClientModels_1.writeClientModels)({
+                models: client.models,
+                templates,
+                outputModelsPath: outputPaths.outputModels,
+                httpClient,
+                useUnionTypes,
+            });
+        }
+        if (exportCore || exportServices || exportSchemas || exportModels) {
+            await fileSystem_1.fileSystem.mkdir(outputPaths.output);
+            await this.writeClientIndex({
+                client,
+                templates,
+                outputPaths,
+                useUnionTypes,
+                exportCore,
+                exportServices,
+                exportModels,
+                exportSchemas,
+            });
+        }
+    }
+    /**
+     * Method keeps all options that is need to create index file
+     * @param options
+     */
+    async writeClientIndex(options) {
+        const { outputPaths } = options;
+        const values = this.options.get(outputPaths.output);
+        if (values) {
+            values.push(options);
+        }
+        else {
+            this.options.set(outputPaths.output, Array.of(options));
+        }
+    }
+    async combineAndWrite() {
+        const result = new Map();
+        for (const [key, value] of this.options.entries()) {
+            for (const item of value) {
+                const { exportCore, outputPaths, exportModels, exportSchemas, exportServices, client, templates } = item;
+                const outputCore = outputPaths.outputCore ? outputPaths.outputCore : (0, pathHelpers_1.resolve)(key, 'core');
+                const outputModels = outputPaths.outputModels ? outputPaths.outputModels : (0, pathHelpers_1.resolve)(key, 'models');
+                const outputSchemas = outputPaths.outputSchemas ? outputPaths.outputSchemas : (0, pathHelpers_1.resolve)(key, 'schemas');
+                const outputServices = outputPaths.outputServices ? outputPaths.outputServices : (0, pathHelpers_1.resolve)(key, 'services');
+                let clientIndex = result.get(`${key}`);
+                if (!clientIndex) {
+                    clientIndex = {
+                        templates: templates,
+                        outputPath: key,
+                        core: [],
+                        models: [],
+                        schemas: [],
+                        services: [],
+                    };
+                    result.set(`${key}`, clientIndex);
+                }
+                if (exportCore) {
+                    const relativePath = `${(0, pathHelpers_1.relative)(key, outputCore)}`;
+                    const clientCore = clientIndex.core.find(item => item === relativePath);
+                    if (!clientCore) {
+                        clientIndex.core.push(relativePath);
+                    }
+                }
+                if (exportModels || exportSchemas) {
+                    const relativePathModel = `${(0, pathHelpers_1.relative)(key, outputModels)}`;
+                    const relativePathSchema = `${(0, pathHelpers_1.relative)(key, outputSchemas)}`;
+                    for (const model of client.models) {
+                        const modelFinal = {
+                            name: model.name,
+                            alias: '',
+                            path: model.path,
+                            package: relativePathModel,
+                            enum: model.enum && model.enum.length > 0,
+                            useUnionTypes: item.useUnionTypes,
+                            enums: model.enums && model.enums.length > 0,
+                        };
+                        if (exportModels) {
+                            const value = clientIndex.models.find(item => item.name === modelFinal.name &&
+                                item.path === modelFinal.path &&
+                                item.package === modelFinal.package &&
+                                item.enum === modelFinal.enum &&
+                                item.enums === modelFinal.enums &&
+                                item.useUnionTypes === modelFinal.useUnionTypes);
+                            if (!value) {
+                                clientIndex.models.push(modelFinal);
+                            }
+                        }
+                        if (exportSchemas) {
+                            const schema = { ...modelFinal, package: relativePathSchema };
+                            const indexValue = clientIndex.schemas.find(item => item.name === schema.name && item.path === schema.path && item.package === schema.package);
+                            if (!indexValue) {
+                                clientIndex.schemas.push(schema);
+                            }
+                        }
+                    }
+                }
+                if (exportServices) {
+                    const relativeService = `${(0, pathHelpers_1.relative)(key, outputServices)}`;
+                    for (const service of client.services) {
+                        const valueIndex = clientIndex.services.find(item => item.name === service.name && item.package === relativeService);
+                        if (!valueIndex) {
+                            clientIndex.services.push({
+                                name: service.name,
+                                package: relativeService,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        for (const value of result.values()) {
+            value.models = value.models.filter(unique_1.unique).sort(sortModelByName);
+            prepareAlias(value.models);
+            value.schemas = value.schemas.filter(unique_1.unique).sort(sortModelByName);
+            prepareAlias(value.schemas);
+            await (0, writeClientIndex_1.writeClientIndex)(value);
+        }
+    }
+}
+exports.WriteClient = WriteClient;

package/dist/core/utils/writeClientCore.d.ts

@@ -0,0 +1,31 @@
+import { HttpClient } from '../types/Enums';
+import type { Client } from '../types/shared/Client.model';
+import { Templates } from './registerHandlebarTemplates';
+/**
+ * @param client Client object, containing, models, schemas and services
+ * @param templates The loaded handlebar templates
+ * @param outputCorePath The directory for generating the kernel settings
+ * @param httpClient The selected httpClient (fetch, xhr or node)
+ * @param request: Path to custom request file
+ * @param useCancelableRequest Use cancelable request type
+ */
+interface IWriteClientCore {
+    client: Client;
+    templates: Templates;
+    outputCorePath: string;
+    httpClient: HttpClient;
+    request?: string;
+    useCancelableRequest?: boolean;
+}
+/**
+ * Generate OpenAPI core files, this includes the basic boilerplate code to handle requests.
+ * @param client Client object, containing, models, schemas and services
+ * @param templates The loaded handlebar templates
+ * @param outputCorePath The directory for generating the kernel settings
+ * @param httpClient The selected httpClient (fetch, xhr or node)
+ * @param request: Path to custom request file
+ * @param useCancelableRequest Use cancelable request type
+ */
+export declare function writeClientCore(options: IWriteClientCore): Promise<void>;
+export {};
+//# sourceMappingURL=writeClientCore.d.ts.map

package/dist/core/utils/writeClientCore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeClientCore.d.ts","sourceRoot":"","sources":["../../../src/core/utils/writeClientCore.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAE3D,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAEzD;;;;;;;GAOG;AACH,UAAU,gBAAgB;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,SAAS,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2B9E"}

package/dist/core/utils/writeClientCore.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeClientCore = writeClientCore;
+const path_1 = require("path");
+const fileSystem_1 = require("./fileSystem");
+/**
+ * Generate OpenAPI core files, this includes the basic boilerplate code to handle requests.
+ * @param client Client object, containing, models, schemas and services
+ * @param templates The loaded handlebar templates
+ * @param outputCorePath The directory for generating the kernel settings
+ * @param httpClient The selected httpClient (fetch, xhr or node)
+ * @param request: Path to custom request file
+ * @param useCancelableRequest Use cancelable request type
+ */
+async function writeClientCore(options) {
+    const { client, templates, outputCorePath, httpClient, request, useCancelableRequest } = options;
+    const context = {
+        httpClient,
+        server: client.server,
+        version: client.version,
+        useCancelableRequest,
+    };
+    await fileSystem_1.fileSystem.writeFile((0, path_1.resolve)(outputCorePath, 'OpenAPI.ts'), templates.core.settings(context));
+    await fileSystem_1.fileSystem.writeFile((0, path_1.resolve)(outputCorePath, 'ApiError.ts'), templates.core.apiError({}));
+    await fileSystem_1.fileSystem.writeFile((0, path_1.resolve)(outputCorePath, 'ApiRequestOptions.ts'), templates.core.apiRequestOptions({}));
+    await fileSystem_1.fileSystem.writeFile((0, path_1.resolve)(outputCorePath, 'ApiResult.ts'), templates.core.apiResult({}));
+    if (useCancelableRequest) {
+        await fileSystem_1.fileSystem.writeFile((0, path_1.resolve)(outputCorePath, 'CancelablePromise.ts'), templates.core.cancelablePromise({}));
+    }
+    await fileSystem_1.fileSystem.writeFile((0, path_1.resolve)(outputCorePath, 'HttpStatusCode.ts'), templates.core.httpStatusCode({}));
+    await fileSystem_1.fileSystem.writeFile((0, path_1.resolve)(outputCorePath, 'request.ts'), templates.core.request(context));
+    if (request) {
+        const requestFile = (0, path_1.resolve)(process.cwd(), request);
+        const requestFileExists = await fileSystem_1.fileSystem.exists(requestFile);
+        if (!requestFileExists) {
+            throw new Error(`Custom request file "${requestFile}" does not exists`);
+        }
+        await fileSystem_1.fileSystem.copyFile(requestFile, (0, path_1.resolve)(outputCorePath, 'request.ts'));
+    }
+}

package/dist/core/utils/writeClientIndex.d.ts

@@ -0,0 +1,59 @@
+import { Templates } from './registerHandlebarTemplates';
+/**
+ * @param name: The name of the model
+ * @param alias: The alias of the model(when there are several similar models in the one specification)
+ * @param path: The name of the file witch contains this model
+ * @param package: The relative location of this service
+ * @param enum: Then flag for mark an enum
+ * @param useUnionTypes: Use union types instead of enums
+ * @param enums: Then flag for mark an enums
+ */
+export interface IModel {
+    name: string;
+    alias: string;
+    path: string;
+    package: string;
+    enum: boolean;
+    useUnionTypes: boolean;
+    enums: boolean;
+}
+/**
+ * @param name: The name of the service
+ * @param package: The relative location of this service
+ */
+export interface IService {
+    name: string;
+    package: string;
+}
+/**
+ * @param templates: The loaded handlebar templates
+ * @param outputPath: Directory to write the generated files to
+ * @param useUnionTypes: Use union types instead of enums
+ * @param exportCore: Generate core
+ * @param exportServices: Generate services
+ * @param exportModels: Generate models
+ * @param exportSchemas: Generate schemas
+ */
+export interface IClientIndex {
+    templates: Templates;
+    outputPath: string;
+    core: string[];
+    models: IModel[];
+    schemas: IModel[];
+    services: IService[];
+}
+/**
+ * Generate the OpenAPI client index file using the Handlebar template and write it to disk.
+ * The index file just contains all the exports you need to use the client as a standalone
+ * library. But yuo can also import individual models and services directly.
+ * @param client: Client object, containing, models, schemas and services
+ * @param templates: The loaded handlebar templates
+ * @param outputPath: Directory to write the generated files to
+ * @param useUnionTypes: Use union types instead of enums
+ * @param exportCore: Generate core
+ * @param exportServices: Generate services
+ * @param exportModels: Generate models
+ * @param exportSchemas: Generate schemas
+ */
+export declare function writeClientIndex(options: IClientIndex): Promise<void>;
+//# sourceMappingURL=writeClientIndex.d.ts.map

package/dist/core/utils/writeClientIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeClientIndex.d.ts","sourceRoot":"","sources":["../../../src/core/utils/writeClientIndex.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAEzD;;;;;;;;GAQG;AACH,MAAM,WAAW,MAAM;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,aAAa,EAAE,OAAO,CAAC;IACvB,KAAK,EAAE,OAAO,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IACzB,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,QAAQ,EAAE,CAAC;CACxB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAW3E"}

package/dist/core/utils/writeClientIndex.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeClientIndex = writeClientIndex;
+const path_1 = require("path");
+const fileSystem_1 = require("./fileSystem");
+/**
+ * Generate the OpenAPI client index file using the Handlebar template and write it to disk.
+ * The index file just contains all the exports you need to use the client as a standalone
+ * library. But yuo can also import individual models and services directly.
+ * @param client: Client object, containing, models, schemas and services
+ * @param templates: The loaded handlebar templates
+ * @param outputPath: Directory to write the generated files to
+ * @param useUnionTypes: Use union types instead of enums
+ * @param exportCore: Generate core
+ * @param exportServices: Generate services
+ * @param exportModels: Generate models
+ * @param exportSchemas: Generate schemas
+ */
+async function writeClientIndex(options) {
+    const { templates, outputPath, core, models, schemas, services } = options;
+    await fileSystem_1.fileSystem.writeFile((0, path_1.resolve)(outputPath, 'index.ts'), templates.index({
+        core,
+        models,
+        schemas,
+        services,
+    }));
+}

package/dist/core/utils/writeClientModels.d.ts

@@ -0,0 +1,28 @@
+import { HttpClient } from '../types/Enums';
+import type { Model } from '../types/shared/Model.model';
+import { Templates } from './registerHandlebarTemplates';
+/**
+ * @param models Array of Models to write
+ * @param templates The loaded handlebar templates
+ * @param outputModelsPath The folder for generating models
+ * @param httpClient The selected httpClient (fetch, xhr or node)
+ * @param useUnionTypes Use union types instead of enums
+ */
+interface IWriteClientModels {
+    models: Model[];
+    templates: Templates;
+    outputModelsPath: string;
+    httpClient: HttpClient;
+    useUnionTypes: boolean;
+}
+/**
+ * Generate Models using the Handlebar template and write to disk.
+ * @param models Array of Models to write
+ * @param templates The loaded handlebar templates
+ * @param outputModelsPath The folder for generating models
+ * @param httpClient The selected httpClient (fetch, xhr or node)
+ * @param useUnionTypes Use union types instead of enums
+ */
+export declare function writeClientModels(options: IWriteClientModels): Promise<void>;
+export {};
+//# sourceMappingURL=writeClientModels.d.ts.map

package/dist/core/utils/writeClientModels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeClientModels.d.ts","sourceRoot":"","sources":["../../../src/core/utils/writeClientModels.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAIzD,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAEzD;;;;;;GAMG;AACH,UAAU,kBAAkB;IACxB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAwBlF"}

package/dist/core/utils/writeClientModels.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeClientModels = writeClientModels;
+const fs_1 = require("fs");
+const pathHelpers_1 = require("../utils/pathHelpers");
+const fileSystem_1 = require("./fileSystem");
+const format_1 = require("./format");
+/**
+ * Generate Models using the Handlebar template and write to disk.
+ * @param models Array of Models to write
+ * @param templates The loaded handlebar templates
+ * @param outputModelsPath The folder for generating models
+ * @param httpClient The selected httpClient (fetch, xhr or node)
+ * @param useUnionTypes Use union types instead of enums
+ */
+async function writeClientModels(options) {
+    const { models, templates, outputModelsPath, httpClient, useUnionTypes } = options;
+    for (const model of models) {
+        const modelFolderPath = model?.path;
+        if (!modelFolderPath) {
+            return;
+        }
+        const dir = (0, pathHelpers_1.dirName)(modelFolderPath);
+        if (dir) {
+            const directory = (0, pathHelpers_1.resolve)(outputModelsPath, dir);
+            (0, fs_1.mkdirSync)(directory, { recursive: true });
+        }
+        const file = (0, pathHelpers_1.resolve)(outputModelsPath, `${modelFolderPath}.ts`);
+        const templateResult = templates.exports.model({
+            ...model,
+            httpClient,
+            useUnionTypes,
+        });
+        const formattedValue = await (0, format_1.format)(templateResult);
+        await fileSystem_1.fileSystem.writeFile(file, formattedValue);
+    }
+}

package/dist/core/utils/writeClientSchemas.d.ts

@@ -0,0 +1,28 @@
+import { HttpClient } from '../types/Enums';
+import type { Model } from '../types/shared/Model.model';
+import { Templates } from './registerHandlebarTemplates';
+/**
+ * @param models Array of Models to write
+ * @param templates The loaded handlebar templates
+ * @param outputSchemasPath A folder for generating model diagrams
+ * @param httpClient The selected httpClient (fetch, xhr or node)
+ * @param useUnionTypes Use union types instead of enums
+ */
+interface IWriteClientSchemas {
+    models: Model[];
+    templates: Templates;
+    outputSchemasPath: string;
+    httpClient: HttpClient;
+    useUnionTypes: boolean;
+}
+/**
+ * Generate Schemas using the Handlebar template and write to disk.
+ * @param models Array of Models to write
+ * @param templates The loaded handlebar templates
+ * @param outputSchemasPath A folder for generating model diagrams
+ * @param httpClient The selected httpClient (fetch, xhr or node)
+ * @param useUnionTypes Use union types instead of enums
+ */
+export declare function writeClientSchemas(options: IWriteClientSchemas): Promise<void>;
+export {};
+//# sourceMappingURL=writeClientSchemas.d.ts.map

package/dist/core/utils/writeClientSchemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeClientSchemas.d.ts","sourceRoot":"","sources":["../../../src/core/utils/writeClientSchemas.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAIzD,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAEzD;;;;;;GAMG;AACH,UAAU,mBAAmB;IACzB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,UAAU,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBpF"}