nango 0.40.0 → 0.40.1

package/dist/sync.unit.cli-test.js

@@ -1,6 +1,6 @@
-import { expect, describe, it, afterEach, beforeAll } from 'vitest';
+import { expect, describe, it, beforeAll } from 'vitest';
 import path from 'path';
-import * as fs from 'fs';
+import fs from 'fs';
 import yaml from 'js-yaml';
 import { SyncConfigType } from '@nangohq/shared';
 import { init, generate } from './cli.js';
@@ -10,37 +10,41 @@ import { compileAllFiles, compileSingleFile, getFileToCompile } from './services
 import { getNangoRootPath } from './utils.js';
 import parserService from './services/parser.service.js';
 import { copyDirectoryAndContents } from './tests/helpers.js';
+function getTestDirectory(name) {
+    const dir = `/tmp/${name}/nango-integrations/`;
+    fs.mkdirSync(dir, { recursive: true });
+    fs.rmSync(dir, { recursive: true, force: true });
+    return dir;
+}
 describe('generate function tests', () => {
-    const testDirectory = './nango-integrations';
     const fixturesPath = './packages/cli/fixtures';
     beforeAll(async () => {
         if (!fs.existsSync('./packages/cli/dist/nango-sync.d.ts')) {
             await fs.promises.writeFile('./packages/cli/dist/nango-sync.d.ts', '', 'utf8');
         }
     });
-    afterEach(async () => {
-        await fs.promises.rm(testDirectory, { recursive: true, force: true });
-    });
     it('should init the expected files in the nango-integrations directory', async () => {
-        await init();
-        expect(fs.existsSync(`./${testDirectory}/demo-github-integration/syncs/${exampleSyncName}.ts`)).toBe(true);
-        expect(fs.existsSync(`./${testDirectory}/.env`)).toBe(true);
-        expect(fs.existsSync(`./${testDirectory}/nango.yaml`)).toBe(true);
+        const dir = getTestDirectory('init');
+        await init({ absolutePath: path.resolve(dir, '..'), debug: false });
+        expect(fs.existsSync(`${dir}/demo-github-integration/syncs/${exampleSyncName}.ts`)).toBe(true);
+        expect(fs.existsSync(`${dir}/.env`)).toBe(true);
+        expect(fs.existsSync(`${dir}/nango.yaml`)).toBe(true);
     });
     it('should not overwrite existing integration files', async () => {
-        await fs.promises.rm(testDirectory, { recursive: true, force: true });
-        await fs.promises.mkdir(testDirectory, { recursive: true });
-        await fs.promises.writeFile(`${testDirectory}/${exampleSyncName}.ts`, 'dummy fake content', 'utf8');
+        const dir = getTestDirectory('overwrite');
+        await init({ absolutePath: dir, debug: false });
+        await fs.promises.writeFile(`${dir}/${exampleSyncName}.ts`, 'dummy fake content', 'utf8');
         const dummyContent = 'This is dummy content. Do not overwrite!';
-        const exampleFilePath = path.join(testDirectory, `${exampleSyncName}.ts`);
+        const exampleFilePath = path.join(dir, `${exampleSyncName}.ts`);
         await fs.promises.writeFile(exampleFilePath, dummyContent, 'utf8');
-        await init();
+        await init({ absolutePath: dir });
         expect(fs.existsSync(exampleFilePath)).toBe(true);
         const fileContentAfterInit = await fs.promises.readFile(exampleFilePath, 'utf8');
         expect(fileContentAfterInit).toBe(dummyContent);
     });
     it('should generate a different sync correctly', async () => {
-        await init();
+        const dir = getTestDirectory('generate');
+        await init({ absolutePath: dir });
         const data = {
             integrations: {
                 'demo-github-integration': {
@@ -68,12 +72,13 @@ describe('generate function tests', () => {
             }
         };
         const yamlData = yaml.dump(data);
-        await fs.promises.writeFile(`${testDirectory}/nango.yaml`, yamlData, 'utf8');
-        await generate(false, true);
-        expect(fs.existsSync(`${testDirectory}/some-other-sync.ts`)).toBe(true);
+        await fs.promises.writeFile(`${dir}/nango.yaml`, yamlData, 'utf8');
+        await generate({ debug: false, fullPath: dir });
+        expect(fs.existsSync(`${dir}/some-other-sync.ts`)).toBe(true);
     });
     it('should support a single model return in v1 format', async () => {
-        await init();
+        const dir = getTestDirectory('single-model-v1');
+        await init({ absolutePath: dir });
         const data = {
             integrations: {
                 'demo-github-integration': {
@@ -101,20 +106,20 @@ describe('generate function tests', () => {
             }
         };
         const yamlData = yaml.dump(data);
-        await fs.promises.writeFile(`${testDirectory}/nango.yaml`, yamlData, 'utf8');
-        await generate(false, true);
-        expect(fs.existsSync(`${testDirectory}/single-model-return.ts`)).toBe(true);
+        await fs.promises.writeFile(`${dir}/nango.yaml`, yamlData, 'utf8');
+        await generate({ debug: false, fullPath: dir });
+        expect(fs.existsSync(`${dir}/single-model-return.ts`)).toBe(true);
     });
     it('should support a single model return in v2 format', async () => {
-        await init();
+        const dir = getTestDirectory('single-model-v2');
+        await init({ absolutePath: dir });
         const data = {
             integrations: {
                 'demo-github-integration': {
                     syncs: {
                         'single-model-return': {
-                            type: 'sync',
                             runs: 'every half hour',
-                            endpoint: '/issues',
+                            endpoint: 'GET /issues',
                             output: 'GithubIssue'
                         }
                     }
@@ -137,12 +142,13 @@ describe('generate function tests', () => {
             }
         };
         const yamlData = yaml.dump(data);
-        await fs.promises.writeFile(`${testDirectory}/nango.yaml`, yamlData, 'utf8');
-        await generate(false, true);
-        expect(fs.existsSync(`${testDirectory}/demo-github-integration/syncs/single-model-return.ts`)).toBe(true);
+        await fs.promises.writeFile(`${dir}/nango.yaml`, yamlData, 'utf8');
+        await generate({ debug: false, fullPath: dir });
+        expect(fs.existsSync(`${dir}/demo-github-integration/syncs/single-model-return.ts`)).toBe(true);
     });
     it('should not create a file if endpoint is missing from a v2 config', async () => {
-        await init();
+        const dir = getTestDirectory('endpoint-missing-v2');
+        await init({ absolutePath: dir });
         const data = {
             integrations: {
                 'demo-github-integration': {
@@ -172,17 +178,17 @@ describe('generate function tests', () => {
             }
         };
         const yamlData = yaml.dump(data);
-        await fs.promises.writeFile(`${testDirectory}/nango.yaml`, yamlData, 'utf8');
-        expect(fs.existsSync(`${testDirectory}/demo-github-integration/syncs/single-model-return.ts`)).toBe(false);
+        await fs.promises.writeFile(`${dir}/nango.yaml`, yamlData, 'utf8');
+        expect(fs.existsSync(`${dir}/demo-github-integration/syncs/single-model-return.ts`)).toBe(false);
     });
     it('should generate missing from a v2 config', async () => {
-        await init();
+        const dir = getTestDirectory('v2-incremental-compile');
+        await init({ absolutePath: dir });
         const data = {
             integrations: {
                 'demo-github-integration': {
                     syncs: {
                         'single-model-issue-output': {
-                            type: 'sync',
                             runs: 'every half hour',
                             endpoint: 'GET /tickets/issue',
                             output: 'GithubIssue'
@@ -207,12 +213,13 @@ describe('generate function tests', () => {
             }
         };
         const yamlData = yaml.dump(data);
-        await fs.promises.writeFile(`${testDirectory}/nango.yaml`, yamlData, 'utf8');
-        await generate(false, true);
-        expect(fs.existsSync(`${testDirectory}/demo-github-integration/syncs/single-model-issue-output.ts`)).toBe(true);
+        await fs.promises.writeFile(`${dir}/nango.yaml`, yamlData, 'utf8');
+        await generate({ debug: false, fullPath: dir });
+        expect(fs.existsSync(`${dir}/demo-github-integration/syncs/single-model-issue-output.ts`)).toBe(true);
     });
     it('should throw an error if a model is missing an id that is actively used', async () => {
-        await init();
+        const dir = getTestDirectory('missing-id');
+        await init({ absolutePath: dir });
         const data = {
             integrations: {
                 'demo-github-integration': {
@@ -239,11 +246,12 @@ describe('generate function tests', () => {
             }
         };
         const yamlData = yaml.dump(data);
-        await fs.promises.writeFile(`${testDirectory}/nango.yaml`, yamlData, 'utf8');
-        await expect(generate(false, true)).rejects.toThrow(`Model "GithubIssue" doesn't have an id field. This is required to be able to uniquely identify the data record.`);
+        await fs.promises.writeFile(`${dir}/nango.yaml`, yamlData, 'utf8');
+        await expect(generate({ debug: false, fullPath: dir })).rejects.toThrow(`Model "GithubIssue" doesn't have an id field. This is required to be able to uniquely identify the data record.`);
     });
-    it('should allow models to end in an s', async () => {
-        await init();
+    it('should allow models to end with an "s"', async () => {
+        const dir = getTestDirectory('model-with-an-s');
+        await init({ absolutePath: dir });
         const data = {
             integrations: {
                 'demo-github-integration': {
@@ -271,13 +279,14 @@ describe('generate function tests', () => {
             }
         };
         const yamlData = yaml.dump(data);
-        await fs.promises.writeFile(`${testDirectory}/nango.yaml`, yamlData, 'utf8');
-        await generate(false, true);
-        const modelsFile = await fs.promises.readFile(`${testDirectory}/models.ts`, 'utf8');
+        await fs.promises.writeFile(`${dir}/nango.yaml`, yamlData, 'utf8');
+        await generate({ debug: false, fullPath: dir });
+        const modelsFile = await fs.promises.readFile(`${dir}/models.ts`, 'utf8');
         expect(modelsFile).toContain('export interface GithubIssues');
     });
     it('should not throw an error if a model is missing an id for an action', async () => {
-        await init();
+        const dir = getTestDirectory('missing-id-action');
+        await init({ absolutePath: dir });
         const data = {
             integrations: {
                 'demo-github-integration': {
@@ -303,11 +312,12 @@ describe('generate function tests', () => {
             }
         };
         const yamlData = yaml.dump(data);
-        await fs.promises.writeFile(`${testDirectory}/nango.yaml`, yamlData, 'utf8');
-        await generate(false, true);
+        await fs.promises.writeFile(`${dir}/nango.yaml`, yamlData, 'utf8');
+        await generate({ debug: false, fullPath: dir });
     });
     it('should allow javascript primitives as a return type with no model', async () => {
-        await init();
+        const dir = getTestDirectory('model-returns-primitives');
+        await init({ absolutePath: dir });
         const data = {
             integrations: {
                 'demo-github-integration': {
@@ -323,11 +333,12 @@ describe('generate function tests', () => {
             }
         };
         const yamlData = yaml.dump(data);
-        await fs.promises.writeFile(`${testDirectory}/nango.yaml`, yamlData, 'utf8');
-        await generate(false, true);
+        await fs.promises.writeFile(`${dir}/nango.yaml`, yamlData, 'utf8');
+        await generate({ debug: false, fullPath: dir });
     });
     it('should catch non javascript primitives in the config', async () => {
-        await init();
+        const dir = getTestDirectory('model-returns-invalid-primitives');
+        await init({ absolutePath: dir });
         const data = {
             integrations: {
                 'demo-github-integration': {
@@ -343,8 +354,8 @@ describe('generate function tests', () => {
             }
         };
         const yamlData = yaml.dump(data);
-        await fs.promises.writeFile(`${testDirectory}/nango.yaml`, yamlData, 'utf8');
-        expect(await generate(false, true)).toBeUndefined();
+        await fs.promises.writeFile(`${dir}/nango.yaml`, yamlData, 'utf8');
+        expect(await generate({ debug: false, fullPath: dir })).toBeUndefined();
     });
     it('should not complain of try catch not being awaited', () => {
         const awaiting = parserService.callsAreUsedCorrectly(`${fixturesPath}/sync.ts`, SyncConfigType.SYNC, ['GithubIssue']);
@@ -392,14 +403,16 @@ describe('generate function tests', () => {
         expect(config).toMatchSnapshot();
     });
     it('v1 - should complain about commas at the end of declared types', async () => {
-        await fs.promises.mkdir(testDirectory, { recursive: true });
-        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v1/no-commas/nango.yaml`, `${testDirectory}/nango.yaml`);
-        expect(generate(false, true)).rejects.toThrow(`Field "integer," in the model GithubIssue ends with a comma or semicolon which is not allowed.`);
+        const dir = getTestDirectory('v1-no-commas');
+        await init({ absolutePath: dir });
+        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v1/no-commas/nango.yaml`, `${dir}/nango.yaml`);
+        await expect(generate({ debug: false, fullPath: dir })).rejects.toThrow(`Field "integer," in the model GithubIssue ends with a comma or semicolon which is not allowed.`);
     });
     it('v1 - should complain about semi colons at the end of declared types', async () => {
-        await fs.promises.mkdir(testDirectory, { recursive: true });
-        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v1/no-semi-colons/nango.yaml`, `${testDirectory}/nango.yaml`);
-        expect(generate(false, true)).rejects.toThrow(`Field "integer;" in the model GithubIssue ends with a comma or semicolon which is not allowed.`);
+        const dir = getTestDirectory('v1-no-semi-colons');
+        await init({ absolutePath: dir });
+        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v1/no-semi-colons/nango.yaml`, `${dir}/nango.yaml`);
+        await expect(generate({ debug: false, fullPath: dir })).rejects.toThrow(`Field "integer;" in the model GithubIssue ends with a comma or semicolon which is not allowed.`);
     });
     it('should parse a nango.yaml file that is version 2 as expected', async () => {
         const { response: config } = await configService.load(path.resolve(__dirname, `../fixtures/nango-yaml/v2/valid`));
@@ -410,7 +423,7 @@ describe('generate function tests', () => {
         const { response: config, error } = await configService.load(path.resolve(__dirname, `../fixtures/nango-yaml/v2/invalid.1`));
         expect(config).toBeNull();
         expect(error).toBeDefined();
-        expect(error?.message).toEqual('Problem validating the nango.yaml file.');
+        expect(error?.message).toMatchSnapshot();
     });
     it('should throw a validation error on a nango.yaml file that is not formatted correctly -- webhook subscriptions are not allowed in an action', async () => {
         const { response: config, error } = await configService.load(path.resolve(__dirname, `../fixtures/nango-yaml/v2/invalid.2`));
@@ -419,32 +432,36 @@ describe('generate function tests', () => {
         expect(error?.message).toEqual('Problem validating the nango.yaml file.');
     });
     it('should correctly interpret a string union literal type', async () => {
-        await fs.promises.mkdir(testDirectory, { recursive: true });
-        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/string-literal/nango.yaml`, `${testDirectory}/nango.yaml`);
-        expect(generate(false, true));
-        const modelsFile = await fs.promises.readFile(`${testDirectory}/models.ts`, 'utf8');
+        const dir = getTestDirectory('validation-string-union');
+        await init({ absolutePath: dir });
+        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/string-literal/nango.yaml`, `${dir}/nango.yaml`);
+        await expect(generate({ debug: false, fullPath: dir })).resolves.toBeUndefined();
+        const modelsFile = await fs.promises.readFile(`${dir}/models.ts`, 'utf8');
         expect(modelsFile).toContain(`gender: 'male' | 'female';`);
     });
     it('should correctly interpret a union literal type with a string and a primitive', async () => {
-        await fs.promises.mkdir(testDirectory, { recursive: true });
-        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/mixed-literal/nango.yaml`, `${testDirectory}/nango.yaml`);
-        expect(generate(false, true));
-        const modelsFile = await fs.promises.readFile(`${testDirectory}/models.ts`, 'utf8');
+        const dir = getTestDirectory('validation-string-primitve');
+        await init({ absolutePath: dir });
+        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/mixed-literal/nango.yaml`, `${dir}/nango.yaml`);
+        await expect(generate({ debug: false, fullPath: dir })).resolves.toBeUndefined();
+        const modelsFile = await fs.promises.readFile(`${dir}/models.ts`, 'utf8');
         expect(modelsFile).toContain(`gender: 'male' | null;`);
     });
     it('should correctly interpret a union literal type with a string and a model', async () => {
-        await fs.promises.mkdir(testDirectory, { recursive: true });
-        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/mixed-literal-model/nango.yaml`, `${testDirectory}/nango.yaml`);
-        expect(generate(false, true));
-        const modelsFile = await fs.promises.readFile(`${testDirectory}/models.ts`, 'utf8');
+        const dir = getTestDirectory('validation-string-model');
+        await init({ absolutePath: dir });
+        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/mixed-literal-model/nango.yaml`, `${dir}/nango.yaml`);
+        await expect(generate({ debug: false, fullPath: dir })).resolves.toBeUndefined();
+        const modelsFile = await fs.promises.readFile(`${dir}/models.ts`, 'utf8');
         expect(modelsFile).toContain(`gender: 'male' | Other`);
         expect(modelsFile).toContain(`user: User | Account`);
     });
     it('should correctly interpret a union types, array types, and record types', async () => {
-        await fs.promises.mkdir(testDirectory, { recursive: true });
-        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/mixed-types/nango.yaml`, `${testDirectory}/nango.yaml`);
-        expect(generate(false, true));
-        const modelsFile = await fs.promises.readFile(`${testDirectory}/models.ts`, 'utf8');
+        const dir = getTestDirectory('validation-array-records');
+        await init({ absolutePath: dir });
+        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/mixed-types/nango.yaml`, `${dir}/nango.yaml`);
+        await expect(generate({ debug: false, fullPath: dir })).resolves.toBeUndefined();
+        const modelsFile = await fs.promises.readFile(`${dir}/models.ts`, 'utf8');
         expect(modelsFile).toContain(`record: Record<string, string>;`);
         expect(modelsFile).toContain(`und: string | null | undefined;`);
         expect(modelsFile).toContain(`def: 'male' | string | null | undefined;`);
@@ -452,112 +469,108 @@ describe('generate function tests', () => {
         expect(modelsFile).toContain(`nullableDate: Date | null;`);
     });
     it('should correctly interpret a union type with an array model', async () => {
-        await fs.promises.mkdir(testDirectory, { recursive: true });
-        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/model-array-types/nango.yaml`, `${testDirectory}/nango.yaml`);
-        expect(generate(false, true));
-        const modelsFile = await fs.promises.readFile(`${testDirectory}/models.ts`, 'utf8');
+        const dir = getTestDirectory('validation-array-model');
+        await init({ absolutePath: dir });
+        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/model-array-types/nango.yaml`, `${dir}/nango.yaml`);
+        await expect(generate({ debug: false, fullPath: dir })).resolves.toBeUndefined();
+        const modelsFile = await fs.promises.readFile(`${dir}/models.ts`, 'utf8');
         expect(modelsFile).not.toContain(`'Other[]' | null | undefined;`);
         expect(modelsFile).toContain(`Other[] | null | undefined;`);
     });
     it('should be able to compile files in nested directories', async () => {
-        await fs.promises.rm(testDirectory, { recursive: true, force: true });
-        await fs.promises.mkdir(testDirectory, { recursive: true });
-        await copyDirectoryAndContents(`${fixturesPath}/nango-yaml/v2/nested-integrations/hubspot`, './hubspot');
-        await copyDirectoryAndContents(`${fixturesPath}/nango-yaml/v2/nested-integrations/github`, './github');
-        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/nested-integrations/nango.yaml`, `./nango.yaml`);
-        const success = await compileAllFiles({ debug: true });
-        await fs.promises.rm('./hubspot', { recursive: true, force: true });
-        await fs.promises.rm('./github', { recursive: true, force: true });
-        await fs.promises.rm('./dist', { recursive: true, force: true });
-        await fs.promises.rm('./nango.yaml', { force: true });
-        await fs.promises.rm('./models.ts', { force: true });
+        const dir = getTestDirectory('nested');
+        await init({ absolutePath: dir });
+        await copyDirectoryAndContents(`${fixturesPath}/nango-yaml/v2/nested-integrations/hubspot`, `${dir}/hubspot`);
+        await copyDirectoryAndContents(`${fixturesPath}/nango-yaml/v2/nested-integrations/github`, `${dir}/github`);
+        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/nested-integrations/nango.yaml`, `${dir}/nango.yaml`);
+        const success = await compileAllFiles({ fullPath: dir, debug: true });
+        expect(fs.existsSync(path.join(dir, 'models.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(dir, 'hubspot/syncs/contacts.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(dir, 'dist/contacts-hubspot.js'))).toBe(true);
+        expect(fs.existsSync(path.join(dir, 'dist/issues-github.js'))).toBe(true);
         expect(success).toBe(true);
     });
     it('should be backwards compatible with the single directory for integration files', async () => {
-        await fs.promises.rm(testDirectory, { recursive: true, force: true });
-        await fs.promises.mkdir(testDirectory, { recursive: true });
-        await copyDirectoryAndContents(`${fixturesPath}/nango-yaml/v2/non-nested-integrations`, './');
-        const success = await compileAllFiles({ debug: true });
-        await fs.promises.rm('./dist', { recursive: true, force: true });
-        await fs.promises.rm('./nango.yaml', { force: true });
-        await fs.promises.rm('./models.ts', { force: true });
-        await fs.promises.rm('./contacts.ts', { force: true });
-        await fs.promises.rm('./create-contact.ts', { force: true });
-        await fs.promises.rm('./create-issue.ts', { force: true });
-        await fs.promises.rm('./issues.ts', { force: true });
+        const dir = getTestDirectory('old-directory');
+        await init({ absolutePath: dir });
+        await copyDirectoryAndContents(`${fixturesPath}/nango-yaml/v2/non-nested-integrations`, dir);
+        const success = await compileAllFiles({ fullPath: dir, debug: false });
+        expect(fs.existsSync(path.join(dir, 'models.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(dir, 'contacts.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(dir, 'dist/contacts-hubspot.js'))).toBe(true);
         expect(success).toBe(true);
     });
     it('should be able to compile and run imported files', async () => {
-        await fs.promises.rm(testDirectory, { recursive: true, force: true });
-        await fs.promises.mkdir(testDirectory, { recursive: true });
-        await copyDirectoryAndContents(`${fixturesPath}/nango-yaml/v2/relative-imports/github`, './github');
-        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/relative-imports/nango.yaml`, `./nango.yaml`);
-        const success = await compileAllFiles({ debug: true });
-        // @ts-expect-error - dynamic import
-        const module = await import('./dist/issues.cjs');
+        const dir = getTestDirectory('relative-imports');
+        await init({ absolutePath: dir });
+        await copyDirectoryAndContents(`${fixturesPath}/nango-yaml/v2/relative-imports/github`, `${dir}/github`);
+        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/relative-imports/nango.yaml`, `${dir}/nango.yaml`);
+        const success = await compileAllFiles({ fullPath: dir, debug: false });
+        const module = await import(`${dir}dist/issues-github.js`);
         const result = module.default.default();
         expect(result).toBe('Hello, world!');
-        await fs.promises.rm('./github', { recursive: true, force: true });
-        await fs.promises.rm('./dist', { recursive: true, force: true });
-        await fs.promises.rm('./nango.yaml', { force: true });
-        await fs.promises.rm('./models.ts', { force: true });
         expect(success).toBe(true);
     });
     it('should compile helper functions and throw an error if there is a complication error with an imported file', async () => {
         const name = 'relative-imports-with-error';
-        await fs.promises.rm(testDirectory, { recursive: true, force: true });
-        await fs.promises.mkdir(testDirectory, { recursive: true });
-        await copyDirectoryAndContents(`${fixturesPath}/nango-yaml/v2/${name}/github`, './github');
-        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/${name}/nango.yaml`, `./nango.yaml`);
+        const dir = getTestDirectory('relative-imports-with-error');
+        await init({ absolutePath: dir });
+        await copyDirectoryAndContents(`${fixturesPath}/nango-yaml/v2/${name}/github`, `${dir}/github`);
+        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/${name}/nango.yaml`, `${dir}/nango.yaml`);
         const tsconfig = fs.readFileSync(`${getNangoRootPath()}/tsconfig.dev.json`, 'utf8');
         const { response: config } = await configService.load(path.resolve(`${fixturesPath}/nango-yaml/v2/${name}`));
-        if (config) {
-            const modelNames = configService.getModelNames(config);
-            const result = await compileSingleFile({ file: getFileToCompile('./github/actions/gh-issues.ts'), tsconfig, config, modelNames, debug: true });
-            expect(result).toBe(false);
-        }
-        await fs.promises.rm('./github', { recursive: true, force: true });
-        await fs.promises.rm('./dist', { recursive: true, force: true });
-        await fs.promises.rm('./nango.yaml', { force: true });
-        await fs.promises.rm('./models.ts', { force: true });
+        expect(config).not.toBeNull();
+        const modelNames = configService.getModelNames(config);
+        const result = await compileSingleFile({
+            fullPath: dir,
+            file: getFileToCompile({ fullPath: dir, filePath: path.join(dir, './github/actions/gh-issues.ts') }),
+            tsconfig,
+            config: config,
+            modelNames,
+            debug: false
+        });
+        expect(result).toBe(false);
     });
     it('should complain if a nango call is used incorrectly in a nested file', async () => {
         const name = 'relative-imports-with-nango-misuse';
-        await fs.promises.rm(testDirectory, { recursive: true, force: true });
-        await fs.promises.mkdir(testDirectory, { recursive: true });
-        await copyDirectoryAndContents(`${fixturesPath}/nango-yaml/v2/${name}/github`, './github');
-        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/${name}/nango.yaml`, `./nango.yaml`);
+        const dir = getTestDirectory('relative-imports-with-nango-misuse');
+        await init({ absolutePath: dir });
+        await copyDirectoryAndContents(`${fixturesPath}/nango-yaml/v2/${name}/github`, `${dir}/github`);
+        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/${name}/nango.yaml`, `${dir}/nango.yaml`);
         const tsconfig = fs.readFileSync(`${getNangoRootPath()}/tsconfig.dev.json`, 'utf8');
         const { response: config } = await configService.load(path.resolve(`${fixturesPath}/nango-yaml/v2/${name}`));
-        if (config) {
-            const modelNames = configService.getModelNames(config);
-            const result = await compileSingleFile({ file: getFileToCompile('./github/actions/gh-issues.ts'), tsconfig, config, modelNames, debug: true });
-            expect(result).toBe(false);
-        }
-        await fs.promises.rm('./github', { recursive: true, force: true });
-        await fs.promises.rm('./dist', { recursive: true, force: true });
-        await fs.promises.rm('./nango.yaml', { force: true });
-        await fs.promises.rm('./models.ts', { force: true });
+        expect(config).not.toBeNull();
+        const modelNames = configService.getModelNames(config);
+        const result = await compileSingleFile({
+            fullPath: dir,
+            file: getFileToCompile({ fullPath: dir, filePath: path.join(dir, './github/actions/gh-issues.ts') }),
+            tsconfig,
+            config: config,
+            modelNames,
+            debug: false
+        });
+        expect(result).toBe(false);
     });
     it('should not allow imports higher than the current directory', async () => {
         const name = 'relative-imports-with-higher-import';
-        await fs.promises.rm(testDirectory, { recursive: true, force: true });
-        await fs.promises.mkdir(testDirectory, { recursive: true });
-        await copyDirectoryAndContents(`${fixturesPath}/nango-yaml/v2/${name}/github`, './github');
-        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/${name}/nango.yaml`, `./nango.yaml`);
-        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/${name}/github/actions/welcomer.ts`, `../welcomer.ts`);
+        const dir = getTestDirectory('relative-imports-with-higher-import');
+        await init({ absolutePath: dir });
+        await copyDirectoryAndContents(`${fixturesPath}/nango-yaml/v2/${name}/github`, `${dir}/github`);
+        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/${name}/nango.yaml`, `${dir}/nango.yaml`);
+        await fs.promises.copyFile(`${fixturesPath}/nango-yaml/v2/${name}/github/actions/welcomer.ts`, `${dir}/welcomer.ts`);
         const tsconfig = fs.readFileSync(`${getNangoRootPath()}/tsconfig.dev.json`, 'utf8');
         const { response: config } = await configService.load(path.resolve(`${fixturesPath}/nango-yaml/v2/${name}`));
-        if (config) {
-            const modelNames = configService.getModelNames(config);
-            const result = await compileSingleFile({ file: getFileToCompile('./github/actions/gh-issues.ts'), tsconfig, config, modelNames, debug: true });
-            expect(result).toBe(false);
-        }
-        await fs.promises.rm('./github', { recursive: true, force: true });
-        await fs.promises.rm('./dist', { recursive: true, force: true });
-        await fs.promises.rm('./nango.yaml', { force: true });
-        await fs.promises.rm('./models.ts', { force: true });
-        await fs.promises.rm('../welcomer.ts', { force: true });
+        expect(config).not.toBeNull();
+        const modelNames = configService.getModelNames(config);
+        const result = await compileSingleFile({
+            fullPath: dir,
+            file: getFileToCompile({ fullPath: dir, filePath: path.join(dir, './github/actions/gh-issues.ts') }),
+            tsconfig,
+            config: config,
+            modelNames,
+            debug: false
+        });
+        expect(result).toBe(false);
     });
 });
 //# sourceMappingURL=sync.unit.cli-test.js.map