@nocobase/database 0.7.0-alpha.6 → 0.7.0-alpha.60

package/lib/update-guard.js

@@ -1,129 +1,172 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.UpdateGuard = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const model_1 = require("./model");
+
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+var _model = require("./model");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 class UpdateGuard {
-    setAction(action) {
-        this.action = action;
+  constructor() {
+    this.model = void 0;
+    this.action = void 0;
+    this.associationKeysToBeUpdate = void 0;
+    this.blackList = void 0;
+    this.whiteList = void 0;
+  }
+
+  setAction(action) {
+    this.action = action;
+  }
+
+  setModel(model) {
+    this.model = model;
+  }
+
+  setAssociationKeysToBeUpdate(associationKeysToBeUpdate) {
+    if (this.action == 'create') {
+      this.associationKeysToBeUpdate = Object.keys(this.model.associations);
+    } else {
+      this.associationKeysToBeUpdate = associationKeysToBeUpdate;
     }
-    setModel(model) {
-        this.model = model;
+  }
+
+  setWhiteList(whiteList) {
+    this.whiteList = whiteList;
+  }
+
+  setBlackList(blackList) {
+    this.blackList = blackList;
+  }
+  /**
+   * Sanitize values by whitelist blacklist
+   * @param values
+   */
+
+
+  sanitize(values) {
+    values = _lodash().default.clone(values);
+
+    if (!this.model) {
+      throw new Error('please set model first');
     }
-    setAssociationKeysToBeUpdate(associationKeysToBeUpdate) {
-        if (this.action == 'create') {
-            this.associationKeysToBeUpdate = Object.keys(this.model.associations);
+
+    const associations = this.model.associations;
+
+    const associationsValues = _lodash().default.pick(values, Object.keys(associations)); // build params of association update guard
+
+
+    const listOfAssociation = (list, association) => {
+      if (list) {
+        list = list.filter(whiteListKey => whiteListKey.startsWith(`${association}.`)).map(whiteListKey => whiteListKey.replace(`${association}.`, ''));
+
+        if (list.length == 0) {
+          return undefined;
         }
-        else {
-            this.associationKeysToBeUpdate = associationKeysToBeUpdate;
+
+        return list;
+      }
+
+      return undefined;
+    }; // sanitize association values
+
+
+    Object.keys(associationsValues).forEach(association => {
+      let associationValues = associationsValues[association];
+
+      const filterAssociationToBeUpdate = value => {
+        const associationKeysToBeUpdate = this.associationKeysToBeUpdate || [];
+
+        if (associationKeysToBeUpdate.includes(association)) {
+          return value;
         }
-    }
-    setWhiteList(whiteList) {
-        this.whiteList = whiteList;
-    }
-    setBlackList(blackList) {
-        this.blackList = blackList;
-    }
-    /**
-     * Sanitize values by whitelist blacklist
-     * @param values
-     */
-    sanitize(values) {
-        values = lodash_1.default.clone(values);
-        if (!this.model) {
-            throw new Error('please set model first');
+
+        const associationObj = associations[association];
+        const associationKeyName = associationObj.associationType == 'BelongsTo' || associationObj.associationType == 'HasOne' ? associationObj.targetKey : associationObj.target.primaryKeyAttribute;
+
+        if (value[associationKeyName]) {
+          return _lodash().default.pick(value, [associationKeyName, ...Object.keys(associationObj.target.associations)]);
         }
-        const associations = this.model.associations;
-        const associationsValues = lodash_1.default.pick(values, Object.keys(associations));
-        // build params of association update guard
-        const listOfAssociation = (list, association) => {
-            if (list) {
-                list = list
-                    .filter((whiteListKey) => whiteListKey.startsWith(`${association}.`))
-                    .map((whiteListKey) => whiteListKey.replace(`${association}.`, ''));
-                if (list.length == 0) {
-                    return undefined;
-                }
-                return list;
-            }
-            return undefined;
-        };
-        // sanitize association values
-        Object.keys(associationsValues).forEach((association) => {
-            let associationValues = associationsValues[association];
-            const filterAssociationToBeUpdate = (value) => {
-                const associationKeysToBeUpdate = this.associationKeysToBeUpdate || [];
-                if (associationKeysToBeUpdate.includes(association)) {
-                    return value;
-                }
-                const associationObj = associations[association];
-                const associationKeyName = associationObj.associationType == 'BelongsTo' || associationObj.associationType == 'HasOne'
-                    ? associationObj.targetKey
-                    : associationObj.target.primaryKeyAttribute;
-                if (value[associationKeyName]) {
-                    return lodash_1.default.pick(value, [associationKeyName, ...Object.keys(associationObj.target.associations)]);
-                }
-                return value;
-            };
-            const sanitizeValue = (value) => {
-                const associationUpdateGuard = new UpdateGuard();
-                associationUpdateGuard.setModel(associations[association].target);
-                ['whiteList', 'blackList', 'associationKeysToBeUpdate'].forEach((optionKey) => {
-                    associationUpdateGuard[`set${lodash_1.default.upperFirst(optionKey)}`](listOfAssociation(this[optionKey], association));
-                });
-                return associationUpdateGuard.sanitize(filterAssociationToBeUpdate(value));
-            };
-            if (Array.isArray(associationValues)) {
-                associationValues = associationValues.map((value) => {
-                    if (typeof value == 'string' || typeof value == 'number') {
-                        return value;
-                    }
-                    else {
-                        return sanitizeValue(value);
-                    }
-                });
-            }
-            else if (typeof associationValues === 'object' && associationValues !== null) {
-                associationValues = sanitizeValue(associationValues);
-            }
-            // set association values to sanitized value
-            values[association] = associationValues;
+
+        return value;
+      };
+
+      const sanitizeValue = value => {
+        const associationUpdateGuard = new UpdateGuard();
+        associationUpdateGuard.setModel(associations[association].target);
+        ['whiteList', 'blackList', 'associationKeysToBeUpdate'].forEach(optionKey => {
+          associationUpdateGuard[`set${_lodash().default.upperFirst(optionKey)}`](listOfAssociation(this[optionKey], association));
         });
-        if (values instanceof model_1.Model) {
-            return values;
-        }
-        let valuesKeys = Object.keys(values || {});
-        // handle whitelist
-        if (this.whiteList) {
-            valuesKeys = valuesKeys.filter((valueKey) => {
-                return (this.whiteList.findIndex((whiteKey) => {
-                    const keyPaths = whiteKey.split('.');
-                    return keyPaths[0] === valueKey;
-                }) !== -1);
-            });
-        }
-        // handle blacklist
-        if (this.blackList) {
-            valuesKeys = valuesKeys.filter((valueKey) => !this.blackList.includes(valueKey));
-        }
-        const result = valuesKeys.reduce((obj, key) => {
-            lodash_1.default.set(obj, key, values[key]);
-            return obj;
-        }, {});
-        return result;
+        return associationUpdateGuard.sanitize(filterAssociationToBeUpdate(value));
+      };
+
+      if (Array.isArray(associationValues)) {
+        associationValues = associationValues.map(value => {
+          if (typeof value == 'string' || typeof value == 'number') {
+            return value;
+          } else {
+            return sanitizeValue(value);
+          }
+        });
+      } else if (typeof associationValues === 'object' && associationValues !== null) {
+        associationValues = sanitizeValue(associationValues);
+      } // set association values to sanitized value
+
+
+      values[association] = associationValues;
+    });
+
+    if (values instanceof _model.Model) {
+      return values;
     }
-    static fromOptions(model, options) {
-        const guard = new UpdateGuard();
-        guard.setModel(model);
-        guard.setWhiteList(options.whitelist);
-        guard.setBlackList(options.blacklist);
-        guard.setAction(lodash_1.default.get(options, 'action', 'update'));
-        guard.setAssociationKeysToBeUpdate(options.updateAssociationValues);
-        return guard;
+
+    let valuesKeys = Object.keys(values || {}); // handle whitelist
+
+    if (this.whiteList) {
+      valuesKeys = valuesKeys.filter(valueKey => {
+        return this.whiteList.findIndex(whiteKey => {
+          const keyPaths = whiteKey.split('.');
+          return keyPaths[0] === valueKey;
+        }) !== -1;
+      });
+    } // handle blacklist
+
+
+    if (this.blackList) {
+      valuesKeys = valuesKeys.filter(valueKey => !this.blackList.includes(valueKey));
     }
+
+    const result = valuesKeys.reduce((obj, key) => {
+      _lodash().default.set(obj, key, values[key]);
+
+      return obj;
+    }, {});
+    return result;
+  }
+
+  static fromOptions(model, options) {
+    const guard = new UpdateGuard();
+    guard.setModel(model);
+    guard.setWhiteList(options.whitelist);
+    guard.setBlackList(options.blacklist);
+    guard.setAction(_lodash().default.get(options, 'action', 'update'));
+    guard.setAssociationKeysToBeUpdate(options.updateAssociationValues);
+    return guard;
+  }
+
 }
-exports.UpdateGuard = UpdateGuard;
-//# sourceMappingURL=update-guard.js.map
+
+exports.UpdateGuard = UpdateGuard;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/database",
-  "version": "0.7.0-alpha.6",
+  "version": "0.7.0-alpha.60",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -11,13 +11,8 @@
       "url": "http://www.apache.org/licenses/LICENSE-2.0"
     }
   ],
-  "scripts": {
-    "build": "rimraf -rf lib esm dist && npm run build:cjs && npm run build:esm",
-    "build:cjs": "tsc --project tsconfig.build.json",
-    "build:esm": "tsc --project tsconfig.build.json --module es2015 --outDir esm"
-  },
   "dependencies": {
-    "@nocobase/utils": "0.7.0-alpha.6",
+    "@nocobase/utils": "0.7.0-alpha.60",
     "async-mutex": "^0.3.2",
     "deepmerge": "^4.2.2",
     "flat": "^5.0.2",
@@ -29,5 +24,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "7d0087cbb3b7663ba05366ca3b80db2853669ee9"
+  "gitHead": "f0d0afbb19dbd90ac3cf4155748fa084c67f54ee"
 }

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

@@ -0,0 +1,30 @@
+import { mockDatabase } from '../';
+import { Database } from '../../database';
+
+describe('string field', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('define', async () => {
+    const Test = db.collection({
+      name: 'tests',
+      autoGenId: false,
+      fields: [
+        {
+          type: 'uuid',
+          name: 'id',
+          primaryKey: true,
+        },
+      ],
+    });
+    await Test.sync();
+    await Test.model.create();
+  });
+});

package/src/__tests__/operator/notIn.test.ts

@@ -0,0 +1,33 @@
+import { mockDatabase } from '../index';
+import Database from '../../database';
+
+describe('ne operator', () => {
+  let db: Database;
+  let Test;
+  beforeEach(async () => {
+    db = mockDatabase({});
+
+    Test = db.collection({
+      name: 'tests',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+
+    await db.sync();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should notIn with null', async () => {
+    await db.getRepository('tests').create({});
+
+    const results = await db.getRepository('tests').count({
+      filter: {
+        'name.$notIn': ['123'],
+      },
+    });
+
+    expect(results).toEqual(1);
+  });
+});

package/src/__tests__/option-parser.test.ts

@@ -81,6 +81,7 @@ describe('option parser', () => {
       ],
     });
   });
+
   test('with sort option', () => {
     let options: any = {
       sort: ['id'],
@@ -182,4 +183,23 @@ describe('option parser', () => {
 
     expect(params['include'][0]['attributes']['exclude']).toContain('id');
   });
+
+  test('option parser with multiple association', () => {
+    // fields with association field
+    const options = {
+      appends: ['user', 'comments.id', 'tags.id'],
+    };
+
+    const parser = new OptionsParser(options, {
+      collection: Post,
+    });
+
+    const params = parser.toSequelizeParams();
+    expect(params.include.length).toBe(3);
+    expect(params.include[0].association).toBe('user');
+    expect(params.include[1].association).toBe('comments');
+    expect(params.include[1].attributes).toEqual(['id']);
+    expect(params.include[2].association).toBe('tags');
+    expect(params.include[2].attributes).toEqual(['id']);
+  });
 });

package/src/database.ts

@@ -2,7 +2,17 @@ import { applyMixins, AsyncEmitter } from '@nocobase/utils';
 import merge from 'deepmerge';
 import { EventEmitter } from 'events';
 import lodash from 'lodash';
-import { ModelCtor, Op, Options, QueryInterfaceDropAllTablesOptions, Sequelize, SyncOptions, Utils } from 'sequelize';
+import { isAbsolute, resolve } from 'path';
+import {
+  ModelCtor,
+  Op,
+  Options,
+  QueryInterfaceDropAllTablesOptions,
+  QueryOptions,
+  Sequelize,
+  SyncOptions,
+  Utils
+} from 'sequelize';
 import { Collection, CollectionOptions, RepositoryType } from './collection';
 import { ImporterReader, ImportFileExtension } from './collection-importer';
 import * as FieldTypes from './fields';
@@ -64,8 +74,22 @@ export class Database extends EventEmitter implements AsyncEmitter {
     if (options instanceof Sequelize) {
       this.sequelize = options;
     } else {
-      this.sequelize = new Sequelize(options);
-      this.options = options;
+      const opts = {
+        sync: {
+          alter: {
+            drop: false,
+          },
+          force: false,
+        },
+        ...options,
+      };
+      if (options.storage && options.storage !== ':memory:') {
+        if (!isAbsolute(options.storage)) {
+          opts.storage = resolve(process.cwd(), options.storage);
+        }
+      }
+      this.sequelize = new Sequelize(opts);
+      this.options = opts;
     }
 
     this.collections = new Map();
@@ -248,6 +272,29 @@ export class Database extends EventEmitter implements AsyncEmitter {
     return this.sequelize.getDialect() === 'sqlite' && lodash.get(this.options, 'storage') == ':memory:';
   }
 
+  async auth(options: QueryOptions & { repeat?: number } = {}) {
+    const { repeat = 10, ...others } = options;
+    const delay = (ms) => new Promise((yea) => setTimeout(yea, ms));
+    let count = 1;
+    const authenticate = async () => {
+      try {
+        await this.sequelize.authenticate(others);
+        console.log('Connection has been established successfully.');
+        return true;
+      } catch (error) {
+        if (count >= repeat) {
+          throw error;
+        }
+        console.log('reconnecting...', count);
+        ++count;
+        await delay(500);
+        return await authenticate();
+      }
+    };
+
+    return await authenticate();
+  }
+
   async reconnect() {
     if (this.isSqliteMemory()) {
       return;
@@ -312,7 +359,7 @@ export class Database extends EventEmitter implements AsyncEmitter {
     return result;
   }
 
-  emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
+  declare emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
 }
 
 export function extend(collectionOptions: CollectionOptions, mergeOptions?: MergeOptions) {

package/src/fields/context-field.ts

@@ -1,4 +1,4 @@
-import { lodash } from '@umijs/utils';
+import lodash from 'lodash';
 import { DataTypes } from 'sequelize';
 import { Model } from '../model';
 import { BaseColumnFieldOptions, Field } from './field';

package/src/fields/index.ts

@@ -22,6 +22,7 @@ import { StringFieldOptions } from './string-field';
 import { TextFieldOptions } from './text-field';
 import { TimeFieldOptions } from './time-field';
 import { UidFieldOptions } from './uid-field';
+import { UUIDFieldOptions } from './uuid-field';
 import { VirtualFieldOptions } from './virtual-field';
 
 export * from './array-field';
@@ -43,6 +44,7 @@ export * from './string-field';
 export * from './text-field';
 export * from './time-field';
 export * from './uid-field';
+export * from './uuid-field';
 export * from './virtual-field';
 
 export type FieldOptions =
@@ -64,6 +66,7 @@ export type FieldOptions =
   | TimeFieldOptions
   | DateFieldOptions
   | UidFieldOptions
+  | UUIDFieldOptions
   | PasswordFieldOptions
   | ContextFieldOptions
   | BelongsToFieldOptions

package/src/fields/uuid-field.ts

@@ -0,0 +1,21 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field, FieldContext } from './field';
+
+export class UuidField extends Field {
+  constructor(options?: any, context?: FieldContext) {
+    super(
+      {
+        defaultValue: DataTypes.UUIDV4,
+        ...options,
+      },
+      context,
+    );
+  }
+  get dataType() {
+    return DataTypes.UUID;
+  }
+}
+
+export interface UUIDFieldOptions extends BaseColumnFieldOptions {
+  type: 'uuid';
+}

package/src/mock-database.ts

@@ -24,7 +24,7 @@ export function getConfigByEnv() {
     host: process.env.DB_HOST,
     port: process.env.DB_PORT,
     dialect: process.env.DB_DIALECT,
-    logging: process.env.DB_LOG_SQL === 'on' ? console.log : false,
+    logging: process.env.DB_LOGGING === 'on' ? console.log : false,
     storage:
       process.env.DB_STORAGE && process.env.DB_STORAGE !== ':memory:'
         ? resolve(process.cwd(), process.env.DB_STORAGE)

package/src/model-hook.ts

@@ -27,7 +27,7 @@ export class ModelHook {
 
   findModelName(hookArgs) {
     for (const arg of hookArgs) {
-      if (arg instanceof Model) {
+      if (arg?._previousDataValues) {
         return (<Model>arg).constructor.name;
       }
 

package/src/operators/boolean.ts

@@ -0,0 +1,18 @@
+import { Op } from 'sequelize';
+
+export default {
+  $isFalsy() {
+    return {
+      [Op.or]: {
+        [Op.is]: null,
+        [Op.eq]: false,
+      },
+    };
+  },
+
+  $isTruly() {
+    return {
+      [Op.eq]: true,
+    };
+  },
+};

package/src/operators/index.ts

@@ -5,4 +5,6 @@ export default {
   ...require('./empty').default,
   ...require('./string').default,
   ...require('./ne').default,
+  ...require('./notIn').default,
+  ...require('./boolean').default,
 };

package/src/operators/notIn.ts

@@ -0,0 +1,12 @@
+import { Op } from 'sequelize';
+
+export default {
+  $notIn(val, ctx) {
+    return {
+      [Op.or]: {
+        [Op.notIn]: val,
+        [Op.is]: null,
+      },
+    };
+  },
+};

package/src/options-parser.ts

@@ -230,7 +230,7 @@ export class OptionsParser {
           association: appendAssociation,
         });
 
-        existIncludeIndex = 0;
+        existIncludeIndex = queryParams['include'].length - 1;
       }
 
       // end appends

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

@@ -1,5 +1,5 @@
 import { omit } from 'lodash';
-import { MultiAssociationAccessors, Op, Sequelize, Transaction } from 'sequelize';
+import { MultiAssociationAccessors, Op, Sequelize, Transaction, Transactionable } from 'sequelize';
 import {
   CommonFindOptions,
   CountOptions,
@@ -9,7 +9,6 @@ import {
   FindOptions,
   TargetKey,
   TK,
-  TransactionAble,
   UpdateOptions
 } from '../repository';
 import { updateModelByValues } from '../update-associations';
@@ -20,7 +19,7 @@ export interface FindAndCountOptions extends CommonFindOptions {}
 
 export interface FindOneOptions extends CommonFindOptions, FilterByTk {}
 
-export interface AssociatedOptions extends TransactionAble {
+export interface AssociatedOptions extends Transactionable {
   tk?: TK;
 }
 
@@ -150,7 +149,10 @@ export abstract class MultipleRelationRepository extends RelationRepository {
 
     const queryOptions = this.buildQueryOptions(options as any);
 
-    const instances = await this.find(queryOptions);
+    const instances = await this.find({
+      ...queryOptions,
+      transaction,
+    });
 
     for (const instance of instances) {
       await updateModelByValues(instance, values, {
@@ -163,8 +165,8 @@ export abstract class MultipleRelationRepository extends RelationRepository {
 
     for (const instance of instances) {
       if (options.hooks !== false) {
-        await this.db.emitAsync(`${this.targetCollection.name}.afterUpdateWithAssociations`, instance, options);
-        await this.db.emitAsync(`${this.targetCollection.name}.afterSaveWithAssociations`, instance, options);
+        await this.db.emitAsync(`${this.targetCollection.name}.afterUpdateWithAssociations`, instance, {...options, transaction});
+        await this.db.emitAsync(`${this.targetCollection.name}.afterSaveWithAssociations`, instance, {...options, transaction});
       }
     }