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

package/lib/collection.d.ts

@@ -65,7 +65,7 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     resetFields(): void;
     remove(): void;
     removeFromDb(options?: QueryInterfaceDropTableOptions): Promise<void>;
-    existsInDb(options?: Transactionable): Promise<boolean>;
+    existsInDb(options?: Transactionable): any;
     removeField(name: string): void | Field;
     /**
      * TODO
@@ -91,4 +91,5 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     isParent(): boolean;
     addSchemaTableName(): any;
     quotedTableName(): any;
+    collectionSchema(): string;
 }

package/lib/collection.js

@@ -396,7 +396,7 @@ class Collection extends _events().EventEmitter {
       })) {
         const queryInterface = _this.db.sequelize.getQueryInterface();
 
-        yield queryInterface.dropTable(_this.model.tableName, options);
+        yield queryInterface.dropTable(_this.addSchemaTableName(), options);
       }
 
       _this.remove();
@@ -407,7 +407,7 @@ class Collection extends _events().EventEmitter {
     var _this2 = this;
 
     return _asyncToGenerator(function* () {
-      return _this2.db.collectionExistsInDb(_this2.name, options);
+      return _this2.db.queryInterface.collectionTableExists(_this2, options);
     })();
   }
 
@@ -659,8 +659,8 @@ class Collection extends _events().EventEmitter {
   addSchemaTableName() {
     const tableName = this.model.tableName;
 
-    if (this.options.schema) {
-      return this.db.utils.addSchema(tableName, this.options.schema);
+    if (this.collectionSchema()) {
+      return this.db.utils.addSchema(tableName, this.collectionSchema());
     }
 
     return tableName;
@@ -670,6 +670,22 @@ class Collection extends _events().EventEmitter {
     return this.db.utils.quoteTable(this.addSchemaTableName());
   }
 
+  collectionSchema() {
+    if (this.options.schema) {
+      return this.options.schema;
+    }
+
+    if (this.db.options.schema) {
+      return this.db.options.schema;
+    }
+
+    if (this.db.inDialect('postgres')) {
+      return 'public';
+    }
+
+    return undefined;
+  }
+
 }
 
 exports.Collection = Collection;

package/lib/database.d.ts

@@ -19,6 +19,8 @@ import { Repository } from './repository';
 import { AfterDefineCollectionListener, BeforeDefineCollectionListener, CreateListener, CreateWithAssociationsListener, DatabaseAfterDefineCollectionEventType, DatabaseAfterRemoveCollectionEventType, DatabaseBeforeDefineCollectionEventType, DatabaseBeforeRemoveCollectionEventType, DestroyListener, EventType, ModelCreateEventTypes, ModelCreateWithAssociationsEventTypes, ModelDestroyEventTypes, ModelSaveEventTypes, ModelSaveWithAssociationsEventTypes, ModelUpdateEventTypes, ModelUpdateWithAssociationsEventTypes, ModelValidateEventTypes, RemoveCollectionListener, SaveListener, SaveWithAssociationsListener, SyncListener, UpdateListener, UpdateWithAssociationsListener, ValidateListener } from './types';
 import DatabaseUtils from './database-utils';
 import { BaseValueParser } from './value-parsers';
+import QueryInterface from './query-interface/query-interface';
+import { Logger } from '@nocobase/logger';
 export interface MergeOptions extends merge.Options {
 }
 export interface PendingOptions {
@@ -84,6 +86,7 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     pendingFields: Map<string, FieldTypes.RelationField[]>;
     modelCollection: Map<ModelStatic<any>, Collection<any, any>>;
     tableNameCollectionMap: Map<string, Collection<any, any>>;
+    queryInterface: QueryInterface;
     utils: DatabaseUtils;
     referenceMap: ReferencesMap;
     inheritanceMap: InheritanceMap;
@@ -94,11 +97,14 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
         collectionOptions: CollectionOptions;
         mergeOptions?: any;
     }[]>;
+    logger: Logger;
     constructor(options: DatabaseOptions);
+    setLogger(logger: Logger): void;
     initListener(): void;
     addMigration(item: MigrationItem): void;
     addMigrations(options: AddMigrationsOptions): void;
     inDialect(...dialect: string[]): boolean;
+    escapeId(identifier: string): string;
     /**
      * Add collection to database
      * @param options

package/lib/database.js

@@ -112,6 +112,8 @@ var _databaseUtils = _interopRequireDefault(require("./database-utils"));
 
 var _valueParsers = require("./value-parsers");
 
+var _queryInterfaceBuilder = _interopRequireDefault(require("./query-interface/query-interface-builder"));
+
 const _excluded = ["drop"],
       _excluded2 = ["retry"];
 
@@ -231,6 +233,7 @@ class Database extends _events().EventEmitter {
     this.pendingFields = new Map();
     this.modelCollection = new Map();
     this.tableNameCollectionMap = new Map();
+    this.queryInterface = void 0;
     this.utils = new _databaseUtils.default(this);
     this.referenceMap = new _ReferencesMap.default();
     this.inheritanceMap = new _inheritedMap.default();
@@ -238,6 +241,7 @@ class Database extends _events().EventEmitter {
     this.modelHook = void 0;
     this.version = void 0;
     this.delayCollectionExtend = new Map();
+    this.logger = void 0;
     this.version = new DatabaseVersion(this);
 
     const opts = _objectSpread({
@@ -268,6 +272,7 @@ class Database extends _events().EventEmitter {
 
     this.options = opts;
     this.sequelize = new (_sequelize().Sequelize)(opts);
+    this.queryInterface = (0, _queryInterfaceBuilder.default)(this);
     this.collections = new Map();
     this.modelHook = new _modelHook.ModelHook(this);
     this.on('afterDefineCollection', collection => {
@@ -337,6 +342,10 @@ class Database extends _events().EventEmitter {
     (0, _utils2.patchSequelizeQueryInterface)(this);
   }
 
+  setLogger(logger) {
+    this.logger = logger;
+  }
+
   initListener() {
     var _this2 = this;
 
@@ -464,6 +473,10 @@ class Database extends _events().EventEmitter {
   inDialect(...dialect) {
     return dialect.includes(this.sequelize.getDialect());
   }
+
+  escapeId(identifier) {
+    return this.inDialect('mysql') ? `\`${identifier}\`` : `"${identifier}"`;
+  }
   /**
    * Add collection to database
    * @param options
@@ -773,10 +786,7 @@ class Database extends _events().EventEmitter {
         return false;
       }
 
-      const tables = yield _this5.sequelize.getQueryInterface().showAllTables({
-        transaction: options === null || options === void 0 ? void 0 : options.transaction
-      });
-      return tables.includes(_this5.getCollection(name).model.tableName);
+      return yield _this5.queryInterface.collectionTableExists(collection, options);
     })();
   }
 

package/lib/fields/belongs-to-many-field.js

@@ -73,9 +73,15 @@ class BelongsToManyField extends _relationField.RelationField {
     if (database.hasCollection(through)) {
       Through = database.getCollection(through);
     } else {
-      Through = database.collection({
+      const throughCollectionOptions = {
         name: through
-      });
+      };
+
+      if (this.collection.collectionSchema()) {
+        throughCollectionOptions['schema'] = this.collection.collectionSchema();
+      }
+
+      Through = database.collection(throughCollectionOptions);
       Object.defineProperty(Through.model, 'isThrough', {
         value: true
       });

package/lib/fields/field.js

@@ -184,7 +184,7 @@ class Field {
       })) && columnReferencesCount == 1) {
         const queryInterface = _this2.database.sequelize.getQueryInterface();
 
-        yield queryInterface.removeColumn(_this2.collection.model.tableName, _this2.columnName(), options);
+        yield queryInterface.removeColumn(_this2.collection.addSchemaTableName(), _this2.columnName(), options);
       }
 
       _this2.remove();
@@ -212,7 +212,7 @@ class Field {
         sql = `
         select column_name
         from INFORMATION_SCHEMA.COLUMNS
-        where TABLE_NAME='${_this3.collection.model.tableName}' AND column_name='${_this3.columnName()}'
+        where TABLE_NAME='${_this3.collection.model.tableName}' AND column_name='${_this3.columnName()}' AND table_schema='${_this3.collection.collectionSchema() || 'public'}'
       `;
       }
 

package/lib/filter-parser.js

@@ -215,7 +215,7 @@ class FilterParser {
           origins.push(attr); // if it is target model attribute
 
           if (target.rawAttributes[attr]) {
-            associationKeys.push(attr);
+            associationKeys.push(target.rawAttributes[attr].field || attr);
             target = null;
           } else if (target.associations[attr]) {
             // if it is target model association (nested association filter)

package/lib/query-interface/mysql-query-interface.d.ts

@@ -0,0 +1,7 @@
+import QueryInterface from './query-interface';
+import { Collection } from '../collection';
+import { Transactionable } from 'sequelize';
+export default class MysqlQueryInterface extends QueryInterface {
+    constructor(db: any);
+    collectionTableExists(collection: Collection, options?: Transactionable): Promise<boolean>;
+}

package/lib/query-interface/mysql-query-interface.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _queryInterface = _interopRequireDefault(require("./query-interface"));
+
+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); }); }; }
+
+class MysqlQueryInterface extends _queryInterface.default {
+  constructor(db) {
+    super(db);
+  }
+
+  collectionTableExists(collection, options) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const transaction = options === null || options === void 0 ? void 0 : options.transaction;
+      const tableName = collection.model.tableName;
+      const databaseName = _this.db.options.database;
+      const sql = `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '${databaseName}' AND TABLE_NAME = '${tableName}'`;
+      const results = yield _this.db.sequelize.query(sql, {
+        type: 'SELECT',
+        transaction
+      });
+      return results.length > 0;
+    })();
+  }
+
+}
+
+exports.default = MysqlQueryInterface;

package/lib/query-interface/postgres-query-interface.d.ts

@@ -0,0 +1,6 @@
+import QueryInterface from './query-interface';
+import { Collection } from '../collection';
+export default class PostgresQueryInterface extends QueryInterface {
+    constructor(db: any);
+    collectionTableExists(collection: Collection, options?: any): Promise<any>;
+}

package/lib/query-interface/postgres-query-interface.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _queryInterface = _interopRequireDefault(require("./query-interface"));
+
+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); }); }; }
+
+class PostgresQueryInterface extends _queryInterface.default {
+  constructor(db) {
+    super(db);
+  }
+
+  collectionTableExists(collection, options) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const transaction = options === null || options === void 0 ? void 0 : options.transaction;
+      const tableName = collection.model.tableName;
+      const schema = collection.collectionSchema() || 'public';
+      const sql = `SELECT EXISTS(SELECT 1 FROM information_schema.tables
+                 WHERE  table_schema = '${schema}'
+                 AND    table_name   = '${tableName}')`;
+      const results = yield _this.db.sequelize.query(sql, {
+        type: 'SELECT',
+        transaction
+      });
+      return results[0]['exists'];
+    })();
+  }
+
+}
+
+exports.default = PostgresQueryInterface;

package/lib/query-interface/query-interface-builder.d.ts

@@ -0,0 +1,2 @@
+import Database from '../database';
+export default function buildQueryInterface(db: Database): any;

package/lib/query-interface/query-interface-builder.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = buildQueryInterface;
+
+var _mysqlQueryInterface = _interopRequireDefault(require("./mysql-query-interface"));
+
+var _postgresQueryInterface = _interopRequireDefault(require("./postgres-query-interface"));
+
+var _sqliteQueryInterface = _interopRequireDefault(require("./sqlite-query-interface"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function buildQueryInterface(db) {
+  const map = {
+    mysql: _mysqlQueryInterface.default,
+    postgres: _postgresQueryInterface.default,
+    sqlite: _sqliteQueryInterface.default
+  };
+  return new map[db.options.dialect](db);
+}

package/lib/query-interface/query-interface.d.ts

@@ -0,0 +1,9 @@
+import Database from '../database';
+import { Collection } from '../collection';
+import { QueryInterface as SequelizeQueryInterface, Transactionable } from 'sequelize';
+export default abstract class QueryInterface {
+    db: Database;
+    sequelizeQueryInterface: SequelizeQueryInterface;
+    protected constructor(db: Database);
+    abstract collectionTableExists(collection: Collection, options?: Transactionable): Promise<boolean>;
+}

package/lib/query-interface/query-interface.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class QueryInterface {
+  constructor(db) {
+    this.db = void 0;
+    this.sequelizeQueryInterface = void 0;
+    this.db = db;
+    this.sequelizeQueryInterface = db.sequelize.getQueryInterface();
+  }
+
+}
+
+exports.default = QueryInterface;

package/lib/query-interface/sqlite-query-interface.d.ts

@@ -0,0 +1,6 @@
+import QueryInterface from './query-interface';
+import { Collection } from '../collection';
+export default class SqliteQueryInterface extends QueryInterface {
+    constructor(db: any);
+    collectionTableExists(collection: Collection, options?: any): Promise<boolean>;
+}

package/lib/query-interface/sqlite-query-interface.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _queryInterface = _interopRequireDefault(require("./query-interface"));
+
+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); }); }; }
+
+class SqliteQueryInterface extends _queryInterface.default {
+  constructor(db) {
+    super(db);
+  }
+
+  collectionTableExists(collection, options) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const transaction = options === null || options === void 0 ? void 0 : options.transaction;
+      const tableName = collection.model.tableName;
+      const sql = `SELECT name FROM sqlite_master WHERE type='table' AND name='${tableName}';`;
+      const results = yield _this.db.sequelize.query(sql, {
+        type: 'SELECT',
+        transaction
+      });
+      return results.length > 0;
+    })();
+  }
+
+}
+
+exports.default = SqliteQueryInterface;

package/lib/relation-repository/multiple-relation-repository.js

@@ -75,6 +75,7 @@ class MultipleRelationRepository extends _relationRepository.RelationRepository
       const getAccessor = _this.accessors().get;
 
       const sourceModel = yield _this.getSourceModel(transaction);
+      if (!sourceModel) return [];
 
       if (findOptions.include && findOptions.include.length > 0) {
         const ids = (yield sourceModel[getAccessor](_objectSpread(_objectSpread({}, findOptions), {}, {
@@ -139,6 +140,7 @@ class MultipleRelationRepository extends _relationRepository.RelationRepository
     return _asyncToGenerator(function* () {
       const transaction = yield _this3.getTransaction(options);
       const sourceModel = yield _this3.getSourceModel(transaction);
+      if (!sourceModel) return 0;
 
       const queryOptions = _this3.buildQueryOptions(options);
 

package/lib/relation-repository/single-relation-repository.js

@@ -80,6 +80,7 @@ class SingleRelationRepository extends _relationRepository.RelationRepository {
       const getAccessor = _this3.accessors().get;
 
       const sourceModel = yield _this3.getSourceModel(transaction);
+      if (!sourceModel) return null;
 
       if ((findOptions === null || findOptions === void 0 ? void 0 : (_findOptions$include = findOptions.include) === null || _findOptions$include === void 0 ? void 0 : _findOptions$include.length) > 0) {
         const templateModel = yield sourceModel[getAccessor](_objectSpread(_objectSpread({}, findOptions), {}, {

package/lib/sync-runner.d.ts

@@ -1,4 +1,4 @@
 export declare class SyncRunner {
     static syncInheritModel(model: any, options: any): Promise<void>;
-    static createTable(tableName: any, attributes: any, options: any, model: any, parentTables: any, db: any): Promise<any>;
+    static createTable(tableName: any, attributes: any, options: any, model: any, parents: any): Promise<any>;
 }

package/lib/sync-runner.js

@@ -41,7 +41,6 @@ class SyncRunner {
       const transaction = options.transaction;
       const inheritedCollection = model.collection;
       const db = inheritedCollection.context.database;
-      const schemaName = db.options.schema || 'public';
       const dialect = db.sequelize.getDialect();
       const queryInterface = db.sequelize.getQueryInterface();
 
@@ -55,10 +54,7 @@ class SyncRunner {
         throw new Error(`Inherit model ${inheritedCollection.name} can't be created without parents, parents option is ${_lodash().default.castArray(inheritedCollection.options.inherits).join(', ')}`);
       }
 
-      const parentTables = parents.map(parent => parent.model.tableName);
-      const tableName = model.tableName;
-      const schemaTableName = db.utils.addSchema(tableName);
-      const quoteTableName = db.utils.quoteTable(tableName);
+      const tableName = inheritedCollection.addSchemaTableName();
       const attributes = model.tableAttributes;
 
       const childAttributes = _lodash().default.pickBy(attributes, value => {
@@ -66,10 +62,10 @@ class SyncRunner {
       });
 
       let maxSequenceVal = 0;
-      let maxSequenceName;
+      let maxSequenceName; // find max sequence
 
       if (childAttributes.id && childAttributes.id.autoIncrement) {
-        var _iterator = _createForOfIteratorHelper(parentTables),
+        var _iterator = _createForOfIteratorHelper(parents),
             _step;
 
         try {
@@ -77,8 +73,8 @@ class SyncRunner {
             const parent = _step.value;
             const sequenceNameResult = yield queryInterface.sequelize.query(`SELECT column_default
            FROM information_schema.columns
-           WHERE table_name = '${parent}'
-            and table_schema = '${schemaName}'
+           WHERE table_name = '${parent.model.tableName}'
+            and table_schema = '${parent.collectionSchema()}'
              and "column_name" = 'id';`, {
               transaction
             });
@@ -114,17 +110,18 @@ class SyncRunner {
         }
       }
 
-      yield _this.createTable(schemaTableName, childAttributes, options, model, parentTables, db);
+      yield _this.createTable(tableName, childAttributes, options, model, parents); // if we have max sequence, set it to child table
 
       if (maxSequenceName) {
-        const parentsDeep = Array.from(db.inheritanceMap.getParents(inheritedCollection.name)).map(parent => db.getCollection(parent).model.tableName);
-        const sequenceTables = [...parentsDeep, tableName.toString()];
+        const parentsDeep = Array.from(db.inheritanceMap.getParents(inheritedCollection.name)).map(parent => db.getCollection(parent).addSchemaTableName());
+        const sequenceTables = [...parentsDeep, tableName];
 
         for (var _i = 0, _sequenceTables = sequenceTables; _i < _sequenceTables.length; _i++) {
           const sequenceTable = _sequenceTables[_i];
-          const queryName = Boolean(sequenceTable.match(/[A-Z]/)) && !sequenceTable.includes(`"`) ? `"${sequenceTable}"` : sequenceTable;
-          const idColumnQuery = yield queryInterface.sequelize.query(`
-          SELECT column_name
+          const tableName = sequenceTable.tableName;
+          const schemaName = sequenceTable.schema;
+          const queryName = Boolean(tableName.match(/[A-Z]/)) && !tableName.includes(`"`) ? `"${tableName}"` : tableName;
+          const idColumnQuery = yield queryInterface.sequelize.query(`SELECT column_name
 FROM information_schema.columns
 WHERE table_name='${queryName}' and column_name='id' and table_schema = '${schemaName}';
           `, {
@@ -135,7 +132,7 @@ WHERE table_name='${queryName}' and column_name='id' and table_schema = '${schem
             continue;
           }
 
-          yield queryInterface.sequelize.query(`alter table "${schemaName}"."${sequenceTable}"
+          yield queryInterface.sequelize.query(`alter table ${db.utils.quoteTable(sequenceTable)}
             alter column id set default nextval('${maxSequenceName}')`, {
             transaction
           });
@@ -156,7 +153,7 @@ WHERE table_name='${queryName}' and column_name='id' and table_schema = '${schem
     })();
   }
 
-  static createTable(tableName, attributes, options, model, parentTables, db) {
+  static createTable(tableName, attributes, options, model, parents) {
     return _asyncToGenerator(function* () {
       let sql = '';
       options = _objectSpread({}, options);
@@ -179,8 +176,8 @@ WHERE table_name='${queryName}' and column_name='id' and table_schema = '${schem
         table: tableName,
         context: 'createTable'
       });
-      sql = `${queryGenerator.createTableQuery(tableName, attributes, options)}`.replace(';', ` INHERITS (${parentTables.map(t => {
-        return db.utils.quoteTable(db.utils.addSchema(t, db.options.schema));
+      sql = `${queryGenerator.createTableQuery(tableName, attributes, options)}`.replace(';', ` INHERITS (${parents.map(t => {
+        return t.addSchemaTableName();
       }).join(', ')});`);
       return yield model.sequelize.query(sql, options);
     })();

package/lib/utils.js

@@ -23,6 +23,16 @@ function _crypto() {
 
 var _identifierError = require("./errors/identifier-error");
 
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
 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; }
@@ -144,14 +154,14 @@ function snakeCase(name) {
 
 function patchShowConstraintsQuery(queryGenerator, db) {
   queryGenerator.showConstraintsQuery = (tableName, constraintName) => {
-    const lines = ['SELECT constraint_catalog AS "constraintCatalog",', 'constraint_schema AS "constraintSchema",', 'constraint_name AS "constraintName",', 'table_catalog AS "tableCatalog",', 'table_schema AS "tableSchema",', 'table_name AS "tableName",', 'constraint_type AS "constraintType",', 'is_deferrable AS "isDeferrable",', 'initially_deferred AS "initiallyDeferred"', 'from INFORMATION_SCHEMA.table_constraints', `WHERE table_name='${tableName}'`];
+    const lines = ['SELECT constraint_catalog AS "constraintCatalog",', 'constraint_schema AS "constraintSchema",', 'constraint_name AS "constraintName",', 'table_catalog AS "tableCatalog",', 'table_schema AS "tableSchema",', 'table_name AS "tableName",', 'constraint_type AS "constraintType",', 'is_deferrable AS "isDeferrable",', 'initially_deferred AS "initiallyDeferred"', 'from INFORMATION_SCHEMA.table_constraints', `WHERE table_name='${_lodash().default.isPlainObject(tableName) ? tableName.tableName : tableName}'`];
 
     if (!constraintName) {
       lines.push(`AND constraint_name='${constraintName}'`);
     }
 
-    if (db.options.schema && db.options.schema !== 'public') {
-      lines.push(`AND table_schema='${db.options.schema}'`);
+    if (_lodash().default.isPlainObject(tableName) && tableName.schema) {
+      lines.push(`AND table_schema='${tableName.schema}'`);
     }
 
     return lines.join(' ');

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "0.9.1-alpha.1",
+  "version": "0.9.1-alpha.2",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
-    "@nocobase/utils": "0.9.1-alpha.1",
+    "@nocobase/logger": "0.9.1-alpha.2",
+    "@nocobase/utils": "0.9.1-alpha.2",
     "async-mutex": "^0.3.2",
     "cron-parser": "4.4.0",
     "deepmerge": "^4.2.2",
@@ -27,5 +28,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "56cb184b00dc383b853015d525bf6e79dea92169"
+  "gitHead": "d588a68eca4feed4642a4cb317301011266fe5c9"
 }

package/src/__tests__/filter.test.ts

@@ -0,0 +1,60 @@
+import Database from '../database';
+import { mockDatabase } from '../mock-database';
+
+describe('filter', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+
+    await db.clean({ drop: true });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should filter by association field', async () => {
+    const UserCollection = db.collection({
+      name: 'users',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'hasMany', name: 'posts' },
+      ],
+    });
+
+    const PostCollection = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'title' },
+        { type: 'belongsTo', name: 'user' },
+      ],
+    });
+
+    await db.sync();
+
+    const user = await UserCollection.repository.create({
+      values: {
+        name: 'John',
+        posts: [
+          {
+            title: 'p1',
+          },
+          {
+            title: 'p2',
+          },
+        ],
+      },
+    });
+
+    const response = await UserCollection.repository.find({
+      filter: {
+        'posts.createdAt': {
+          $dateOn: user.get('createdAt'),
+        },
+      },
+    });
+
+    expect(response).toHaveLength(1);
+  });
+});

package/src/collection.ts

@@ -308,13 +308,13 @@ export class Collection<
       })
     ) {
       const queryInterface = this.db.sequelize.getQueryInterface();
-      await queryInterface.dropTable(this.model.tableName, options);
+      await queryInterface.dropTable(this.addSchemaTableName(), options);
     }
     this.remove();
   }
 
   async existsInDb(options?: Transactionable) {
-    return this.db.collectionExistsInDb(this.name, options);
+    return this.db.queryInterface.collectionTableExists(this, options);
   }
 
   removeField(name: string): void | Field {
@@ -542,8 +542,8 @@ export class Collection<
   public addSchemaTableName() {
     const tableName = this.model.tableName;
 
-    if (this.options.schema) {
-      return this.db.utils.addSchema(tableName, this.options.schema);
+    if (this.collectionSchema()) {
+      return this.db.utils.addSchema(tableName, this.collectionSchema());
     }
 
     return tableName;
@@ -552,4 +552,20 @@ export class Collection<
   public quotedTableName() {
     return this.db.utils.quoteTable(this.addSchemaTableName());
   }
+
+  public collectionSchema() {
+    if (this.options.schema) {
+      return this.options.schema;
+    }
+
+    if (this.db.options.schema) {
+      return this.db.options.schema;
+    }
+
+    if (this.db.inDialect('postgres')) {
+      return 'public';
+    }
+
+    return undefined;
+  }
 }

package/src/database.ts

@@ -64,6 +64,9 @@ import { patchSequelizeQueryInterface, snakeCase } from './utils';
 
 import DatabaseUtils from './database-utils';
 import { BaseValueParser, registerFieldValueParsers } from './value-parsers';
+import buildQueryInterface from './query-interface/query-interface-builder';
+import QueryInterface from './query-interface/query-interface';
+import { Logger } from '@nocobase/logger';
 
 export interface MergeOptions extends merge.Options {}
 
@@ -166,6 +169,8 @@ export class Database extends EventEmitter implements AsyncEmitter {
   modelCollection = new Map<ModelStatic<any>, Collection>();
   tableNameCollectionMap = new Map<string, Collection>();
 
+  queryInterface: QueryInterface;
+
   utils = new DatabaseUtils(this);
   referenceMap = new ReferencesMap();
   inheritanceMap = new InheritanceMap();
@@ -177,6 +182,8 @@ export class Database extends EventEmitter implements AsyncEmitter {
 
   delayCollectionExtend = new Map<string, { collectionOptions: CollectionOptions; mergeOptions?: any }[]>();
 
+  logger: Logger;
+
   constructor(options: DatabaseOptions) {
     super();
 
@@ -212,6 +219,8 @@ export class Database extends EventEmitter implements AsyncEmitter {
 
     this.sequelize = new Sequelize(opts);
 
+    this.queryInterface = buildQueryInterface(this);
+
     this.collections = new Map();
     this.modelHook = new ModelHook(this);
 
@@ -280,6 +289,10 @@ export class Database extends EventEmitter implements AsyncEmitter {
     patchSequelizeQueryInterface(this);
   }
 
+  setLogger(logger: Logger) {
+    this.logger = logger;
+  }
+
   initListener() {
     this.on('beforeDefine', (model, options) => {
       if (this.options.underscored) {
@@ -374,6 +387,10 @@ export class Database extends EventEmitter implements AsyncEmitter {
     return dialect.includes(this.sequelize.getDialect());
   }
 
+  escapeId(identifier: string) {
+    return this.inDialect('mysql') ? `\`${identifier}\`` : `"${identifier}"`;
+  }
+
   /**
    * Add collection to database
    * @param options
@@ -627,15 +644,12 @@ export class Database extends EventEmitter implements AsyncEmitter {
 
   async collectionExistsInDb(name: string, options?: Transactionable) {
     const collection = this.getCollection(name);
+
     if (!collection) {
       return false;
     }
 
-    const tables = await this.sequelize.getQueryInterface().showAllTables({
-      transaction: options?.transaction,
-    });
-
-    return tables.includes(this.getCollection(name).model.tableName);
+    return await this.queryInterface.collectionTableExists(collection, options);
   }
 
   public isSqliteMemory() {

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

@@ -55,9 +55,15 @@ export class BelongsToManyField extends RelationField {
     if (database.hasCollection(through)) {
       Through = database.getCollection(through);
     } else {
-      Through = database.collection({
+      const throughCollectionOptions = {
         name: through,
-      });
+      };
+
+      if (this.collection.collectionSchema()) {
+        throughCollectionOptions['schema'] = this.collection.collectionSchema();
+      }
+
+      Through = database.collection(throughCollectionOptions);
 
       Object.defineProperty(Through.model, 'isThrough', { value: true });
     }

package/src/fields/field.ts

@@ -6,7 +6,7 @@ import {
   ModelIndexesOptions,
   QueryInterfaceOptions,
   SyncOptions,
-  Transactionable
+  Transactionable,
 } from 'sequelize';
 import { Collection } from '../collection';
 import { Database } from '../database';
@@ -169,7 +169,7 @@ export abstract class Field {
       columnReferencesCount == 1
     ) {
       const queryInterface = this.database.sequelize.getQueryInterface();
-      await queryInterface.removeColumn(this.collection.model.tableName, this.columnName(), options);
+      await queryInterface.removeColumn(this.collection.addSchemaTableName(), this.columnName(), options);
     }
 
     this.remove();
@@ -194,7 +194,9 @@ export abstract class Field {
       sql = `
         select column_name
         from INFORMATION_SCHEMA.COLUMNS
-        where TABLE_NAME='${this.collection.model.tableName}' AND column_name='${this.columnName()}'
+        where TABLE_NAME='${
+          this.collection.model.tableName
+        }' AND column_name='${this.columnName()}' AND table_schema='${this.collection.collectionSchema() || 'public'}'
       `;
     }
     const [rows] = await this.database.sequelize.query(sql, opts);

package/src/filter-parser.ts

@@ -178,7 +178,7 @@ export default class FilterParser {
           origins.push(attr);
           // if it is target model attribute
           if (target.rawAttributes[attr]) {
-            associationKeys.push(attr);
+            associationKeys.push(target.rawAttributes[attr].field || attr);
             target = null;
           } else if (target.associations[attr]) {
             // if it is target model association (nested association filter)

package/src/query-interface/mysql-query-interface.ts

@@ -0,0 +1,20 @@
+import QueryInterface from './query-interface';
+import { Collection } from '../collection';
+import { Transactionable } from 'sequelize';
+
+export default class MysqlQueryInterface extends QueryInterface {
+  constructor(db) {
+    super(db);
+  }
+
+  async collectionTableExists(collection: Collection, options?: Transactionable) {
+    const transaction = options?.transaction;
+
+    const tableName = collection.model.tableName;
+    const databaseName = this.db.options.database;
+    const sql = `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '${databaseName}' AND TABLE_NAME = '${tableName}'`;
+
+    const results = await this.db.sequelize.query(sql, { type: 'SELECT', transaction });
+    return results.length > 0;
+  }
+}

package/src/query-interface/postgres-query-interface.ts

@@ -0,0 +1,22 @@
+import QueryInterface from './query-interface';
+import { Collection } from '../collection';
+
+export default class PostgresQueryInterface extends QueryInterface {
+  constructor(db) {
+    super(db);
+  }
+
+  async collectionTableExists(collection: Collection, options?) {
+    const transaction = options?.transaction;
+
+    const tableName = collection.model.tableName;
+    const schema = collection.collectionSchema() || 'public';
+
+    const sql = `SELECT EXISTS(SELECT 1 FROM information_schema.tables
+                 WHERE  table_schema = '${schema}'
+                 AND    table_name   = '${tableName}')`;
+
+    const results = await this.db.sequelize.query(sql, { type: 'SELECT', transaction });
+    return results[0]['exists'];
+  }
+}

package/src/query-interface/query-interface-builder.ts

@@ -0,0 +1,14 @@
+import Database from '../database';
+import MysqlQueryInterface from './mysql-query-interface';
+import PostgresQueryInterface from './postgres-query-interface';
+import SqliteQueryInterface from './sqlite-query-interface';
+
+export default function buildQueryInterface(db: Database) {
+  const map = {
+    mysql: MysqlQueryInterface,
+    postgres: PostgresQueryInterface,
+    sqlite: SqliteQueryInterface,
+  };
+
+  return new map[db.options.dialect](db);
+}

package/src/query-interface/query-interface.ts

@@ -0,0 +1,12 @@
+import Database from '../database';
+import { Collection } from '../collection';
+import { QueryInterface as SequelizeQueryInterface, Transactionable } from 'sequelize';
+
+export default abstract class QueryInterface {
+  sequelizeQueryInterface: SequelizeQueryInterface;
+  protected constructor(public db: Database) {
+    this.sequelizeQueryInterface = db.sequelize.getQueryInterface();
+  }
+
+  abstract collectionTableExists(collection: Collection, options?: Transactionable): Promise<boolean>;
+}

package/src/query-interface/sqlite-query-interface.ts

@@ -0,0 +1,18 @@
+import QueryInterface from './query-interface';
+import { Collection } from '../collection';
+
+export default class SqliteQueryInterface extends QueryInterface {
+  constructor(db) {
+    super(db);
+  }
+
+  async collectionTableExists(collection: Collection, options?) {
+    const transaction = options?.transaction;
+
+    const tableName = collection.model.tableName;
+
+    const sql = `SELECT name FROM sqlite_master WHERE type='table' AND name='${tableName}';`;
+    const results = await this.db.sequelize.query(sql, { type: 'SELECT', transaction });
+    return results.length > 0;
+  }
+}

package/src/relation-repository/multiple-relation-repository.ts

@@ -42,6 +42,8 @@ export abstract class MultipleRelationRepository extends RelationRepository {
     const getAccessor = this.accessors().get;
     const sourceModel = await this.getSourceModel(transaction);
 
+    if (!sourceModel) return [];
+
     if (findOptions.include && findOptions.include.length > 0) {
       const ids = (
         await sourceModel[getAccessor]({
@@ -103,6 +105,8 @@ export abstract class MultipleRelationRepository extends RelationRepository {
     const transaction = await this.getTransaction(options);
 
     const sourceModel = await this.getSourceModel(transaction);
+    if (!sourceModel) return 0;
+
     const queryOptions = this.buildQueryOptions(options);
 
     const count = await sourceModel[this.accessors().get]({

package/src/relation-repository/single-relation-repository.ts

@@ -54,6 +54,8 @@ export abstract class SingleRelationRepository extends RelationRepository {
     const getAccessor = this.accessors().get;
     const sourceModel = await this.getSourceModel(transaction);
 
+    if (!sourceModel) return null;
+
     if (findOptions?.include?.length > 0) {
       const templateModel = await sourceModel[getAccessor]({
         ...findOptions,

package/src/sync-runner.ts

@@ -7,7 +7,6 @@ export class SyncRunner {
 
     const inheritedCollection = model.collection as InheritedCollection;
     const db = inheritedCollection.context.database;
-    const schemaName = db.options.schema || 'public';
 
     const dialect = db.sequelize.getDialect();
 
@@ -27,12 +26,7 @@ export class SyncRunner {
       );
     }
 
-    const parentTables = parents.map((parent) => parent.model.tableName);
-
-    const tableName = model.tableName;
-
-    const schemaTableName = db.utils.addSchema(tableName);
-    const quoteTableName = db.utils.quoteTable(tableName);
+    const tableName = inheritedCollection.addSchemaTableName();
 
     const attributes = model.tableAttributes;
 
@@ -43,13 +37,14 @@ export class SyncRunner {
     let maxSequenceVal = 0;
     let maxSequenceName;
 
+    // find max sequence
     if (childAttributes.id && childAttributes.id.autoIncrement) {
-      for (const parent of parentTables) {
+      for (const parent of parents) {
         const sequenceNameResult = await queryInterface.sequelize.query(
           `SELECT column_default
            FROM information_schema.columns
-           WHERE table_name = '${parent}'
-            and table_schema = '${schemaName}'
+           WHERE table_name = '${parent.model.tableName}'
+            and table_schema = '${parent.collectionSchema()}'
              and "column_name" = 'id';`,
           {
             transaction,
@@ -88,22 +83,24 @@ export class SyncRunner {
       }
     }
 
-    await this.createTable(schemaTableName, childAttributes, options, model, parentTables, db);
+    await this.createTable(tableName, childAttributes, options, model, parents);
 
+    // if we have max sequence, set it to child table
     if (maxSequenceName) {
-      const parentsDeep = Array.from(db.inheritanceMap.getParents(inheritedCollection.name)).map(
-        (parent) => db.getCollection(parent).model.tableName,
+      const parentsDeep = Array.from(db.inheritanceMap.getParents(inheritedCollection.name)).map((parent) =>
+        db.getCollection(parent).addSchemaTableName(),
       );
 
-      const sequenceTables = [...parentsDeep, tableName.toString()];
+      const sequenceTables = [...parentsDeep, tableName];
 
       for (const sequenceTable of sequenceTables) {
-        const queryName =
-          Boolean(sequenceTable.match(/[A-Z]/)) && !sequenceTable.includes(`"`) ? `"${sequenceTable}"` : sequenceTable;
+        const tableName = sequenceTable.tableName;
+        const schemaName = sequenceTable.schema;
+
+        const queryName = Boolean(tableName.match(/[A-Z]/)) && !tableName.includes(`"`) ? `"${tableName}"` : tableName;
 
         const idColumnQuery = await queryInterface.sequelize.query(
-          `
-          SELECT column_name
+          `SELECT column_name
 FROM information_schema.columns
 WHERE table_name='${queryName}' and column_name='id' and table_schema = '${schemaName}';
           `,
@@ -117,7 +114,7 @@ WHERE table_name='${queryName}' and column_name='id' and table_schema = '${schem
         }
 
         await queryInterface.sequelize.query(
-          `alter table "${schemaName}"."${sequenceTable}"
+          `alter table ${db.utils.quoteTable(sequenceTable)}
             alter column id set default nextval('${maxSequenceName}')`,
           {
             transaction,
@@ -139,7 +136,7 @@ WHERE table_name='${queryName}' and column_name='id' and table_schema = '${schem
     }
   }
 
-  static async createTable(tableName, attributes, options, model, parentTables, db) {
+  static async createTable(tableName, attributes, options, model, parents) {
     let sql = '';
 
     options = { ...options };
@@ -164,9 +161,9 @@ WHERE table_name='${queryName}' and column_name='id' and table_schema = '${schem
 
     sql = `${queryGenerator.createTableQuery(tableName, attributes, options)}`.replace(
       ';',
-      ` INHERITS (${parentTables
+      ` INHERITS (${parents
         .map((t) => {
-          return db.utils.quoteTable(db.utils.addSchema(t, db.options.schema));
+          return t.addSchemaTableName();
         })
         .join(', ')});`,
     );

package/src/utils.ts

@@ -2,6 +2,7 @@ import crypto from 'crypto';
 import Database from './database';
 import { IdentifierError } from './errors/identifier-error';
 import { Model } from './model';
+import lodash from 'lodash';
 
 type HandleAppendsQueryOptions = {
   templateModel: any;
@@ -96,15 +97,15 @@ function patchShowConstraintsQuery(queryGenerator, db) {
       'is_deferrable AS "isDeferrable",',
       'initially_deferred AS "initiallyDeferred"',
       'from INFORMATION_SCHEMA.table_constraints',
-      `WHERE table_name='${tableName}'`,
+      `WHERE table_name='${lodash.isPlainObject(tableName) ? tableName.tableName : tableName}'`,
     ];
 
     if (!constraintName) {
       lines.push(`AND constraint_name='${constraintName}'`);
     }
 
-    if (db.options.schema && db.options.schema !== 'public') {
-      lines.push(`AND table_schema='${db.options.schema}'`);
+    if (lodash.isPlainObject(tableName) && tableName.schema) {
+      lines.push(`AND table_schema='${tableName.schema}'`);
     }
 
     return lines.join(' ');