@goast/typescript 0.2.19 → 0.3.0

package/esm/lib/ast/nodes/generic-parameter.js

@@ -30,7 +30,7 @@ export class TsGenericParameter extends TsNode {
         }
     }
 }
-const createGenericParameter = (name, options) => new TsGenericParameter(Object.assign(Object.assign({}, options), { name }));
+const createGenericParameter = (name, options) => new TsGenericParameter({ ...options, name });
 export const tsGenericParameter = Object.assign(createGenericParameter, {
     write: writeTsGenericParameters,
 });

package/esm/lib/ast/nodes/indexer.js

@@ -22,7 +22,7 @@ export class TsIndexer extends TsNode {
         builder.appendLine();
     }
 }
-const createIndexer = (keyType, valueType, options) => new TsIndexer(Object.assign(Object.assign({}, options), { keyType, valueType }));
+const createIndexer = (keyType, valueType, options) => new TsIndexer({ ...options, keyType, valueType });
 export const tsIndexer = Object.assign(createIndexer, {
     write: writeTsNodes,
 });

package/esm/lib/ast/nodes/interface.js

@@ -50,7 +50,7 @@ export class TsInterface extends TsNode {
         builder.appendLine();
     }
 }
-const createInterface = (name, options) => new TsInterface(Object.assign(Object.assign({}, options), { name }));
+const createInterface = (name, options) => new TsInterface({ ...options, name });
 export const tsInterface = Object.assign(createInterface, {
     write: writeTsNodes,
 });

package/esm/lib/ast/nodes/intersection-type.js

@@ -22,7 +22,7 @@ export class TsIntersectionType extends TsNode {
         }
     }
 }
-const createIntersectionType = (types, options) => new TsIntersectionType(Object.assign(Object.assign({}, options), { types }));
+const createIntersectionType = (types, options) => new TsIntersectionType({ ...options, types });
 export const tsIntersectionType = Object.assign(createIntersectionType, {
     write: writeTsNodes,
 });

package/esm/lib/ast/nodes/lookup-type.js

@@ -20,7 +20,7 @@ export class TsLookupType extends TsNode {
         });
     }
 }
-const createLookupType = (type, index, options) => new TsLookupType(Object.assign(Object.assign({}, options), { type, index }));
+const createLookupType = (type, index, options) => new TsLookupType({ ...options, type, index });
 export const tsLookupType = Object.assign(createLookupType, {
     write: writeTsNodes,
 });

package/esm/lib/ast/nodes/method.js

@@ -71,7 +71,7 @@ export class TsMethod extends TsNode {
         builder.appendLine();
     }
 }
-export const createMethod = (name, options) => new TsMethod(Object.assign(Object.assign({}, options), { name }));
+export const createMethod = (name, options) => new TsMethod({ ...options, name });
 export const tsMethod = Object.assign(createMethod, {
     write: writeTsNodes,
 });

package/esm/lib/ast/nodes/parameter.js

@@ -35,7 +35,7 @@ export class TsParameter extends TsNode {
         }
     }
 }
-const createParameter = (name, options) => new TsParameter(Object.assign(Object.assign({}, options), { name }));
+const createParameter = (name, options) => new TsParameter({ ...options, name });
 export const tsParameter = Object.assign(createParameter, {
     write: writeTsParameters,
 });

package/esm/lib/ast/nodes/property.js

