@nocobase/database 0.7.4-alpha.7 → 0.7.6-alpha.1

package/lib/utils.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.checkIdentifier = checkIdentifier;
+exports.handleAppendsQuery = handleAppendsQuery;
+exports.md5 = md5;
+
+function _crypto() {
+  const data = _interopRequireDefault(require("crypto"));
+
+  _crypto = function _crypto() {
+    return data;
+  };
+
+  return data;
+}
+
+var _identifierError = require("./errors/identifier-error");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+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); }); }; }
+
+function handleAppendsQuery(_x) {
+  return _handleAppendsQuery.apply(this, arguments);
+}
+
+function _handleAppendsQuery() {
+  _handleAppendsQuery = _asyncToGenerator(function* (options) {
+    const templateModel = options.templateModel,
+          queryPromises = options.queryPromises;
+    const primaryKey = templateModel.constructor.primaryKeyAttribute;
+    const results = yield Promise.all(queryPromises);
+    let rows;
+
+    var _iterator = _createForOfIteratorHelper(results),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const appendedResult = _step.value;
+
+        if (!rows) {
+          rows = appendedResult.rows;
+
+          if (rows.length == 0) {
+            return [];
+          }
+
+          const modelOptions = templateModel['_options'];
+
+          var _iterator2 = _createForOfIteratorHelper(rows),
+              _step2;
+
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              const row = _step2.value;
+              row['_options'] = _objectSpread(_objectSpread({}, row['_options']), {}, {
+                include: modelOptions['include'],
+                includeNames: modelOptions['includeNames'],
+                includeMap: modelOptions['includeMap']
+              });
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+
+          continue;
+        }
+
+        for (let i = 0; i < appendedResult.rows.length; i++) {
+          const appendingRow = appendedResult.rows[i];
+          const key = appendedResult.include.association;
+          const val = appendingRow.get(key);
+          const rowKey = appendingRow.get(primaryKey);
+          const targetIndex = rows.findIndex(row => row.get(primaryKey) === rowKey);
+
+          if (targetIndex === -1) {
+            throw new Error('target row not found');
+          }
+
+          rows[targetIndex].set(key, val, {
+            raw: true
+          });
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return rows;
+  });
+  return _handleAppendsQuery.apply(this, arguments);
+}
+
+function md5(value) {
+  return _crypto().default.createHash('md5').update(value).digest('hex');
+}
+
+const MAX_IDENTIFIER_LENGTH = 63;
+
+function checkIdentifier(value) {
+  if (value.length > MAX_IDENTIFIER_LENGTH) {
+    throw new _identifierError.IdentifierError(`Identifier ${value} is too long`);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/database",
-  "version": "0.7.4-alpha.7",
+  "version": "0.7.6-alpha.1",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -12,12 +12,14 @@
     }
   ],
   "dependencies": {
-    "@nocobase/utils": "0.7.4-alpha.7",
+    "@nocobase/utils": "0.7.6-alpha.1",
     "async-mutex": "^0.3.2",
+    "cron-parser": "4.4.0",
     "deepmerge": "^4.2.2",
     "flat": "^5.0.2",
     "glob": "^7.1.6",
     "mathjs": "^10.6.1",
+    "moment": "2.x",
     "semver": "^7.3.7",
     "sequelize": "^6.9.0",
     "umzug": "^3.1.1"
@@ -30,5 +32,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "77f22e6da464d19be111835316faf4b94cd80413"
+  "gitHead": "f20ce011a9ac516dc6aec110979f063a0e63f923"
 }

package/src/__tests__/collection.test.ts

@@ -1,6 +1,7 @@
 import { Collection } from '../collection';
 import { Database } from '../database';
 import { mockDatabase } from './index';
+import { IdentifierError } from '../errors/identifier-error';
 
 describe('collection', () => {
   let db: Database;
@@ -258,4 +259,50 @@ describe('collection sync', () => {
     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);
+  });
+
+  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.test.ts

@@ -268,8 +268,10 @@ describe('database', () => {
     });
 
     await Test.sync();
+    expect(Test.model.prototype).toBeInstanceOf(CustomModel);
 
     const test = await Test.model.create<any>();
+    expect(test).toBeInstanceOf(CustomModel);
     test.customMethod();
     expect(test.get('abc')).toBe('abc');
   });

