feat(upgrade): added imports prop in upgrade.yml

close #6

Author: Murat

src/__tests__/unit/utils/upgrade/restoreBackupFiles.spec.ts

@@ -7,7 +7,7 @@ import { mockFs } from '../../../mocks/mockFs';
 describe('restoreBackupFiles', () => {
   it('should restore backup files in .upgrade', async () => {
     mockFs.writeFileSync(
-      path.join(getProjectPath(), '.upgrade/backup/test/some.file'),
+      path.join(getProjectPath(), '.upgrade/imports/test/some.file'),
       'random'
     );
 
@@ -25,7 +25,7 @@ describe('restoreBackupFiles', () => {
   });
   it('should handle copy error', async () => {
     mockFs.writeFileSync(
-      path.join(getProjectPath(), '.upgrade/backup/test/some.file'),
+      path.join(getProjectPath(), '.upgrade/imports/test/some.file'),
       'random'
     );
     mockFs.copyFile.mockImplementationOnce(

src/__tests__/unit/utils/upgrade/runUpgradeTasks.spec.ts

@@ -24,7 +24,7 @@ tasks:
       - append: test`
     );
 
-    const result = await runUpgradeTasks();
+    const result = await runUpgradeTasks(undefined);
 
     expect(result.didRun).toBeTruthy();
     expect(mockRunTask).toHaveBeenCalledWith({
@@ -52,13 +52,13 @@ tasks:
       - append: test`
     );
 
-    const result = await runUpgradeTasks();
+    const result = await runUpgradeTasks(undefined);
 
     expect(result.didRun).toBeTruthy();
     expect(mockRunTask).not.toHaveBeenCalled();
   });
   it('should handle not finding upgrade.yml', async () => {
-    const result = await runUpgradeTasks();
+    const result = await runUpgradeTasks(undefined);
 
     expect(result.didRun).toBeFalsy();
   });
@@ -67,7 +67,7 @@ tasks:
       path.join(getProjectPath(), '.upgrade/upgrade.yml'),
       'random'
     );
-    const result = await runUpgradeTasks();
+    const result = await runUpgradeTasks(undefined);
 
     expect(result.didRun).toBeFalsy();
   });
@@ -82,11 +82,69 @@ tasks:
       - append: test`
     );
 
-    const result = await runUpgradeTasks();
+    const result = await runUpgradeTasks(undefined);
 
     expect(result.didRun).toBeTruthy();
     if (result.didRun) {
       expect(result.failedTaskCount).toBe(1);
     }
   });
+  it('should execute upgrade.yml imports', async () => {
+    mockFs.writeFileSync('/oldProject/path/some.file', 'random');
+    mockFs.writeFileSync(
+      path.join(getProjectPath(), '.upgrade/upgrade.yml'),
+      `
+imports:
+  - path
+  - path/some.file`
+    );
+
+    const result = await runUpgradeTasks('/oldProject');
+
+    expect(result.didRun).toBeTruthy();
+    expect(mockFs.readFileSync(getProjectPath() + '/path/some.file')).toBe(
+      'random'
+    );
+  });
+  it('should skip non existing upgrade.yml imports', async () => {
+    mockFs.writeFileSync(
+      path.join(getProjectPath(), '.upgrade/upgrade.yml'),
+      `
+imports:
+  - path/some.file`
+    );
+    mockFs.lstatSync.mockClear();
+    const result = await runUpgradeTasks('/oldProject');
+
+    expect(result.didRun).toBeTruthy();
+    expect(mockFs.lstatSync).not.toHaveBeenCalled();
+  });
+  it('should skip when no old project path specified', async () => {
+    mockFs.writeFileSync(
+      path.join(getProjectPath(), '.upgrade/upgrade.yml'),
+      `
+imports:
+  - path/some.file`
+    );
+    mockFs.lstatSync.mockClear();
+    const result = await runUpgradeTasks(undefined);
+
+    expect(result.didRun).toBeTruthy();
+    expect(mockFs.lstatSync).not.toHaveBeenCalled();
+  });
+  it('should handle copy error', async () => {
+    mockFs.writeFileSync('/oldProject/path/some.file', 'random');
+    mockFs.writeFileSync(
+      path.join(getProjectPath(), '.upgrade/upgrade.yml'),
+      `
+imports:
+  - path/some.file`
+    );
+    mockFs.copyFile.mockImplementationOnce(
+      (from: string, to: string, cb: CallableFunction) => {
+        cb(new Error('random'));
+      }
+    );
+    await expect(runUpgradeTasks('/oldProject')).rejects.toThrow('random');
+  });
 });

src/getInfo.ts

@@ -80,7 +80,10 @@ export async function getInfo(packageName: string): Promise<void> {
   if (localPathExists && localConfigPath) {
     config = parseConfig(localConfigPath) as IntegrationConfig;
   } else if (remoteFileContent)
-    config = parseConfigString(remoteFileContent) as IntegrationConfig;
+    config = parseConfigString(
+      remoteFileContent,
+      'integrate'
+    ) as IntegrationConfig;
   if (config) {
     const _config = config;
     logSuccess(

src/schema/upgrade.schema.json

@@ -1727,16 +1727,19 @@
         "env": {
             "$ref": "#/definitions/AnyObject"
         },
+        "imports": {
+            "items": {
+                "type": "string"
+            },
+            "type": "array"
+        },
         "tasks": {
             "items": {
                 "$ref": "#/definitions/ModTask"
             },
             "type": "array"
         }
     },
-    "required": [
-        "tasks"
-    ],
     "type": "object"
 }
 

src/types/upgrade.types.ts

@@ -2,7 +2,8 @@ import { AnyObject, ModTask } from './mod.types';
 
 export type UpgradeConfig = {
   env?: AnyObject;
-  tasks: ModTask[];
+  imports?: string[];
+  tasks?: ModTask[];
 };
 
 export type ImportGetter = {

src/upgrade.ts

@@ -320,16 +320,16 @@ export async function upgrade(): Promise<void> {
 
   logInfo(
     color.bold(color.inverse(color.magenta(' stage 3 '))) +
-      color.bold(color.magenta(' Restore backup files '))
+      color.bold(color.magenta(' Import files from .upgrade/imports '))
   );
 
   const didRestore = await restoreBackupFiles().catch((e: Error) => {
     logWarning(e.message);
   });
   if (didRestore) {
     logSuccess(
-      color.inverse(color.bold(color.green(' restored '))) +
-        color.green(' backup files were restored successfully')
+      color.inverse(color.bold(color.green(' imported '))) +
+        color.green(' files were imported successfully')
     );
   }
 
@@ -338,9 +338,11 @@ export async function upgrade(): Promise<void> {
       color.bold(color.magenta(' Execute upgrade.yml tasks '))
   );
 
-  const upgradeResult = await runUpgradeTasks().catch((e: Error) => {
-    logWarning(e.message);
-  });
+  const upgradeResult = await runUpgradeTasks(oldProjectPath).catch(
+    (e: Error) => {
+      logWarning(e.message);
+    }
+  );
   if (upgradeResult && upgradeResult.didRun) {
     if (upgradeResult.failedTaskCount) {
       logWarning(

src/utils/parseConfig.ts

@@ -1,20 +1,33 @@
 import Ajv from 'ajv';
 import fs from 'fs';
 import { parse } from 'yaml';
+import { Constants } from '../constants';
 import integrateYmlSchema from '../schema/integrate.schema.json';
+import upgradeYmlSchema from '../schema/upgrade.schema.json';
 
 const ajv = new Ajv({ allowUnionTypes: true });
-const validate = ajv.compile(integrateYmlSchema);
+const validateIntegrate = ajv.compile(integrateYmlSchema);
+const validateUpgrade = ajv.compile(upgradeYmlSchema);
 
 export function parseConfig(configPath: string): Record<string, any> {
   const configContent = fs.readFileSync(configPath, 'utf8');
-  return parseConfigString(configContent);
+  return parseConfigString(
+    configContent,
+    configPath.endsWith(Constants.UPGRADE_CONFIG_FILE_NAME)
+      ? 'upgrade'
+      : 'integrate'
+  );
 }
 
-export function parseConfigString(configContent: string): Record<string, any> {
+export function parseConfigString(
+  configContent: string,
+  schema: 'integrate' | 'upgrade'
+): Record<string, any> {
   const config = parse(configContent) as Record<string, any>;
-  if (!validate(config)) {
-    throw new Error(validate.errors?.map(e => e.message).join(', '));
+  if (schema == 'integrate' && !validateIntegrate(config)) {
+    throw new Error(validateIntegrate.errors?.map(e => e.message).join(', '));
+  } else if (schema == 'upgrade' && !validateUpgrade(config)) {
+    throw new Error(validateUpgrade.errors?.map(e => e.message).join(', '));
   }
   return config;
 }

src/utils/upgrade/restoreBackupFiles.ts

@@ -13,25 +13,25 @@ import { getProjectPath } from '../getProjectPath';
 
 export async function restoreBackupFiles(): Promise<boolean> {
   const backupFiles = globSync(
-    [getProjectPath(), Constants.UPGRADE_FOLDER_NAME, 'backup', '**/*'].join(
+    [getProjectPath(), Constants.UPGRADE_FOLDER_NAME, 'imports', '**/*'].join(
       '/'
     ),
     { nodir: true }
   );
   if (backupFiles.length === 0) {
-    logMessageGray('skipped restore, no backup files found');
+    logMessageGray('skipped restore, found no files to import');
     return false;
   }
 
-  startSpinner(`copying files from ${color.yellow('.upgrade/backup')}`);
+  startSpinner(`copying files from ${color.yellow('.upgrade/imports')}`);
 
   for (let i = 0; i < backupFiles.length; i++) {
     updateSpinner(
-      `copying files from ${color.yellow('.upgrade/backup')} (${i + 1}/${backupFiles.length})`
+      `copying files from ${color.yellow('.upgrade/imports')} (${i + 1}/${backupFiles.length})`
     );
     const file = backupFiles[i];
     const relativePath = path.relative(
-      path.join(getProjectPath(), Constants.UPGRADE_FOLDER_NAME, 'backup'),
+      path.join(getProjectPath(), Constants.UPGRADE_FOLDER_NAME, 'imports'),
       file
     );
     const destination = path.join(getProjectPath(), relativePath);