@goast/typescript 0.3.13 → 0.4.0-beta2

package/{cjs → script}/lib/generators/services/easy-network-stub/easy-network-stub-generator.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultTypeScriptEasyNetworkStubGenerator = void 0;
-const path_1 = require("path");
+const node_path_1 = require("node:path");
 const core_1 = require("@goast/core");
-const ast_1 = require("../../../ast");
-const file_builder_1 = require("../../../file-builder");
-const file_generator_1 = require("../../file-generator");
-class DefaultTypeScriptEasyNetworkStubGenerator extends file_generator_1.TypeScriptFileGenerator {
+const index_js_1 = require("../../../ast/index.js");
+const file_builder_js_1 = require("../../../file-builder.js");
+const file_generator_js_1 = require("../../file-generator.js");
+class DefaultTypeScriptEasyNetworkStubGenerator extends file_generator_js_1.TypeScriptFileGenerator {
     generate(ctx) {
         const filePath = this.getStubFilePath(ctx);
         const name = this.getStubClassName(ctx);
-        file_builder_1.TypeScriptFileBuilder.generate({
+        file_builder_js_1.TypeScriptFileBuilder.generate({
             logName: `stub ${name}`,
             filePath,
             options: ctx.config,
@@ -25,47 +25,47 @@ class DefaultTypeScriptEasyNetworkStubGenerator extends file_generator_1.TypeScr
         return (0, core_1.appendValueGroup)([...ctx.service.endpoints.map((endpoint) => this.getResponderVariable(ctx, endpoint)), this.getStubClass(ctx)], '\n');
     }
     getResponderVariable(ctx, endpoint) {
-        return ast_1.ts.variable(this.getResponderVariableName(ctx, endpoint), {
+        return index_js_1.ts.variable(this.getResponderVariableName(ctx, endpoint), {
             readonly: true,
-            value: ast_1.ts.call(ctx.refs.getStubResponder([
-                ast_1.ts.objectType({
-                    members: Object.entries(this.getEndpointStatusCodes(ctx, endpoint)).map(([statusCode, type]) => ast_1.ts.property(statusCode, { type })),
+            value: index_js_1.ts.call(ctx.refs.getStubResponder([
+                index_js_1.ts.objectType({
+                    members: Object.entries(this.getEndpointStatusCodes(ctx, endpoint)).map(([statusCode, type]) => index_js_1.ts.property(statusCode, { type })),
                 }),
             ]), []),
         });
     }
     getStubClass(ctx) {
-        return ast_1.ts.class(this.getStubClassName(ctx), {
+        return index_js_1.ts.class(this.getStubClassName(ctx), {
             export: true,
             extends: ctx.refs.easyNetworkStubBase(),
             members: [
-                ...ctx.service.endpoints.map((endpoint) => ast_1.ts.property(this.getEndpointPathPropertyName(ctx, endpoint), {
+                ...ctx.service.endpoints.map((endpoint) => index_js_1.ts.property(this.getEndpointPathPropertyName(ctx, endpoint), {
                     static: true,
                     readonly: true,
                     accessModifier: 'private',
-                    value: (0, core_1.builderTemplate) `${ast_1.ts.string(this.getStubRoute(ctx, endpoint))} as const`,
+                    value: (0, core_1.builderTemplate) `${index_js_1.ts.string(this.getStubRoute(ctx, endpoint))} as const`,
                 })),
                 '\n',
-                ...ctx.service.endpoints.map((endpoint) => ast_1.ts.property(this.getEndpointRequestsFieldName(ctx, endpoint), {
+                ...ctx.service.endpoints.map((endpoint) => index_js_1.ts.property(this.getEndpointRequestsFieldName(ctx, endpoint), {
                     readonly: true,
                     accessModifier: 'private',
                     type: this.getEndpointRequestsType(ctx, endpoint),
-                    value: ast_1.ts.tuple([]),
+                    value: index_js_1.ts.tuple([]),
                 })),
                 '\n',
-                ...ctx.service.endpoints.map((endpoint) => ast_1.ts.property(this.getEndpointRequestsPropertyName(ctx, endpoint), {
+                ...ctx.service.endpoints.map((endpoint) => index_js_1.ts.property(this.getEndpointRequestsPropertyName(ctx, endpoint), {
                     readonly: true,
                     accessModifier: 'public',
                     type: this.getEndpointRequestsType(ctx, endpoint, { readonly: true }),
-                    get: ast_1.ts.property.getter({
+                    get: index_js_1.ts.property.getter({
                         body: (0, core_1.appendValueGroup)([`return this.${this.getEndpointRequestsFieldName(ctx, endpoint)};`], '\n'),
                     }),
                 })),
                 ...ctx.service.endpoints.map((endpoint) => this.getEndpointStubMethod(ctx, endpoint)),
-                ast_1.ts.method('reset', {
+                index_js_1.ts.method('reset', {
                     accessModifier: 'public',
                     override: true,
-                    returnType: ast_1.ts.refs.void_(),
+                    returnType: index_js_1.ts.refs.void_(),
                     body: (0, core_1.appendValueGroup)([
                         ...ctx.service.endpoints.map((endpoint) => `this.${this.getEndpointRequestsFieldName(ctx, endpoint)}.length = 0;`),
                         'super.reset();',
@@ -76,29 +76,29 @@ class DefaultTypeScriptEasyNetworkStubGenerator extends file_generator_1.TypeScr
     }
     getEndpointRequestsType(ctx, endpoint, options) {
         var _a;
-        return ast_1.ts.arrayType(ctx.refs.stubRequestInfo([
-            ast_1.ts.typeof(ast_1.ts.call([this.getStubClassName(ctx), this.getEndpointPathPropertyName(ctx, endpoint)])),
+        return index_js_1.ts.arrayType(ctx.refs.stubRequestInfo([
+            index_js_1.ts.typeof(index_js_1.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 ast_1.ts.method(this.getEndpointStubMethodName(ctx, endpoint), {
+        return index_js_1.ts.method(this.getEndpointStubMethodName(ctx, endpoint), {
             accessModifier: 'public',
             parameters: [
-                ast_1.ts.parameter('response', {
+                index_js_1.ts.parameter('response', {
                     type: ctx.refs.strictRouteResponseCallback([
                         requestType,
-                        ast_1.ts.typeof(ast_1.ts.call([this.getStubClassName(ctx), this.getEndpointPathPropertyName(ctx, endpoint)])),
-                        ast_1.ts.typeof(this.getResponderVariableName(ctx, endpoint)),
+                        index_js_1.ts.typeof(index_js_1.ts.call([this.getStubClassName(ctx), this.getEndpointPathPropertyName(ctx, endpoint)])),
+                        index_js_1.ts.typeof(this.getResponderVariableName(ctx, endpoint)),
                     ]),
                 }),
             ],
             returnType: 'this',
             body: (0, core_1.appendValueGroup)([
                 (0, core_1.builderTemplate) `this.stubWrapper.stub2<${requestType}>()(${core_1.builderTemplate.indent `
-              ${ast_1.ts.string(endpoint.method.toUpperCase())},
+              ${index_js_1.ts.string(endpoint.method.toUpperCase())},
               ${this.getStubClassName(ctx)}.${this.getEndpointPathPropertyName(ctx, endpoint)},
               async (request) => {${core_1.builderTemplate.indent `
                 if (this.stubWrapper.options.rememberRequests) {${core_1.builderTemplate.indent `
@@ -113,7 +113,7 @@ class DefaultTypeScriptEasyNetworkStubGenerator extends file_generator_1.TypeScr
     }
     getStubFilePath(ctx) {
         var _a;
-        return (0, path_1.resolve)(ctx.config.outputDir, ctx.config.stubsDir, `${(0, core_1.toCasing)(ctx.service.name, (_a = ctx.config.stubFileNameCasing) !== null && _a !== void 0 ? _a : ctx.config.fileNameCasing)}.ts`);
+        return (0, node_path_1.resolve)(ctx.config.outputDir, ctx.config.stubsDir, `${(0, core_1.toCasing)(ctx.service.name, (_a = ctx.config.stubFileNameCasing) !== null && _a !== void 0 ? _a : ctx.config.fileNameCasing)}.ts`);
     }
     getResponderVariableName(ctx, endpoint) {
         return (0, core_1.toCasing)(endpoint.name + '_Responder', ctx.config.propertyNameCasing);
@@ -138,7 +138,8 @@ class DefaultTypeScriptEasyNetworkStubGenerator extends file_generator_1.TypeScr
         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 : ast_1.ts.refs.unknown.name).replace(/^readonly /, '');
+            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 : index_js_1.ts.refs.unknown.name)
+                .replace(/^readonly /, '');
             const arrayMatch = /^\((.*)\)\[\]$/.exec(type);
             if (arrayMatch !== null) {
                 type = `${arrayMatch[1]}[]`;
@@ -161,7 +162,7 @@ class DefaultTypeScriptEasyNetworkStubGenerator extends file_generator_1.TypeScr
             ]),
             ...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, ast_1.ts.refs.never())]; }),
+                .map((x) => { var _a; return [x.statusCode, this.getSchemaType(ctx, (_a = x.contentOptions[0]) === null || _a === void 0 ? void 0 : _a.schema, index_js_1.ts.refs.never())]; }),
         ]);
     }
     getSchemaType(ctx, schema, fallback) {

package/script/lib/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 { type TypeScriptEasyNetworkStubGenerator } from './easy-network-stub-generator.js';
+import { type TypeScriptEasyNetworkStubGeneratorOutput, type TypeScriptEasyNetworkStubsGeneratorConfig, type TypeScriptEasyNetworkStubsGeneratorContext, type TypeScriptEasyNetworkStubsGeneratorInput, type TypeScriptEasyNetworkStubsGeneratorOutput } from './models.js';
+import { ts } from '../../../ast/index.js';
+import type { TypeScriptExportOutput } from '../../../common-results.js';
+import { TypeScriptFileBuilder } from '../../../file-builder.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/script/lib/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/lib/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;AAErB,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;AAErB,OAAO,EAAE,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAC3C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAGjE,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"}

package/{cjs → script}/lib/generators/services/easy-network-stub/easy-network-stubs-generator.js

@@ -2,18 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeScriptEasyNetworkStubsGenerator = void 0;
 const tslib_1 = require("tslib");
-const path_1 = require("path");
+const node_path_1 = require("node:path");
 const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const core_1 = require("@goast/core");
-const easy_network_stub_generator_1 = require("./easy-network-stub-generator");
-const models_1 = require("./models");
-const refs_1 = require("./refs");
-const ast_1 = require("../../../ast");
-const file_builder_1 = require("../../../file-builder");
+const easy_network_stub_generator_js_1 = require("./easy-network-stub-generator.js");
+const models_js_1 = require("./models.js");
+const refs_js_1 = require("./refs.js");
+const index_js_1 = require("../../../ast/index.js");
+const file_builder_js_1 = require("../../../file-builder.js");
+const assets_js_1 = require("../../../assets.js");
 class TypeScriptEasyNetworkStubsGenerator extends core_1.OpenApiServicesGenerationProviderBase {
     constructor(generatorFactory) {
         super();
-        this._generatorFactory = generatorFactory !== null && generatorFactory !== void 0 ? generatorFactory : core_1.Factory.fromValue(new easy_network_stub_generator_1.DefaultTypeScriptEasyNetworkStubGenerator());
+        Object.defineProperty(this, "_generatorFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._generatorFactory = generatorFactory !== null && generatorFactory !== void 0 ? generatorFactory : core_1.Factory.fromValue(new easy_network_stub_generator_js_1.DefaultTypeScriptEasyNetworkStubGenerator());
     }
     initResult() {
         return {
@@ -24,16 +31,14 @@ class TypeScriptEasyNetworkStubsGenerator extends core_1.OpenApiServicesGenerati
         };
     }
     buildContext(context, config) {
-        const providerContext = this.getProviderContext(context, config, models_1.defaultTypeScriptEasyNetworkStubsGeneratorConfig);
+        const providerContext = this.getProviderContext(context, config, models_js_1.defaultTypeScriptEasyNetworkStubsGeneratorConfig);
         return Object.assign(providerContext, {
-            refs: (0, refs_1.getReferenceFactories)(providerContext.config),
+            refs: (0, refs_js_1.getReferenceFactories)(providerContext.config),
         });
     }
-    onGenerate(ctx) {
-        const output = super.onGenerate(ctx);
-        this.generateUtilsFiles(ctx);
-        output.typescript.indexFiles = this.generateIndexFiles(ctx);
-        return output;
+    async generateAdditionalFiles(ctx) {
+        await this.generateUtilsFiles(ctx);
+        ctx.output.typescript.indexFiles = this.generateIndexFiles(ctx);
     }
     generateService(ctx, service) {
         const clientGenerator = this._generatorFactory.create();
@@ -45,15 +50,14 @@ class TypeScriptEasyNetworkStubsGenerator extends core_1.OpenApiServicesGenerati
     addServiceResult(ctx, service, result) {
         ctx.output.typescript.stubs[service.id] = result;
     }
-    generateUtilsFiles(ctx) {
-        const sourceDir = (0, path_1.resolve)((0, path_1.dirname)(require.resolve('@goast/typescript')), '../assets/stubs/easy-network-stub');
-        const targetDir = (0, path_1.resolve)(ctx.config.outputDir, ctx.config.utilsDir);
-        fs_extra_1.default.ensureDirSync(targetDir);
-        this.copyFile('easy-network-stub utils', sourceDir, targetDir, 'easy-network-stub.utils.ts');
+    async generateUtilsFiles(ctx) {
+        const targetDir = (0, node_path_1.resolve)(ctx.config.outputDir, ctx.config.utilsDir);
+        await fs_extra_1.default.ensureDir(targetDir);
+        await (0, assets_js_1.copyAssetFile)('stubs/easy-network-stub/easy-network-stub.utils.ts', targetDir, 'easy-network-stub utils');
     }
     generateIndexFiles(ctx) {
         const stubsIndexFilePath = this.getStubsIndexFilePath(ctx);
-        file_builder_1.TypeScriptFileBuilder.tryGenerate({
+        file_builder_js_1.TypeScriptFileBuilder.tryGenerate({
             logName: 'stubs index file',
             filePath: stubsIndexFilePath,
             options: ctx.config,
@@ -65,53 +69,53 @@ class TypeScriptEasyNetworkStubsGenerator extends core_1.OpenApiServicesGenerati
     }
     getStubsIndexFileContent(ctx) {
         return (0, core_1.appendValueGroup)([
-            (0, core_1.appendValueGroup)(Object.values(ctx.output.typescript.stubs).map((x) => ast_1.ts.export(x.component, x.filePath))),
+            (0, core_1.appendValueGroup)(Object.values(ctx.output.typescript.stubs).map((x) => index_js_1.ts.export(x.component, x.filePath))),
             this.getStubsClass(ctx),
         ], '\n');
     }
     getStubsClass(ctx) {
         const fieldCasing = (0, core_1.adjustCasing)(ctx.config.propertyNameCasing, { prefix: '_' });
         const serviceNames = Object.fromEntries(ctx.data.services.map((x) => [x.id, x.name]));
-        return ast_1.ts.class(this.getStubsClassName(ctx), {
+        return index_js_1.ts.class(this.getStubsClassName(ctx), {
             export: true,
             members: [
-                ast_1.ts.property('_stubWrapper', {
+                index_js_1.ts.property('_stubWrapper', {
                     accessModifier: 'private',
                     readonly: true,
                     type: ctx.refs.easyNetworkStubWrapper(),
                 }),
-                ...Object.entries(ctx.output.typescript.stubs).map(([id, x]) => ast_1.ts.property((0, core_1.toCasing)(serviceNames[id], fieldCasing), {
+                ...Object.entries(ctx.output.typescript.stubs).map(([id, x]) => index_js_1.ts.property((0, core_1.toCasing)(serviceNames[id], fieldCasing), {
                     accessModifier: 'private',
                     optional: true,
-                    type: ctx.refs.easyNetworkStubGroup([ast_1.ts.reference(x.component, x.filePath), 'this']),
+                    type: ctx.refs.easyNetworkStubGroup([index_js_1.ts.reference(x.component, x.filePath), 'this']),
                 })),
-                ast_1.ts.constructor({
+                index_js_1.ts.constructor({
                     parameters: [
-                        ast_1.ts.constructorParameter('stub', { type: ast_1.ts.refs.easyNetworkStub.easyNetworkStub() }),
-                        ast_1.ts.constructorParameter('options', {
-                            type: ast_1.ts.refs.partial([ctx.refs.easyNetworkStubWrapperOptions()]),
+                        index_js_1.ts.constructorParameter('stub', { type: index_js_1.ts.refs.easyNetworkStub.easyNetworkStub() }),
+                        index_js_1.ts.constructorParameter('options', {
+                            type: index_js_1.ts.refs.partial([ctx.refs.easyNetworkStubWrapperOptions()]),
                             optional: true,
                         }),
                     ],
                     body: (0, core_1.appendValueGroup)([(0, core_1.builderTemplate) `this._stubWrapper = new ${ctx.refs.easyNetworkStubWrapper()}(stub, options);`], '\n'),
                 }),
-                ast_1.ts.property('requests', {
+                index_js_1.ts.property('requests', {
                     accessModifier: 'public',
-                    type: ast_1.ts.arrayType(ctx.refs.stubRequestItem(), { readonly: true }),
-                    get: ast_1.ts.property.getter({
+                    type: index_js_1.ts.arrayType(ctx.refs.stubRequestItem(), { readonly: true }),
+                    get: index_js_1.ts.property.getter({
                         body: (0, core_1.appendValueGroup)(['return this._stubWrapper.requests;'], '\n'),
                     }),
                 }),
-                ...Object.entries(ctx.output.typescript.stubs).map(([id, x]) => ast_1.ts.property((0, core_1.toCasing)(serviceNames[id], ctx.config.propertyNameCasing), {
+                ...Object.entries(ctx.output.typescript.stubs).map(([id, x]) => index_js_1.ts.property((0, core_1.toCasing)(serviceNames[id], ctx.config.propertyNameCasing), {
                     accessModifier: 'public',
-                    type: ctx.refs.easyNetworkStubGroup([ast_1.ts.reference(x.component, x.filePath), 'this']),
-                    get: ast_1.ts.property.getter({
+                    type: ctx.refs.easyNetworkStubGroup([index_js_1.ts.reference(x.component, x.filePath), 'this']),
+                    get: index_js_1.ts.property.getter({
                         body: (0, core_1.appendValueGroup)([
-                            (0, core_1.builderTemplate) `return this.${(0, core_1.toCasing)(serviceNames[id], fieldCasing)} ??= ${ctx.refs.createEasyNetworkStubGroup.infer()}(this, this._stubWrapper, ${ast_1.ts.reference(x.component, x.filePath)});`,
+                            (0, core_1.builderTemplate) `return this.${(0, core_1.toCasing)(serviceNames[id], fieldCasing)} ??= ${ctx.refs.createEasyNetworkStubGroup.infer()}(this, this._stubWrapper, ${index_js_1.ts.reference(x.component, x.filePath)});`,
                         ], '\n'),
                     }),
                 })),
-                ast_1.ts.method('resetStubs', {
+                index_js_1.ts.method('resetStubs', {
                     accessModifier: 'public',
                     returnType: 'this',
                     body: (0, core_1.appendValueGroup)([
@@ -123,17 +127,11 @@ class TypeScriptEasyNetworkStubsGenerator extends core_1.OpenApiServicesGenerati
         });
     }
     getStubsIndexFilePath(ctx) {
-        return ctx.config.stubsIndexFile ? (0, path_1.resolve)(ctx.config.outputDir, ctx.config.stubsIndexFile) : null;
+        return ctx.config.stubsIndexFile ? (0, node_path_1.resolve)(ctx.config.outputDir, ctx.config.stubsIndexFile) : null;
     }
     getStubsClassName(ctx) {
         var _a;
         return (0, core_1.toCasing)(`${(_a = ctx.config.domainName) !== null && _a !== void 0 ? _a : ''}_ApiStubs`, ctx.config.typeNameCasing);
     }
-    copyFile(logName, sourceDir, targetDir, fileName) {
-        const source = (0, path_1.resolve)(sourceDir, fileName);
-        const target = (0, path_1.resolve)(targetDir, fileName);
-        console.log(`Generating ${logName} to ${target}...`);
-        fs_extra_1.default.copyFileSync(source, target);
-    }
 }
 exports.TypeScriptEasyNetworkStubsGenerator = TypeScriptEasyNetworkStubsGenerator;

package/script/lib/generators/services/easy-network-stub/index.d.ts

@@ -0,0 +1,4 @@
+export * from './easy-network-stub-generator.js';
+export * from './easy-network-stubs-generator.js';
+export * from './models.js';
+//# sourceMappingURL=index.d.ts.map

package/script/lib/generators/services/easy-network-stub/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/generators/services/easy-network-stub/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,aAAa,CAAC"}

package/script/lib/generators/services/easy-network-stub/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./easy-network-stub-generator.js"), exports);
+tslib_1.__exportStar(require("./easy-network-stubs-generator.js"), exports);
+tslib_1.__exportStar(require("./models.js"), exports);

package/script/lib/generators/services/easy-network-stub/models.d.ts

@@ -0,0 +1,78 @@
+import type { ApiSchema, ApiService, DefaultGenerationProviderConfig, ExtendedStringCasing, Nullable, OpenApiServicesGenerationProviderContext } from '@goast/core';
+import type { getReferenceFactories } from './refs.js';
+import { 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';
+export type TypeScriptEasyNetworkStubsGeneratorConfig = TypeScriptGeneratorConfig & {
+    /**
+     * The domain name of the API. Used as a prefix for exported components (e.g. `ApiStubs`).
+     * @default undefined
+     */
+    domainName: Nullable<string>;
+    /**
+     * The default response types for status codes that are not defined in the OpenAPI specification.
+     * @example
+     * {
+     *   400: schemas =>
+     *     schemas.find(s => s.name === 'BadRequestResponse')
+     *       ?? throwExp('BadRequestResponse not found'),
+     *   404: 'never',
+     *   500: ts.refs.any(),
+     * }
+     * @default
+     * {
+     *   401: ts.refs.never(),
+     *   403: ts.refs.never(),
+     *   500: ts.refs.never(),
+     * }
+     */
+    defaultStatusCodeResponseTypes: Record<number, Exclude<ts.Type<TypeScriptFileBuilder>, Function> | ((schemas: readonly ApiSchema[]) => ApiSchema)>;
+    /**
+     * The directory where the stubs should be saved. The path is relative to the output directory.
+     * @default 'stubs'
+     */
+    stubsDir: string;
+    /**
+     * The casing of the stub file names. If nullish, the `fileNameCasing` is used.
+     * @default { casing: 'kebab', suffix: '.stubs' }
+     */
+    stubFileNameCasing: Nullable<ExtendedStringCasing>;
+    /**
+     * The index file where all stubs should be exported. The path is relative to the output directory. If nullish, no index file will be generated.
+     * @default 'stubs.ts'
+     */
+    stubsIndexFile: 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 defaultTypeScriptEasyNetworkStubsGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptEasyNetworkStubsGeneratorConfig>;
+export type TypeScriptEasyNetworkStubsGeneratorInput = {
+    typescript: {
+        models: {
+            [schemaId: string]: TypeScriptModelGeneratorOutput;
+        };
+    };
+};
+export type TypeScriptEasyNetworkStubsGeneratorOutput = {
+    typescript: {
+        stubs: {
+            [serviceId: string]: TypeScriptEasyNetworkStubGeneratorOutput;
+        };
+        indexFiles: {
+            stubs: Nullable<string>;
+        };
+    };
+};
+export type TypeScriptEasyNetworkStubGeneratorOutput = TypeScriptExportOutput;
+export type TypeScriptEasyNetworkStubsGeneratorContext = OpenApiServicesGenerationProviderContext<TypeScriptEasyNetworkStubsGeneratorInput, TypeScriptEasyNetworkStubsGeneratorOutput, TypeScriptEasyNetworkStubsGeneratorConfig, TypeScriptEasyNetworkStubGeneratorOutput> & {
+    refs: ReturnType<typeof getReferenceFactories>;
+};
+export type TypeScriptEasyNetworkStubGeneratorContext = TypeScriptEasyNetworkStubsGeneratorContext & {
+    readonly service: ApiService;
+};
+//# sourceMappingURL=models.d.ts.map

package/script/lib/generators/services/easy-network-stub/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../../../src/lib/generators/services/easy-network-stub/models.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,UAAU,EACV,+BAA+B,EAC/B,oBAAoB,EACpB,QAAQ,EACR,wCAAwC,EACzC,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AACvD,OAAO,EAAE,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAC3C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,EAAoC,KAAK,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AACtG,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AAE5E,MAAM,MAAM,yCAAyC,GAAG,yBAAyB,GAAG;IAClF;;;OAGG;IACH,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAE7B;;;;;;;;;;;;;;;;OAgBG;IACH,8BAA8B,EAAE,MAAM,CACpC,MAAM,EAEN,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,qBAAqB,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,KAAK,SAAS,CAAC,CACnG,CAAC;IAEF;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,kBAAkB,EAAE,QAAQ,CAAC,oBAAoB,CAAC,CAAC;IAEnD;;;OAGG;IACH,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAEjC;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,gDAAgD,EAAE,+BAA+B,CAC5F,yCAAyC,CAe1C,CAAC;AAEF,MAAM,MAAM,wCAAwC,GAAG;IACrD,UAAU,EAAE;QACV,MAAM,EAAE;YACN,CAAC,QAAQ,EAAE,MAAM,GAAG,8BAA8B,CAAC;SACpD,CAAC;KACH,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,yCAAyC,GAAG;IACtD,UAAU,EAAE;QACV,KAAK,EAAE;YACL,CAAC,SAAS,EAAE,MAAM,GAAG,wCAAwC,CAAC;SAC/D,CAAC;QACF,UAAU,EAAE;YACV,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;SACzB,CAAC;KACH,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,wCAAwC,GAAG,sBAAsB,CAAC;AAE9E,MAAM,MAAM,0CAA0C,GAClD,wCAAwC,CACxC,wCAAwC,EACxC,yCAAyC,EACzC,yCAAyC,EACzC,wCAAwC,CACzC,GACC;IACA,IAAI,EAAE,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;CAChD,CAAC;AAEJ,MAAM,MAAM,yCAAyC,GAAG,0CAA0C,GAAG;IACnG,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;CAC9B,CAAC"}

package/{cjs → script}/lib/generators/services/easy-network-stub/models.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultTypeScriptEasyNetworkStubsGeneratorConfig = void 0;
-const ast_1 = require("../../../ast");
-const config_1 = require("../../../config");
+const index_js_1 = require("../../../ast/index.js");
+const config_js_1 = require("../../../config.js");
 exports.defaultTypeScriptEasyNetworkStubsGeneratorConfig = {
-    ...config_1.defaultTypeScriptGeneratorConfig,
+    ...config_js_1.defaultTypeScriptGeneratorConfig,
     domainName: undefined,
     defaultStatusCodeResponseTypes: {
-        401: ast_1.ts.refs.never(),
-        403: ast_1.ts.refs.never(),
-        500: ast_1.ts.refs.never(),
+        401: index_js_1.ts.refs.never(),
+        403: index_js_1.ts.refs.never(),
+        500: index_js_1.ts.refs.never(),
     },
     stubsDir: 'stubs',
     stubFileNameCasing: { casing: 'kebab', suffix: '.stubs' },

package/script/lib/generators/services/easy-network-stub/refs.d.ts

@@ -0,0 +1,82 @@
+import type { TypeScriptEasyNetworkStubsGeneratorConfig } from './models.js';
+import { ts } from '../../../ast/index.js';
+export declare function getReferenceFactories(options: TypeScriptEasyNetworkStubsGeneratorConfig): {
+    easyNetworkStubWrapperOptions: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results.js").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    stubRequestItem: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results.js").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    stubRequestInfo: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>, ts.Type<TBuilder>], options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results.js").TypeScriptImportType>;
+    } | undefined) => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+        infer: <TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    strictRouteResponseCallback: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>, ts.Type<TBuilder>, ts.Type<TBuilder>], options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results.js").TypeScriptImportType>;
+    } | undefined) => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+        infer: <TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    getStubResponder: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>], options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results.js").TypeScriptImportType>;
+    } | undefined) => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+        infer: <TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    easyNetworkStubWrapper: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results.js").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    easyNetworkStubBase: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results.js").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    easyNetworkStubGroup: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>, ts.Type<TBuilder>], options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results.js").TypeScriptImportType>;
+    } | undefined) => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+        infer: <TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    createEasyNetworkStubGroup: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>, ts.Type<TBuilder>], options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results.js").TypeScriptImportType>;
+    } | undefined) => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+        infer: <TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+};
+//# sourceMappingURL=refs.d.ts.map

package/script/lib/generators/services/easy-network-stub/refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs.d.ts","sourceRoot":"","sources":["../../../../../src/lib/generators/services/easy-network-stub/refs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,yCAAyC,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,EAAE,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAG3C,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BvF"}

package/script/lib/generators/services/easy-network-stub/refs.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReferenceFactories = getReferenceFactories;
+const node_path_1 = require("node:path");
+const index_js_1 = require("../../../ast/index.js");
+// See packages/typescript/assets/stubs/easy-network-stub for reference
+function getReferenceFactories(options) {
+    const utilsDirPath = (0, node_path_1.resolve)(options.outputDir, options.utilsDir);
+    const easyNetworkStubUtilsPath = (0, node_path_1.join)(utilsDirPath, 'easy-network-stub.utils.ts');
+    return {
+        // easy-network-stub.utils.ts
+        easyNetworkStubWrapperOptions: index_js_1.ts.reference.factory('EasyNetworkStubWrapperOptions', easyNetworkStubUtilsPath, {
+            importType: 'type-import',
+        }),
+        stubRequestItem: index_js_1.ts.reference.factory('StubRequestItem', easyNetworkStubUtilsPath, { importType: 'type-import' }),
+        stubRequestInfo: index_js_1.ts.reference.genericFactory('StubRequestInfo', easyNetworkStubUtilsPath, {
+            importType: 'type-import',
+        }),
+        strictRouteResponseCallback: index_js_1.ts.reference.genericFactory('StrictRouteResponseCallback', easyNetworkStubUtilsPath, {
+            importType: 'type-import',
+        }),
+        getStubResponder: index_js_1.ts.reference.genericFactory('getStubResponder', easyNetworkStubUtilsPath),
+        easyNetworkStubWrapper: index_js_1.ts.reference.factory('EasyNetworkStubWrapper', easyNetworkStubUtilsPath),
+        easyNetworkStubBase: index_js_1.ts.reference.factory('EasyNetworkStubBase', easyNetworkStubUtilsPath),
+        easyNetworkStubGroup: index_js_1.ts.reference.genericFactory('EasyNetworkStubGroup', easyNetworkStubUtilsPath, {
+            importType: 'type-import',
+        }),
+        createEasyNetworkStubGroup: index_js_1.ts.reference.genericFactory('createEasyNetworkStubGroup', easyNetworkStubUtilsPath),
+    };
+}

package/script/lib/generators/services/fetch-clients/fetch-client-generator.d.ts

@@ -0,0 +1,33 @@
+import { type ApiEndpoint, type ApiSchema, type AppendValueGroup, type MaybePromise } from '@goast/core';
+import type { TypeScriptFetchClientGeneratorContext, TypeScriptFetchClientGeneratorOutput } from './models.js';
+import { ts } from '../../../ast/index.js';
+import { TypeScriptFileBuilder } from '../../../file-builder.js';
+import { TypeScriptFileGenerator } from '../../file-generator.js';
+type Context = TypeScriptFetchClientGeneratorContext;
+type Output = TypeScriptFetchClientGeneratorOutput;
+type Builder = TypeScriptFileBuilder;
+export interface TypeScriptFetchClientGenerator<TOutput extends Output = Output> {
+    generate(ctx: Context): MaybePromise<TOutput>;
+}
+export declare class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerator<Context, Output> implements TypeScriptFetchClientGenerator {
+    generate(ctx: Context): MaybePromise<Output>;
+    protected getInterfaceFileContent(ctx: Context): AppendValueGroup<Builder>;
+    protected getInterface(ctx: Context): ts.Interface<Builder>;
+    protected getInterfaceEndpointMethod(ctx: Context, endpoint: ApiEndpoint): ts.Method<Builder>;
+    protected getClassFileContent(ctx: Context): AppendValueGroup<Builder>;
+    protected getDefaultOptionsConstant(ctx: Context): ts.Variable<Builder>;
+    protected getClass(ctx: Context): ts.Class<Builder>;
+    protected getServiceMethod(ctx: Context, endpoint: ApiEndpoint): ts.Method<Builder>;
+    protected getSchemaType(ctx: Context, schema: ApiSchema | undefined, fallback?: ts.Type<Builder>): ts.Type<Builder>;
+    protected shouldGenerateInterface(ctx: Context): boolean;
+    protected shouldGenerateClass(ctx: Context): boolean;
+    protected getInterfaceName(ctx: Context): string;
+    protected getClassName(ctx: Context): string;
+    protected getDefaultOptionsConstantName(ctx: Context): string;
+    protected getInterfaceFilePath(ctx: Context): string;
+    protected getClassFilePath(ctx: Context): string;
+    protected getUtilPath(ctx: Context, fileName: string): string;
+    private getResponseSchema;
+}
+export {};
+//# sourceMappingURL=fetch-client-generator.d.ts.map