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

package/dist/core/utils/writeClient.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriteClient = void 0;
+const Enums_1 = require("../../common/Enums");
+const Logger_1 = require("../../common/Logger");
+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();
+    _logger;
+    constructor() {
+        this._logger = new Logger_1.Logger({
+            level: Enums_1.ELogLevel.ERROR,
+            instanceId: 'client',
+            logOutput: Enums_1.ELogOutput.CONSOLE,
+        });
+    }
+    /**
+     * 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);
+        }
+    }
+    get logger() {
+        return this._logger;
+    }
+}
+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"}

package/dist/core/utils/writeClientSchemas.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeClientSchemas = writeClientSchemas;
+const fs_1 = require("fs");
+const pathHelpers_1 = require("../utils/pathHelpers");
+const fileSystem_1 = require("./fileSystem");
+const format_1 = require("./format");
+/**
+ * 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
+ */
+async function writeClientSchemas(options) {
+    const { models, templates, outputSchemasPath, httpClient, useUnionTypes } = options;
+    for (const model of models) {
+        const modelFolderPath = model?.path;
+        const dir = (0, pathHelpers_1.dirName)(modelFolderPath);
+        if (dir) {
+            const directory = (0, pathHelpers_1.resolve)(outputSchemasPath, dir);
+            (0, fs_1.mkdirSync)(directory, { recursive: true });
+        }
+        const file = (0, pathHelpers_1.resolve)(outputSchemasPath, `${modelFolderPath}Schema.ts`);
+        const templateResult = templates.exports.schema({
+            ...model,
+            httpClient,
+            useUnionTypes,
+        });
+        const formattedValue = await (0, format_1.format)(templateResult);
+        await fileSystem_1.fileSystem.writeFile(file, formattedValue);
+    }
+}

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

@@ -0,0 +1,35 @@
+import { HttpClient } from '../types/Enums';
+import { IOutput } from '../types/Models';
+import type { Service } from '../types/shared/Service.model';
+import { Templates } from './registerHandlebarTemplates';
+type TServeceOutputsPath = Omit<IOutput, 'output' | 'outputSchemas'>;
+/**
+ * @param services Array of Services to write
+ * @param templates The loaded handlebar templates
+ * @param outputServicePath Folder options for generating the core, models, and service part
+ * @param httpClient The selected httpClient (fetch, xhr or node)
+ * @param useUnionTypes Use union types instead of enums
+ * @param useOptions Use options or arguments functions
+ * @param useCancelableRequest Use cancelable request type
+ */
+interface IWriteClientServices {
+    services: Service[];
+    templates: Templates;
+    outputPaths: TServeceOutputsPath;
+    httpClient: HttpClient;
+    useUnionTypes: boolean;
+    useOptions: boolean;
+    useCancelableRequest: boolean;
+}
+/**
+ * Generate Services using the Handlebar template and write to disk.
+ * @param services Array of Services to write
+ * @param templates The loaded handlebar templates
+ * @param outputServicePath Folder options for generating the core, models, and service part
+ * @param httpClient The selected httpClient (fetch, xhr or node)
+ * @param useUnionTypes Use union types instead of enums
+ * @param useOptions Use options or arguments functions
+ */
+export declare function writeClientServices(options: IWriteClientServices): Promise<void>;
+export {};
+//# sourceMappingURL=writeClientServices.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writeClientServices.d.ts","sourceRoot":"","sources":["../../../src/core/utils/writeClientServices.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAG7D,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAEzD,KAAK,mBAAmB,GAAG,IAAI,CAAC,OAAO,EAAE,QAAQ,GAAG,eAAe,CAAC,CAAC;AAErE;;;;;;;;GAQG;AACH,UAAU,oBAAoB;IAC1B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,mBAAmB,CAAC;IACjC,UAAU,EAAE,UAAU,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,oBAAoB,EAAE,OAAO,CAAC;CACjC;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBtF"}

package/dist/core/utils/writeClientServices.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeClientServices = writeClientServices;
+const path_1 = require("path");
+const fileSystem_1 = require("./fileSystem");
+const format_1 = require("./format");
+/**
+ * Generate Services using the Handlebar template and write to disk.
+ * @param services Array of Services to write
+ * @param templates The loaded handlebar templates
+ * @param outputServicePath Folder options for generating the core, models, and service part
+ * @param httpClient The selected httpClient (fetch, xhr or node)
+ * @param useUnionTypes Use union types instead of enums
+ * @param useOptions Use options or arguments functions
+ */
+async function writeClientServices(options) {
+    const { services, templates, outputPaths, httpClient, useUnionTypes, useOptions, useCancelableRequest } = options;
+    for (const service of services) {
+        const file = (0, path_1.resolve)(outputPaths.outputServices, `${service.name}.ts`);
+        const templateResult = templates.exports.service({
+            ...service,
+            httpClient,
+            useUnionTypes,
+            useOptions,
+            outputCore: outputPaths.outputCore,
+            outputModels: outputPaths.outputModels,
+            useCancelableRequest,
+        });
+        const formattedValue = await (0, format_1.format)(templateResult);
+        await fileSystem_1.fileSystem.writeFile(file, formattedValue);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './core';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC"}

package/dist/templatesCompiled/core/ApiError.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    compiler: (string | number)[];
+    main: (container: any, depth0: any, helpers: any, partials: any, data: any) => string;
+    usePartial: boolean;
+    useData: boolean;
+};
+export default _default;
+//# sourceMappingURL=ApiError.d.ts.map

package/dist/templatesCompiled/core/ApiError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiError.d.ts","sourceRoot":"","sources":["../../../src/templatesCompiled/core/ApiError.ts"],"names":[],"mappings":";;;;;;AAMA,wBAUmC"}

package/dist/templatesCompiled/core/ApiError.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// This is an automatically generated file for the hbs template.
+// You don't need to change it, run npm run build:hbs to update it.
+/* istanbul ignore file */
+/* tslint: disable */
+/* eslint: disable */
+// @ts-nocheck
+exports.default = { "compiler": [8, ">= 4.3.0"], "main": function (container, depth0, helpers, partials, data) {
+        var stack1, lookupProperty = container.lookupProperty || function (parent, propertyName) {
+            if (Object.prototype.hasOwnProperty.call(parent, propertyName)) {
+                return parent[propertyName];
+            }
+            return undefined;
+        };
+        return ((stack1 = container.invokePartial(lookupProperty(partials, "header"), depth0, { "name": "header", "data": data, "helpers": helpers, "partials": partials, "decorators": container.decorators })) != null ? stack1 : "")
+            + "\nimport type { ApiResult } from './ApiResult';\n\nexport class ApiError extends Error {\n    public readonly url: string;\n    public readonly status: number;\n    public readonly statusText: string;\n    public readonly body: any;\n\n    constructor(response: ApiResult, message: string) {\n        super(message);\n\n        this.url = response.url;\n        this.status = response.status;\n        this.statusText = response.statusText;\n        this.body = response.body;\n    }\n}\n";
+    }, "usePartial": true, "useData": true };

package/dist/templatesCompiled/core/ApiRequestOptions.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    compiler: (string | number)[];
+    main: (container: any, depth0: any, helpers: any, partials: any, data: any) => string;
+    usePartial: boolean;
+    useData: boolean;
+};
+export default _default;
+//# sourceMappingURL=ApiRequestOptions.d.ts.map