@@ -102,9 +102,9 @@ export class TsAccessorProperty extends TsProperty {
 }
 const createProperty = (name, options) => {
     if (options && ('get' in options || 'set' in options)) {
-        return new TsAccessorProperty(Object.assign(Object.assign({}, options), { name }));
+        return new TsAccessorProperty({ ...options, name });
     }
-    return new TsSimpleProperty(Object.assign(Object.assign({}, options), { name }));
+    return new TsSimpleProperty({ ...options, name });
 };
 export const tsProperty = Object.assign(createProperty, {
     write: writeTsNodes,

package/esm/lib/ast/nodes/reference.js

@@ -32,7 +32,7 @@ TsReference.addImportHandlers = [
         handler: (builder, reference) => builder.addImport(reference.name, reference.moduleNameOrfilePath),
     },
 ];
-const createReference = (name, moduleNameOrfilePath, options) => new TsReference(Object.assign(Object.assign({}, options), { name, moduleNameOrfilePath }));
+const createReference = (name, moduleNameOrfilePath, options) => new TsReference({ ...options, name, moduleNameOrfilePath });
 function _createFactory(name, moduleNameOrfilePath) {
     return Object.assign(() => createReference(name, moduleNameOrfilePath), {
         refName: name,

package/esm/lib/ast/nodes/string.js

@@ -20,7 +20,7 @@ export class TsString extends TsNode {
         builder.append(value);
     }
 }
-const createString = (value, options) => new TsString(Object.assign(Object.assign({}, options), { value }));
+const createString = (value, options) => new TsString({ ...options, value });
 export const tsString = Object.assign(createString, {
     write: writeTsNodes,
 });

package/esm/lib/ast/nodes/tuple.js

@@ -23,7 +23,7 @@ export class TsTuple extends TsNode {
         }
     }
 }
-const createTuple = (elements, options) => new TsTuple(Object.assign(Object.assign({}, options), { elements }));
+const createTuple = (elements, options) => new TsTuple({ ...options, elements });
 export const tsTuple = Object.assign(createTuple, {
     write: writeTsNodes,
 });

package/esm/lib/ast/nodes/type-alias.js

@@ -28,7 +28,7 @@ export class TsTypeAlias extends TsNode {
         builder.appendLine();
     }
 }
-const createTypeAlias = (name, type, options) => new TsTypeAlias(Object.assign(Object.assign({}, options), { name, type }));
+const createTypeAlias = (name, type, options) => new TsTypeAlias({ ...options, name, type });
 export const tsTypeAlias = Object.assign(createTypeAlias, {
     write: writeTsNodes,
 });

package/esm/lib/ast/nodes/typeof.js

@@ -12,7 +12,7 @@ export class TsTypeof extends TsNode {
         builder.append(this.inject.afterValue);
     }
 }
-export const createTypeof = (value, options) => new TsTypeof(Object.assign(Object.assign({}, options), { value }));
+export const createTypeof = (value, options) => new TsTypeof({ ...options, value });
 export const tsTypeof = Object.assign(createTypeof, {
     write: writeTsNodes,
 });

package/esm/lib/ast/nodes/union-type.js

@@ -22,7 +22,7 @@ export class TsUnionType extends TsNode {
         }
     }
 }
-const createUnionType = (types, options) => new TsUnionType(Object.assign(Object.assign({}, options), { types }));
+const createUnionType = (types, options) => new TsUnionType({ ...options, types });
 export const tsUnionType = Object.assign(createUnionType, {
     write: writeTsNodes,
 });

package/esm/lib/ast/nodes/variable.js

@@ -30,7 +30,7 @@ export class TsVariable extends TsNode {
         builder.appendLine();
     }
 }
-const createVariable = (name, options) => new TsVariable(Object.assign(Object.assign({}, options), { name }));
+const createVariable = (name, options) => new TsVariable({ ...options, name });
 export const tsVariable = Object.assign(createVariable, {
     write: writeTsNodes,
 });

package/esm/lib/ast/utils/get-type-script-builder-options.js

@@ -9,7 +9,7 @@ export function getTypeScriptBuilderOptions(builder) {
     if (tsConfigSymbol in builder.options) {
         return builder.options[tsConfigSymbol];
     }
-    const options = Object.assign(Object.assign(Object.assign({}, defaultOpenApiGeneratorConfig), defaultTypeScriptGeneratorConfig), builder.options);
+    const options = { ...defaultOpenApiGeneratorConfig, ...defaultTypeScriptGeneratorConfig, ...builder.options };
     builder[tsConfigSymbol] = options;
     return options;
 }

package/esm/lib/generators/models/model-generator.js

