WIP migration

Author: Yadro

.vscode/settings.json

@@ -18,6 +18,8 @@
     "editor.defaultFormatter": "esbenp.prettier-vscode"
   },
 
+  "jest.autoRun": {},
+
   "search.exclude": {
     ".git": true,
     ".eslintcache": true,

docs/Migrations.md

@@ -0,0 +1,19 @@
+1. Добавить в `schemas` новую схему `{entity}/migrations/{Name}SchemaV{N}`
+2. Добавить в `schemas` в файл `index.ts` новую схему
+
+```ts
+export const schemaMigrations: SchemaMigration[] = [
+  ...{ version: N, schema: NameSchemaVN },
+];
+```
+
+3. В AbstractFileRepository.ts restore
+   1. Парсит json
+   2. Проверяет являются ли полученные данные объектом
+4. Миграция
+   1. Смотрит есть ли `__version` в корне объекта
+   2. Если нет, то валидирует с помощью схемы `{Name}SchemaV0`, иначе ищет схему с соответствующей версией
+   3. Если версия не самая последняя из списка `schemaMigrations`, то применяет миграцию
+      1. Миграция принимает версию V{N} и возвращает v{N+1}
+      2. Применяем миграции с N до последней
+   4. После того как все миграции прошли, передаем данные в конструктор модели

package.json

@@ -231,6 +231,7 @@
     "@ant-design/colors": "6.0.0",
     "@ant-design/icons": "4.6.2",
     "@sentry/electron": "2.5.0",
+    "ajv": "^8.8.2",
     "antd": "4.17.2",
     "caniuse-lite": "1.0.30001214",
     "clsx": "^1.1.1",

src/base/MigrationRunner.test.ts

@@ -0,0 +1,100 @@
+import MigrationRunner from './MigrationRunner';
+import { SchemaMigration } from '../types/SchemaMigration';
+import { JSONSchemaType } from 'ajv';
+
+describe('MigrationRunner tests', () => {
+  describe('constructor tests', () => {
+    test('throw error when schemaMigrations is empty', () => {
+      expect(() => new MigrationRunner([])).toThrow(
+        'schemaMigrations can`t be empty'
+      );
+    });
+
+    test('throw error when there is no migration `version=0`', () => {
+      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', () => {
+      expect(
+        () =>
+          new MigrationRunner([
+            { version: 0, schema: {} },
+            { version: 2, schema: {} },
+          ])
+      ).toThrow('Each version should go one after the other');
+    });
+  });
+
+  describe('migration tests', () => {
+    test('Test migration', () => {
+      type TypeV0 = { data: number };
+      type TypeV1 = { data: number[]; __version: number };
+      type TypeV2 = {
+        data: number[];
+        additionalData: string;
+        __version: number;
+      };
+      const schemaV0: JSONSchemaType<TypeV0> = {
+        type: 'object',
+        properties: {
+          data: { type: 'number' },
+        },
+        required: ['data'],
+      };
+      const schemaV1: JSONSchemaType<TypeV1> = {
+        type: 'object',
+        properties: {
+          __version: { type: 'number' },
+          data: { type: 'array', items: { type: 'number' } },
+        },
+        required: ['data', '__version'],
+      };
+      const schemaV2: JSONSchemaType<TypeV2> = {
+        type: 'object',
+        properties: {
+          __version: { type: 'number' },
+          data: { type: 'array', items: { type: 'number' } },
+          additionalData: { type: 'string' },
+        },
+        required: ['data', '__version', 'additionalData'],
+      };
+      const migrations: SchemaMigration[] = [
+        { version: 0, schema: schemaV0 },
+        {
+          version: 1,
+          schema: schemaV1,
+          migration(item: TypeV0): TypeV1 {
+            return {
+              data: [item.data],
+              __version: 1,
+            };
+          },
+        },
+        {
+          version: 2,
+          schema: schemaV2,
+          migration(item: TypeV1): TypeV2 {
+            return {
+              data: item.data,
+              additionalData: 'test',
+              __version: 2,
+            };
+          },
+        },
+      ];
+
+      const dataV0: TypeV0 = { data: 77 };
+      const expectedData: TypeV2 = {
+        data: [77],
+        additionalData: 'test',
+        __version: 2,
+      };
+      const mr = new MigrationRunner(migrations);
+
+      const resultData = mr.runMigration(dataV0);
+      expect(resultData).toStrictEqual(expectedData);
+    });
+  });
+});

src/base/MigrationRunner.ts

@@ -0,0 +1,92 @@
+import { SchemaMigration } from '../types/SchemaMigration';
+import { SchemaType } from '../types/SchemaType';
+import { last } from '../helpers/ArrayHelper';
+
+export default class MigrationRunner {
+  private schemaMigrations: SchemaMigration[] = [];
+  private genErrorMsg = (message: string) => `[MigrationRunner] ${message}`;
+
+  constructor(schemaMigrations: SchemaMigration[]) {
+    const schemaMigrationsSorted = schemaMigrations.slice();
+    schemaMigrationsSorted.sort((a, b) => a.version - b.version);
+
+    if (!schemaMigrationsSorted.length) {
+      throw new Error(this.genErrorMsg('schemaMigrations can`t be empty'));
+    }
+
+    if (!schemaMigrationsSorted.find((i) => i.version === 0)) {
+      throw new Error(
+        this.genErrorMsg(
+          'schemaMigrations should have migration for `version=0`'
+        )
+      );
+    }
+
+    const hasAllVersions = schemaMigrations.every(
+      (i, idx) => i.version === idx
+    );
+    if (!hasAllVersions) {
+      throw new Error(
+        this.genErrorMsg('Each version should go one after the other')
+      );
+    }
+
+    this.schemaMigrations = schemaMigrationsSorted;
+  }
+
+  runMigration<T extends SchemaType>(data: T) {
+    let newData: T = data;
+    const lastVersion = last(this.schemaMigrations)?.version;
+
+    if (lastVersion === undefined) {
+      throw new Error('There are no migrations');
+    }
+
+    // if (!('__version' in data)) {
+    //   const migration = this.schemaMigrations.find((i) => i.version === 1);
+    //   if (!migration) {
+    //     throw new Error();
+    //   }
+    //   newData = migration.migration?.(data);
+    // } else {
+    //   newData = data;
+    // }
+
+    // if (newData === undefined || newData.__version === undefined) {
+    //   throw new Error();
+    // }
+
+    let nextVersion =
+      newData.__version !== undefined ? newData.__version + 1 : 1;
+
+    while (true) {
+      if (nextVersion > lastVersion) {
+        return newData;
+      }
+
+      const migration = this.schemaMigrations.find(
+        (m) => m.version === nextVersion
+      );
+
+      if (!migration) {
+        throw new Error(
+          `Migration from ${newData.__version} to ${nextVersion} not found`
+        );
+      }
+
+      if (migration?.migration) {
+        const nextData: T = migration.migration(newData);
+
+        if (nextData === undefined) {
+          throw new Error();
+        }
+        if (nextData.__version === undefined) {
+          throw new Error();
+        }
+
+        newData = nextData;
+        nextVersion = nextData.__version + 1;
+      }
+    }
+  }
+}

src/base/repositories/AbstractFileRepository.ts

@@ -5,7 +5,8 @@ const path = require('path');
 import { ipcRenderer } from 'electron';
 
 import FsHelper from '../../helpers/FsHelper';
-import PromiseQueue from '../../helpers/PromiseQueueHellper';
+import PromiseQueue from '../../helpers/PromiseQueueHelper';
+import { SchemaMigration } from '../../types/SchemaMigration';
 
 const APP_DIR =
   process.env.NODE_ENV === 'development'
@@ -18,8 +19,9 @@ export default abstract class AbstractFileRepository<T = any> {
   dirWithProfileData: string = 'profile1';
   fileName: string = 'defaultFileName.json';
   saveInRoot: boolean = false;
+  schemaMigrations: SchemaMigration[] = [];
 
-  writeFileQueue = new PromiseQueue();
+  private writeFileQueue = new PromiseQueue();
 
   private get logPrefix() {
     const filePath = !this.saveInRoot ? this.dirWithProfileData : '';
@@ -55,7 +57,7 @@ export default abstract class AbstractFileRepository<T = any> {
     if (fs.existsSync(this.filePath)) {
       const data = fs.readFileSync(this.filePath, { encoding: 'utf-8' });
       // TODO handle parse error. Backup file with issues and return defaultValue
-      return JSON.parse(data);
+      const parsedData = JSON.parse(data);
     }
     return defaultValue;
   }

src/helpers/PromiseQueueHellper.ts src/helpers/PromiseQueueHelper.tssrc/helpers/PromiseQueueHellper.ts renamed to src/helpers/PromiseQueueHelper.ts

@@ -0,0 +1,5 @@
+import Ajv from 'ajv';
+import ProjectSchemaV0 from './schemas/ProjectSchemaV0';
+
+const ajv = new Ajv({ allErrors: true });
+export const validate = ajv.compile(ProjectSchemaV0);

src/modules/projects/ProjectValidator.ts

@@ -0,0 +1,26 @@
+import { JSONSchemaType } from 'ajv';
+import ProjectModel from '../models/ProjectModel';
+
+const ProjectSchemaV0: JSONSchemaType<ProjectModel> = {
+  type: 'object',
+  properties: {
+    key: { type: 'string' },
+    title: { type: 'string' },
+    color: { type: 'string' },
+    expanded: { type: 'boolean', default: false, nullable: true },
+    deletable: { type: 'boolean', default: true, nullable: true },
+    children: {
+      type: 'array',
+      items: {
+        type: 'object',
+        $ref: '#',
+        required: ['key', 'title', 'color'],
+      },
+      nullable: true,
+    },
+    parent: { type: 'object', $ref: '#', nullable: true },
+  },
+  required: [],
+};
+
+export default ProjectSchemaV0;