package/src/__tests__/field-options/inddex.test.ts

@@ -0,0 +1,43 @@
+import { mockDatabase } from '../';
+import { Database } from '../../database';
+import { md5 } from '../../utils';
+
+describe('index field options', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('case 1', async () => {
+    const t1 = 't1234567890223456789032345678904234567890523456789';
+    const f1 = 'f1234567890223456789032345678904234567890523456789062345678901';
+    const f2 = 'f1234567890223456789032345678904234567890523456789062345678902';
+    db.collection({
+      name: t1,
+      fields: [
+        {
+          type: 'string',
+          name: f1,
+          index: true,
+        },
+        {
+          type: 'string',
+          name: f2,
+          index: true,
+        },
+      ],
+    });
+    await db.sync();
+    // @ts-ignore
+    const indexes = db.getModel(t1)._indexes;
+    const index1 = indexes.find((item) => item.fields.includes(f1));
+    const index2 = indexes.find((item) => item.fields.includes(f2));
+    expect('i_' + md5(db.getTablePrefix() + `${t1}_${f1}`)).toBe(index1.name);
+    expect('i_' + md5(db.getTablePrefix() + `${t1}_${f2}`)).toBe(index2.name);
+  });
+});

package/src/__tests__/fields/array.test.ts

@@ -0,0 +1,66 @@
+import { mockDatabase } from '../';
+import { Database } from '../../database';
+
+describe('array field', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should not be ambiguous', async () => {
+    db.collection({
+      name: 'a',
+      fields: [
+        {
+          type: 'array',
+          name: 'arr',
+        },
+        {
+          type: 'belongsToMany',
+          name: 'b',
+          target: 'b',
+        },
+      ],
+    });
+    db.collection({
+      name: 'b',
+      fields: [
+        {
+          type: 'array',
+          name: 'arr',
+        },
+      ],
+    });
+    await db.sync();
+    const repository = db.getRepository('a');
+    await repository.find({
+      filter: {
+        'arr.$match': ['aa'],
+      },
+      appends: ['b'],
+    });
+    await repository.find({
+      filter: {
+        'arr.$notMatch': ['aa'],
+      },
+      appends: ['b'],
+    });
+    await repository.find({
+      filter: {
+        'arr.$anyOf': ['aa'],
+      },
+      appends: ['b'],
+    });
+    await repository.find({
+      filter: {
+        'arr.$noneOf': ['aa'],
+      },
+      appends: ['b'],
+    });
+  });
+});

package/src/__tests__/fields/belongs-to-field.test.ts

@@ -1,5 +1,6 @@
 import { Database } from '../../database';
 import { mockDatabase } from '../';
