@nocobase/database 0.10.0-alpha.4 → 0.10.1-alpha.1

package/lib/fields/uid-field.js

@@ -31,7 +31,7 @@ class UidField extends _field.Field {
       _this$options$prefix = _this$options.prefix,
       prefix = _this$options$prefix === void 0 ? '' : _this$options$prefix,
       pattern = _this$options.pattern;
-    const re = new RegExp(pattern || '^[A-Za-z0-9][A-Za-z0-9_-]*$');
+    const re = new RegExp(pattern || '^[A-Za-z0-9_][A-Za-z0-9_-]*$');
     this.listener = /*#__PURE__*/function () {
       var _ref = _asyncToGenerator(function* (instance) {
         const value = instance.get(name);

package/lib/index.d.ts

@@ -23,3 +23,4 @@ export * from './value-parsers';
 export * from './collection-group-manager';
 export * from './view-collection';
 export * from './view/view-inference';
+export { default as FilterParser } from './filter-parser';

package/lib/index.js

@@ -6,7 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 var _exportNames = {
   DataTypes: true,
   Op: true,
-  snakeCase: true
+  snakeCase: true,
+  FilterParser: true
 };
 Object.defineProperty(exports, "DataTypes", {
   enumerable: true,
@@ -14,6 +15,12 @@ Object.defineProperty(exports, "DataTypes", {
     return _sequelize().DataTypes;
   }
 });
+Object.defineProperty(exports, "FilterParser", {
+  enumerable: true,
+  get: function get() {
+    return _filterParser.default;
+  }
+});
 Object.defineProperty(exports, "Op", {
   enumerable: true,
   get: function get() {
@@ -303,4 +310,6 @@ Object.keys(_viewInference).forEach(function (key) {
       return _viewInference[key];
     }
   });
-});
+});
+var _filterParser = _interopRequireDefault(require("./filter-parser"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/lib/operators/child-collection.js

@@ -4,6 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+  _lodash = function _lodash() {
+    return data;
+  };
+  return data;
+}
 function _sequelize() {
   const data = require("sequelize");
   _sequelize = function _sequelize() {
@@ -11,22 +18,37 @@ function _sequelize() {
   };
   return data;
 }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const mapVal = (values, db) => values.map(v => {
   const collection = db.getCollection(v);
   return _sequelize().Sequelize.literal(`'${collection.tableNameAsString()}'::regclass`);
 });
+const filterItems = (values, db) => {
+  return _lodash().default.castArray(values).map(v => {
+    const collection = db.getCollection(v);
+    if (!collection) return null;
+    return `'${collection.tableNameAsString()}'::regclass`;
+  }).filter(Boolean);
+};
+const joinValues = items => items.join(', ');
 var _default = {
   $childIn(values, ctx) {
     const db = ctx.db;
-    return {
-      [_sequelize().Op.in]: mapVal(values, db)
-    };
+    const items = filterItems(values, db);
+    if (items.length) {
+      return _sequelize().Sequelize.literal(`"${ctx.model.name}"."tableoid" IN (${joinValues(items)})`);
+    } else {
+      return _sequelize().Sequelize.literal(`1 = 2`);
+    }
   },
   $childNotIn(values, ctx) {
     const db = ctx.db;
-    return {
-      [_sequelize().Op.notIn]: mapVal(values, db)
-    };
+    const items = filterItems(values, db);
+    if (items.length) {
+      return _sequelize().Sequelize.literal(`"${ctx.model.name}"."tableoid" NOT IN (${joinValues(items)})`);
+    } else {
+      return _sequelize().Sequelize.literal(`1 = 1`);
+    }
   }
 };
 exports.default = _default;

package/lib/repository.js

@@ -4,6 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Repository = void 0;
+function _flat() {
+  const data = require("flat");
+  _flat = function _flat() {
+    return data;
+  };
+  return data;
+}
 function _lodash() {
   const data = _interopRequireDefault(require("lodash"));
   _lodash = function _lodash() {
@@ -20,6 +27,7 @@ function _sequelize() {
 }
 var _mustHaveFilterDecorator = _interopRequireDefault(require("./decorators/must-have-filter-decorator"));
 var _transactionDecorator = require("./decorators/transaction-decorator");
+var _eagerLoadingTree = require("./eager-loading/eager-loading-tree");
 var _arrayFieldRepository = require("./field-repository/array-field-repository");
 var _fields = require("./fields");
 var _filterParser = _interopRequireDefault(require("./filter-parser"));
@@ -30,14 +38,6 @@ var _hasmanyRepository = require("./relation-repository/hasmany-repository");
 var _hasoneRepository = require("./relation-repository/hasone-repository");
 var _updateAssociations = require("./update-associations");
 var _updateGuard = require("./update-guard");
-var _eagerLoadingTree = require("./eager-loading/eager-loading-tree");
-function _flat() {
-  const data = require("flat");
-  _flat = function _flat() {
-    return data;
-  };
-  return data;
-}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

package/lib/update-associations.js

@@ -12,8 +12,6 @@ exports.updateModelByValues = updateModelByValues;
 exports.updateMultipleAssociation = updateMultipleAssociation;
 exports.updateSingleAssociation = updateSingleAssociation;
 exports.updateThroughTableValue = updateThroughTableValue;
-var _model = require("./model");
-var _updateGuard = require("./update-guard");
 function _lodash() {
   const data = _interopRequireDefault(require("lodash"));
   _lodash = function _lodash() {
@@ -21,6 +19,8 @@ function _lodash() {
   };
   return data;
 }
+var _model = require("./model");
+var _updateGuard = require("./update-guard");
 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; }
@@ -367,6 +367,10 @@ function _updateMultipleAssociation() {
     if (!association) {
       return false;
     }
+    // @ts-ignore skip update association if through model is a view
+    if (association.through && association.through.model.options.view) {
+      return false;
+    }
     if (!['undefined', 'string', 'number', 'object'].includes(typeof value)) {
       return false;
     }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "0.10.0-alpha.4",
+  "version": "0.10.1-alpha.1",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
-    "@nocobase/logger": "0.10.0-alpha.4",
-    "@nocobase/utils": "0.10.0-alpha.4",
+    "@nocobase/logger": "0.10.1-alpha.1",
+    "@nocobase/utils": "0.10.1-alpha.1",
     "async-mutex": "^0.3.2",
     "cron-parser": "4.4.0",
     "deepmerge": "^4.2.2",
@@ -28,5 +28,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "62dacadb2a83d30cb36dda9074f2f3a072a37484"
+  "gitHead": "8f415f5e0ee2e72d681f9ab16af5911b52c374a9"
 }

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

@@ -1,7 +1,7 @@
+import { BelongsToManyRepository } from '@nocobase/database';
 import Database from '../../database';
 import { InheritedCollection } from '../../inherited-collection';
 import { mockDatabase } from '../index';
-import { BelongsToManyRepository } from '@nocobase/database';
 import pgOnly from './helper';
 
 pgOnly()('collection inherits', () => {
@@ -182,9 +182,17 @@ pgOnly()('collection inherits', () => {
   });
 
   it('should list data filtered by child type', async () => {
+    const assocs = db.collection({
+      name: 'assocs',
+      fields: [{ name: 'name', type: 'string' }],
+    });
+
     const rootCollection = db.collection({
       name: 'root',
-      fields: [{ name: 'name', type: 'string' }],
+      fields: [
+        { name: 'name', type: 'string' },
+        { name: 'assocs', type: 'hasMany', target: 'assocs' },
+      ],
     });
 
     const child1Collection = db.collection({
@@ -202,11 +210,29 @@ pgOnly()('collection inherits', () => {
     await rootCollection.repository.create({
       values: {
         name: 'root1',
+        assocs: [
+          {
+            name: 'assoc1',
+          },
+        ],
       },
     });
 
     await child1Collection.repository.create({
-      values: [{ name: 'child1-1' }, { name: 'child1-2' }],
+      values: [
+        {
+          name: 'child1-1',
+          assocs: [
+            {
+              name: 'child-assoc1-1',
+            },
+          ],
+        },
+        {
+          name: 'child1-2',
+          assocs: [{ name: 'child-assoc1-2' }],
+        },
+      ],
     });
 
     await child2Collection.repository.create({
@@ -215,18 +241,38 @@ pgOnly()('collection inherits', () => {
 
     const records = await rootCollection.repository.find({
       filter: {
-        'tableoid.$childIn': [child1Collection.name],
+        '__collection.$childIn': [child1Collection.name],
       },
+      appends: ['assocs'],
     });
 
     expect(records.every((r) => r.get('__collection') === child1Collection.name)).toBe(true);
 
     const records2 = await rootCollection.repository.find({
       filter: {
-        'tableoid.$childNotIn': [child1Collection.name],
+        '__collection.$childNotIn': [child1Collection.name],
       },
     });
     expect(records2.every((r) => r.get('__collection') !== child1Collection.name)).toBe(true);
+
+    const recordsWithFilter = await rootCollection.repository.find({
+      filter: {
+        '__collection.$childIn': [child1Collection.name],
+        assocs: {
+          name: 'child-assoc1-1',
+        },
+      },
+    });
+
+    expect(recordsWithFilter.every((r) => r.get('__collection') == child1Collection.name)).toBe(true);
+
+    const filterWithUndefined = await rootCollection.repository.find({
+      filter: {
+        '__collection.$childIn': 'undefined',
+      },
+    });
+
+    expect(filterWithUndefined).toHaveLength(0);
   });
 
   it('should list collection name in relation repository', async () => {

package/src/__tests__/update-associations.test.ts

@@ -3,6 +3,185 @@ import { Database } from '../database';
 import { updateAssociations } from '../update-associations';
 import { mockDatabase } from './';
 
+describe('update belongs to many with view as through table', () => {
+  let db: Database;
+  beforeEach(async () => {
+    db = mockDatabase({
+      tablePrefix: '',
+    });
+    await db.clean({
+      drop: true,
+    });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should not update through table', async () => {
+    const Order = db.collection({
+      name: 'orders',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'hasMany',
+          name: 'orderItems',
+          foreignKey: 'order_id',
+          target: 'orderItems',
+        },
+      ],
+    });
+
+    const OrderItem = db.collection({
+      name: 'orderItems',
+      timestamps: false,
+      fields: [
+        {
+          type: 'integer',
+          name: 'count',
+        },
+        {
+          type: 'belongsTo',
+          name: 'item',
+          target: 'items',
+          foreignKey: 'item_id',
+        },
+        {
+          type: 'belongsTo',
+          name: 'order',
+          target: 'orders',
+          foreignKey: 'order_id',
+        },
+      ],
+    });
+
+    const Item = db.collection({
+      name: 'items',
+      fields: [{ name: 'name', type: 'string' }],
+    });
+
+    await db.sync();
+
+    const viewName = 'order_item_view';
+
+    const dropViewSQL = `DROP VIEW IF EXISTS ${viewName}`;
+    await db.sequelize.query(dropViewSQL);
+
+    const viewSQL = `CREATE VIEW ${viewName} as SELECT orders.*, items.name as item_name FROM ${OrderItem.quotedTableName()} as orders INNER JOIN ${Item.quotedTableName()} as items ON orders.item_id = items.id`;
+
+    await db.sequelize.query(viewSQL);
+
+    const OrderItemView = db.collection({
+      name: viewName,
+      view: true,
+      schema: db.inDialect('postgres') ? 'public' : undefined,
+      fields: [
+        {
+          type: 'bigInt',
+          name: 'order_id',
+        },
+        {
+          type: 'bigInt',
+          name: 'item_id',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    Order.setField('items', {
+      type: 'belongsToMany',
+      target: 'orderItems',
+      through: viewName,
+      foreignKey: 'order_id',
+      otherKey: 'item_id',
+      sourceKey: 'id',
+      targetKey: 'id',
+    });
+
+    await db.sync();
+
+    const order1 = await db.getRepository('orders').create({
+      values: {
+        name: 'order1',
+        orderItems: [
+          {
+            count: 1,
+            item: {
+              name: 'item1',
+            },
+          },
+          {
+            count: 2,
+            item: {
+              name: 'item2',
+            },
+          },
+        ],
+      },
+    });
+
+    const item1 = await db.getRepository('items').findOne({
+      filter: {
+        name: 'item1',
+      },
+    });
+
+    const item2 = await db.getRepository('items').findOne({
+      filter: {
+        name: 'item2',
+      },
+    });
+
+    await db.getRepository('orders').update({
+      filterByTk: order1.get('id'),
+      values: {
+        name: 'order1',
+        orderItems: [
+          {
+            count: 1,
+            item: {
+              id: item1.get('id'),
+            },
+          },
+          {
+            count: 2,
+            item: {
+              id: item2.get('id'),
+            },
+          },
+          {
+            count: 3,
+            item: {
+              name: 'item3',
+            },
+          },
+        ],
+        items: [
+          {
+            id: item1.get('id'),
+          },
+          {
+            id: item2.get('id'),
+          },
+        ],
+      },
+    });
+
+    const order1AfterUpdate = await db.getRepository('orders').findOne({
+      filter: {
+        name: 'order1',
+      },
+      appends: ['items'],
+    });
+
+    expect(order1AfterUpdate.get('items').length).toBe(3);
+  });
+});
+
 describe('update associations', () => {
   describe('belongsTo', () => {
     let db: Database;

package/src/fields/uid-field.ts

@@ -9,7 +9,7 @@ export class UidField extends Field {
 
   init() {
     const { name, prefix = '', pattern } = this.options;
-    const re = new RegExp(pattern || '^[A-Za-z0-9][A-Za-z0-9_-]*$');
+    const re = new RegExp(pattern || '^[A-Za-z0-9_][A-Za-z0-9_-]*$');
     this.listener = async (instance) => {
       const value = instance.get(name);
       if (!value) {

package/src/filter-parser.ts

@@ -226,6 +226,7 @@ export default class FilterParser {
       if (values && typeof values === 'object' && value && typeof value === 'object') {
         value = { ...value, ...values };
       }
+
       _.set(where, paths, value);
     }
 

package/src/index.ts

@@ -23,3 +23,4 @@ export * from './value-parsers';
 export * from './collection-group-manager';
 export * from './view-collection';
 export * from './view/view-inference';
+export { default as FilterParser } from './filter-parser';

package/src/operators/child-collection.ts

@@ -1,4 +1,5 @@
-import { Op, Sequelize } from 'sequelize';
+import lodash from 'lodash';
+import { Sequelize } from 'sequelize';
 
 const mapVal = (values, db) =>
   values.map((v) => {
@@ -6,19 +7,37 @@ const mapVal = (values, db) =>
     return Sequelize.literal(`'${collection.tableNameAsString()}'::regclass`);
   });
 
+const filterItems = (values, db) => {
+  return lodash
+    .castArray(values)
+    .map((v) => {
+      const collection = db.getCollection(v);
+      if (!collection) return null;
+      return `'${collection.tableNameAsString()}'::regclass`;
+    })
+    .filter(Boolean);
+};
+const joinValues = (items) => items.join(', ');
 export default {
   $childIn(values, ctx: any) {
     const db = ctx.db;
+    const items = filterItems(values, db);
 
-    return {
-      [Op.in]: mapVal(values, db),
-    };
+    if (items.length) {
+      return Sequelize.literal(`"${ctx.model.name}"."tableoid" IN (${joinValues(items)})`);
+    } else {
+      return Sequelize.literal(`1 = 2`);
+    }
   },
+
   $childNotIn(values, ctx: any) {
     const db = ctx.db;
+    const items = filterItems(values, db);
 
-    return {
-      [Op.notIn]: mapVal(values, db),
-    };
+    if (items.length) {
+      return Sequelize.literal(`"${ctx.model.name}"."tableoid" NOT IN (${joinValues(items)})`);
+    } else {
+      return Sequelize.literal(`1 = 1`);
+    }
   },
 } as Record<string, any>;

package/src/repository.ts

@@ -1,3 +1,4 @@
+import { flatten } from 'flat';
 import lodash from 'lodash';
 import {
   Association,
@@ -18,6 +19,7 @@ import { Collection } from './collection';
 import { Database } from './database';
 import mustHaveFilter from './decorators/must-have-filter-decorator';
 import { transactionWrapperBuilder } from './decorators/transaction-decorator';
+import { EagerLoadingTree } from './eager-loading/eager-loading-tree';
 import { ArrayFieldRepository } from './field-repository/array-field-repository';
 import { ArrayField, RelationField } from './fields';
 import FilterParser from './filter-parser';
@@ -31,8 +33,6 @@ import { HasOneRepository } from './relation-repository/hasone-repository';
 import { RelationRepository } from './relation-repository/relation-repository';
 import { updateAssociations, updateModelByValues } from './update-associations';
 import { UpdateGuard } from './update-guard';
-import { EagerLoadingTree } from './eager-loading/eager-loading-tree';
-import { flatten } from 'flat';
 
 const debug = require('debug')('noco-database');
 

package/src/update-associations.ts

@@ -1,3 +1,4 @@
+import lodash from 'lodash';
 import {
   Association,
   BelongsTo,
@@ -10,7 +11,6 @@ import {
 } from 'sequelize';
 import { Model } from './model';
 import { UpdateGuard } from './update-guard';
-import lodash from 'lodash';
 
 function isUndefinedOrNull(value: any) {
   return typeof value === 'undefined' || value === null;
@@ -377,6 +377,11 @@ export async function updateMultipleAssociation(
     return false;
   }
 
+  // @ts-ignore skip update association if through model is a view
+  if (association.through && association.through.model.options.view) {
+    return false;
+  }
+
   if (!['undefined', 'string', 'number', 'object'].includes(typeof value)) {
     return false;
   }