@@ -8,13 +8,22 @@ export class DefaultTypeScriptModelGenerator extends TypeScriptFileGenerator {
         if (this.shouldGenerateTypeDeclaration(ctx, ctx.schema)) {
             const name = this.getDeclarationTypeName(ctx, ctx.schema);
             const filePath = this.getFilePath(ctx, ctx.schema);
+            const fileContent = this.getFileContent(ctx);
             TypeScriptFileBuilder.generate({
                 logName: `model ${name}`,
                 filePath,
                 options: ctx.config,
-                generator: (b) => b.append(this.getFileContent(ctx)),
+                generator: (b) => b.append(fileContent),
             });
-            return { component: name, filePath, imports: [{ kind: 'file', name, modulePath: filePath }] };
+            return {
+                component: name,
+                filePath,
+                imports: [{ kind: 'file', name, modulePath: filePath }],
+                additionalExports: fileContent.values
+                    .filter((x) => typeof x === 'object' && x !== null && 'export' in x && x.export === true && 'name' in x)
+                    .filter((x) => x.name !== name)
+                    .map((x) => x.name),
+            };
         }
         else {
             const builder = new TypeScriptFileBuilder(undefined, ctx.config);
@@ -318,6 +327,7 @@ export class DefaultTypeScriptModelGenerator extends TypeScriptFileGenerator {
             .filter((item, index, self) => self.indexOf(item) === index);
     }
     getFilePath(ctx, schema) {
-        return resolve(ctx.config.outputDir, ctx.config.modelsDirPath, `${toCasing(schema.name, ctx.config.fileNameCasing)}.ts`);
+        var _a;
+        return resolve(ctx.config.outputDir, ctx.config.modelsDir, `${toCasing(schema.name, (_a = ctx.config.modelFileNameCasing) !== null && _a !== void 0 ? _a : ctx.config.fileNameCasing)}.ts`);
     }
 }

package/esm/lib/generators/models/models-generator.js

@@ -11,8 +11,10 @@ export class TypeScriptModelsGenerator extends OpenApiSchemasGenerationProviderB
     }
     initResult() {
         return {
-            models: {},
-            indexFiles: { models: undefined },
+            typescript: {
+                models: {},
+                indexFiles: { models: undefined },
+            },
         };
     }
     buildContext(context, config) {
@@ -20,15 +22,18 @@ export class TypeScriptModelsGenerator extends OpenApiSchemasGenerationProviderB
     }
     onGenerate(ctx) {
         const output = super.onGenerate(ctx);
-        output.indexFiles.models = this.generateIndexFile(ctx);
+        output.typescript.indexFiles.models = this.generateIndexFile(ctx);
         return output;
     }
     generateSchema(ctx, schema) {
         const modelGenerator = this._modelGeneratorFactory.create();
-        return modelGenerator.generate(Object.assign(Object.assign({}, ctx), { schema }));
+        return modelGenerator.generate({
+            ...ctx,
+            schema,
+        });
     }
     addSchemaResult(ctx, schema, result) {
-        ctx.output.models[schema.id] = result;
+        ctx.output.typescript.models[schema.id] = result;
     }
     generateIndexFile(ctx) {
         const filePath = this.getIndexFilePath(ctx);
@@ -41,9 +46,15 @@ export class TypeScriptModelsGenerator extends OpenApiSchemasGenerationProviderB
         return filePath;
     }
     getIndexFilePath(ctx) {
-        return ctx.config.indexFilePath ? resolve(ctx.config.outputDir, ctx.config.indexFilePath) : null;
+        return ctx.config.modelsIndexFile ? resolve(ctx.config.outputDir, ctx.config.modelsIndexFile) : null;
     }
     getIndexFileContent(ctx) {
-        return appendValueGroup(Object.values(ctx.output.models).map((x) => (x.filePath ? ts.export(x.component, x.filePath) : null)));
+        return appendValueGroup(Object.values(ctx.output.typescript.models).flatMap((x) => {
+            var _a, _b;
+            const { filePath } = x;
+            if (!filePath)
+                return [];
+            return [ts.export(x.component, filePath), ...((_b = (_a = x.additionalExports) === null || _a === void 0 ? void 0 : _a.map((e) => ts.export(e, filePath))) !== null && _b !== void 0 ? _b : [])];
+        }));
     }
 }

