@nocobase/database 0.9.0-alpha.2 → 0.9.1-alpha.1

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

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StringValueParser = void 0;
+
+var _baseValueParser = require("./base-value-parser");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+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 StringValueParser extends _baseValueParser.BaseValueParser {
+  setValue(value) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const _this$getOptions = _this.getOptions(),
+            map = _this$getOptions.map,
+            set = _this$getOptions.set;
+
+      if (set.size > 0) {
+        if (map.has(value)) {
+          value = map.get(value);
+        }
+
+        if (set.has(value)) {
+          _this.value = value;
+        } else {
+          _this.errors.push(`No matching option found - ${JSON.stringify(value)}`);
+        }
+      } else {
+        _this.value = value;
+      }
+    })();
+  }
+
+  getOptions() {
+    var _this$field$options, _this$field$options$u;
+
+    const options = ((_this$field$options = this.field.options) === null || _this$field$options === void 0 ? void 0 : (_this$field$options$u = _this$field$options['uiSchema']) === null || _this$field$options$u === void 0 ? void 0 : _this$field$options$u.enum) || [];
+    const map = new Map();
+    const set = new Set();
+
+    var _iterator = _createForOfIteratorHelper(options),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const option = _step.value;
+        set.add(option.value);
+        set.add(option.label);
+        map.set(option.label, option.value);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return {
+      map,
+      set
+    };
+  }
+
+}
+
+exports.StringValueParser = StringValueParser;

package/lib/value-parsers/to-many-value-parser.d.ts

@@ -0,0 +1,13 @@
+import { BaseValueParser } from './base-value-parser';
+export declare class ToManyValueParser extends BaseValueParser {
+    setAccessors: {
+        attachment: string;
+        chinaRegion: string;
+    };
+    setAttachments(value: any): Promise<void>;
+    setChinaRegion(value: any): Promise<void>;
+    setAssociations(value: any): Promise<void>;
+    setValue(value: any): Promise<void>;
+    getInterface(): string;
+    isInterface(name: string): boolean;
+}

package/lib/value-parsers/to-many-value-parser.js

@@ -0,0 +1,169 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ToManyValueParser = void 0;
+
+function _path() {
+  const data = require("path");
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+var _baseValueParser = require("./base-value-parser");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+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 ToManyValueParser extends _baseValueParser.BaseValueParser {
+  constructor(...args) {
+    super(...args);
+    this.setAccessors = {
+      attachment: 'setAttachments',
+      chinaRegion: 'setChinaRegion'
+    };
+  }
+
+  setAttachments(value) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      _this.value = _this.toArr(value).map(url => {
+        return {
+          title: (0, _path().basename)(url),
+          extname: (0, _path().extname)(url),
+          filename: (0, _path().basename)(url),
+          url
+        };
+      });
+    })();
+  }
+
+  setChinaRegion(value) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      const repository = _this2.field.database.getRepository(_this2.field.target);
+
+      try {
+        const values = [];
+
+        const names = _this2.toArr(value, '/');
+
+        let parentCode = null;
+
+        var _iterator = _createForOfIteratorHelper(names),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            const name = _step.value;
+            const instance = yield repository.findOne({
+              filter: {
+                name: name.trim(),
+                parentCode
+              }
+            });
+
+            if (!instance) {
+              throw new Error(`"${value}" does not exist`);
+            }
+
+            parentCode = instance.get('code');
+            values.push(parentCode);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+
+        if (values.length !== names.length) {
+          throw new Error(`"${value}" does not exist`);
+        }
+
+        _this2.value = values;
+      } catch (error) {
+        _this2.errors.push(error.message);
+      }
+    })();
+  }
+
+  setAssociations(value) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      var _this3$ctx, _this3$ctx$column;
+
+      const dataIndex = ((_this3$ctx = _this3.ctx) === null || _this3$ctx === void 0 ? void 0 : (_this3$ctx$column = _this3$ctx.column) === null || _this3$ctx$column === void 0 ? void 0 : _this3$ctx$column.dataIndex) || [];
+
+      if (Array.isArray(dataIndex) && dataIndex.length < 2) {
+        _this3.errors.push(`data index invalid`);
+
+        return;
+      }
+
+      const key = _this3.ctx.column.dataIndex[1];
+
+      const repository = _this3.field.database.getRepository(_this3.field.target);
+
+      try {
+        _this3.value = yield Promise.all(_this3.toArr(value).map( /*#__PURE__*/function () {
+          var _ref = _asyncToGenerator(function* (v) {
+            const instance = yield repository.findOne({
+              filter: {
+                [key]: v
+              }
+            });
+
+            if (!instance) {
+              throw new Error(`"${v}" does not exist`);
+            }
+
+            return instance.get(_this3.field.targetKey || 'id');
+          });
+
+          return function (_x) {
+            return _ref.apply(this, arguments);
+          };
+        }()));
+      } catch (error) {
+        _this3.errors.push(error.message);
+      }
+    })();
+  }
+
+  setValue(value) {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      const setAccessor = _this4.setAccessors[_this4.getInterface()] || 'setAssociations';
+      yield _this4[setAccessor](value);
+    })();
+  }
+
+  getInterface() {
+    var _this$field, _this$field$options;
+
+    return (_this$field = this.field) === null || _this$field === void 0 ? void 0 : (_this$field$options = _this$field.options) === null || _this$field$options === void 0 ? void 0 : _this$field$options.interface;
+  }
+
+  isInterface(name) {
+    return this.getInterface() === name;
+  }
+
+}
+
+exports.ToManyValueParser = ToManyValueParser;

