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

package/lib/mock-database.js

@@ -6,35 +6,26 @@ Object.defineProperty(exports, "__esModule", {
 exports.MockDatabase = void 0;
 exports.getConfigByEnv = getConfigByEnv;
 exports.mockDatabase = mockDatabase;
-
 function _utils() {
   const data = require("@nocobase/utils");
-
   _utils = function _utils() {
     return data;
   };
-
   return data;
 }
-
 function _path() {
   const data = require("path");
-
   _path = function _path() {
     return data;
   };
-
   return data;
 }
-
 var _database = require("./database");
-
 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 _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 class MockDatabase extends _database.Database {
   constructor(options) {
     super(_objectSpread({
@@ -43,20 +34,17 @@ class MockDatabase extends _database.Database {
       dialect: 'sqlite'
     }, options));
   }
-
 }
-
 exports.MockDatabase = MockDatabase;
-
 function getConfigByEnv() {
-  return {
+  const options = {
     username: process.env.DB_USER,
     password: process.env.DB_PASSWORD,
     database: process.env.DB_DATABASE,
     host: process.env.DB_HOST,
     port: process.env.DB_PORT,
     dialect: process.env.DB_DIALECT || 'sqlite',
-    logging: process.env.DB_LOGGING === 'on' ? console.log : false,
+    logging: process.env.DB_LOGGING === 'on' ? customLogger : false,
     storage: process.env.DB_STORAGE && process.env.DB_STORAGE !== ':memory:' ? (0, _path().resolve)(process.cwd(), process.env.DB_STORAGE) : ':memory:',
     define: {
       charset: 'utf8mb4',
@@ -64,8 +52,17 @@ function getConfigByEnv() {
     },
     timezone: process.env.DB_TIMEZONE,
     underscored: process.env.DB_UNDERSCORED === 'true',
-    schema: process.env.DB_SCHEMA !== 'public' ? process.env.DB_SCHEMA : undefined
+    schema: process.env.DB_SCHEMA !== 'public' ? process.env.DB_SCHEMA : undefined,
+    dialectOptions: {}
   };
+  if (process.env.DB_DIALECT == 'postgres') {
+    options.dialectOptions['application_name'] = 'nocobase.main';
+  }
+  return options;
+}
+function customLogger(queryString, queryObject) {
+  console.log(queryString); // outputs a string
+  console.log(queryObject.bind); // outputs an array
 }
 
 function mockDatabase(options = {}) {

package/lib/model-hook.js

@@ -4,76 +4,54 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ModelHook = void 0;
-
 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 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 _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; }
-
 const _require = require('sequelize/lib/hooks'),
-      hooks = _require.hooks;
-
+  hooks = _require.hooks;
 class ModelHook {
   constructor(database) {
     this.database = void 0;
     this.boundEvents = new Set();
     this.database = database;
   }
-
   match(event) {
     // NOTE: skip Symbol event
     if (!_lodash().default.isString(event)) {
       return null;
     }
-
     const type = event.split('.').pop();
     return type in hooks ? type : null;
   }
-
   findModelName(hookArgs) {
     var _iterator = _createForOfIteratorHelper(hookArgs),
-        _step;
-
+      _step;
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
         const arg = _step.value;
-
         if (arg === null || arg === void 0 ? void 0 : arg._previousDataValues) {
           return arg.constructor.name;
         }
-
         if (_lodash().default.isPlainObject(arg)) {
           var _arg$name, _arg$name2;
-
           if (arg['model']) {
             return arg['model'].name;
           }
-
           const plural = arg === null || arg === void 0 ? void 0 : (_arg$name = arg.name) === null || _arg$name === void 0 ? void 0 : _arg$name.plural;
-
           if (this.database.sequelize.isDefined(plural)) {
             return plural;
           }
-
           const singular = arg === null || arg === void 0 ? void 0 : (_arg$name2 = arg.name) === null || _arg$name2 === void 0 ? void 0 : _arg$name2.singular;
-
           if (this.database.sequelize.isDefined(singular)) {
             return singular;
           }
@@ -84,34 +62,25 @@ class ModelHook {
     } finally {
       _iterator.f();
     }
-
     return null;
   }
-
   bindEvent(type) {
     this.boundEvents.add(type);
   }
-
   hasBoundEvent(type) {
     return this.boundEvents.has(type);
   }
-
   buildSequelizeHook(type) {
     var _this = this;
-
     return /*#__PURE__*/_asyncToGenerator(function* (...args) {
       const modelName = _this.findModelName(args);
-
       if (modelName) {
         // emit model event
         yield _this.database.emitAsync(`${modelName}.${type}`, ...args);
-      } // emit sequelize global event
-
-
+      }
+      // emit sequelize global event
       yield _this.database.emitAsync(type, ...args);
     });
   }
-
 }
-
 exports.ModelHook = ModelHook;

package/lib/model.js

@@ -4,114 +4,86 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Model = 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() {
     return data;
   };
-
   return data;
 }
-
 var _syncRunner = require("./sync-runner");
-
 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); }); }; }
