@nocobase/database 0.7.7-alpha.1 → 0.8.0-alpha.5

package/lib/fields/has-many-field.d.ts

@@ -1,5 +1,6 @@
 import { AssociationScope, DataType, ForeignKeyOptions, HasManyOptions, HasManyOptions as SequelizeHasManyOptions } from 'sequelize';
 import { MultipleRelationFieldOptions, RelationField } from './relation-field';
+import { Reference } from '../features/ReferencesMap';
 export interface HasManyFieldOptions extends HasManyOptions {
     /**
      * The name of the field to use as the key for the association in the source table. Defaults to the primary
@@ -55,6 +56,7 @@ export interface HasManyFieldOptions extends HasManyOptions {
 }
 export declare class HasManyField extends RelationField {
     get foreignKey(): any;
+    reference(association: any): Reference;
     bind(): boolean;
     unbind(): void;
 }

package/lib/fields/has-many-field.js

@@ -45,6 +45,17 @@ class HasManyField extends _relationField.RelationField {
     return _sequelize().Utils.camelize([model.options.name.singular, this.sourceKey || model.primaryKeyAttribute].join('_'));
   }
 
+  reference(association) {
+    const sourceKey = association.sourceKey;
+    return {
+      sourceCollectionName: this.database.modelCollection.get(association.target).name,
+      sourceField: association.foreignKey,
+      targetField: sourceKey,
+      targetCollectionName: this.database.modelCollection.get(association.source).name,
+      onDelete: this.options.onDelete
+    };
+  }
+
   bind() {
     const _this$context = this.context,
           database = _this$context.database,
@@ -62,7 +73,7 @@ class HasManyField extends _relationField.RelationField {
 
     const association = collection.model.hasMany(Target, _objectSpread(_objectSpread({
       constraints: false
-    }, (0, _lodash().omit)(this.options, ['name', 'type', 'target'])), {}, {
+    }, (0, _lodash().omit)(this.options, ['name', 'type', 'target', 'onDelete'])), {}, {
       as: this.name,
       foreignKey: this.foreignKey
     })); // inverse relation
@@ -99,6 +110,7 @@ class HasManyField extends _relationField.RelationField {
       tcoll.addIndex([this.options.foreignKey]);
     }
 
+    this.database.referenceMap.addReference(this.reference(association));
     return true;
   }
 
@@ -121,6 +133,12 @@ class HasManyField extends _relationField.RelationField {
 
     if (!field) {
       tcoll.model.removeAttribute(foreignKey);
+    }
+
+    const association = collection.model.associations[this.name];
+
+    if (association) {
+      this.database.referenceMap.removeReference(this.reference(association));
     } // 删掉 model 的关联字段
 
 

package/lib/fields/has-one-field.d.ts

@@ -1,5 +1,6 @@
 import { AssociationScope, DataType, ForeignKeyOptions, HasOneOptions, HasOneOptions as SequelizeHasOneOptions } from 'sequelize';
 import { BaseRelationFieldOptions, RelationField } from './relation-field';
+import { Reference } from '../features/ReferencesMap';
 export interface HasOneFieldOptions extends HasOneOptions {
     /**
      * The name of the field to use as the key for the association in the source table. Defaults to the primary
@@ -56,6 +57,7 @@ export interface HasOneFieldOptions extends HasOneOptions {
 export declare class HasOneField extends RelationField {
     get target(): any;
     get foreignKey(): any;
+    reference(association: any): Reference;
     bind(): boolean;
     unbind(): void;
 }

package/lib/fields/has-one-field.js

@@ -52,6 +52,17 @@ class HasOneField extends _relationField.RelationField {
     return _sequelize().Utils.camelize([model.options.name.singular, model.primaryKeyAttribute].join('_'));
   }
 
+  reference(association) {
+    const sourceKey = association.sourceKey;
+    return {
+      sourceCollectionName: this.database.modelCollection.get(association.target).name,
+      sourceField: association.foreignKey,
+      targetField: sourceKey,
+      targetCollectionName: this.database.modelCollection.get(association.source).name,
+      onDelete: this.options.onDelete
+    };
+  }
+
   bind() {
     const _this$context = this.context,
           database = _this$context.database,
@@ -65,7 +76,7 @@ class HasOneField extends _relationField.RelationField {
 
     const association = collection.model.hasOne(Target, _objectSpread(_objectSpread({
       constraints: false
-    }, (0, _lodash().omit)(this.options, ['name', 'type', 'target'])), {}, {
+    }, (0, _lodash().omit)(this.options, ['name', 'type', 'target', 'onDelete'])), {}, {
       as: this.name,
       foreignKey: this.foreignKey
     })); // 建立关系之后从 pending 列表中删除
@@ -100,6 +111,7 @@ class HasOneField extends _relationField.RelationField {
       tcoll.addIndex([this.options.foreignKey]);
     }
 
+    this.database.referenceMap.addReference(this.reference(association));
     return true;
   }
 
@@ -122,8 +134,10 @@ class HasOneField extends _relationField.RelationField {
 
     if (!field) {
       tcoll.model.removeAttribute(foreignKey);
-    } // 删掉 model 的关联字段
+    }
 
+    const association = collection.model.associations[this.name];
+    this.database.referenceMap.removeReference(this.reference(association)); // 删掉 model 的关联字段
 
     delete collection.model.associations[this.name]; // @ts-ignore
 

package/lib/filter-parser.js

@@ -115,9 +115,6 @@ class FilterParser {
     debug('flattened filter %o', flattenedFilter);
     const include = {};
     const where = {};
-
-    const filter2 = _lodash().default.cloneDeep(flattenedFilter);
-
     let skipPrefix = null;
     const associations = model.associations;
     debug('associations %O', associations);
@@ -130,6 +127,11 @@ class FilterParser {
       // 处理 filter 条件
       if (skipPrefix && key.startsWith(skipPrefix)) {
         continue;
+      } // skip empty logic operator value
+
+
+      if ((key == '$or' || key == '$and') && Array.isArray(value) && value.length == 0) {
+        continue;
       }
 
       debug('handle filter key "%s: "%s"', key, value);

package/lib/model.d.ts

@@ -7,6 +7,7 @@ interface IModel {
 export declare class Model<TModelAttributes extends {} = any, TCreationAttributes extends {} = TModelAttributes> extends SequelizeModel<TModelAttributes, TCreationAttributes> implements IModel {
     static database: Database;
     static collection: Collection;
+    [key: string]: any;
     protected _changedWithAssociations: Set<unknown>;
     protected _previousDataValuesWithAssociations: {};
     toChangedWithAssociations(): void;

package/lib/options-parser.js

@@ -261,8 +261,9 @@ class OptionsParser {
     if (!appends) return filterParams;
     /**
      * set include params
-     * @param includeRoot
-     * @param appends
+     * @param model
+     * @param queryParams
+     * @param append
      */
 
     const setInclude = (model, queryParams, append) => {

package/lib/relation-repository/belongs-to-many-repository.d.ts

@@ -1,14 +1,14 @@
 import { Transaction } from 'sequelize';
 import { Model } from '../model';
-import { CreateOptions, DestroyOptions, FindOptions, TargetKey, UpdateOptions } from '../repository';
-import { FindAndCountOptions, FindOneOptions, MultipleRelationRepository } from './multiple-relation-repository';
+import { CreateOptions, DestroyOptions, FindOneOptions, FindOptions, TargetKey, UpdateOptions } from '../repository';
+import { FindAndCountOptions, MultipleRelationRepository } from './multiple-relation-repository';
 import { AssociatedOptions, PrimaryKeyWithThroughValues } from './types';
 declare type CreateBelongsToManyOptions = CreateOptions;
 interface IBelongsToManyRepository<M extends Model> {
     find(options?: FindOptions): Promise<M[]>;
     findAndCount(options?: FindAndCountOptions): Promise<[M[], number]>;
     findOne(options?: FindOneOptions): Promise<M>;
-    create(options?: CreateBelongsToManyOptions): Promise<M>;
+    create(options?: CreateOptions): Promise<M>;
     update(options?: UpdateOptions): Promise<M>;
     destroy(options?: number | string | number[] | string[] | DestroyOptions): Promise<Boolean>;
     set(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;

package/lib/relation-repository/hasmany-repository.d.ts

@@ -1,6 +1,6 @@
 import { Model } from '../model';
-import { CreateOptions, DestroyOptions, FindOptions, TargetKey, TK, UpdateOptions } from '../repository';
-import { AssociatedOptions, FindAndCountOptions, FindOneOptions, MultipleRelationRepository } from './multiple-relation-repository';
+import { CreateOptions, DestroyOptions, FindOneOptions, FindOptions, TargetKey, TK, UpdateOptions } from '../repository';
+import { AssociatedOptions, FindAndCountOptions, MultipleRelationRepository } from './multiple-relation-repository';
 interface IHasManyRepository<M extends Model> {
     find(options?: FindOptions): Promise<M>;
     findAndCount(options?: FindAndCountOptions): Promise<[M[], number]>;

package/lib/relation-repository/hasone-repository.d.ts

@@ -1,11 +1,9 @@
 import { Model } from '../model';
 import { CreateOptions } from '../repository';
 import { SingleRelationFindOption, SingleRelationRepository } from './single-relation-repository';
-interface HasOneFindOptions extends SingleRelationFindOption {
-}
 interface IHasOneRepository<M extends Model> {
-    find(options?: HasOneFindOptions): Promise<M>;
-    findOne(options?: HasOneFindOptions): Promise<M>;
+    find(options?: SingleRelationFindOption): Promise<M>;
+    findOne(options?: SingleRelationFindOption): Promise<M>;
     create(options?: CreateOptions): Promise<M>;
     update(options?: any): Promise<M>;
     destroy(): Promise<Boolean>;

package/lib/relation-repository/multiple-relation-repository.d.ts

@@ -1,10 +1,7 @@
 import { MultiAssociationAccessors, Transaction, Transactionable } from 'sequelize';
-import { CommonFindOptions, CountOptions, DestroyOptions, Filter, FilterByTk, FindOptions, TargetKey, TK, UpdateOptions } from '../repository';
+import { CommonFindOptions, CountOptions, DestroyOptions, Filter, FindOneOptions, FindOptions, TargetKey, TK, UpdateOptions } from '../repository';
 import { RelationRepository } from './relation-repository';
-export interface FindAndCountOptions extends CommonFindOptions {
-}
-export interface FindOneOptions extends CommonFindOptions, FilterByTk {
-}
+export declare type FindAndCountOptions = CommonFindOptions;
 export interface AssociatedOptions extends Transactionable {
     tk?: TK;
 }

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

@@ -15,12 +15,12 @@ function _lodash() {
   return data;
 }
 
+var _transactionDecorator = require("../decorators/transaction-decorator");
+
 var _filterParser = _interopRequireDefault(require("../filter-parser"));
 
 var _optionsParser = require("../options-parser");
 
-var _transactionDecorator = require("../decorators/transaction-decorator");
-
 var _updateAssociations = require("../update-associations");
 
 var _updateGuard = require("../update-guard");

package/lib/relation-repository/single-relation-repository.d.ts

@@ -14,7 +14,7 @@ interface SetOption extends Transactionable {
 export declare abstract class SingleRelationRepository extends RelationRepository {
     remove(options?: Transactionable): Promise<void>;
     set(options: TargetKey | SetOption): Promise<void>;
-    find(options?: SingleRelationFindOption): Promise<Model<any>>;
+    find(options?: SingleRelationFindOption): Promise<Model<any> | null>;
     findOne(options?: SingleRelationFindOption): Promise<Model<any>>;
     destroy(options?: Transactionable): Promise<Boolean>;
     update(options: UpdateOptions): Promise<any>;

package/lib/repository.d.ts

@@ -1,7 +1,10 @@
-import { Association, BulkCreateOptions, CreateOptions as SequelizeCreateOptions, DestroyOptions as SequelizeDestroyOptions, FindAndCountOptions as SequelizeAndCountOptions, FindOptions as SequelizeFindOptions, ModelCtor, Transactionable, UpdateOptions as SequelizeUpdateOptions } from 'sequelize';
+/// <reference types="node" />
+import { Association, BulkCreateOptions, CountOptions as SequelizeCountOptions, CreateOptions as SequelizeCreateOptions, DestroyOptions as SequelizeDestroyOptions, FindAndCountOptions as SequelizeAndCountOptions, FindOptions as SequelizeFindOptions, ModelCtor, Transactionable, UpdateOptions as SequelizeUpdateOptions } from 'sequelize';
+import { WhereOperators } from 'sequelize/types/lib/model';
 import { Collection } from './collection';
 import { Database } from './database';
 import { Model } from './model';
+import operators from './operators';
 import { BelongsToManyRepository } from './relation-repository/belongs-to-many-repository';
 import { BelongsToRepository } from './relation-repository/belongs-to-repository';
 import { HasManyRepository } from './relation-repository/hasmany-repository';
@@ -18,7 +21,23 @@ export interface FilterAble {
 }
 export declare type TargetKey = string | number;
 export declare type TK = TargetKey | TargetKey[];
-export declare type Filter = any;
+declare type FieldValue = string | number | bigint | boolean | Date | Buffer | null | FieldValue[] | FilterWithOperator;
+declare type Operators = keyof typeof operators & keyof WhereOperators;
+export declare type FilterWithOperator = {
+    [key: string]: {
+        [K in Operators]: FieldValue;
+    } | FieldValue;
+};
+export declare type FilterWithValue = {
+    [key: string]: FieldValue;
+};
+declare type FilterAnd = {
+    $and: Filter[];
+};
+declare type FilterOr = {
+    $or: Filter[];
+};
+export declare type Filter = FilterWithOperator | FilterWithValue | FilterAnd | FilterOr;
 export declare type Appends = string[];
 export declare type Except = string[];
 export declare type Fields = string[];
@@ -27,16 +46,14 @@ export declare type WhiteList = string[];
 export declare type BlackList = string[];
 export declare type AssociationKeysToBeUpdate = string[];
 export declare type Values = any;
-export interface CountOptions extends Omit<SequelizeCreateOptions, 'distinct' | 'where' | 'include'>, Transactionable {
-    fields?: Fields;
+export interface CountOptions extends Omit<SequelizeCountOptions, 'distinct' | 'where' | 'include'>, Transactionable {
     filter?: Filter;
     context?: any;
 }
 export interface FilterByTk {
     filterByTk?: TargetKey;
 }
-export interface FindOptions extends SequelizeFindOptions, CommonFindOptions, FilterByTk {
-}
+export declare type FindOptions = SequelizeFindOptions & CommonFindOptions & FilterByTk;
 export interface CommonFindOptions extends Transactionable {
     filter?: Filter;
     fields?: Fields;
@@ -45,21 +62,14 @@ export interface CommonFindOptions extends Transactionable {
     sort?: Sort;
     context?: any;
 }
-interface FindOneOptions extends FindOptions {
-}
+export declare type FindOneOptions = Omit<FindOptions, 'limit'>;
 export interface DestroyOptions extends SequelizeDestroyOptions {
     filter?: Filter;
     filterByTk?: TargetKey | TargetKey[];
     truncate?: boolean;
     context?: any;
 }
-interface FindAndCountOptions extends Omit<SequelizeAndCountOptions, 'where' | 'include' | 'order'> {
-    filter?: Filter;
-    fields?: Fields;
-    except?: Except;
-    appends?: Appends;
-    sort?: Sort;
-}
+declare type FindAndCountOptions = Omit<SequelizeAndCountOptions, 'where' | 'include' | 'order'> & CommonFindOptions;
 export interface CreateOptions extends SequelizeCreateOptions {
     values?: Values | Values[];
     whitelist?: WhiteList;

package/lib/repository.js

@@ -219,7 +219,9 @@ class Repository {
       options = _objectSpread(_objectSpread({}, options), {}, {
         transaction
       });
-      return [yield _this3.find(options), yield _this3.count(options)];
+      const count = yield _this3.count(options);
+      const results = count ? yield _this3.find(options) : [];
+      return [results, count];
     })();
   }
   /**

package/lib/types.d.ts

@@ -0,0 +1,43 @@
+import type { Model } from './model';
+import type { ValidationOptions } from 'sequelize/types/lib/instance-validator';
+import type { HookReturn } from 'sequelize/types/lib/hooks';
+import type { CreateOptions, DestroyOptions, SaveOptions, SyncOptions, UpdateOptions } from 'sequelize/types';
+import { Collection, CollectionOptions } from './collection';
+export declare type CollectionNameType = string;
+export declare type ModelSyncEventType = 'beforeSync' | 'afterSync';
+export declare type ModelValidateEventType = 'beforeValidate' | 'afterValidate';
+export declare type ModelCreateEventType = 'beforeCreate' | 'afterCreate';
+export declare type ModelUpdateEventType = 'beforeUpdate' | 'afterUpdate';
+export declare type ModelSaveEventType = 'beforeSave' | 'afterSave';
+export declare type ModelDestroyEventType = 'beforeDestroy' | 'afterDestroy';
+export declare type ModelCreateWithAssociationsEventType = 'afterCreateWithAssociations';
+export declare type ModelUpdateWithAssociationsEventType = 'afterUpdateWithAssociations';
+export declare type ModelSaveWithAssociationsEventType = 'afterSaveWithAssociations';
+export declare type ModelValidateEventTypes = ModelValidateEventType | `${CollectionNameType}.${ModelValidateEventType}`;
+export declare type ModelCreateEventTypes = ModelCreateEventType | `${CollectionNameType}.${ModelCreateEventType}`;
+export declare type ModelUpdateEventTypes = ModelUpdateEventType | `${CollectionNameType}.${ModelUpdateEventType}`;
+export declare type ModelSaveEventTypes = ModelSaveEventType | `${CollectionNameType}.${ModelSaveEventType}`;
+export declare type ModelDestroyEventTypes = ModelDestroyEventType | `${CollectionNameType}.${ModelDestroyEventType}`;
+export declare type ModelCreateWithAssociationsEventTypes = ModelCreateWithAssociationsEventType | `${CollectionNameType}.${ModelCreateWithAssociationsEventType}`;
+export declare type ModelUpdateWithAssociationsEventTypes = ModelUpdateWithAssociationsEventType | `${CollectionNameType}.${ModelUpdateWithAssociationsEventType}`;
+export declare type ModelSaveWithAssociationsEventTypes = ModelSaveWithAssociationsEventType | `${CollectionNameType}.${ModelSaveWithAssociationsEventType}`;
+export declare type ModelEventTypes = ModelSyncEventType | ModelValidateEventTypes | ModelCreateEventTypes | ModelUpdateEventTypes | ModelSaveEventTypes | ModelDestroyEventTypes | ModelCreateWithAssociationsEventTypes | ModelUpdateWithAssociationsEventTypes | ModelSaveWithAssociationsEventTypes;
+export declare type DatabaseBeforeDefineCollectionEventType = 'beforeDefineCollection';
+export declare type DatabaseAfterDefineCollectionEventType = 'afterDefineCollection';
+export declare type DatabaseBeforeRemoveCollectionEventType = 'beforeRemoveCollection';
+export declare type DatabaseAfterRemoveCollectionEventType = 'afterRemoveCollection';
+export declare type DatabaseEventTypes = DatabaseBeforeDefineCollectionEventType | DatabaseAfterDefineCollectionEventType | DatabaseBeforeRemoveCollectionEventType | DatabaseAfterRemoveCollectionEventType;
+export declare type EventType = ModelEventTypes | DatabaseEventTypes | string;
+export type { HookReturn };
+export declare type SyncListener = (options?: SyncOptions) => HookReturn;
+export declare type ValidateListener = (model: Model, options?: ValidationOptions) => HookReturn;
+export declare type CreateListener = (model: Model, options?: CreateOptions) => HookReturn;
+export declare type UpdateListener = (model: Model, options?: UpdateOptions) => HookReturn;
+export declare type SaveListener = (model: Model, options?: SaveOptions) => HookReturn;
+export declare type DestroyListener = (model: Model, options?: DestroyOptions) => HookReturn;
+export declare type CreateWithAssociationsListener = (model: Model, options?: CreateOptions) => HookReturn;
+export declare type UpdateWithAssociationsListener = (model: Model, options?: UpdateOptions) => HookReturn;
+export declare type SaveWithAssociationsListener = (model: Model, options?: SaveOptions) => HookReturn;
+export declare type BeforeDefineCollectionListener = (options: CollectionOptions) => void;
+export declare type AfterDefineCollectionListener = (collection: Collection) => void;
+export declare type RemoveCollectionListener = (collection: Collection) => void;

package/lib/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/database",
-  "version": "0.7.7-alpha.1",
+  "version": "0.8.0-alpha.5",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -12,7 +12,7 @@
     }
   ],
   "dependencies": {
-    "@nocobase/utils": "0.7.7-alpha.1",
+    "@nocobase/utils": "0.8.0-alpha.5",
     "async-mutex": "^0.3.2",
     "cron-parser": "4.4.0",
     "deepmerge": "^4.2.2",
@@ -32,5 +32,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "f82374e6f9daaf71ba63eaf156468ea7ddc042da"
+  "gitHead": "335f62b0098089cc43a0488ea5c76136a655f97e"
 }

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

@@ -64,10 +64,13 @@ describe('belongs to field', () => {
   });
 
   it('custom targetKey and foreignKey', async () => {
-    const Post = db.collection({
-      name: 'posts',
-      fields: [{ type: 'string', name: 'key', unique: true }],
+    db.collection({
+      name: "posts",
+      fields: [
+        { type: "string", name: "key" },
+      ]
     });
+
     const Comment = db.collection({
       name: 'comments',
       fields: [
@@ -79,6 +82,7 @@ describe('belongs to field', () => {
         },
       ],
     });
+
     const association = Comment.model.associations.post;
     expect(association).toBeDefined();
     expect(association.foreignKey).toBe('postKey');
@@ -99,7 +103,7 @@ describe('belongs to field', () => {
     let error;
 
     try {
-      const Comment = db.collection({
+      db.collection({
         name: 'comments1',
         fields: [
           {
@@ -114,6 +118,7 @@ describe('belongs to field', () => {
       error = e;
     }
 
+
     expect(error).toBeInstanceOf(IdentifierError);
   });
 
@@ -194,4 +199,107 @@ describe('belongs to field', () => {
     const association = Post.model.associations;
     expect(association['comments']).toBeDefined();
   });
+
+  describe('foreign constraints', () => {
+    it('should set null on delete', async () => {
+      const Product = db.collection({
+        name: 'products',
+        fields: [{ type: 'string', name: 'name' }],
+      });
+
+      const Order = db.collection({
+        name: 'order',
+        fields: [{ type: 'belongsTo', name: 'product', onDelete: 'SET NULL' }],
+      });
+
+      await db.sync();
+
+      const p = await Product.repository.create({ values: { name: 'p1' } });
+      const o = await Order.repository.create({ values: { product: p.id } });
+
+      expect(o.productId).toBe(p.id);
+
+      await Product.repository.destroy({
+        filterByTk: p.id,
+      });
+
+      const newO = await o.reload();
+
+      expect(newO.productId).toBeNull();
+    });
+
+    it('should delete reference map item when field unbind', async () => {
+      const Product = db.collection({
+        name: 'products',
+        fields: [{ type: 'string', name: 'name' }],
+      });
+
+      const Order = db.collection({
+        name: 'order',
+        fields: [{ type: 'belongsTo', name: 'product', onDelete: 'CASCADE' }],
+      });
+
+      await db.sync();
+
+      Order.removeField('product');
+
+      expect(db.referenceMap.getReferences(Product.name)).toHaveLength(0);
+    });
+
+    it('should delete cascade', async () => {
+      const Product = db.collection({
+        name: 'products',
+        fields: [{ type: 'string', name: 'name' }],
+      });
+
+      const Order = db.collection({
+        name: 'order',
+        fields: [{ type: 'belongsTo', name: 'product', onDelete: 'CASCADE' }],
+      });
+
+      await db.sync();
+      const p = await Product.repository.create({ values: { name: 'p1' } });
+      await Order.repository.create({ values: { product: p.id } });
+      await Order.repository.create({ values: { product: p.id } });
+
+      expect(await Order.repository.count({ filter: { productId: p.id } })).toBe(2);
+
+      await Product.repository.destroy({
+        filterByTk: p.id,
+      });
+
+      expect(await Order.repository.count({ filter: { productId: p.id } })).toBe(0);
+    });
+
+    it('should delete restrict', async () => {
+      const Product = db.collection({
+        name: 'products',
+        fields: [{ type: 'string', name: 'name' }],
+      });
+
+      const Order = db.collection({
+        name: 'order',
+        fields: [{ type: 'belongsTo', name: 'product', onDelete: 'RESTRICT' }],
+      });
+
+      await db.sync();
+
+      const p = await Product.repository.create({ values: { name: 'p1' } });
+      const o = await Order.repository.create({ values: { product: p.id } });
+
+      expect(o.productId).toBe(p.id);
+
+      let error = null;
+
+      try {
+        await Product.repository.destroy({
+          filterByTk: p.id,
+        });
+      } catch (e) {
+        error = e;
+      }
+
+      expect(error).not.toBeNull();
+    });
+  });
 });

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

@@ -171,4 +171,87 @@ describe('has many field', () => {
 
     expect(error).toBeInstanceOf(IdentifierError);
   });
+
+  describe('foreign key constraint', function () {
+    it('should cascade delete', async () => {
+      const Post = db.collection({
+        name: 'posts',
+        fields: [
+          { type: 'string', name: 'title' },
+          { type: 'hasMany', name: 'comments', onDelete: 'CASCADE' },
+        ],
+      });
+
+      const Comment = db.collection({
+        name: 'comments',
+        fields: [
+          { type: 'string', name: 'content' },
+          { type: 'belongsTo', name: 'post', onDelete: "CASCADE" },
+        ],
+      });
+
+      await db.sync();
+
+      const post = await Post.repository.create({
+        values: {
+          title: 'post1',
+        },
+      });
+
+      const comment = await Comment.repository.create({
+        values: {
+          content: 'comment1',
+          postId: post.id,
+        },
+      });
+
+      await Post.repository.destroy({
+        filterByTk: post.id,
+      });
+
+      expect(await Comment.repository.count()).toEqual(0);
+    });
+
+    it('should throw error when foreign key constraint is violated', async function () {
+      const Post = db.collection({
+        name: 'posts',
+        fields: [
+          { type: 'string', name: 'title' },
+          { type: 'hasMany', name: 'comments', onDelete: 'RESTRICT' },
+        ],
+      });
+
+      const Comment = db.collection({
+        name: 'comments',
+        fields: [{ type: 'string', name: 'content' }],
+      });
+
+      await db.sync();
+
+      const post = await Post.repository.create({
+        values: {
+          title: 'post1',
+        },
+      });
+
+      const comment = await Comment.repository.create({
+        values: {
+          content: 'comment1',
+          postId: post.id,
+        },
+      });
+
+      let error;
+
+      try {
+        await Post.repository.destroy({
+          filterByTk: post.id,
+        });
+      } catch (e) {
+        error = e;
+      }
+
+      expect(error).toBeDefined();
+    });
+  });
 });