@nocobase/database 0.7.0-alpha.80 → 0.7.0-alpha.83

package/lib/database.d.ts

@@ -3,10 +3,12 @@ import { AsyncEmitter } from '@nocobase/utils';
 import merge from 'deepmerge';
 import { EventEmitter } from 'events';
 import { ModelCtor, Options, QueryInterfaceDropAllTablesOptions, QueryOptions, Sequelize, SyncOptions } from 'sequelize';
+import { Umzug } from 'umzug';
 import { Collection, CollectionOptions, RepositoryType } from './collection';
 import { ImportFileExtension } from './collection-importer';
 import * as FieldTypes from './fields';
 import { Field, FieldContext, RelationField } from './fields';
+import { Migrations } from './migration';
 import { Model } from './model';
 import { ModelHook } from './model-hook';
 import { RelationRepository } from './relation-repository/relation-repository';
@@ -22,8 +24,9 @@ interface MapOf<T> {
 }
 export interface IDatabaseOptions extends Options {
     tablePrefix?: string;
+    migrator?: any;
 }
-export declare type DatabaseOptions = IDatabaseOptions | Sequelize;
+export declare type DatabaseOptions = IDatabaseOptions;
 interface RegisterOperatorsContext {
     db?: Database;
     path?: string;
@@ -36,6 +39,8 @@ export interface CleanOptions extends QueryInterfaceDropAllTablesOptions {
 declare type OperatorFunc = (value: any, ctx?: RegisterOperatorsContext) => any;
 export declare class Database extends EventEmitter implements AsyncEmitter {
     sequelize: Sequelize;
+    migrator: Umzug;
+    migrations: Migrations;
     fieldTypes: Map<any, any>;
     options: IDatabaseOptions;
     models: Map<string, ModelCtor<Model<any, any>>>;
@@ -50,6 +55,7 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
         mergeOptions?: any;
     }[]>;
     constructor(options: DatabaseOptions);
+    addMigration(item: any): void;
     /**
      * Add collection to database
      * @param options

package/lib/database.js

@@ -57,12 +57,24 @@ function _sequelize() {
   return data;
 }
 
+function _umzug() {
+  const data = require("umzug");
+
+  _umzug = function _umzug() {
+    return data;
+  };
+
+  return data;
+}
+
 var _collection = require("./collection");
 
 var _collectionImporter = require("./collection-importer");
 
 var FieldTypes = _interopRequireWildcard(require("./fields"));
 
+var _migration = require("./migration");
+
 var _modelHook = require("./model-hook");
 
 var _operators = _interopRequireDefault(require("./operators"));
@@ -108,6 +120,8 @@ class Database extends _events().EventEmitter {
   constructor(options) {
     super();
     this.sequelize = void 0;
+    this.migrator = void 0;
+    this.migrations = void 0;
     this.fieldTypes = new Map();
     this.options = void 0;
     this.models = new Map();
@@ -119,28 +133,29 @@ class Database extends _events().EventEmitter {
     this.modelHook = void 0;
     this.delayCollectionExtend = new Map();
 
-    if (options instanceof _sequelize().Sequelize) {
-      this.sequelize = options;
-    } else {
-      const opts = _objectSpread({
-        sync: {
-          alter: {
-            drop: false
-          },
-          force: false
-        }
-      }, options);
+    const opts = _objectSpread({
+      sync: {
+        alter: {
+          drop: false
+        },
+        force: false
+      }
+    }, options);
 
-      if (options.storage && options.storage !== ':memory:') {
-        if (!(0, _path().isAbsolute)(options.storage)) {
-          opts.storage = (0, _path().resolve)(process.cwd(), options.storage);
-        }
+    if (options.storage && options.storage !== ':memory:') {
+      if (!(0, _path().isAbsolute)(options.storage)) {
+        opts.storage = (0, _path().resolve)(process.cwd(), options.storage);
       }
+    }
 
-      this.sequelize = new (_sequelize().Sequelize)(opts);
-      this.options = opts;
+    if (options.dialect === 'sqlite') {
+      delete opts.timezone;
+    } else if (!opts.timezone) {
+      opts.timezone = '+00:00';
     }
 
+    this.sequelize = new (_sequelize().Sequelize)(opts);
+    this.options = opts;
     this.collections = new Map();
     this.modelHook = new _modelHook.ModelHook(this);
     this.on('afterDefineCollection', collection => {
@@ -170,6 +185,29 @@ class Database extends _events().EventEmitter {
     }
 
     this.initOperators();
+    const migratorOptions = this.options.migrator || {};
+
+    const context = _objectSpread({
+      db: this,
+      sequelize: this.sequelize,
+      queryInterface: this.sequelize.getQueryInterface()
+    }, migratorOptions.context);
+
+    this.migrations = new _migration.Migrations(context);
+    this.migrator = new (_umzug().Umzug)({
+      logger: migratorOptions.logger || console,
+      migrations: this.migrations.callback(),
+      context,
+      storage: new (_umzug().SequelizeStorage)(_objectSpread(_objectSpread({
+        modelName: `${this.options.tablePrefix || ''}migrations`
+      }, migratorOptions.storage), {}, {
+        sequelize: this.sequelize
+      }))
+    });
+  }
+
+  addMigration(item) {
+    return this.migrations.add(item);
   }
   /**
    * Add collection to database

package/lib/index.d.ts

@@ -4,6 +4,7 @@ export * from './database';
 export { Database as default } from './database';
 export * from './fields';
 export * from './magic-attribute-model';
+export * from './migration';
 export * from './mock-database';
 export * from './model';
 export * from './relation-repository/belongs-to-many-repository';

package/lib/index.js

@@ -85,6 +85,20 @@ Object.keys(_magicAttributeModel).forEach(function (key) {
   });
 });
 
+var _migration = require("./migration");
+
+Object.keys(_migration).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _migration[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _migration[key];
+    }
+  });
+});
+
 var _mockDatabase = require("./mock-database");
 
 Object.keys(_mockDatabase).forEach(function (key) {

package/lib/migration.d.ts

@@ -0,0 +1,33 @@
+import { QueryInterface, Sequelize } from 'sequelize';
+import Database from './database';
+export interface MigrationContext {
+    db: Database;
+    queryInterface: QueryInterface;
+    sequelize: Sequelize;
+}
+export declare class Migration {
+    name: string;
+    context: {
+        db: Database;
+    };
+    constructor(context: MigrationContext);
+    get db(): Database;
+    get sequelize(): Sequelize;
+    get queryInterface(): QueryInterface;
+    up(): Promise<void>;
+    down(): Promise<void>;
+}
+export interface MigrationItem {
+    name: string;
+    migration?: typeof Migration;
+    up?: any;
+    down?: any;
+}
+export declare class Migrations {
+    items: any[];
+    context: any;
+    constructor(context: any);
+    clear(): void;
+    add(item: MigrationItem): void;
+    callback(): (ctx: any) => any[];
+}

package/lib/migration.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Migrations = exports.Migration = void 0;
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+class Migration {
+  constructor(context) {
+    this.name = void 0;
+    this.context = void 0;
+    this.context = context;
+  }
+
+  get db() {
+    return this.context.db;
+  }
+
+  get sequelize() {
+    return this.context.db.sequelize;
+  }
+
+  get queryInterface() {
+    return this.context.db.sequelize.getQueryInterface();
+  }
+
+  up() {// todo
+
+    return _asyncToGenerator(function* () {})();
+  }
+
+  down() {// todo
+
+    return _asyncToGenerator(function* () {})();
+  }
+
+}
+
+exports.Migration = Migration;
+
+class Migrations {
+  constructor(context) {
+    this.items = [];
+    this.context = void 0;
+    this.context = context;
+  }
+
+  clear() {
+    this.items = [];
+  }
+
+  add(item) {
+    const Migration = item.migration;
+
+    if (Migration) {
+      const migration = new Migration(this.context);
+      migration.name = item.name;
+      this.items.push(migration);
+    } else {
+      this.items.push(item);
+    }
+  }
+
+  callback() {
+    return ctx => {
+      return this.items;
+    };
+  }
+
+}
+
+exports.Migrations = Migrations;

package/lib/mock-database.d.ts

@@ -18,5 +18,6 @@ export declare function getConfigByEnv(): {
         charset: string;
         collate: string;
     };
+    timezone: string;
 };
 export declare function mockDatabase(options?: IDatabaseOptions): MockDatabase;

package/lib/mock-database.js

@@ -64,7 +64,8 @@ function getConfigByEnv() {
     define: {
       charset: 'utf8mb4',
       collate: 'utf8mb4_unicode_ci'
-    }
+    },
+    timezone: process.env.DB_TIMEZONE
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/database",
-  "version": "0.7.0-alpha.80",
+  "version": "0.7.0-alpha.83",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -12,17 +12,18 @@
     }
   ],
   "dependencies": {
-    "@nocobase/utils": "0.7.0-alpha.80",
+    "@nocobase/utils": "0.7.0-alpha.83",
     "async-mutex": "^0.3.2",
     "deepmerge": "^4.2.2",
     "flat": "^5.0.2",
     "glob": "^7.1.6",
-    "sequelize": "^6.9.0"
+    "sequelize": "^6.9.0",
+    "umzug": "^3.1.1"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "9ec196c514d958d2c32c0879def6b98f24bf92fc"
+  "gitHead": "838f4f18dcd9ed4fe2ae2660a4918e2a5bd3a869"
 }

package/src/__tests__/migrator.test.ts

@@ -0,0 +1,52 @@
+import { Database, Migration, mockDatabase } from '@nocobase/database';
+
+const names = (migrations: Array<{ name: string }>) => migrations.map(m => m.name);
+
+describe('migrator', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+
+    db = mockDatabase({
+      tablePrefix: 'test_',
+    });
+
+    await db.clean({ drop: true });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  test('up and down', async () => {
+    const spy = jest.fn();
+    db.addMigration({
+      name: 'migration1',
+      migration: class extends Migration {
+        async up() {
+          spy('migration1-up');
+        }
+        async down() {
+          spy('migration1-down');
+        }
+      },
+    });
+    db.addMigration({
+      name: 'migration2',
+      migration: class extends Migration {
+        async up() {
+          spy('migration2-up');
+        }
+        async down() {
+          spy('migration2-down');
+        }
+      },
+    });
+    await db.migrator.up();
+    expect(names(await db.migrator.executed())).toEqual(['migration1', 'migration2']);
+    await db.migrator.down();
+    expect(names(await db.migrator.executed())).toEqual(['migration1']);
+    expect(spy).toHaveBeenCalledTimes(3);
+    expect(spy).toHaveBeenNthCalledWith(1, 'migration1-up');
+  });
+});

package/src/database.ts

@@ -13,10 +13,12 @@ import {
   SyncOptions,
   Utils
 } from 'sequelize';
+import { SequelizeStorage, Umzug } from 'umzug';
 import { Collection, CollectionOptions, RepositoryType } from './collection';
 import { ImporterReader, ImportFileExtension } from './collection-importer';
 import * as FieldTypes from './fields';
 import { Field, FieldContext, RelationField } from './fields';
+import { Migrations } from './migration';
 import { Model } from './model';
 import { ModelHook } from './model-hook';
 import extendOperators from './operators';
@@ -36,9 +38,10 @@ interface MapOf<T> {
 
 export interface IDatabaseOptions extends Options {
   tablePrefix?: string;
+  migrator?: any;
 }
 
-export type DatabaseOptions = IDatabaseOptions | Sequelize;
+export type DatabaseOptions = IDatabaseOptions;
 
 interface RegisterOperatorsContext {
   db?: Database;
@@ -55,6 +58,8 @@ type OperatorFunc = (value: any, ctx?: RegisterOperatorsContext) => any;
 
 export class Database extends EventEmitter implements AsyncEmitter {
   sequelize: Sequelize;
+  migrator: Umzug;
+  migrations: Migrations;
   fieldTypes = new Map();
   options: IDatabaseOptions;
   models = new Map<string, ModelCtor<Model>>();
@@ -71,27 +76,30 @@ export class Database extends EventEmitter implements AsyncEmitter {
   constructor(options: DatabaseOptions) {
     super();
 
-    if (options instanceof Sequelize) {
-      this.sequelize = options;
-    } else {
-      const opts = {
-        sync: {
-          alter: {
-            drop: false,
-          },
-          force: false,
+    const opts = {
+      sync: {
+        alter: {
+          drop: false,
         },
-        ...options,
-      };
-      if (options.storage && options.storage !== ':memory:') {
-        if (!isAbsolute(options.storage)) {
-          opts.storage = resolve(process.cwd(), options.storage);
-        }
+        force: false,
+      },
+      ...options,
+    };
+
+    if (options.storage && options.storage !== ':memory:') {
+      if (!isAbsolute(options.storage)) {
+        opts.storage = resolve(process.cwd(), options.storage);
       }
-      this.sequelize = new Sequelize(opts);
-      this.options = opts;
     }
 
+    if (options.dialect === 'sqlite') {
+      delete opts.timezone;
+    } else if (!opts.timezone) {
+      opts.timezone = '+00:00';
+    }
+
+    this.sequelize = new Sequelize(opts);
+    this.options = opts;
     this.collections = new Map();
     this.modelHook = new ModelHook(this);
 
@@ -116,6 +124,32 @@ export class Database extends EventEmitter implements AsyncEmitter {
     }
 
     this.initOperators();
+
+    const migratorOptions: any = this.options.migrator || {};
+
+    const context = {
+      db: this,
+      sequelize: this.sequelize,
+      queryInterface: this.sequelize.getQueryInterface(),
+      ...migratorOptions.context,
+    };
+
+    this.migrations = new Migrations(context);
+
+    this.migrator = new Umzug({
+      logger: migratorOptions.logger || console,
+      migrations: this.migrations.callback(),
+      context,
+      storage: new SequelizeStorage({
+        modelName: `${this.options.tablePrefix||''}migrations`,
+        ...migratorOptions.storage,
+        sequelize: this.sequelize,
+      }),
+    });
+  }
+
+  addMigration(item) {
+    return this.migrations.add(item);
   }
 
   /**

package/src/index.ts

@@ -4,6 +4,7 @@ export * from './database';
 export { Database as default } from './database';
 export * from './fields';
 export * from './magic-attribute-model';
+export * from './migration';
 export * from './mock-database';
 export * from './model';
 export * from './relation-repository/belongs-to-many-repository';

package/src/migration.ts

@@ -0,0 +1,75 @@
+import { QueryInterface, Sequelize } from 'sequelize';
+import Database from './database';
+
+export interface MigrationContext {
+  db: Database;
+  queryInterface: QueryInterface;
+  sequelize: Sequelize;
+}
+
+export class Migration {
+  public name: string;
+
+  public context: { db: Database };
+
+  constructor(context: MigrationContext) {
+    this.context = context;
+  }
+
+  get db() {
+    return this.context.db;
+  }
+
+  get sequelize() {
+    return this.context.db.sequelize;
+  }
+
+  get queryInterface() {
+    return this.context.db.sequelize.getQueryInterface();
+  }
+
+  async up() {
+    // todo
+  }
+
+  async down() {
+    // todo
+  }
+}
+
+export interface MigrationItem {
+  name: string;
+  migration?: typeof Migration;
+  up?: any;
+  down?: any;
+}
+
+export class Migrations {
+  items = [];
+  context: any;
+
+  constructor(context: any) {
+    this.context = context;
+  }
+
+  clear() {
+    this.items = [];
+  }
+
+  add(item: MigrationItem) {
+    const Migration = item.migration;
+    if (Migration) {
+      const migration = new Migration(this.context);
+      migration.name = item.name;
+      this.items.push(migration);
+    } else {
+      this.items.push(item);
+    }
+  }
+
+  callback() {
+    return (ctx) => {
+      return this.items;
+    };
+  }
+}

package/src/mock-database.ts

@@ -33,6 +33,7 @@ export function getConfigByEnv() {
       charset: 'utf8mb4',
       collate: 'utf8mb4_unicode_ci',
     },
+    timezone: process.env.DB_TIMEZONE,
   };
 }