package/esm/lib/generators/models/models.js

@@ -1,3 +1,14 @@
 import { defaultTypeScriptGeneratorConfig } from '../../config';
-export const defaultTypeScriptModelGeneratorConfig = Object.assign(Object.assign({}, defaultTypeScriptGeneratorConfig), { enumGeneration: 'union', immutableTypes: false, inlineUnnamedSchemas: true, modelsDirPath: 'models', typeDeclaration: 'type' });
-export const defaultTypeScriptModelsGeneratorConfig = Object.assign(Object.assign({}, defaultTypeScriptModelGeneratorConfig), { indexFilePath: 'models.ts' });
+export const defaultTypeScriptModelGeneratorConfig = {
+    ...defaultTypeScriptGeneratorConfig,
+    enumGeneration: 'union',
+    immutableTypes: false,
+    inlineUnnamedSchemas: true,
+    modelsDir: 'models',
+    modelFileNameCasing: undefined,
+    typeDeclaration: 'type',
+};
+export const defaultTypeScriptModelsGeneratorConfig = {
+    ...defaultTypeScriptModelGeneratorConfig,
+    modelsIndexFile: 'models.ts',
+};

package/esm/lib/generators/services/angular-services/angular-service-generator.js

@@ -99,7 +99,7 @@ export class DefaultTypeScriptAngularServiceGenerator extends TypeScriptFileGene
                         parser: (_a = value === null || value === void 0 ? void 0 : value.parser) !== null && _a !== void 0 ? _a : 'text',
                         type: typeof (value === null || value === void 0 ? void 0 : value.type) === 'function'
                             ? this.getSchemaType(ctx, value.type(ctx.data.schemas))
-                            : value !== null && value !== void 0 ? value : ts.refs.never(),
+                            : (value !== null && value !== void 0 ? value : ts.refs.never()),
                     },
                 ];
             }),
@@ -137,7 +137,7 @@ export class DefaultTypeScriptAngularServiceGenerator extends TypeScriptFileGene
                     description: parameter.description,
                     tags: [parameter.deprecated ? ts.docTag('deprecated') : null],
                 }),
-                type: schema ? (b) => b.appendModelUsage(ctx.input.models[schema.id]) : this.getAnyType(ctx),
+                type: schema ? (b) => b.appendModelUsage(ctx.input.typescript.models[schema.id]) : this.getAnyType(ctx),
                 optional: !parameter.required,
             }));
         }
@@ -146,7 +146,7 @@ export class DefaultTypeScriptAngularServiceGenerator extends TypeScriptFileGene
             const schema = body.content[0].schema;
             type.members.push(ts.property('body', {
                 doc: ts.doc({ description: body.description }),
-                type: schema ? (b) => b.appendModelUsage(ctx.input.models[schema.id]) : this.getAnyType(ctx),
+                type: schema ? (b) => b.appendModelUsage(ctx.input.typescript.models[schema.id]) : this.getAnyType(ctx),
                 optional: !body.required,
             }));
         }
@@ -228,13 +228,13 @@ export class DefaultTypeScriptAngularServiceGenerator extends TypeScriptFileGene
                     }
                     : null,
                 '',