package/lib/value-parsers/to-one-value-parser.d.ts

@@ -0,0 +1,4 @@
+import { BaseValueParser } from './base-value-parser';
+export declare class ToOneValueParser extends BaseValueParser {
+    setValue(value: any): Promise<void>;
+}

package/lib/value-parsers/to-one-value-parser.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ToOneValueParser = void 0;
+
+var _baseValueParser = require("./base-value-parser");
+
+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 ToOneValueParser extends _baseValueParser.BaseValueParser {
+  setValue(value) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      var _this$ctx, _this$ctx$column;
+
+      const dataIndex = ((_this$ctx = _this.ctx) === null || _this$ctx === void 0 ? void 0 : (_this$ctx$column = _this$ctx.column) === null || _this$ctx$column === void 0 ? void 0 : _this$ctx$column.dataIndex) || [];
+
+      if (Array.isArray(dataIndex) && dataIndex.length < 2) {
+        _this.errors.push(`data index invalid`);
+
+        return;
+      }
+
+      const key = _this.ctx.column.dataIndex[1];
+
+      const repository = _this.field.database.getRepository(_this.field.target);
+
+      const instance = yield repository.findOne({
+        filter: {
+          [key]: _this.trim(value)
+        }
+      });
+
+      if (instance) {
+        _this.value = instance.get(_this.field.targetKey || 'id');
+      } else {
+        _this.errors.push(`"${value}" does not exist`);
+      }
+    })();
+  }
+
+}
+
+exports.ToOneValueParser = ToOneValueParser;

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@nocobase/database",
-  "version": "0.9.0-alpha.2",
+  "version": "0.9.1-alpha.1",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
-    "@nocobase/utils": "0.9.0-alpha.2",
+    "@nocobase/utils": "0.9.1-alpha.1",
     "async-mutex": "^0.3.2",
     "cron-parser": "4.4.0",
     "deepmerge": "^4.2.2",
+    "excel-date-to-js": "^1.1.5",
     "flat": "^5.0.2",
     "glob": "^7.1.6",
     "mathjs": "^10.6.1",
@@ -26,5 +27,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "b8f76ad38e60e677c5bb4aab0a4cdb28d98a0f49"
+  "gitHead": "56cb184b00dc383b853015d525bf6e79dea92169"
 }

package/src/__tests__/bigint.test.ts

@@ -43,6 +43,6 @@ excludeSqlite()('collection', () => {
 
     const profileTableInfo = await db.sequelize.getQueryInterface().describeTable(profile.model.tableName);
 
-    expect(profileTableInfo['userId'].type).toBe('BIGINT');
+    expect(profileTableInfo[profile.model.rawAttributes['userId'].field].type).toBe('BIGINT');
   });
 });

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

