@nocobase/database 0.11.1-alpha.5 → 0.12.0-alpha.2

package/lib/fields/json-field.js

@@ -14,6 +14,11 @@ function _sequelize() {
 var _field = require("./field");
 class JsonField extends _field.Field {
   get dataType() {
+    const dialect = this.context.database.sequelize.getDialect();
+    const jsonb = this.options.jsonb;
+    if (dialect === 'postgres' && jsonb) {
+      return _sequelize().DataTypes.JSONB;
+    }
     return _sequelize().DataTypes.JSON;
   }
 }

package/lib/value-parsers/date-value-parser.js

@@ -11,6 +11,13 @@ function _utils() {
   };
   return data;
 }
+function _dayjs() {
+  const data = _interopRequireDefault(require("dayjs"));
+  _dayjs = function _dayjs() {
+    return data;
+  };
+  return data;
+}
 function _excelDateToJs() {
   const data = require("excel-date-to-js");
   _excelDateToJs = function _excelDateToJs() {
@@ -19,6 +26,7 @@ function _excelDateToJs() {
   return data;
 }
 var _baseValueParser = require("./base-value-parser");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 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); }); }; }
 function isNumeric(str) {
@@ -30,7 +38,7 @@ class DateValueParser extends _baseValueParser.BaseValueParser {
   setValue(value) {
     var _this = this;
     return _asyncToGenerator(function* () {
-      if (_utils().dayjs.isDayjs(value)) {
+      if (_dayjs().default.isDayjs(value)) {
         _this.value = value;
       } else if (isDate(value)) {
         _this.value = value;
@@ -42,7 +50,7 @@ class DateValueParser extends _baseValueParser.BaseValueParser {
         }
       } else if (typeof value === 'string') {
         const props = _this.getProps();
-        const m = (0, _utils().dayjs)(value);
+        const m = (0, _dayjs().default)(value);
         if (m.isValid()) {
           _this.value = (0, _utils().moment2str)(m, props);
         } else {

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "0.11.1-alpha.5",
+  "version": "0.12.0-alpha.2",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
-    "@nocobase/logger": "0.11.1-alpha.5",
-    "@nocobase/utils": "0.11.1-alpha.5",
+    "@nocobase/logger": "0.12.0-alpha.2",
+    "@nocobase/utils": "0.12.0-alpha.2",
     "async-mutex": "^0.3.2",
     "cron-parser": "4.4.0",
     "dayjs": "^1.11.8",
@@ -29,5 +29,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "1dcfd15a7d95a40b0a2f60e1de19ec574066fb20"
+  "gitHead": "a95e9e2666f0318c955113a4735bc005a2c9a767"
 }

package/src/__tests__/bigint.test.ts

@@ -1,48 +0,0 @@
-import { Database } from '../database';
-import { mockDatabase } from './index';
-
-const excludeSqlite = () => (process.env.DB_DIALECT != 'sqlite' ? describe : describe.skip);
-
-excludeSqlite()('collection', () => {
-  let db: Database;
-
-  beforeEach(async () => {
-    db = mockDatabase({
-      logging: console.log,
-    });
-
-    await db.clean({ drop: true });
-  });
-
-  afterEach(async () => {
-    await db.close();
-  });
-
-  it('should using bigint for id field', async () => {
-    const collection = db.collection({
-      name: 'users',
-      fields: [{ type: 'hasOne', name: 'profile' }],
-    });
-
-    await db.sync();
-    const tableInfo = await db.sequelize.getQueryInterface().describeTable(collection.model.tableName);
-
-    expect(tableInfo['id'].type).toBe('BIGINT');
-
-    const profile = db.collection({
-      name: 'profiles',
-      fields: [
-        {
-          type: 'belongsTo',
-          name: 'user',
-        },
-      ],
-    });
-
-    await db.sync();
-
-    const profileTableInfo = await db.sequelize.getQueryInterface().describeTable(profile.model.tableName);
-
-    expect(profileTableInfo[profile.model.rawAttributes['userId'].field].type).toBe('BIGINT');
-  });
-});

package/src/__tests__/collection-importer.test.ts

@@ -1,33 +0,0 @@
-import { ImporterReader } from '../collection-importer';
-import * as path from 'path';
-import { extend } from '../database';
-
-describe('collection importer', () => {
-  test('import reader', async () => {
-    const reader = new ImporterReader(path.resolve(__dirname, './fixtures/collections'));
-
-    const modules = await reader.read();
-
-    const posts = modules.find((m) => m.name === 'posts');
-
-    expect(posts).toMatchObject({
-      name: 'posts',
-      fields: [{ type: 'string', name: 'title' }],
-    });
-
-    posts.schema = 'test';
-
-    const modules2 = await reader.read();
-    const posts2 = modules2.find((m) => m.name === 'posts');
-    expect(posts2.schema).toBeFalsy();
-  });
-
-  test('extend', async () => {
-    const extendObject = extend({
-      name: 'tags',
-      fields: [{ type: 'string', name: 'title' }],
-    });
-
-    expect(extendObject).toHaveProperty('extend');
-  });
-});

package/src/__tests__/collection.sortable.test.ts

@@ -1,65 +0,0 @@
-import { mockDatabase } from './index';
-import { Database } from '../database';
-
-describe('collection sortable options', () => {
-  let db: Database;
-
-  beforeEach(async () => {
-    db = mockDatabase();
-  });
-
-  afterEach(async () => {
-    await db.close();
-  });
-
-  test('sortable=true', async () => {
-    const Test = db.collection({
-      name: 'test',
-      sortable: true,
-    });
-
-    const model = Test.model;
-
-    await db.sync();
-    const instance = await model.create();
-    expect(model.rawAttributes['sort']).toBeDefined();
-    expect(instance.get('sort')).toBe(1);
-  });
-
-  test('sortable=string', async () => {
-    const Test = db.collection({
-      name: 'test',
-      sortable: 'order',
-    });
-
-    const model = Test.model;
-
-    await db.sync();
-    const instance = await model.create();
-    expect(model.rawAttributes['order']).toBeDefined();
-    expect(instance.get('order')).toBe(1);
-  });
-
-  test('sortable=object', async () => {
-    const Test = db.collection({
-      name: 'test',
-      sortable: {
-        name: 'sort',
-        scopeKey: 'status',
-      },
-      fields: [{ type: 'string', name: 'status' }],
-    });
-
-    await db.sync();
-
-    const t1 = await Test.model.create({ status: 'publish' });
-    const t2 = await Test.model.create({ status: 'publish' });
-    const t3 = await Test.model.create({ status: 'draft' });
-    const t4 = await Test.model.create({ status: 'draft' });
-
-    expect(t1.get('sort')).toBe(1);
-    expect(t2.get('sort')).toBe(2);
-    expect(t3.get('sort')).toBe(1);
-    expect(t4.get('sort')).toBe(2);
-  });
-});

package/src/__tests__/collection.test.ts

@@ -1,416 +0,0 @@
-import { Collection } from '../collection';
-import { Database } from '../database';
-import { mockDatabase } from './index';
-import { IdentifierError } from '../errors/identifier-error';
-
-const pgOnly = () => (process.env.DB_DIALECT == 'postgres' ? it : it.skip);
-describe('collection', () => {
-  let db: Database;
-
-  beforeEach(async () => {
-    db = mockDatabase();
-
-    await db.clean({ drop: true });
-  });
-
-  afterEach(async () => {
-    await db.close();
-  });
-
-  it('should remove sequelize model prototype methods after field remove', async () => {
-    db.collection({
-      name: 'tags',
-    });
-
-    const UserCollection = db.collection({
-      name: 'users',
-      fields: [{ type: 'belongsToMany', name: 'tags' }],
-    });
-
-    console.log(Object.getOwnPropertyNames(UserCollection.model.prototype));
-
-    await UserCollection.removeField('tags');
-
-    console.log(Object.getOwnPropertyNames(UserCollection.model.prototype));
-    // @ts-ignore
-    expect(UserCollection.model.prototype.getTags).toBeUndefined();
-  });
-
-  it('should not throw error when create empty collection in sqlite and mysql', async () => {
-    if (!db.inDialect('sqlite', 'mysql')) {
-      return;
-    }
-
-    db.collection({
-      name: 'empty',
-      timestamps: false,
-      autoGenId: false,
-      fields: [],
-    });
-
-    let error;
-
-    try {
-      await db.sync({
-        force: false,
-        alter: {
-          drop: false,
-        },
-      });
-    } catch (e) {
-      error = e;
-    }
-
-    expect(error).toBeUndefined();
-  });
-
-  pgOnly()('can create empty collection', async () => {
-    db.collection({
-      name: 'empty',
-      timestamps: false,
-      autoGenId: false,
-      fields: [],
-    });
-
-    await db.sync({
-      force: false,
-      alter: {
-        drop: false,
-      },
-    });
-
-    expect(db.getCollection('empty')).toBeInstanceOf(Collection);
-  });
-
-  test('removeFromDb', async () => {
-    await db.clean({ drop: true });
-    const collection = db.collection({
-      name: 'test',
-      fields: [
-        {
-          type: 'string',
-          name: 'name',
-        },
-      ],
-    });
-    await db.sync();
-
-    const field = collection.getField('name');
-    const r1 = await field.existsInDb();
-    expect(r1).toBe(true);
-    await field.removeFromDb();
-    const r2 = await field.existsInDb();
-    expect(r2).toBe(false);
-
-    const r3 = await collection.existsInDb();
-    expect(r3).toBe(true);
-    await collection.removeFromDb();
-    const r4 = await collection.existsInDb();
-    expect(r4).toBe(false);
-  });
-
-  test('collection disable authGenId', async () => {
-    const Test = db.collection({
-      name: 'test',
-      autoGenId: false,
-      fields: [{ type: 'string', name: 'uid', primaryKey: true }],
-    });
-
-    const model = Test.model;
-
-    await db.sync();
-    expect(model.rawAttributes['id']).toBeUndefined();
-  });
-
-  test('new collection', async () => {
-    const collection = new Collection(
-      {
-        name: 'test',
-      },
-      { database: db },
-    );
-
-    expect(collection.name).toEqual('test');
-  });
-
-  test('collection create field', async () => {
-    const collection = new Collection(
-      {
-        name: 'user',
-      },
-      { database: db },
-    );
-
-    collection.addField('age', {
-      type: 'integer',
-    });
-
-    const ageField = collection.getField('age');
-    expect(ageField).toBeDefined();
-    expect(collection.hasField('age')).toBeTruthy();
-    expect(collection.hasField('test')).toBeFalsy();
-
-    collection.removeField('age');
-    expect(collection.hasField('age')).toBeFalsy();
-  });
-
-  test('collection set fields', () => {
-    const collection = new Collection(
-      {
-        name: 'user',
-      },
-      { database: db },
-    );
-
-    collection.setFields([{ type: 'string', name: 'firstName' }]);
-    expect(collection.hasField('firstName')).toBeTruthy();
-  });
-
-  test('update collection field', async () => {
-    const collection = new Collection(
-      {
-        name: 'posts',
-        fields: [{ type: 'string', name: 'title' }],
-      },
-      {
-        database: db,
-      },
-    );
-    expect(collection.hasField('title')).toBeTruthy();
-
-    collection.updateField('title', {
-      type: 'string',
-      name: 'content',
-    });
-
-    expect(collection.hasField('title')).toBeFalsy();
-    expect(collection.hasField('content')).toBeTruthy();
-  });
-
-  test('collection with association', async () => {
-    const User = db.collection({
-      name: 'users',
-      fields: [
-        { type: 'string', name: 'name' },
-        { type: 'integer', name: 'age' },
-        { type: 'hasMany', name: 'posts' },
-      ],
-    });
-
-    const Post = db.collection({
-      name: 'posts',
-      fields: [
-        { type: 'string', name: 'title' },
-        { type: 'string', name: 'content' },
-        {
-          type: 'belongsTo',
-          name: 'user',
-        },
-        {
-          type: 'hasMany',
-          name: 'comments',
-        },
-      ],
-    });
-
-    const Comment = db.collection({
-      name: 'comments',
-      fields: [
-        { type: 'string', name: 'content' },
-        { type: 'string', name: 'comment_as' },
-        { type: 'belongsTo', name: 'post' },
-      ],
-    });
-
-    expect(User.model.associations['posts']).toBeDefined();
-    expect(Post.model.associations['comments']).toBeDefined();
-
-    expect(User.model.associations['posts'].target.associations['comments']).toBeDefined();
-  });
-});
-
-describe('collection sync', () => {
-  let db: Database;
-
-  beforeEach(async () => {
-    db = mockDatabase();
-  });
-
-  afterEach(async () => {
-    await db.close();
-  });
-
-  test('sync fields', async () => {
-    const collection = new Collection(
-      {
-        name: 'users',
-      },
-      { database: db },
-    );
-
-    collection.setFields([
-      { type: 'string', name: 'firstName' },
-      { type: 'string', name: 'lastName' },
-      { type: 'integer', name: 'age' },
-    ]);
-
-    await collection.sync();
-    const tableFields = await (<any>collection.model).queryInterface.describeTable(`${db.getTablePrefix()}users`);
-
-    if (db.options.underscored) {
-      expect(tableFields).toHaveProperty('first_name');
-      expect(tableFields).toHaveProperty('last_name');
-      expect(tableFields).toHaveProperty('age');
-    } else {
-      expect(tableFields).toHaveProperty('firstName');
-      expect(tableFields).toHaveProperty('lastName');
-      expect(tableFields).toHaveProperty('age');
-    }
-  });
-
-  test('sync with association not exists', async () => {
-    const collection = new Collection(
-      {
-        name: 'posts',
-        fields: [
-          { type: 'string', name: 'title' },
-          { type: 'belongsTo', name: 'users' },
-        ],
-      },
-      { database: db },
-    );
-
-    await collection.sync();
-
-    const model = collection.model;
-
-    const tableFields = await (<any>model).queryInterface.describeTable(`${db.getTablePrefix()}posts`);
-
-    expect(tableFields['userId']).toBeUndefined();
-  });
-
-  test('sync with association', async () => {
-    new Collection(
-      {
-        name: 'tags',
-        fields: [{ type: 'string', name: 'name' }],
-      },
-      { database: db },
-    );
-
-    const collection = new Collection(
-      {
-        name: 'posts',
-        fields: [
-          { type: 'string', name: 'title' },
-          { type: 'belongsToMany', name: 'tags' },
-        ],
-      },
-      {
-        database: db,
-      },
-    );
-
-    const model = collection.model;
-    await collection.sync();
-    if (db.options.underscored) {
-      const tableFields = await (<any>model).queryInterface.describeTable(`${db.getTablePrefix()}posts_tags`);
-      expect(tableFields['post_id']).toBeDefined();
-      expect(tableFields['tag_id']).toBeDefined();
-    } else {
-      const tableFields = await (<any>model).queryInterface.describeTable(`${db.getTablePrefix()}postsTags`);
-      expect(tableFields['postId']).toBeDefined();
-      expect(tableFields['tagId']).toBeDefined();
-    }
-  });
-
-  test('limit table name length', async () => {
-    const longName =
-      'this_is_a_very_long_table_name_that_should_be_truncated_this_is_a_very_long_table_name_that_should_be_truncated';
-
-    let error;
-
-    try {
-      const collection = new Collection(
-        {
-          name: longName,
-          fields: [{ type: 'string', name: 'test' }],
-        },
-        {
-          database: db,
-        },
-      );
-    } catch (e) {
-      error = e;
-    }
-
-    expect(error).toBeInstanceOf(IdentifierError);
-  });
-
-  it('should throw error when collection has same table name and same schema', async () => {
-    const c1 = db.collection({
-      name: 'test',
-      tableName: 'test',
-      schema: 'public',
-    });
-
-    let err;
-
-    try {
-      const c2 = db.collection({
-        name: 'test2',
-        tableName: 'test',
-        schema: 'public',
-      });
-    } catch (e) {
-      err = e;
-    }
-
-    expect(err.message).toContain('have same tableName');
-  });
-
-  it('should allow same table name in difference schema', async () => {
-    const c1 = db.collection({
-      name: 'test',
-      tableName: 'test',
-      schema: 'public',
-    });
-
-    let err;
-
-    try {
-      const c2 = db.collection({
-        name: 'test2',
-        tableName: 'test',
-        schema: 'other_schema',
-      });
-    } catch (e) {
-      err = e;
-    }
-
-    expect(err).toBeFalsy();
-  });
-
-  test('limit field name length', async () => {
-    const longFieldName =
-      'this_is_a_very_long_field_name_that_should_be_truncated_this_is_a_very_long_field_name_that_should_be_truncated';
-
-    let error;
-
-    try {
-      const collection = new Collection(
-        {
-          name: 'test',
-          fields: [{ type: 'string', name: longFieldName }],
-        },
-        {
-          database: db,
-        },
-      );
-    } catch (e) {
-      error = e;
-    }
-
-    expect(error).toBeInstanceOf(IdentifierError);
-  });
-});

package/src/__tests__/database.import.test.ts

@@ -1,33 +0,0 @@
-import { mockDatabase } from './index';
-import path from 'path';
-import Database from '../database';
-
-describe('database', () => {
-  let db: Database;
-
-  beforeEach(() => {
-    db = mockDatabase();
-  });
-
-  afterEach(async () => {
-    await db.close();
-  });
-
-  test('import', async () => {
-    await db.import({
-      directory: path.resolve(__dirname, './fixtures/c0'),
-    });
-    await db.import({
-      directory: path.resolve(__dirname, './fixtures/c1'),
-    });
-    await db.import({
-      directory: path.resolve(__dirname, './fixtures/c2'),
-    });
-
-    const test = db.getCollection('tests');
-
-    expect(test.getField('n0')).toBeDefined();
-    expect(test.getField('n1')).toBeDefined();
-    expect(test.getField('n2')).toBeDefined();
-  });
-});