-                s `return ${ctx.refs.waitForResponse([responseModelType])}(${s.indent `
-              this.http.request(rb.build({${s.indent `
-                responseType: ${ts.string(responseType)},
-                accept: ${ts.string(accept)},
-                context,`}
-              })),
-              {${s.indent `
+                s `return ${ctx.refs.waitForResponse([responseModelType])}(${s.indent `
+              this.http.request(rb.build({${s.indent `
+                responseType: ${ts.string(responseType)},
+                accept: ${ts.string(accept)},
+                context,`}
+              })),
+              {${s.indent `
                 errorResponseTypes: ${ts.object({
                     members: [
                         ...Object.entries(this.getEndpointStatusCodes(ctx, endpoint))
@@ -243,8 +243,8 @@ export class DefaultTypeScriptAngularServiceGenerator extends TypeScriptFileGene
                             return ts.property(key, { value: ts.string(value.parser) });
                         }),
                     ],
-                })}`}
-              }`}
+                })}`}
+              }`}
             )`,
             ], '\n'),
         });
@@ -269,16 +269,18 @@ export class DefaultTypeScriptAngularServiceGenerator extends TypeScriptFileGene
         return toCasing(endpoint.name, ctx.config.functionNameCasing);
     }
     getServiceFilePath(ctx) {
-        return resolve(ctx.config.outputDir, ctx.config.servicesDirPath, `${toCasing(ctx.service.name, ctx.config.fileNameCasing)}.ts`);
+        var _a;
+        return resolve(ctx.config.outputDir, ctx.config.servicesDir, `${toCasing(ctx.service.name, (_a = ctx.config.serviceFileNameCasing) !== null && _a !== void 0 ? _a : ctx.config.fileNameCasing)}.ts`);
     }
     getResponseModelFilePath(ctx) {
-        return resolve(ctx.config.outputDir, ctx.config.responseModelsDirPath, `${toCasing(ctx.service.name, ctx.config.responseModelFileNameCasing)}.ts`);
+        var _a;
+        return resolve(ctx.config.outputDir, ctx.config.responseModelsDir, `${toCasing(ctx.service.name, (_a = ctx.config.responseModelFileNameCasing) !== null && _a !== void 0 ? _a : ctx.config.fileNameCasing)}.ts`);
     }
     hasEndpointParams(ctx, endpoint) {
         return endpoint.parameters.length > 0 || endpoint.requestBody !== undefined;
     }
     getSchemaType(ctx, schema, fallback) {
-        const output = schema && ctx.input.models[schema.id];
+        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/lib/generators/services/angular-services/angular-services-generator.js

@@ -15,8 +15,10 @@ export class TypeScriptAngularServicesGenerator extends OpenApiServicesGeneratio
     }
     initResult() {
         return {
-            services: {},
-            indexFiles: { services: undefined, responseModels: undefined },
+            typescript: {
+                services: {},
+                indexFiles: { services: undefined, responseModels: undefined },
+            },
         };
     }
     buildContext(context, config) {
@@ -28,20 +30,23 @@ export class TypeScriptAngularServicesGenerator extends OpenApiServicesGeneratio
     onGenerate(ctx) {
         const output = super.onGenerate(ctx);
         this.generateUtilsFiles(ctx);
-        output.indexFiles = this.generateIndexFiles(ctx);
+        output.typescript.indexFiles = this.generateIndexFiles(ctx);
         return output;
     }
     generateService(ctx, service) {
         const clientGenerator = this._clientGeneratorFactory.create();
-        return clientGenerator.generate(Object.assign(Object.assign({}, ctx), { service }));
+        return clientGenerator.generate({
+            ...ctx,
+            service,
+        });
     }
     addServiceResult(ctx, service, result) {
-        ctx.output.services[service.id] = result;
+        ctx.output.typescript.services[service.id] = result;
     }
     // #region Utils
     generateUtilsFiles(ctx) {
         const sourceDir = resolve(dirname(require.resolve('@goast/typescript')), '../assets/client/angular');
-        const targetDir = resolve(ctx.config.outputDir, ctx.config.utilsDirPath);
+        const targetDir = resolve(ctx.config.outputDir, ctx.config.utilsDir);
         ensureDirSync(targetDir);
         this.copyFile('Request Builder', sourceDir, targetDir, 'request-builder.ts');
         this.copyFile('Angular Service Utils', sourceDir, targetDir, 'angular-service.utils.ts');
@@ -146,7 +151,7 @@ export class TypeScriptAngularServicesGenerator extends OpenApiServicesGeneratio
                     'return ',
                     ts.tuple([
                         (b) => b.append('config ? { provide: ', ctx.refs.apiConfiguration(), ', useValue: config } : ', ctx.refs.apiConfiguration()),
-                        ...Object.values(ctx.output.services).map((x) => ts.reference(x.component, x.filePath)),
+                        ...Object.values(ctx.output.typescript.services).map((x) => ts.reference(x.component, x.filePath)),
                     ]),
                     ';',
                 ]),
@@ -185,20 +190,20 @@ export class TypeScriptAngularServicesGenerator extends OpenApiServicesGeneratio
             ctx.config.provideKind === 'provide-fn'
                 ? ts.export(ctx.refs.provide.refName, ctx.refs.provide.moduleNameOrfilePath)
                 : null,
-            ...Object.values(ctx.output.services).map((x) => ts.export(x.component, x.filePath)),
+            ...Object.values(ctx.output.typescript.services).map((x) => ts.export(x.component, x.filePath)),
         ]);
     }
     getResponseModelsIndexFileContent(ctx) {
-        return appendValueGroup(Object.values(ctx.output.services)
+        return appendValueGroup(Object.values(ctx.output.typescript.services)
             .flatMap((x) => Object.values(x.responseModels))
             .map((x) => ts.export(x.component, x.filePath)));
     }
     getServicesIndexFilePath(ctx) {
-        return ctx.config.servicesIndexFilePath ? resolve(ctx.config.outputDir, ctx.config.servicesIndexFilePath) : null;
+        return ctx.config.servicesIndexFile ? resolve(ctx.config.outputDir, ctx.config.servicesIndexFile) : null;
     }
     getResponseModelsIndexFilePath(ctx) {
-        return ctx.config.responseModelsIndexFilePath
-            ? resolve(ctx.config.outputDir, ctx.config.responseModelsIndexFilePath)
+        return ctx.config.responseModelsIndexFile
+            ? resolve(ctx.config.outputDir, ctx.config.responseModelsIndexFile)
             : null;
     }
     // #endregion

package/esm/lib/generators/services/angular-services/models.js

@@ -1,10 +1,26 @@
 import { defaultTypeScriptGeneratorConfig } from '../../../config';
-export const defaultTypeScriptAngularServicesGeneratorConfig = Object.assign(Object.assign({}, defaultTypeScriptGeneratorConfig), { fileNameCasing: { casing: 'kebab', suffix: '.service' }, responseModelFileNameCasing: { casing: 'kebab', suffix: '-responses.model' }, provideKind: 'provide-fn', strictResponseTypes: true, defaultStatusCodeResponseTypes: {
+export const defaultTypeScriptAngularServicesGeneratorConfig = {
+    ...defaultTypeScriptGeneratorConfig,
+    provideKind: 'provide-fn',
+    domainName: undefined,
+    strictResponseTypes: true,
+    defaultStatusCodeResponseTypes: {
         401: null,
         403: null,
         500: null,
-    }, possibleStatusCodes: [
+    },
+    possibleStatusCodes: [
         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,
-    ], servicesDirPath: 'services', servicesIndexFilePath: 'services.ts', responseModelsDirPath: 'models/responses', responseModelsIndexFilePath: 'responses.ts', utilsDirPath: 'utils' });
+    ],
+    rootUrl: undefined,
+    pathModifier: undefined,
+    servicesDir: 'services',
+    serviceFileNameCasing: { casing: 'kebab', suffix: '.service' },
+    servicesIndexFile: 'services.ts',
+    responseModelsDir: 'models/responses',
+    responseModelFileNameCasing: { casing: 'kebab', suffix: '-responses.model' },
+    responseModelsIndexFile: 'responses.ts',
+    utilsDir: 'utils',
+};

package/esm/lib/generators/services/angular-services/refs.js

@@ -4,7 +4,7 @@ import { ts } from '../../../ast';
 // See packages/typescript/assets/client/angular for reference
 export function getReferenceFactories(options) {
     var _a, _b;
-    const utilsDirPath = resolve(options.outputDir, options.utilsDirPath);
+    const utilsDirPath = resolve(options.outputDir, options.utilsDir);
     return {
         // angular-service.utils.ts
         abortablePromise: ts.reference.genericFactory('AbortablePromise', join(utilsDirPath, 'angular-service.utils.ts')),

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

@@ -94,22 +94,23 @@ export class DefaultTypeScriptEasyNetworkStubGenerator extends TypeScriptFileGen
             ],
             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);`}