@@ -7,7 +7,19 @@ describe('collection importer', () => {
     const reader = new ImporterReader(path.resolve(__dirname, './fixtures/collections'));
 
     const modules = await reader.read();
-    expect(modules).toBeDefined();
+
+    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 () => {

package/src/__tests__/collection.test.ts

@@ -8,9 +8,7 @@ describe('collection', () => {
   let db: Database;
 
   beforeEach(async () => {
-    db = mockDatabase({
-      logging: console.log,
-    });
+    db = mockDatabase();
 
     await db.clean({ drop: true });
   });
@@ -240,9 +238,15 @@ describe('collection sync', () => {
     await collection.sync();
     const tableFields = await (<any>collection.model).queryInterface.describeTable(`${db.getTablePrefix()}users`);
 
-    expect(tableFields).toHaveProperty('firstName');
-    expect(tableFields).toHaveProperty('lastName');
-    expect(tableFields).toHaveProperty('age');
+    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 () => {
@@ -290,9 +294,15 @@ describe('collection sync', () => {
 
     const model = collection.model;
     await collection.sync();
-    const tableFields = await (<any>model).queryInterface.describeTable(`${db.getTablePrefix()}postsTags`);
-    expect(tableFields['postId']).toBeDefined();
-    expect(tableFields['tagId']).toBeDefined();
+    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 () => {

package/src/__tests__/database.test.ts

@@ -285,4 +285,36 @@ describe('database', () => {
     test.customMethod();
     expect(test.get('abc')).toBe('abc');
   });
+
+  test('getFieldByPath', () => {
+    db.collection({
+      name: 'users',
+      fields: [{ type: 'hasMany', name: 'p', target: 'posts' }],
+    });
+    db.collection({
+      name: 'comments',
+      fields: [{ type: 'string', name: 'title' }],
+    });
+    db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'hasMany', name: 'c', target: 'comments' },
+        { type: 'belongsToMany', name: 't', target: 'tags' },
+      ],
+    });
+    db.collection({
+      name: 'tags',
+      fields: [{ type: 'string', name: 'title' }],
+    });
+    const f1 = db.getFieldByPath('users.p.t');
+    const f2 = db.getFieldByPath('users.p.c');
+    const f3 = db.getFieldByPath('users.p');
+    expect(f1.name).toBe('t');
+    expect(f2.name).toBe('c');
+    expect(f3.name).toBe('p');
+    expect(db.getFieldByPath('users.d')).toBeNull;
+    expect(db.getFieldByPath('users.d.e')).toBeNull;
+    expect(db.getFieldByPath('users.p.f')).toBeNull;
+    expect(db.getFieldByPath('users.p.c.j')).toBeNull;
+  });
 });

package/src/__tests__/fields/sort-field.test.ts

@@ -17,6 +17,29 @@ describe('string field', () => {
     await db.close();
   });
 
+  it('should init sorted value by createdAt when primaryKey not exists', async () => {
+    const Test = db.collection({
+      autoGenId: false,
+      name: 'tests',
+    });
+
+    await db.sync();
+    await Test.repository.create({
+      values: [{}, {}, {}],
+    });
+
+    // add sort field
+    Test.setField('sort', { type: 'sort' });
+
+    let err;
+    try {
+      await db.sync();
+    } catch (e) {
+      err = e;
+    }
+    expect(err).toBeFalsy();
+  });
+
   it('sort', async () => {
     const Test = db.collection({
       name: 'tests',

package/src/__tests__/inhertits/collection-inherits.test.ts

@@ -886,11 +886,13 @@ pgOnly()('collection inherits', () => {
 
     const studentTableInfo = await db.sequelize.getQueryInterface().describeTable(student.model.tableName);
 
-    expect(studentTableInfo.score).toBeDefined();
-    expect(studentTableInfo.name).toBeDefined();
-    expect(studentTableInfo.id).toBeDefined();
-    expect(studentTableInfo.createdAt).toBeDefined();
-    expect(studentTableInfo.updatedAt).toBeDefined();
+    const getField = (name) => student.model.rawAttributes[name].field;
+
+    expect(studentTableInfo[getField('score')]).toBeDefined();
+    expect(studentTableInfo[getField('name')]).toBeDefined();
+    expect(studentTableInfo[getField('id')]).toBeDefined();
+    expect(studentTableInfo[getField('createdAt')]).toBeDefined();
+    expect(studentTableInfo[getField('updatedAt')]).toBeDefined();
   });
 
   it('should get parent fields', async () => {

package/src/__tests__/percent2float.test.ts

@@ -0,0 +1,14 @@
+import { percent2float } from '../utils';
+
+describe('percent2float', () => {
+  it('should be NaN', () => {
+    expect(percent2float('123')).toBe(NaN);
+    expect(percent2float('3a')).toBe(NaN);
+    expect(percent2float('3a%')).toBe(NaN);
+  });
+
+  it('should be a floating point number', () => {
+    expect(percent2float('123%')).toBe(1.23);
+    expect(percent2float('22.5507%')).toBe(0.225507); // not 0.22550699999999999
+  });
+});

package/src/__tests__/postgres/schema.test.ts

@@ -0,0 +1,120 @@
+import { mockDatabase } from '../index';
+import { Database } from '../../database';
+import { randomStr } from '@nocobase/test';
+
+describe('auth', () => {
+  let db: Database;
+  afterEach(async () => {
+    if (db) {
+      await db.close();
+    }
+  });
+
+  it('should auto create schema on prepare when schema missing', async () => {
+    const schemaName = randomStr();
+
+    db = mockDatabase({
+      schema: schemaName,
+    });
+
+    if (!db.inDialect('postgres')) return;
+
+    const querySchemaExists = async () =>
+      await db.sequelize.query(
+        `SELECT schema_name
+         FROM information_schema.schemata
+         WHERE schema_name = '${schemaName}';`,
+      );
+
+    expect((await querySchemaExists())[0].length).toEqual(0);
+    await db.prepare();
+    expect((await querySchemaExists())[0].length).toEqual(1);
+  });
+});
+
+describe('postgres schema', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase({
+      schema: 'test_schema',
+    });
+
+    if (!db.inDialect('postgres')) return;
+  });
+
+  afterEach(async () => {
+    if (db.inDialect('postgres')) {
+      await db.sequelize.query(`DROP SCHEMA IF EXISTS ${db.options.schema} CASCADE;`);
+    }
+    await db.close();
+  });
+
+  it('should drop all tables in schemas', async () => {
+    if (!db.inDialect('postgres')) return;
+
+    const collection = db.collection({
+      name: 'test',
+    });
+
+    await db.sync();
+
+    await db.clean({ drop: true });
+
+    const tableInfo = await db.sequelize.query(
+      `SELECT *
+       FROM information_schema.tables
+       where table_schema = '${db.options.schema}'`,
+    );
+
+    expect(tableInfo[0].length).toEqual(0);
+  });
+
+  it('should support database schema option', async () => {
+    if (!db.inDialect('postgres')) return;
+
+    await db.clean({ drop: true });
+
+    const tableInfo = await db.sequelize.query(
+      `SELECT *
+       FROM information_schema.tables
+       where table_schema = '${db.options.schema}'`,
+    );
+
+    expect(tableInfo[0].length).toEqual(0);
+
+    const collection = db.collection({
+      name: 'test',
+    });
+
+    await db.sync();
+
+    const newTableInfo = await db.sequelize.query(
+      `SELECT *
+       FROM information_schema.tables
+       where table_schema = '${db.options.schema}'`,
+    );
+
+    expect(newTableInfo[0].find((item) => item['table_name'] == collection.model.tableName)).toBeTruthy();
+  });
+
+  it('should update schema options', async () => {
+    if (!db.inDialect('postgres')) return;
+
+    await db.clean({ drop: true });
+
+    const collection = db.collection({
+      name: 'test',
+    });
+
+    await db.sync();
+
+    collection.updateOptions({
+      ...collection.options,
+      schema: 'test',
+    });
+
+    // @ts-ignore
+    expect(collection.model._schema).toEqual('test');
+  });
+});