Fixed migration, updated tests

Author: Yadro

src/base/MigrationRunner.test.ts

@@ -1,22 +1,23 @@
 import MigrationRunner from './MigrationRunner';
 import { SchemaMigration } from '../types/SchemaMigration';
 import { JSONSchemaType } from 'ajv';
+import MigrationErrorCodes from '../types/MigrationErrorCodes';
 
 describe('MigrationRunner tests', () => {
-  describe('constructor tests', () => {
-    test('throw error when schemaMigrations is empty', () => {
+  describe('Constructor tests', () => {
+    test(`Throw ErrorCode=${MigrationErrorCodes.NoMigrations} NoMigrations`, () => {
       expect(() => new MigrationRunner([])).toThrow(
-        'schemaMigrations can`t be empty'
+        `schemaMigrations can't be empty`
       );
     });
 
-    test('throw error when there is no migration `version=0`', () => {
+    test(`Throw ErrorCode=${MigrationErrorCodes.NoZeroMigration} NoZeroMigration`, () => {
       expect(() => new MigrationRunner([{ version: 1, schema: {} }])).toThrow(
         'schemaMigrations should have migration for `version=0`'
       );
     });
 
-    test('throw error when versions doesn`t go one after the other', () => {
+    test(`Throw ErrorCode=${MigrationErrorCodes.IncorrectMigrationsOrder} IncorrectMigrationsOrder`, () => {
       expect(
         () =>
           new MigrationRunner([
@@ -27,8 +28,8 @@ describe('MigrationRunner tests', () => {
     });
   });
 
-  describe('migration tests', () => {
-    test('Test migration', () => {
+  describe('Migration tests', () => {
+    test('Test migration with 3 iterations', () => {
       type TypeV0 = { data: number };
       type TypeV1 = { data: number[]; __version: number };
       type TypeV2 = {
@@ -67,7 +68,7 @@ describe('MigrationRunner tests', () => {
           schema: schemaV1,
           migration(item: TypeV0): TypeV1 {
             return {
-              data: [item.data],
+              data: [item.data] as number[],
               __version: 1,
             };
           },
@@ -97,7 +98,7 @@ describe('MigrationRunner tests', () => {
       expect(resultData).toStrictEqual(expectedData);
     });
 
-    test('Test when there is schema validation error', () => {
+    test(`Throw ErrorCode=${MigrationErrorCodes.ValidationFailed} ValidationFailed`, () => {
       type TypeV0 = { data: number; text: string; prop: { test: 1 } };
 
       const schemaV0: JSONSchemaType<TypeV0> = {
@@ -129,5 +130,108 @@ describe('MigrationRunner tests', () => {
         ].join('\n')
       );
     });
+
+    test(`Throw ErrorCode=${MigrationErrorCodes.MigrationNotFound} MigrationNotFound`, () => {
+      type TypeV0 = { data: number };
+
+      const schemaV0: JSONSchemaType<TypeV0> = {
+        type: 'object',
+        properties: {
+          data: { type: 'number' },
+        },
+        required: ['data'],
+      };
+
+      const migrations: SchemaMigration[] = [
+        { version: 0, schema: schemaV0 },
+        { version: 1, schema: schemaV0 },
+      ];
+
+      const dataV0 = { data: 1 };
+
+      const mr = new MigrationRunner(migrations);
+
+      expect(() => mr.runMigration(dataV0)).toThrow(
+        /Migration {undefined->\d} not found/
+      );
+    });
+
+    test(`Throw ErrorCode=${MigrationErrorCodes.MigrationFailed} MigrationFailed - migration returned undefined`, () => {
+      type TypeV0 = { data: number };
+      type TypeV1 = { data: number };
+
+      const schemaV0: JSONSchemaType<TypeV0> = {
+        type: 'object',
+        properties: {
+          data: { type: 'number' },
+        },
+        required: ['data'],
+      };
+      const schemaV1: JSONSchemaType<TypeV1> = {
+        type: 'object',
+        properties: {
+          data: { type: 'number' },
+        },
+        required: ['data'],
+      };
+
+      const migrations: SchemaMigration[] = [
+        { version: 0, schema: schemaV0 },
+        {
+          version: 1,
+          schema: schemaV1,
+          migration() {
+            return undefined;
+          },
+        },
+      ];
+
+      const dataV0 = { data: 1 };
+
+      const mr = new MigrationRunner(migrations);
+
+      expect(() => mr.runMigration(dataV0)).toThrow(
+        `migration returned 'undefined'`
+      );
+    });
+
+    test(`Throw ErrorCode=${MigrationErrorCodes.MigrationFailed} MigrationFailed migration returned 'data' without '__version'`, () => {
+      type TypeV0 = { data: number };
+      type TypeV1 = { data: number };
+
+      const schemaV0: JSONSchemaType<TypeV0> = {
+        type: 'object',
+        properties: {
+          data: { type: 'number' },
+        },
+        required: ['data'],
+      };
+      const schemaV1: JSONSchemaType<TypeV1> = {
+        type: 'object',
+        properties: {
+          data: { type: 'number' },
+        },
+        required: ['data'],
+      };
+
+      const migrations: SchemaMigration[] = [
+        { version: 0, schema: schemaV0 },
+        {
+          version: 1,
+          schema: schemaV1,
+          migration(item) {
+            return item;
+          },
+        },
+      ];
+
+      const dataV0 = { data: 1 };
+
+      const mr = new MigrationRunner(migrations);
+
+      expect(() => mr.runMigration(dataV0)).toThrow(
+        `migration returned 'data' without '__version'`
+      );
+    });
   });
 });

src/base/MigrationRunner.ts

@@ -25,10 +25,7 @@ export default class MigrationRunner {
     );
 
   constructor(schemaMigrations: SchemaMigration[]) {
-    const schemaMigrationsSorted = schemaMigrations.slice();
-    schemaMigrationsSorted.sort((a, b) => a.version - b.version);
-
-    if (!schemaMigrationsSorted.length) {
+    if (!schemaMigrations.length) {
       throw new Error(
         this.genErrorMsg(
           MigrationErrorCodes.NoMigrations,
@@ -37,6 +34,9 @@ export default class MigrationRunner {
       );
     }
 
+    const schemaMigrationsSorted = schemaMigrations.slice();
+    schemaMigrationsSorted.sort((a, b) => a.version - b.version);
+
     if (!schemaMigrationsSorted.find((i) => i.version === 0)) {
       throw new Error(
         this.genErrorMsg(
@@ -80,7 +80,12 @@ export default class MigrationRunner {
       (i) => i.version === zeroVersion
     );
     if (!firstMigration) {
-      throw new Error();
+      throw new Error(
+        this.genErrorMsg(
+          MigrationErrorCodes.NoMigrations,
+          `There are no migrations 'version=${zeroVersion}'`
+        )
+      );
     }
 
     const validate = this.ajv.compile(firstMigration.schema);
@@ -101,34 +106,42 @@ export default class MigrationRunner {
         (m) => m.version === toVersion
       );
 
-      if (!migration) {
+      if (!migration?.migration) {
         throw new Error(
           this.genErrorMsg(
             MigrationErrorCodes.MigrationNotFound,
-            `Migration from ${fromVersion} to ${toVersion} not found`
+            `Migration {${fromVersion}->${toVersion}} not found`
           )
         );
       }
 
-      if (migration?.migration) {
-        const nextData: T = migration.migration(newData);
-
-        if (nextData === undefined) {
-          throw new Error();
-        }
-        if (nextData.__version === undefined) {
-          throw new Error();
-        }
+      const nextData: T = migration.migration(newData);
 
-        const validate = this.ajv.compile(migration.schema);
-        const validateResult = validate(nextData);
-        if (!validateResult) {
-          throw new Error(this.genValidationErrors(validate, toVersion));
-        }
+      if (nextData === undefined) {
+        throw new Error(
+          this.genErrorMsg(
+            MigrationErrorCodes.MigrationFailed,
+            `After run migration {${fromVersion}->${toVersion}}, migration returned 'undefined'`
+          )
+        );
+      }
+      if (nextData.__version === undefined) {
+        throw new Error(
+          this.genErrorMsg(
+            MigrationErrorCodes.MigrationFailed,
+            `After run migration {${fromVersion}->${toVersion}}, migration returned 'data' without '__version'`
+          )
+        );
+      }
 
-        newData = nextData;
-        toVersion = nextData.__version + 1;
+      const validate = this.ajv.compile(migration.schema);
+      const validateResult = validate(nextData);
+      if (!validateResult) {
+        throw new Error(this.genValidationErrors(validate, toVersion));
       }
+
+      newData = nextData;
+      toVersion = nextData.__version + 1;
     }
   }
 }

src/types/MigrationErrorCodes.ts

@@ -4,6 +4,7 @@ enum MigrationErrorCodes {
   IncorrectMigrationsOrder = 2,
   ValidationFailed = 3,
   MigrationNotFound = 4,
+  MigrationFailed = 5,
 }
 
 export default MigrationErrorCodes;

src/types/SchemaMigration.ts

@@ -1,5 +1,5 @@
 export type SchemaMigration = {
   version: number;
   schema: any;
-  migration?: <TIn = unknown, TOut = unknown>(data: TIn) => TOut;
+  migration?: (data: any) => any;
 };