@goast/typescript 0.4.0-beta4 → 0.4.1-beta1

package/esm/src/generators/services/angular-services/angular-services-generator.js

@@ -0,0 +1,213 @@
+import { resolve } from 'node:path';
+import fs from 'fs-extra';
+import { appendValueGroup, Factory, OpenApiServicesGenerationProviderBase, toCasing, } from '@goast/core';
+import { copyAssetFile } from '../../../assets.js';
+import { ts } from '../../../ast/index.js';
+import { TypeScriptFileBuilder } from '../../../file-builder.js';
+import { modifyString } from '../../../utils.js';
+import { DefaultTypeScriptAngularServiceGenerator, } from './angular-service-generator.js';
+import { defaultTypeScriptAngularServicesGeneratorConfig, } from './models.js';
+import { getReferenceFactories } from './refs.js';
+export class TypeScriptAngularServicesGenerator extends OpenApiServicesGenerationProviderBase {
+    constructor(clientGeneratorFactory) {
+        super();
+        Object.defineProperty(this, "_clientGeneratorFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._clientGeneratorFactory = clientGeneratorFactory !== null && clientGeneratorFactory !== void 0 ? clientGeneratorFactory : Factory.fromValue(new DefaultTypeScriptAngularServiceGenerator());
+    }
+    initResult() {
+        return {
+            typescript: {
+                services: {},
+                indexFiles: { services: undefined, responseModels: undefined },
+            },
+        };
+    }
+    buildContext(context, config) {
+        const providerContext = this.getProviderContext(context, config, defaultTypeScriptAngularServicesGeneratorConfig);
+        return Object.assign(providerContext, {
+            refs: getReferenceFactories(providerContext.config),
+        });
+    }
+    async generateAdditionalFiles(ctx) {
+        await this.generateUtilsFiles(ctx);
+        ctx.output.typescript.indexFiles = this.generateIndexFiles(ctx);
+    }
+    generateService(ctx, service) {
+        const clientGenerator = this._clientGeneratorFactory.create();
+        return clientGenerator.generate({
+            ...ctx,
+            service,
+        });
+    }
+    addServiceResult(ctx, service, result) {
+        ctx.output.typescript.services[service.id] = result;
+    }
+    // #region Utils
+    async generateUtilsFiles(ctx) {
+        const targetDir = resolve(ctx.config.outputDir, ctx.config.utilsDir);
+        await fs.ensureDir(targetDir);
+        await copyAssetFile('client/angular/request-builder.ts', targetDir, 'Request Builder');
+        await copyAssetFile('client/angular/angular-service.utils.ts', targetDir, 'Angular Service Utils');
+        TypeScriptFileBuilder.generate({
+            logName: 'api configuration',
+            filePath: resolve(targetDir, 'api-configuration.ts'),
+            options: ctx.config,
+            generator: (b) => b.append(this.getApiConfigurationFileContent(ctx)),
+        });
+        TypeScriptFileBuilder.generate({
+            logName: 'api base service',
+            filePath: resolve(targetDir, 'api-base-service.ts'),
+            options: ctx.config,
+            generator: (b) => b.append(this.getApiBaseServiceFileContent(ctx)),
+        });
+        if (!ctx.config.strictResponseTypes) {
+            TypeScriptFileBuilder.generate({
+                logName: 'http status codes',
+                filePath: resolve(targetDir, 'http-status-code.ts'),
+                options: ctx.config,
+                generator: (b) => b.append(this.getHttpStatusCodeFileContent(ctx)),
+            });
+        }
+        if (ctx.config.provideKind === 'provide-fn') {
+            TypeScriptFileBuilder.generate({
+                logName: 'providers',
+                filePath: resolve(targetDir, 'provide.ts'),
+                options: ctx.config,
+                generator: (b) => b.append(this.getProvideFnFileContent(ctx)),
+            });
+        }
+    }
+    getApiConfigurationFileContent(ctx) {
+        var _a, _b;
+        return appendValueGroup([
+            ts.class(toCasing(`${(_a = ctx.config.domainName) !== null && _a !== void 0 ? _a : ''}ApiConfiguration`, ctx.config.typeNameCasing), {
+                doc: ts.doc({ description: `${(_b = ctx.config.domainName) !== null && _b !== void 0 ? _b : 'Global'} API Configuration.` }),
+                decorators: [
+                    ts.decorator(ts.refs.angular.injectable(), [
+                        ctx.config.provideKind === 'root' ? ts.toNode({ providedIn: 'root' }) : null,
+                    ]),
+                ],
+                export: true,
+                members: [
+                    ts.property('rootUrl', {
+                        accessModifier: 'public',
+                        type: ts.refs.string(),
+                        value: ts.string(this.getRootUrl(ctx)),
+                    }),
+                ],
+            }),
+        ], '\n');
+    }
+    getApiBaseServiceFileContent(ctx) {
+        return appendValueGroup([
+            ts.class('ApiBaseService', {
+                doc: ts.doc({ description: 'Base class for API services.' }),
+                export: true,
+                abstract: true,
+                members: [
+                    ts.property('config', {
+                        accessModifier: 'protected',
+                        value: (b) => b.append(ts.refs.angular.inject(), '(', ctx.refs.apiConfiguration(), ')'),
+                    }),
+                    ts.property('http', {
+                        accessModifier: 'protected',
+                        value: (b) => b.append(ts.refs.angular.inject(), '(', ts.refs.angular.httpClient(), ')'),
+                    }),
+                    ts.property('_rootUrl', { accessModifier: 'private', type: ts.refs.string(), value: ts.string('') }),
+                    ts.property('rootUrl', {
+                        doc: ts.doc({
+                            description: `Gets or sets the root URL for API operations provided by this service.\nFalls back to \`${ctx.refs.apiConfiguration.refName}.rootUrl\` if not set in this service.`,
+                        }),
+                        accessModifier: 'public',
+                        type: ts.refs.string(),
+                        get: ts.property.getter({ body: 'return this._rootUrl || this.config.rootUrl;' }),
+                        set: ts.property.setter({ body: 'this._rootUrl = value;' }),
+                    }),
+                ],
+            }),
+        ], '\n');
+    }
+    getHttpStatusCodeFileContent(ctx) {
+        return appendValueGroup([
+            ts.typeAlias('HttpStatusCode', ts.unionType(ctx.config.possibleStatusCodes), {
+                doc: ts.doc({ description: 'The possible status codes that any API endpoint can return.' }),
+                export: true,
+            }),
+        ], '\n');
+    }
+    getProvideFnFileContent(ctx) {
+        var _a;
+        return appendValueGroup([
+            ts.function(toCasing(`provide_${(_a = ctx.config.domainName) !== null && _a !== void 0 ? _a : ''}_Api`, ctx.config.functionNameCasing), {
+                doc: ts.doc({
+                    description: 'Provides all the API services' +
+                        (ctx.config.domainName ? ` for ${ctx.config.domainName}` : '') + '.',
+                }),
+                export: true,
+                parameters: [ts.parameter('config', { type: ctx.refs.apiConfiguration(), optional: true })],
+                returnType: ts.refs.angular.provider(),
+                body: appendValueGroup([
+                    'return ',
+                    ts.tuple([
+                        (b) => b.append('config ? { provide: ', ctx.refs.apiConfiguration(), ', useValue: config } : ', ctx.refs.apiConfiguration()),
+                        ...Object.values(ctx.output.typescript.services).map((x) => ts.reference(x.component, x.filePath)),
+                    ]),
+                    ';',
+                ]),
+            }),
+        ], '\n');
+    }
+    getRootUrl(ctx) {
+        var _a, _b, _c, _d, _e, _f;
+        return modifyString((_f = (_e = (_d = (_c = ((_a = ctx.data.services[0].$src) !== null && _a !== void 0 ? _a : (_b = ctx.data.services[0].endpoints[0]) === null || _b === void 0 ? void 0 : _b.$src)) === null || _c === void 0 ? void 0 : _c.document.servers) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.url) !== null && _f !== void 0 ? _f : '/', ctx.config.rootUrl);
+    }
+    // #endregion
+    // #region Index
+    generateIndexFiles(ctx) {
+        const servicesIndexFilePath = this.getServicesIndexFilePath(ctx);
+        const responseModelsIndexFilePath = this.getResponseModelsIndexFilePath(ctx);
+        TypeScriptFileBuilder.tryGenerate({
+            logName: 'services index file',
+            filePath: servicesIndexFilePath,
+            options: ctx.config,
+            generator: (b) => b.append(this.getServicesIndexFileContent(ctx)),
+        });
+        TypeScriptFileBuilder.tryGenerate({
+            logName: 'response models index file',
+            filePath: responseModelsIndexFilePath,
+            options: ctx.config,
+            generator: (b) => b.append(this.getResponseModelsIndexFileContent(ctx)),
+        });
+        return {
+            services: servicesIndexFilePath,
+            responseModels: responseModelsIndexFilePath,
+        };
+    }
+    getServicesIndexFileContent(ctx) {
+        return appendValueGroup([
+            ts.export(ctx.refs.apiConfiguration.refName, ctx.refs.apiConfiguration.moduleNameOrfilePath),
+            ctx.config.provideKind === 'provide-fn'
+                ? ts.export(ctx.refs.provide.refName, ctx.refs.provide.moduleNameOrfilePath)
+                : null,
+            ...Object.values(ctx.output.typescript.services).map((x) => ts.export(x.component, x.filePath)),
+        ]);
+    }
+    getResponseModelsIndexFileContent(ctx) {
+        return appendValueGroup(Object.values(ctx.output.typescript.services)
+            .flatMap((x) => Object.values(x.responseModels))
+            .map((x) => ts.export(x.component, x.filePath, { kind: 'type-export' })));
+    }
+    getServicesIndexFilePath(ctx) {
+        return ctx.config.servicesIndexFile ? resolve(ctx.config.outputDir, ctx.config.servicesIndexFile) : null;
+    }
+    getResponseModelsIndexFilePath(ctx) {
+        return ctx.config.responseModelsIndexFile
+            ? resolve(ctx.config.outputDir, ctx.config.responseModelsIndexFile)
+            : null;
+    }
+}

package/esm/src/generators/services/angular-services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/src/generators/services/angular-services/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC;AAChD,cAAc,aAAa,CAAC"}

package/esm/src/generators/services/angular-services/models.d.ts

@@ -0,0 +1,142 @@
+import type { ApiEndpoint, ApiSchema, ApiService, DefaultGenerationProviderConfig, ExtendedStringCasing, Nullable, OpenApiServicesGenerationProviderContext } from '@goast/core';
+import type { ts } from '../../../ast/index.js';
+import type { TypeScriptExportOutput } from '../../../common-results.js';
+import { type TypeScriptGeneratorConfig } from '../../../config.js';
+import type { TypeScriptFileBuilder } from '../../../file-builder.js';
+import type { TypeScriptModelGeneratorOutput } from '../../models/index.js';
+import type { getReferenceFactories } from './refs.js';
+export type TypeScriptAngularServicesGeneratorConfig = TypeScriptGeneratorConfig & {
+    /**
+     * How the services should be provided in the Angular application.
+     * - `root` - provides all the services using `Injectable({ providedIn: 'root' })`
+     * - `provide-fn` - generates a function `provideApiClients` that provides the services
+     * @default 'root'
+     */
+    provideKind: 'root' | 'provide-fn';
+    /**
+     * The domain name of the API. Used as a prefix for exported components (e.g. `ApiConfiguration`).
+     * @default undefined
+     */
+    domainName: Nullable<string>;
+    /**
+     * Whether to use strict response types for the services.
+     * If enabled only the status codes are included that are defined in the OpenAPI specification or the `defaultStatusCodeResponseTypes` option.
+     * @default true
+     */
+    strictResponseTypes: boolean;
+    /**
+     * The default response types for status codes that are not defined in the OpenAPI specification.
+     * @example
+     * {
+     *   400: {
+     *     parser: 'json',
+     *     type: schemas =>
+     *       schemas.find(s => s.name === 'BadRequestResponse')
+     *         ?? throwExp('BadRequestResponse not found'),
+     *   },
+     *   404: null,
+     *   500: {
+     *     parser: 'json',
+     *     type: ts.refs.any(),
+     *   },
+     * }
+     * @default
+     * {
+     *   401: null,
+     *   403: null,
+     *   500: null,
+     * }
+     */
+    defaultStatusCodeResponseTypes: Record<number, {
+        parser: 'text' | 'json';
+        type: Exclude<ts.Type<TypeScriptFileBuilder>, Function> | ((schemas: readonly ApiSchema[]) => ApiSchema);
+    } | null>;
+    /**
+     * The default content type which is used for the success response. If not defined the first one defined in the OpenApi specification is used.
+     * @default undefined
+     */
+    defaultSuccessResponseType: Nullable<string>;
+    /**
+     * The possible status codes that any API endpoint can return.
+     * This is only used when `strictResponseTypes` is set to `false`.
+     * @default
+     * [100, 101, 102, 103, 200, 201, 202, 203, 204, 205, 206, 207, 208, 226, 300, 301, 302, 303, 304, 305, 306, 307, 308, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 421, 422, 423, 424, 425, 426, 428, 429, 431, 451, 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, 511]
+     */
+    possibleStatusCodes: number[];
+    /**
+     * Explicitly set the root URL of the API. If `undefined`, the root URL is taken from the first `server` in the OpenAPI specification.
+     * @default undefined
+     */
+    rootUrl: Nullable<string | RegExp | ((rootUrl: string) => string)>;
+    /**
+     * Modifier that is applied to the path of each endpoint.
+     * @default undefined
+     */
+    pathModifier: Nullable<RegExp | ((path: string, endpoint: ApiEndpoint) => string)>;
+    /**
+     * The directory where the services should be saved. The path is relative to the output directory.
+     * @default 'services'
+     */
+    servicesDir: string;
+    /**
+     * The casing of the file names for the services. If nullish, the `fileNameCasing` is used.
+     * @default { casing: 'kebab', suffix: '.service' }
+     */
+    serviceFileNameCasing: Nullable<ExtendedStringCasing>;
+    /**
+     * The path to the index file where all services should be exported. The path is relative to the output directory. If nullish, no index file will be generated.
+     * @default 'services.ts'
+     */
+    servicesIndexFile: Nullable<string>;
+    /**
+     * The directory where the response models should be saved. The path is relative to the output directory.
+     * @default 'models/responses'
+     */
+    responseModelsDir: string;
+    /**
+     * The casing of the file names for the response models. If nullish, the `fileNameCasing` is used.
+     * @default { casing: 'kebab', suffix: '-responses.model' }
+     */
+    responseModelFileNameCasing: Nullable<ExtendedStringCasing>;
+    /**
+     * The path to the index file where all response models should be exported. The path is relative to the output directory. If nullish, no index file will be generated.
+     * @default 'responses.ts'
+     */
+    responseModelsIndexFile: Nullable<string>;
+    /**
+     * The directory where the utilies should be saved. The path is relative to the output directory.
+     * @default 'utils'
+     */
+    utilsDir: string;
+};
+export declare const defaultTypeScriptAngularServicesGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptAngularServicesGeneratorConfig>;
+export type TypeScriptAngularServicesGeneratorInput = {
+    typescript: {
+        models: {
+            [schemaId: string]: TypeScriptModelGeneratorOutput;
+        };
+    };
+};
+export type TypeScriptAngularServicesGeneratorOutput = {
+    typescript: {
+        services: {
+            [serviceId: string]: TypeScriptAngularServiceGeneratorOutput;
+        };
+        indexFiles: {
+            services: Nullable<string>;
+            responseModels: Nullable<string>;
+        };
+    };
+};
+export type TypeScriptAngularServiceGeneratorOutput = TypeScriptExportOutput & {
+    responseModels: {
+        [operationId: string]: TypeScriptExportOutput;
+    };
+};
+export type TypeScriptAngularServicesGeneratorContext = OpenApiServicesGenerationProviderContext<TypeScriptAngularServicesGeneratorInput, TypeScriptAngularServicesGeneratorOutput, TypeScriptAngularServicesGeneratorConfig, TypeScriptAngularServiceGeneratorOutput> & {
+    refs: ReturnType<typeof getReferenceFactories>;
+};
+export type TypeScriptAngularServiceGeneratorContext = TypeScriptAngularServicesGeneratorContext & {
+    readonly service: ApiService;
+};
+//# sourceMappingURL=models.d.ts.map

package/esm/src/generators/services/angular-services/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../../../src/src/generators/services/angular-services/models.ts"],"names":[],"mappings":"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"}

package/esm/src/generators/services/angular-services/refs.d.ts

@@ -0,0 +1,12 @@
+import { ts } from '../../../ast/index.js';
+import type { TypeScriptAngularServicesGeneratorConfig } from './models.js';
+export declare function getReferenceFactories(options: TypeScriptAngularServicesGeneratorConfig): {
+    abortablePromise: ts.GenericModuleReferenceFactory<1>;
+    waitForResponse: ts.GenericModuleReferenceFactory<1>;
+    requestBuilder: ts.ModuleReferenceFactory;
+    apiConfiguration: ts.ModuleReferenceFactory;
+    apiBaseService: ts.ModuleReferenceFactory;
+    httpStatusCode: ts.ModuleReferenceFactory;
+    provide: ts.ModuleReferenceFactory;
+};
+//# sourceMappingURL=refs.d.ts.map

package/esm/src/generators/services/angular-services/refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs.d.ts","sourceRoot":"","sources":["../../../../../src/src/generators/services/angular-services/refs.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAE3C,OAAO,KAAK,EAAE,wCAAwC,EAAE,MAAM,aAAa,CAAC;AAG5E,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,wCAAwC,GAAG;IACxF,gBAAgB,EAAE,EAAE,CAAC,6BAA6B,CAAC,CAAC,CAAC,CAAC;IACtD,eAAe,EAAE,EAAE,CAAC,6BAA6B,CAAC,CAAC,CAAC,CAAC;IACrD,cAAc,EAAE,EAAE,CAAC,sBAAsB,CAAC;IAC1C,gBAAgB,EAAE,EAAE,CAAC,sBAAsB,CAAC;IAC5C,cAAc,EAAE,EAAE,CAAC,sBAAsB,CAAC;IAC1C,cAAc,EAAE,EAAE,CAAC,sBAAsB,CAAC;IAC1C,OAAO,EAAE,EAAE,CAAC,sBAAsB,CAAC;CACpC,CAoCA"}

package/esm/src/generators/services/easy-network-stub/easy-network-stub-generator.d.ts

@@ -0,0 +1,33 @@
+import { type ApiEndpoint, type ApiSchema, type AppendValueGroup, type MaybePromise } from '@goast/core';
+import { ts } from '../../../ast/index.js';
+import { TypeScriptFileBuilder } from '../../../file-builder.js';
+import { TypeScriptFileGenerator } from '../../file-generator.js';
+import type { TypeScriptEasyNetworkStubGeneratorContext, TypeScriptEasyNetworkStubGeneratorOutput } from './models.js';
+type Context = TypeScriptEasyNetworkStubGeneratorContext;
+type Output = TypeScriptEasyNetworkStubGeneratorOutput;
+type Builder = TypeScriptFileBuilder;
+export interface TypeScriptEasyNetworkStubGenerator<TOutput extends Output = Output> {
+    generate(ctx: Context): MaybePromise<TOutput>;
+}
+export declare class DefaultTypeScriptEasyNetworkStubGenerator extends TypeScriptFileGenerator<Context, Output> implements TypeScriptEasyNetworkStubGenerator {
+    generate(ctx: Context): MaybePromise<Output>;
+    protected getStubFileContent(ctx: Context): AppendValueGroup<Builder>;
+    protected getResponderVariable(ctx: Context, endpoint: ApiEndpoint): ts.Variable<Builder>;
+    protected getStubClass(ctx: Context): ts.Class<Builder>;
+    protected getEndpointRequestsType(ctx: Context, endpoint: ApiEndpoint, options?: {
+        readonly?: boolean;
+    }): ts.Type<Builder>;
+    protected getEndpointStubMethod(ctx: Context, endpoint: ApiEndpoint): ts.Method<Builder>;
+    protected getStubFilePath(ctx: Context): string;
+    protected getResponderVariableName(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getStubClassName(ctx: Context): string;
+    protected getEndpointPathPropertyName(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getEndpointRequestsFieldName(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getEndpointRequestsPropertyName(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getEndpointStubMethodName(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getStubRoute(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getEndpointStatusCodes(ctx: Context, endpoint: ApiEndpoint): Record<number, ts.Type<Builder>>;
+    protected getSchemaType(ctx: Context, schema: ApiSchema | undefined, fallback?: ts.Type<Builder>): ts.Type<Builder>;
+}
+export {};
+//# sourceMappingURL=easy-network-stub-generator.d.ts.map

package/esm/src/generators/services/easy-network-stub/easy-network-stub-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"easy-network-stub-generator.d.ts","sourceRoot":"","sources":["../../../../../src/src/generators/services/easy-network-stub/easy-network-stub-generator.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,gBAAgB,EAGrB,KAAK,YAAY,EAElB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAC3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,yCAAyC,EAAE,wCAAwC,EAAE,MAAM,aAAa,CAAC;AAEvH,KAAK,OAAO,GAAG,yCAAyC,CAAC;AACzD,KAAK,MAAM,GAAG,wCAAwC,CAAC;AACvD,KAAK,OAAO,GAAG,qBAAqB,CAAC;AAErC,MAAM,WAAW,kCAAkC,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM;IACjF,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;CAC/C;AAED,qBAAa,yCAA0C,SAAQ,uBAAuB,CAAC,OAAO,EAAE,MAAM,CACpG,YAAW,kCAAkC;IACtC,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY,CAAC,MAAM,CAAC;IAiBnD,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,CAAC,OAAO,CAAC;IAOrE,SAAS,CAAC,oBAAoB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,GAAG,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC;IAgBzF,SAAS,CAAC,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC;IAoDvD,SAAS,CAAC,uBAAuB,CAC/B,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,WAAW,EACrB,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GAC/B,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC;IAUnB,SAAS,CAAC,qBAAqB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC;IAiCxF,SAAS,CAAC,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM;IAQ/C,SAAS,CAAC,wBAAwB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,GAAG,MAAM;IAI/E,SAAS,CAAC,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM;IAIhD,SAAS,CAAC,2BAA2B,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,GAAG,MAAM;IAIlF,SAAS,CAAC,4BAA4B,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,GAAG,MAAM;IAInF,SAAS,CAAC,+BAA+B,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,GAAG,MAAM;IAItF,SAAS,CAAC,yBAAyB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,GAAG,MAAM;IAIhF,SAAS,CAAC,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,GAAG,MAAM;IAyBnE,SAAS,CAAC,sBAAsB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAYvG,SAAS,CAAC,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,GAAG,SAAS,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC;CAKpH"}

package/esm/src/generators/services/easy-network-stub/easy-network-stub-generator.js

@@ -0,0 +1,171 @@
+import { resolve } from 'node:path';
+import { adjustCasing, appendValueGroup, builderTemplate as s, toCasing, } from '@goast/core';
+import { ts } from '../../../ast/index.js';
+import { TypeScriptFileBuilder } from '../../../file-builder.js';
+import { TypeScriptFileGenerator } from '../../file-generator.js';
+export class DefaultTypeScriptEasyNetworkStubGenerator extends TypeScriptFileGenerator {
+    generate(ctx) {
+        const filePath = this.getStubFilePath(ctx);
+        const name = this.getStubClassName(ctx);
+        TypeScriptFileBuilder.generate({
+            logName: `stub ${name}`,
+            filePath,
+            options: ctx.config,
+            generator: (b) => b.append(this.getStubFileContent(ctx)),
+        });
+        return {
+            filePath,
+            component: name,
+        };
+    }
+    getStubFileContent(ctx) {
+        return appendValueGroup([...ctx.service.endpoints.map((endpoint) => this.getResponderVariable(ctx, endpoint)), this.getStubClass(ctx)], '\n');
+    }
+    getResponderVariable(ctx, endpoint) {
+        return ts.variable(this.getResponderVariableName(ctx, endpoint), {
+            readonly: true,
+            value: ts.call(ctx.refs.getStubResponder([
+                ts.objectType({
+                    members: Object.entries(this.getEndpointStatusCodes(ctx, endpoint)).map(([statusCode, type]) => ts.property(statusCode, { type })),
+                }),
+            ]), []),
+        });
+    }
+    getStubClass(ctx) {
+        return ts.class(this.getStubClassName(ctx), {
+            export: true,
+            extends: ctx.refs.easyNetworkStubBase(),
+            members: [
+                ...ctx.service.endpoints.map((endpoint) => ts.property(this.getEndpointPathPropertyName(ctx, endpoint), {
+                    static: true,
+                    readonly: true,
+                    accessModifier: 'private',
+                    value: s `${ts.string(this.getStubRoute(ctx, endpoint))} as const`,
+                })),
+                '\n',
+                ...ctx.service.endpoints.map((endpoint) => ts.property(this.getEndpointRequestsFieldName(ctx, endpoint), {
+                    readonly: true,
+                    accessModifier: 'private',
+                    type: this.getEndpointRequestsType(ctx, endpoint),
+                    value: ts.tuple([]),
+                })),
+                '\n',
+                ...ctx.service.endpoints.map((endpoint) => ts.property(this.getEndpointRequestsPropertyName(ctx, endpoint), {
+                    readonly: true,
+                    accessModifier: 'public',
+                    type: this.getEndpointRequestsType(ctx, endpoint, { readonly: true }),
+                    get: ts.property.getter({
+                        body: appendValueGroup([`return this.${this.getEndpointRequestsFieldName(ctx, endpoint)};`], '\n'),
+                    }),
+                })),
+                ...ctx.service.endpoints.map((endpoint) => this.getEndpointStubMethod(ctx, endpoint)),
+                ts.method('reset', {
+                    accessModifier: 'public',
+                    override: true,
+                    returnType: ts.refs.void_(),
+                    body: appendValueGroup([
+                        ...ctx.service.endpoints.map((endpoint) => `this.${this.getEndpointRequestsFieldName(ctx, endpoint)}.length = 0;`),
+                        'super.reset();',
+                    ], '\n'),
+                }),
+            ],
+        });
+    }
+    getEndpointRequestsType(ctx, endpoint, options) {
+        var _a;
+        return ts.arrayType(ctx.refs.stubRequestInfo([
+            ts.typeof(ts.call([this.getStubClassName(ctx), this.getEndpointPathPropertyName(ctx, endpoint)])),
+            this.getSchemaType(ctx, (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0].schema),
+        ]), options);
+    }
+    getEndpointStubMethod(ctx, endpoint) {
+        var _a;
+        const requestType = this.getSchemaType(ctx, (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0].schema);
+        return ts.method(this.getEndpointStubMethodName(ctx, endpoint), {
+            accessModifier: 'public',
+            parameters: [
+                ts.parameter('response', {
+                    type: ctx.refs.strictRouteResponseCallback([
+                        requestType,
+                        ts.typeof(ts.call([this.getStubClassName(ctx), this.getEndpointPathPropertyName(ctx, endpoint)])),
+                        ts.typeof(this.getResponderVariableName(ctx, endpoint)),
+                    ]),
+                }),
+            ],
+            returnType: 'this',
+            body: appendValueGroup([
+                s `this.stubWrapper.stub2<${requestType}>()(${s.indent `
+              ${ts.string(endpoint.method.toUpperCase())},
+              ${this.getStubClassName(ctx)}.${this.getEndpointPathPropertyName(ctx, endpoint)},
+              async (request) => {${s.indent `
+                if (this.stubWrapper.options.rememberRequests) {${s.indent `
+                  this.${this.getEndpointRequestsFieldName(ctx, endpoint)}.push(request);`}
+                }
+                throw await response(${this.getResponderVariableName(ctx, endpoint)}, request);`}
+              }`}
+            );`,
+                'return this;',
+            ], '\n'),
+        });
+    }
+    getStubFilePath(ctx) {
+        var _a;
+        return resolve(ctx.config.outputDir, ctx.config.stubsDir, `${toCasing(ctx.service.name, (_a = ctx.config.stubFileNameCasing) !== null && _a !== void 0 ? _a : ctx.config.fileNameCasing)}.ts`);
+    }
+    getResponderVariableName(ctx, endpoint) {
+        return toCasing(endpoint.name + '_Responder', ctx.config.propertyNameCasing);
+    }
+    getStubClassName(ctx) {
+        return toCasing(ctx.service.name + '_Stubs', ctx.config.typeNameCasing);
+    }
+    getEndpointPathPropertyName(ctx, endpoint) {
+        return toCasing(endpoint.name + '_Path', ctx.config.constantNameCasing);
+    }
+    getEndpointRequestsFieldName(ctx, endpoint) {
+        return toCasing(endpoint.name + '_Requests', adjustCasing(ctx.config.propertyNameCasing, { prefix: '_' }));
+    }
+    getEndpointRequestsPropertyName(ctx, endpoint) {
+        return toCasing(endpoint.name + '_Requests', ctx.config.propertyNameCasing);
+    }
+    getEndpointStubMethodName(ctx, endpoint) {
+        return toCasing('stub_' + endpoint.name, ctx.config.functionNameCasing);
+    }
+    getStubRoute(ctx, endpoint) {
+        var _a, _b;
+        let path = endpoint.path;
+        let isFirstQueryParam = true;
+        for (const param of endpoint.parameters) {
+            let type = ((_b = (param.schema && ((_a = ctx.input.typescript.models[param.schema.id]) === null || _a === void 0 ? void 0 : _a.component))) !== null && _b !== void 0 ? _b : ts.refs.unknown.name)
+                .replace(/^readonly /, '');
+            const arrayMatch = /^\((.*)\)\[\]$/.exec(type);
+            if (arrayMatch !== null) {
+                type = `${arrayMatch[1]}[]`;
+            }
+            if (param.target === 'path') {
+                path = path.replace(`{${param.name}}`, `{${param.name}${param.required ? '' : '?'}:${type}}`);
+            }
+            else if (param.target === 'query') {
+                path = path + (isFirstQueryParam ? '?' : '&') + `{${param.name}${param.required ? '' : '?'}:${type}}`;
+                isFirstQueryParam = false;
+            }
+        }
+        return path.replace(/^\/+/, '');
+    }
+    getEndpointStatusCodes(ctx, endpoint) {
+        return Object.fromEntries([
+            ...Object.entries(ctx.config.defaultStatusCodeResponseTypes).map(([key, value]) => [
+                key,
+                typeof value === 'function' ? this.getSchemaType(ctx, value(ctx.data.schemas)) : value,
+            ]),
+            ...endpoint.responses
+                .filter((x) => x.statusCode)
+                .map((x) => { var _a; return [x.statusCode, this.getSchemaType(ctx, (_a = x.contentOptions[0]) === null || _a === void 0 ? void 0 : _a.schema, ts.refs.never())]; }),
+        ]);
+    }
+    getSchemaType(ctx, schema, fallback) {
+        const output = schema && ctx.input.typescript.models[schema.id];
+        if (!output)
+            return fallback !== null && fallback !== void 0 ? fallback : this.getAnyType(ctx);
+        return (b) => b.appendModelUsage(output);
+    }
+}

package/esm/src/generators/services/easy-network-stub/easy-network-stubs-generator.d.ts

@@ -0,0 +1,28 @@
+import { type ApiService, type AppendValueGroup, Factory, type MaybePromise, type OpenApiGeneratorContext, OpenApiServicesGenerationProviderBase } from '@goast/core';
+import { ts } from '../../../ast/index.js';
+import type { TypeScriptExportOutput } from '../../../common-results.js';
+import { TypeScriptFileBuilder } from '../../../file-builder.js';
+import { type TypeScriptEasyNetworkStubGenerator } from './easy-network-stub-generator.js';
+import { type TypeScriptEasyNetworkStubGeneratorOutput, type TypeScriptEasyNetworkStubsGeneratorConfig, type TypeScriptEasyNetworkStubsGeneratorContext, type TypeScriptEasyNetworkStubsGeneratorInput, type TypeScriptEasyNetworkStubsGeneratorOutput } from './models.js';
+type Input = TypeScriptEasyNetworkStubsGeneratorInput;
+type Output = TypeScriptEasyNetworkStubsGeneratorOutput;
+type Config = TypeScriptEasyNetworkStubsGeneratorConfig;
+type ServiceOutput = TypeScriptEasyNetworkStubGeneratorOutput;
+type Context = TypeScriptEasyNetworkStubsGeneratorContext;
+export declare class TypeScriptEasyNetworkStubsGenerator extends OpenApiServicesGenerationProviderBase<Input, Output, Config, ServiceOutput, Context> {
+    private readonly _generatorFactory;
+    constructor(generatorFactory?: Factory<TypeScriptEasyNetworkStubGenerator, []>);
+    protected initResult(): Output;
+    protected buildContext(context: OpenApiGeneratorContext<Input>, config?: Partial<Config> | undefined): Context;
+    protected generateAdditionalFiles(ctx: TypeScriptEasyNetworkStubsGeneratorContext): Promise<void>;
+    protected generateService(ctx: Context, service: ApiService): MaybePromise<TypeScriptExportOutput>;
+    protected addServiceResult(ctx: Context, service: ApiService, result: TypeScriptExportOutput): void;
+    protected generateUtilsFiles(ctx: Context): Promise<void>;
+    protected generateIndexFiles(ctx: Context): Output['typescript']['indexFiles'];
+    protected getStubsIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
+    protected getStubsClass(ctx: Context): ts.Class<TypeScriptFileBuilder>;
+    protected getStubsIndexFilePath(ctx: Context): string | null;
+    protected getStubsClassName(ctx: Context): string;
+}
+export {};
+//# sourceMappingURL=easy-network-stubs-generator.d.ts.map

package/esm/src/generators/services/easy-network-stub/easy-network-stubs-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"easy-network-stubs-generator.d.ts","sourceRoot":"","sources":["../../../../../src/src/generators/services/easy-network-stub/easy-network-stubs-generator.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,gBAAgB,EAGrB,OAAO,EACP,KAAK,YAAY,EACjB,KAAK,uBAAuB,EAC5B,qCAAqC,EAEtC,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAC3C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAEL,KAAK,kCAAkC,EACxC,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAEL,KAAK,wCAAwC,EAC7C,KAAK,yCAAyC,EAC9C,KAAK,0CAA0C,EAC/C,KAAK,wCAAwC,EAC7C,KAAK,yCAAyC,EAC/C,MAAM,aAAa,CAAC;AAGrB,KAAK,KAAK,GAAG,wCAAwC,CAAC;AACtD,KAAK,MAAM,GAAG,yCAAyC,CAAC;AACxD,KAAK,MAAM,GAAG,yCAAyC,CAAC;AACxD,KAAK,aAAa,GAAG,wCAAwC,CAAC;AAC9D,KAAK,OAAO,GAAG,0CAA0C,CAAC;AAE1D,qBAAa,mCAAoC,SAAQ,qCAAqC,CAC5F,KAAK,EACL,MAAM,EACN,MAAM,EACN,aAAa,EACb,OAAO,CACR;IACC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAkD;gBAExE,gBAAgB,CAAC,EAAE,OAAO,CAAC,kCAAkC,EAAE,EAAE,CAAC;cAK3D,UAAU,IAAI,MAAM;cASpB,YAAY,CAC7B,OAAO,EAAE,uBAAuB,CAAC,KAAK,CAAC,EACvC,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,GACnC,OAAO;cAOe,uBAAuB,CAAC,GAAG,EAAE,0CAA0C,GAAG,OAAO,CAAC,IAAI,CAAC;cAK7F,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,GAAG,YAAY,CAAC,sBAAsB,CAAC;cAQxF,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,sBAAsB,GAAG,IAAI;cAI5F,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAO/D,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,YAAY,CAAC;IAe9E,SAAS,CAAC,wBAAwB,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,CAAC,qBAAqB,CAAC;IAUzF,SAAS,CAAC,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,EAAE,CAAC,KAAK,CAAC,qBAAqB,CAAC;IA+EtE,SAAS,CAAC,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI;IAI5D,SAAS,CAAC,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM;CAGlD"}