-              }`}
+                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) {
-        return resolve(ctx.config.outputDir, ctx.config.stubsDirPath, `${toCasing(ctx.service.name, ctx.config.fileNameCasing)}.ts`);
+        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);
@@ -134,7 +135,7 @@ export class DefaultTypeScriptEasyNetworkStubGenerator extends TypeScriptFileGen
         let path = endpoint.path;
         let isFirstQueryParam = true;
         for (const param of endpoint.parameters) {
-            let type = ((_b = (param.schema && ((_a = ctx.input.models[param.schema.id]) === null || _a === void 0 ? void 0 : _a.component))) !== null && _b !== void 0 ? _b : 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 : ts.refs.unknown.name).replace(/^readonly /, '');
             const arrayMatch = /^\((.*)\)\[\]$/.exec(type);
             if (arrayMatch !== null) {
                 type = `${arrayMatch[1]}[]`;
@@ -161,7 +162,7 @@ export class DefaultTypeScriptEasyNetworkStubGenerator extends TypeScriptFileGen
         ]);
     }
     getSchemaType(ctx, schema, fallback) {
-        const output = schema && ctx.input.models[schema.id];
+        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/lib/generators/services/easy-network-stub/easy-network-stubs-generator.js

@@ -13,8 +13,10 @@ export class TypeScriptEasyNetworkStubsGenerator extends OpenApiServicesGenerati
     }
     initResult() {
         return {
-            stubs: {},
-            indexFiles: { stubs: undefined },
+            typescript: {
+                stubs: {},
+                indexFiles: { stubs: undefined },
+            },
         };
     }
     buildContext(context, config) {
@@ -26,19 +28,22 @@ export class TypeScriptEasyNetworkStubsGenerator extends OpenApiServicesGenerati
     onGenerate(ctx) {
         const output = super.onGenerate(ctx);
         this.generateUtilsFiles(ctx);
-        output.indexFiles = this.generateIndexFiles(ctx);
+        output.typescript.indexFiles = this.generateIndexFiles(ctx);
         return output;
     }
     generateService(ctx, service) {
         const clientGenerator = this._generatorFactory.create();
-        return clientGenerator.generate(Object.assign(Object.assign({}, ctx), { service }));
+        return clientGenerator.generate({
+            ...ctx,
+            service,
+        });
     }
     addServiceResult(ctx, service, result) {
-        ctx.output.stubs[service.id] = result;
+        ctx.output.typescript.stubs[service.id] = result;
     }
     generateUtilsFiles(ctx) {
         const sourceDir = resolve(dirname(require.resolve('@goast/typescript')), '../assets/stubs/easy-network-stub');
-        const targetDir = resolve(ctx.config.outputDir, ctx.config.utilsDirPath);
+        const targetDir = resolve(ctx.config.outputDir, ctx.config.utilsDir);
         ensureDirSync(targetDir);
         this.copyFile('easy-network-stub utils', sourceDir, targetDir, 'easy-network-stub.utils.ts');
     }
@@ -56,7 +61,7 @@ export class TypeScriptEasyNetworkStubsGenerator extends OpenApiServicesGenerati
     }
     getStubsIndexFileContent(ctx) {
         return appendValueGroup([
-            appendValueGroup(Object.values(ctx.output.stubs).map((x) => ts.export(x.component, x.filePath))),
+            appendValueGroup(Object.values(ctx.output.typescript.stubs).map((x) => ts.export(x.component, x.filePath))),
             this.getStubsClass(ctx),
         ], '\n');
     }
@@ -71,7 +76,7 @@ export class TypeScriptEasyNetworkStubsGenerator extends OpenApiServicesGenerati
                     readonly: true,
                     type: ctx.refs.easyNetworkStubWrapper(),
                 }),
-                ...Object.entries(ctx.output.stubs).map(([id, x]) => ts.property(toCasing(serviceNames[id], fieldCasing), {
+                ...Object.entries(ctx.output.typescript.stubs).map(([id, x]) => ts.property(toCasing(serviceNames[id], fieldCasing), {
                     accessModifier: 'private',
                     optional: true,
                     type: ctx.refs.easyNetworkStubGroup([ts.reference(x.component, x.filePath), 'this']),
@@ -93,7 +98,7 @@ export class TypeScriptEasyNetworkStubsGenerator extends OpenApiServicesGenerati
                         body: appendValueGroup(['return this._stubWrapper.requests;'], '\n'),
                     }),
                 }),
-                ...Object.entries(ctx.output.stubs).map(([id, x]) => ts.property(toCasing(serviceNames[id], ctx.config.propertyNameCasing), {
+                ...Object.entries(ctx.output.typescript.stubs).map(([id, x]) => ts.property(toCasing(serviceNames[id], ctx.config.propertyNameCasing), {
                     accessModifier: 'public',
                     type: ctx.refs.easyNetworkStubGroup([ts.reference(x.component, x.filePath), 'this']),
                     get: ts.property.getter({
@@ -106,7 +111,7 @@ export class TypeScriptEasyNetworkStubsGenerator extends OpenApiServicesGenerati
                     accessModifier: 'public',
                     returnType: 'this',
                     body: appendValueGroup([
-                        ...Object.keys(ctx.output.stubs).map((id) => `this.${toCasing(serviceNames[id], fieldCasing)}?.reset();`),
+                        ...Object.keys(ctx.output.typescript.stubs).map((id) => `this.${toCasing(serviceNames[id], fieldCasing)}?.reset();`),
                         'return this;',
                     ], '\n'),
                 }),
@@ -114,7 +119,7 @@ export class TypeScriptEasyNetworkStubsGenerator extends OpenApiServicesGenerati
         });
     }
     getStubsIndexFilePath(ctx) {
-        return ctx.config.stubsIndexFilePath ? resolve(ctx.config.outputDir, ctx.config.stubsIndexFilePath) : null;
+        return ctx.config.stubsIndexFile ? resolve(ctx.config.outputDir, ctx.config.stubsIndexFile) : null;
     }
     getStubsClassName(ctx) {
         var _a;

package/esm/lib/generators/services/easy-network-stub/models.js

@@ -1,7 +1,15 @@
 import { ts } from '../../../ast';
 import { defaultTypeScriptGeneratorConfig } from '../../../config';
-export const defaultTypeScriptEasyNetworkStubsGeneratorConfig = Object.assign(Object.assign({}, defaultTypeScriptGeneratorConfig), { fileNameCasing: { casing: 'kebab', suffix: '.stubs' }, defaultStatusCodeResponseTypes: {
+export const defaultTypeScriptEasyNetworkStubsGeneratorConfig = {
+    ...defaultTypeScriptGeneratorConfig,
+    domainName: undefined,
+    defaultStatusCodeResponseTypes: {
         401: ts.refs.never(),
         403: ts.refs.never(),
         500: ts.refs.never(),
-    }, stubsDirPath: 'stubs', stubsIndexFilePath: 'stubs.ts', utilsDirPath: 'utils' });
+    },
+    stubsDir: 'stubs',
+    stubFileNameCasing: { casing: 'kebab', suffix: '.stubs' },
+    stubsIndexFile: 'stubs.ts',
+    utilsDir: 'utils',
+};

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

@@ -2,7 +2,7 @@ import { join, resolve } from 'path';
 import { ts } from '../../../ast';
 // See packages/typescript/assets/stubs/easy-network-stub for reference
 export function getReferenceFactories(options) {
-    const utilsDirPath = resolve(options.outputDir, options.utilsDirPath);
+    const utilsDirPath = resolve(options.outputDir, options.utilsDir);
     const easyNetworkStubUtilsPath = join(utilsDirPath, 'easy-network-stub.utils.ts');
     return {
         // easy-network-stub.utils.ts