-
 const _ = _lodash().default;
-
 class Model extends _sequelize().Model {
   constructor(...args) {
     super(...args);
     this._changedWithAssociations = new Set();
     this._previousDataValuesWithAssociations = {};
   }
-
   // TODO
   toChangedWithAssociations() {
     // @ts-ignore
-    this._changedWithAssociations = new Set([...this._changedWithAssociations, ...this._changed]); // @ts-ignore
-
+    this._changedWithAssociations = new Set([...this._changedWithAssociations, ...this._changed]);
+    // @ts-ignore
     this._previousDataValuesWithAssociations = this._previousDataValues;
   }
-
   changedWithAssociations(key, value) {
     if (key === undefined) {
       if (this._changedWithAssociations.size > 0) {
         return Array.from(this._changedWithAssociations);
       }
-
       return false;
     }
-
     if (value === true) {
       this._changedWithAssociations.add(key);
-
       return this;
     }
-
     if (value === false) {
       this._changedWithAssociations.delete(key);
-
       return this;
     }
-
     return this._changedWithAssociations.has(key);
   }
-
   clearChangedWithAssociations() {
     this._changedWithAssociations = new Set();
   }
-
   toJSON() {
     const handleObj = (obj, options) => {
       const handles = [data => {
         if (data instanceof Model) {
           return data.toJSON();
         }
-
         return data;
       }, this.hiddenObjKey];
       return handles.reduce((carry, fn) => fn.apply(this, [carry, options]), obj);
     };
-
     const handleArray = (arrayOfObj, options) => {
       const handles = [this.sortAssociations];
       return handles.reduce((carry, fn) => fn.apply(this, [carry, options]), arrayOfObj || []);
     };
-
     const opts = {
       model: this.constructor,
       collection: this.constructor.collection,
       db: this.constructor.database
     };
-
     const traverseJSON = (data, options) => {
       const model = options.model,
-            db = options.db,
-            collection = options.collection; // handle Object
-
+        db = options.db,
+        collection = options.collection;
+      // handle Object
       data = handleObj(data, options);
       const result = {};
-
       for (var _i = 0, _Object$keys = Object.keys(data); _i < _Object$keys.length; _i++) {
         const key = _Object$keys[_i];
-
         // @ts-ignore
         if (model.hasAlias(key)) {
           const association = model.associations[key];
@@ -122,7 +94,6 @@ class Model extends _sequelize().Model {
             key,
             field: collection.getField(key)
           };
-
           if (['HasMany', 'BelongsToMany'].includes(association.associationType)) {
             result[key] = handleArray(data[key], opts).map(item => traverseJSON(item, opts));
           } else {
@@ -132,30 +103,24 @@ class Model extends _sequelize().Model {
           result[key] = data[key];
         }
       }
-
       return result;
     };
-
     return traverseJSON(super.toJSON(), opts);
   }
-
   hiddenObjKey(obj, options) {
     const hiddenFields = Array.from(options.collection.fields.values()).filter(field => field.options.hidden).map(field => field.options.name);
     return _lodash().default.omit(obj, hiddenFields);
   }
-
   sortAssociations(data, {
     field
   }) {
     const sortBy = field.options.sortBy;
     return sortBy ? this.sortArray(data, sortBy) : data;
   }
-
   sortArray(data, sortBy) {
     if (!_lodash().default.isArray(sortBy)) {
       sortBy = [sortBy];
     }
-
     const orderItems = [];
     const orderDirections = [];
     sortBy.forEach(sortItem => {
@@ -164,31 +129,28 @@ class Model extends _sequelize().Model {
     });
     return _lodash().default.orderBy(data, orderItems, orderDirections);
   }
-
   static sync(options) {
     var _this = this;
-
     return _asyncToGenerator(function* () {
+      if (_this.collection.isView()) {
+        return;
+      }
       const model = _this;
       const _schema = model._schema;
-
       if (_schema && _schema != 'public') {
         yield _this.sequelize.query(`CREATE SCHEMA IF NOT EXISTS "${_schema}";`, {
           raw: true,
           transaction: options === null || options === void 0 ? void 0 : options.transaction
         });
-      } // fix sequelize sync with model that not have any column
-
-
+      }
+      // fix sequelize sync with model that not have any column
       if (Object.keys(model.tableAttributes).length === 0) {
         if (_this.database.inDialect('sqlite', 'mysql')) {
           console.error(`Zero-column tables aren't supported in ${_this.database.sequelize.getDialect()}`);
           return;
-        } // @ts-ignore
-
-
+        }
+        // @ts-ignore
         const queryInterface = _this.sequelize.queryInterface;
-
         if (!queryInterface.patched) {
           const oldDescribeTable = queryInterface.describeTable;
           queryInterface.describeTable = /*#__PURE__*/_asyncToGenerator(function* (...args) {
@@ -205,17 +167,13 @@ class Model extends _sequelize().Model {
           queryInterface.patched = true;
         }
       }
-
       if (_this.collection.isInherited()) {
         return _syncRunner.SyncRunner.syncInheritModel(model, options);
       }
-
       return _sequelize().Model.sync.call(_this, options);
     })();
   }
-
 }
-
 exports.Model = Model;
 Model.database = void 0;
 Model.collection = void 0;

package/lib/operators/array.js

@@ -4,29 +4,22 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 function _sequelize() {
   const data = require("sequelize");
-
   _sequelize = function _sequelize() {
     return data;
   };
-
   return data;
 }
-
 var _utils = require("./utils");
-
 const getFieldName = ctx => {
   const fieldName = ctx.fieldName;
   return fieldName;
 };
-
 const escape = (value, ctx) => {
   const sequelize = ctx.db.sequelize;
   return sequelize.escape(value);
 };
-
 const sqliteExistQuery = (value, ctx) => {
   const fieldName = getFieldName(ctx);
   const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
@@ -34,91 +27,72 @@ const sqliteExistQuery = (value, ctx) => {
   const subQuery = `exists (select * from json_each(${name}) where json_each.value in ${sqlArray})`;
   return subQuery;
 };
-
 const emptyQuery = (ctx, operator) => {
   const fieldName = getFieldName(ctx);
   let funcName = 'json_array_length';
   let ifNull = 'IFNULL';
-
   if ((0, _utils.isPg)(ctx)) {
     funcName = 'jsonb_array_length';
     ifNull = 'coalesce';
   }
-
   if ((0, _utils.isMySQL)(ctx)) {
     funcName = 'json_length';
   }
-
   return `(select ${ifNull}(${funcName}(${fieldName}), 0) ${operator} 0)`;
 };
-
 var _default = {
   $match(value, ctx) {
     const fieldName = getFieldName(ctx);
-
     if ((0, _utils.isPg)(ctx)) {
       return {
         [_sequelize().Op.contained]: value,
         [_sequelize().Op.contains]: value
       };
     }
-
     value = escape(JSON.stringify(value.sort()), ctx);
-
     if ((0, _utils.isMySQL)(ctx)) {
       const name = ctx.fullName === fieldName ? `\`${ctx.model.name}\`.\`${fieldName}\`` : `\`${fieldName}\``;
       return _sequelize().Sequelize.literal(`JSON_CONTAINS(${name}, ${value}) AND JSON_CONTAINS(${value}, ${name})`);
     }
-
     return {
       [_sequelize().Op.eq]: _sequelize().Sequelize.literal(`json(${value})`)
     };
   },
-
   $notMatch(value, ctx) {
     const fieldName = getFieldName(ctx);
     value = escape(JSON.stringify(value), ctx);
-
     if ((0, _utils.isPg)(ctx)) {
       const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
       return _sequelize().Sequelize.literal(`not (${name} <@ ${value}::JSONB and ${name} @> ${value}::JSONB)`);
     }
-
     if ((0, _utils.isMySQL)(ctx)) {
       const name = ctx.fullName === fieldName ? `\`${ctx.model.name}\`.\`${fieldName}\`` : `\`${fieldName}\``;
       return _sequelize().Sequelize.literal(`not (JSON_CONTAINS(${name}, ${value}) AND JSON_CONTAINS(${value}, ${name}))`);
     }
-
     return {
       [_sequelize().Op.ne]: _sequelize().Sequelize.literal(`json(${value})`)
     };
   },
-
   $anyOf(value, ctx) {
     const fieldName = getFieldName(ctx);
-
     if ((0, _utils.isPg)(ctx)) {
       const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
       return _sequelize().Sequelize.literal(`${name} ?| ${escape(value.map(i => `${i}`), ctx)}`);
     }
-
     if ((0, _utils.isMySQL)(ctx)) {
       value = escape(JSON.stringify(value), ctx);
       const name = ctx.fullName === fieldName ? `\`${ctx.model.name}\`.\`${fieldName}\`` : `\`${fieldName}\``;
       return _sequelize().Sequelize.literal(`JSON_OVERLAPS(${name}, ${value})`);
     }
-
     const subQuery = sqliteExistQuery(value, ctx);
     return _sequelize().Sequelize.literal(subQuery);
   },
-
   $noneOf(value, ctx) {
     let where;
-
     if ((0, _utils.isPg)(ctx)) {
       const fieldName = getFieldName(ctx);
-      const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`; // pg single quote
-
+      const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
+      // pg single quote
       where = _sequelize().Sequelize.literal(`not (${name} ?| ${escape(value.map(i => `${i}`), ctx)})`);
     } else if ((0, _utils.isMySQL)(ctx)) {
       const fieldName = getFieldName(ctx);
@@ -129,27 +103,23 @@ var _default = {
       const subQuery = sqliteExistQuery(value, ctx);
       where = _sequelize().Sequelize.literal(`not ${subQuery}`);
     }
-
     return {
       [_sequelize().Op.or]: [where, {
         [_sequelize().Op.is]: null
       }]
     };
   },
-
   $arrayEmpty(value, ctx) {
     const subQuery = emptyQuery(ctx, '=');
     return {
       [_sequelize().Op.and]: [_sequelize().Sequelize.literal(`${subQuery}`)]
     };
   },
-
   $arrayNotEmpty(value, ctx) {
     const subQuery = emptyQuery(ctx, '>');
     return {
       [_sequelize().Op.and]: [_sequelize().Sequelize.literal(`${subQuery}`)]
     };
   }
-
 };
 exports.default = _default;

package/lib/operators/association.js

@@ -4,29 +4,23 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 function _sequelize() {
   const data = require("sequelize");
-
   _sequelize = function _sequelize() {
     return data;
   };
-
   return data;
 }
-
 var _default = {
   $exists(value, ctx) {
     return {
       [_sequelize().Op.not]: null
     };
   },
-
   $notExists(value, ctx) {
     return {
       [_sequelize().Op.is]: null
     };
   }
-
 };
 exports.default = _default;

package/lib/operators/boolean.js

@@ -4,17 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 function _sequelize() {
   const data = require("sequelize");
-
   _sequelize = function _sequelize() {
     return data;
   };
-
   return data;
 }
-
 var _default = {
   $isFalsy() {
     return {
@@ -24,12 +20,10 @@ var _default = {
       }
     };
   },
-
   $isTruly() {
     return {
       [_sequelize().Op.eq]: true
     };
   }
-
 };
 exports.default = _default;

package/lib/operators/child-collection.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Record<string, any>;
+export default _default;

package/lib/operators/child-collection.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _sequelize() {
+  const data = require("sequelize");
+  _sequelize = function _sequelize() {
+    return data;
+  };
+  return data;
+}
+const mapVal = (values, db) => values.map(v => {
+  const collection = db.getCollection(v);
+  return _sequelize().Sequelize.literal(`'${collection.tableNameAsString()}'::regclass`);
+});
+var _default = {
+  $childIn(values, ctx) {
+    const db = ctx.db;
+    return {
+      [_sequelize().Op.in]: mapVal(values, db)
+    };
+  },
+  $childNotIn(values, ctx) {
+    const db = ctx.db;
+    return {
+      [_sequelize().Op.notIn]: mapVal(values, db)
+    };
+  }
+};
+exports.default = _default;