use specified paths

Author: annacb40

src/templates/exportService.hbs

@@ -2,7 +2,7 @@
 
 {{#if imports}}
 {{#each imports}}
-import type { {{{this}}} } from '../models/{{{this}}}';
+import type { {{{this}}} } from '{{{@root.modelsPath}}}/{{{this}}}';
 {{/each}}
 {{/if}}
 import { BaseAPI, globalImportUrl, AxiosPromise } from '../core/request';

src/templates/index.hbs

@@ -1,22 +1,22 @@
 {{>header}}
 {{#if @root.exportCore}}
 
-export { ApiError } from './core/ApiError';
-export { OpenAPI } from './core/OpenAPI';
-export { BaseAPI } from './core/request';
+export { ApiError } from '{{{@root.corePath}}}/ApiError';
+export { OpenAPI } from '{{{@root.corePath}}}/OpenAPI';
+export { BaseAPI } from '{{{@root.corePath}}}/request';
 {{/if}}
 {{#if @root.exportModels}}
 {{#if models}}
 
 {{#each models}}
 {{#if @root.useUnionTypes}}
-export type { {{{name}}} } from './models/{{{name}}}';
+export type { {{{name}}} } from '{{{@root.modelsPath}}}/{{{name}}}';
 {{else if enum}}
-export { {{{name}}} } from './models/{{{name}}}';
+export { {{{name}}} } from '{{{@root.modelsPath}}}/{{{name}}}';
 {{else if enums}}
-export { {{{name}}} } from './models/{{{name}}}';
+export { {{{name}}} } from '{{{@root.modelsPath}}}/{{{name}}}';
 {{else}}
-export type { {{{name}}} } from './models/{{{name}}}';
+export type { {{{name}}} } from '{{{@root.modelsPath}}}/{{{name}}}';
 {{/if}}
 {{/each}}
 {{/if}}
@@ -25,15 +25,15 @@ export type { {{{name}}} } from './models/{{{name}}}';
 {{#if models}}
 
 {{#each models}}
-export { ${{{name}}} } from './schemas/${{{name}}}';
+export { ${{{name}}} } from '{{{@root.schemasPath}}}/${{{name}}}';
 {{/each}}
 {{/if}}
 {{/if}}
 {{#if @root.exportServices}}
 {{#if services}}
 
 {{#each services}}
-export * from './services/{{{name}}}';
+export * from '{{{@root.servicesPath}}}/{{{name}}}';
 {{/each}}
 {{/if}}
 {{/if}}

src/utils/writeClient.ts

@@ -16,6 +16,10 @@ import { writeClientServices } from './writeClientServices';
  * @param client Client object with all the models, services, etc.
  * @param templates Templates wrapper with all loaded Handlebars templates
  * @param output The relative ___location of the output directory
+ * @param outputCore The relative ___location of the core output directory
+ * @param outputModels The relative ___location of the models output directory
+ * @param outputSchemas The relative ___location of the schemas output directory
+ * @param outputServices The relative ___location of the services output directory
  * @param httpClient The selected httpClient (fetch, xhr or node)
  * @param useOptions Use options or arguments functions
  * @param useUnionTypes Use union types instead of enums
@@ -29,6 +33,10 @@ export async function writeClient(
     client: Client,
     templates: Templates,
     output: string,
+    outputCore: string,
+    outputModels: string,
+    outputSchemas: string,
+    outputServices: string,
     httpClient: HttpClient,
     useOptions: boolean,
     useUnionTypes: boolean,
@@ -39,10 +47,10 @@ export async function writeClient(
     request?: string
 ): Promise<void> {
     const outputPath = resolve(process.cwd(), output);
-    const outputPathCore = resolve(outputPath, 'core');
-    const outputPathModels = resolve(outputPath, 'models');
-    const outputPathSchemas = resolve(outputPath, 'schemas');
-    const outputPathServices = resolve(outputPath, 'services');
+    const outputPathCore = resolve(process.cwd(), outputCore);
+    const outputPathModels = resolve(process.cwd(), outputModels);
+    const outputPathSchemas = resolve(process.cwd(), outputSchemas);
+    const outputPathServices = resolve(process.cwd(), outputServices);
 
     if (!isSubDirectory(process.cwd(), output)) {
         throw new Error(`Output folder is not a subdirectory of the current working directory`);
@@ -57,7 +65,7 @@ export async function writeClient(
     if (exportServices) {
         await rmdir(outputPathServices);
         await mkdir(outputPathServices);
-        await writeClientServices(client.services, templates, outputPathServices, httpClient, useUnionTypes, useOptions);
+        await writeClientServices(client.services, templates, outputPathServices, outputPathModels, httpClient, useUnionTypes, useOptions);
     }
 
     if (exportSchemas) {
@@ -74,6 +82,19 @@ export async function writeClient(
 
     if (exportCore || exportServices || exportSchemas || exportModels) {
         await mkdir(outputPath);
-        await writeClientIndex(client, templates, outputPath, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas);
+        await writeClientIndex(
+            client,
+            templates,
+            outputPath,
+            outputPathCore,
+            outputPathModels,
+            outputPathSchemas,
+            outputPathServices,
+            useUnionTypes,
+            exportCore,
+            exportServices,
+            exportModels,
+            exportSchemas
+        );
     }
 }

src/utils/writeClientIndex.spec.ts

@@ -30,7 +30,7 @@ describe('writeClientIndex', () => {
             },
         };
 
-        await writeClientIndex(client, templates, '/', true, true, true, true, true);
+        await writeClientIndex(client, templates, '/', '/core', '/models', '/schemas', '/services', true, true, true, true, true);
 
         expect(writeFile).toBeCalledWith('/index.ts', 'index');
     });

src/utils/writeClientIndex.ts

@@ -1,4 +1,4 @@
-import { resolve } from 'path';
+import { resolve, relative } from 'path';
 
 import type { Client } from '../client/interfaces/Client';
 import { writeFile } from './fileSystem';
@@ -23,6 +23,10 @@ export async function writeClientIndex(
     client: Client,
     templates: Templates,
     outputPath: string,
+    corePath: string,
+    modelsPath: string,
+    schemasPath: string,
+    servicesPath: string,
     useUnionTypes: boolean,
     exportCore: boolean,
     exportServices: boolean,
@@ -41,6 +45,10 @@ export async function writeClientIndex(
             version: client.version,
             models: sortModelsByName(client.models),
             services: sortServicesByName(client.services),
+            modelsPath: relative(outputPath, modelsPath),
+            schemasPath: relative(outputPath, schemasPath),
+            servicesPath: relative(outputPath, servicesPath),
+            corePath: relative(outputPath, corePath),
         })
     );
 }

src/utils/writeClientServices.spec.ts

@@ -32,8 +32,9 @@ describe('writeClientServices', () => {
             },
         };
 
-        await writeClientServices(services, templates, '/', HttpClient.FETCH, false, false);
+        await writeClientServices(services, templates, '/', '../models', HttpClient.FETCH, false, false);
 
         expect(writeFile).toBeCalledWith('/MyService.ts', 'service');
+        expect(writeFile).toBeCalledWith('/index.ts', 'index');
     });
 });

src/utils/writeClientServices.ts

@@ -17,12 +17,21 @@ const VERSION_TEMPLATE_STRING = 'OpenAPI.VERSION';
  * @param useUnionTypes Use union types instead of enums
  * @param useOptions Use options or arguments functions
  */
-export async function writeClientServices(services: Service[], templates: Templates, outputPath: string, httpClient: HttpClient, useUnionTypes: boolean, useOptions: boolean): Promise<void> {
+export async function writeClientServices(
+    services: Service[],
+    templates: Templates,
+    outputPath: string,
+    modelsOutputPath: string,
+    httpClient: HttpClient,
+    useUnionTypes: boolean,
+    useOptions: boolean
+): Promise<void> {
     for (const service of services) {
         const file = resolve(outputPath, `${service.name}.ts`);
         const useVersion = service.operations.some(operation => operation.path.includes(VERSION_TEMPLATE_STRING));
         const templateResult = templates.exports.service({
             ...service,
+            modelsPath: relative(outputPath, modelsOutputPath),
             httpClient,
             useUnionTypes,
             useVersion,