+import { IdentifierError } from '../../errors/identifier-error';
 
 describe('belongs to field', () => {
   let db: Database;
@@ -28,12 +29,16 @@ describe('belongs to field', () => {
         { type: 'belongsTo', name: 'post' },
       ],
     });
+
     expect(Comment.model.associations.post).toBeUndefined();
+
     const Post = db.collection({
       name: 'posts',
       fields: [{ type: 'string', name: 'title' }],
     });
+
     const association = Comment.model.associations.post;
+
     expect(Comment.model.associations.post).toBeDefined();
     expect(association.foreignKey).toBe('postId');
     // @ts-ignore
@@ -77,11 +82,41 @@ describe('belongs to field', () => {
     const association = Comment.model.associations.post;
     expect(association).toBeDefined();
     expect(association.foreignKey).toBe('postKey');
+
     // @ts-ignore
     expect(association.targetKey).toBe('key');
     expect(Comment.model.rawAttributes['postKey']).toBeDefined();
   });
 
+  it('should throw error when foreignKey is too long', async () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [{ type: 'string', name: 'key', unique: true }],
+    });
+
+    const longForeignKey = 'a'.repeat(128);
+
+    let error;
+
+    try {
+      const Comment = db.collection({
+        name: 'comments1',
+        fields: [
+          {
+            type: 'belongsTo',
+            name: 'post',
+            targetKey: 'key',
+            foreignKey: longForeignKey,
+          },
+        ],
+      });
+    } catch (e) {
+      error = e;
+    }
+
+    expect(error).toBeInstanceOf(IdentifierError);
+  });
+
   it('custom name and target', async () => {
     const Comment = db.collection({
       name: 'comments',

package/src/__tests__/fields/belongs-to-many-field.test.ts

@@ -1,5 +1,6 @@
 import { mockDatabase } from '../';
 import { Database } from '../../database';
+import { IdentifierError } from '../../errors/identifier-error';
 
 describe('belongs to many field', () => {
   let db: Database;
@@ -58,4 +59,48 @@ describe('belongs to many field', () => {
     expect(PostTag.model.rawAttributes['postId']).toBeDefined();
     expect(PostTag.model.rawAttributes['tagId']).toBeDefined();
   });
+
+  it('should throw error when foreignKey is too long', async () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'belongsToMany', name: 'tags', foreignKey: 'a'.repeat(128) },
+      ],
+    });
+
+    let error;
+    try {
+      const Tag = db.collection({
+        name: 'tags',
+        fields: [{ type: 'string', name: 'name' }],
+      });
+    } catch (e) {
+      error = e;
+    }
+
+    expect(error).toBeInstanceOf(IdentifierError);
+  });
+
+  it('should throw error when through is too long', async () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'belongsToMany', name: 'tags', through: 'a'.repeat(128) },
+      ],
+    });
+
+    let error;
+    try {
+      const Tag = db.collection({
+        name: 'tags',
+        fields: [{ type: 'string', name: 'name' }],
+      });
+    } catch (e) {
+      error = e;
+    }
+
+    expect(error).toBeInstanceOf(IdentifierError);
+  });
 });

package/src/__tests__/fields/has-many-field.test.ts

@@ -1,6 +1,7 @@
 import { Database } from '../../database';
 import { mockDatabase } from '../';
 import { makeWatchHost } from 'ts-loader/dist/servicesHost';
+import { IdentifierError } from '../../errors/identifier-error';
 
 describe('has many field', () => {
   let db: Database;
@@ -149,4 +150,25 @@ describe('has many field', () => {
     Comment.removeField('post');
     expect(Comment.model.rawAttributes.postId).toBeUndefined();
   });
+
+  it('should throw error when foreignKey is too long', async () => {
+    const longForeignKey = 'a'.repeat(64);
+
+    const Post = db.collection({
+      name: 'posts',
+      fields: [{ type: 'hasMany', name: 'comments', foreignKey: longForeignKey }],
+    });
+
+    let error;
+    try {
+      const Comment = db.collection({
+        name: 'comments',
+        fields: [{ type: 'belongsTo', name: 'post' }],
+      });
+    } catch (e) {
+      error = e;
+    }
+
+    expect(error).toBeInstanceOf(IdentifierError);
+  });
 });

package/src/__tests__/fields/has-one-field.test.ts

@@ -1,5 +1,6 @@
 import { Database } from '../../database';
 import { mockDatabase } from '../';
+import { IdentifierError } from '../../errors/identifier-error';
 
 describe('has many field', () => {
   let db: Database;
@@ -64,4 +65,24 @@ describe('has many field', () => {
     Profile.removeField('user');
     expect(Profile.model.rawAttributes.userId).toBeUndefined();
   });
+
+  it('should throw error when foreignKey is too long', async () => {
+    const longForeignKey = 'a'.repeat(128);
+
+    const User = db.collection({
+      name: 'users',
+      fields: [{ type: 'hasOne', name: 'profile', foreignKey: longForeignKey }],
+    });
+
+    let error;
+    try {
+      const Profile = db.collection({
+        name: 'profiles',
+        fields: [{ type: 'belongsTo', name: 'user' }],
+      });
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeInstanceOf(IdentifierError);
+  });
 });