Merge pull request #17 from chenshoo/master

fix: add soft delete configs
Enigmatis · Jun 4, 2019 · 0142544 · 0142544
2 parents 204abd1 + b5dfac8
commit 0142544
Show file tree

Hide file tree

Showing 7 changed files with 118 additions and 61 deletions.
diff --git a/package-lock.json b/package-lock.json
diff --git a/src/model-config.ts b/src/model-config.ts
@@ -0,0 +1,4 @@
+export interface ModelConfiguration {
+    allowSoftDelete?: boolean;
+    softDeleteReturnEntities?: boolean;
+}
diff --git a/src/model-creator.ts b/src/model-creator.ts
@@ -1,6 +1,7 @@
 import { PolarisBaseContext, PolarisRequestHeaders } from '@enigmatis/utills';
 import * as Joi from 'joi';
 import { Model, model, models, Schema } from 'mongoose';
+import { ModelConfiguration } from './model-config';
 import { getCollectionName } from './schema-helpers/middleware-functions';
 import {
     addDocumentMiddleware,
@@ -29,14 +30,20 @@ export declare type SchemaCreator = (refNameCreator: (name: string) => string) =
 export const getModelCreator = <T>(
     collectionPrefix: string,
     schemaOrCreator: Schema | SchemaCreator,
+    modelConfiguration?: ModelConfiguration,
 ): ModelCreator<T> => {
     return ({ headers }: PolarisBaseContext): Model<InnerModelType<T>> => {
         const collectionName = getCollectionName(collectionPrefix, headers);
         return (
             models[collectionName] ||
             model<InnerModelType<T>>(
                 collectionName,
-                createSchemaForModel(collectionPrefix, schemaOrCreator, headers),
+                createSchemaForModel(
+                    collectionPrefix,
+                    schemaOrCreator,
+                    headers,
+                    modelConfiguration,
+                ),
             )
         );
     };
@@ -49,14 +56,15 @@ const createSchemaForModel = <T>(
     collectionPrefix: string,
     schemaOrCreator: Schema | SchemaCreator,
     headers: PolarisRequestHeaders,
+    modelConfiguration?: ModelConfiguration,
 ) => {
     const schema =
         schemaOrCreator instanceof Function
             ? schemaOrCreator(getRefNameCreator(headers))
             : schemaOrCreator.clone();
     headers = checkHeaders(headers);
     addFields(schema);
-    addQueryMiddleware(schema, headers);
+    addQueryMiddleware(schema, headers, modelConfiguration);
     addDocumentMiddleware(schema, headers);
     addModelMiddleware(schema, headers);
     return schema;

diff --git a/src/schema-helpers/middleware-functions.ts b/src/schema-helpers/middleware-functions.ts
@@ -1,5 +1,6 @@
 import { PolarisRequestHeaders } from '@enigmatis/utills';
 import { Aggregate, HookNextFunction, Model } from 'mongoose';
+import { ModelConfiguration } from '../model-config';
 import { RepositoryModel } from '../model-creator';
 import { InnerModelType } from '../types';
 import { deleted, notDeleted } from './constants';
@@ -33,9 +34,15 @@ export const getPreInsertMany = (headers: PolarisRequestHeaders) => {
     };
 };
 
-export const getFindHandler = (headers: PolarisRequestHeaders) => {
+export const getFindHandler = (
+    headers: PolarisRequestHeaders,
+    modelConfig?: ModelConfiguration,
+) => {
     return function findHandler(this: any) {
         const conditions = this._conditions;
+        if (modelConfig && modelConfig.softDeleteReturnEntities) {
+            conditions.deleted = true;
+        }
         const realityId =
             headers.realityId !== undefined &&
             conditions.realityId === undefined &&
@@ -51,7 +58,7 @@ export const getFindHandler = (headers: PolarisRequestHeaders) => {
     };
 };
 
-export function softRemoveFunc<T>(
+export function softRemove<T>(
     this: Model<any>,
     query: any,
     optionsOrCallback: any,
@@ -72,13 +79,13 @@ export function softRemoveFunc<T>(
     }
 }
 
-export function singleSoftRemove(
+export function softRemoveOne(
     this: Model<any>,
     query: any,
     callback?: (err: any, raw: any) => void,
 ) {
     // using thisModule to be abale to mock softRemoveFunc in tests
-    return thisModule.softRemoveFunc.call(this, query, { single: true }, callback);
+    return thisModule.softRemove.call(this, query, { single: true }, callback);
 }
 
 export function findOneAndSoftDelete(

diff --git a/src/schema-helpers/middleware-setters.ts b/src/schema-helpers/middleware-setters.ts
@@ -1,31 +1,41 @@
 import { PolarisRequestHeaders } from '@enigmatis/utills';
-import { Aggregate, HookNextFunction, Model, Schema } from 'mongoose';
+import { Schema } from 'mongoose';
+import { ModelConfiguration } from '../model-config';
 import {
     findOneAndSoftDelete,
     getFindHandler,
     getPreInsertMany,
     getPreSave,
     preAggregate,
-    singleSoftRemove,
-    softRemoveFunc,
+    softRemove,
+    softRemoveOne,
 } from './middleware-functions';
 
-export const addQueryMiddleware = (schema: Schema, headers: PolarisRequestHeaders) => {
-    const findHandlerFunc = getFindHandler(headers);
+export const addQueryMiddleware = (
+    schema: Schema,
+    headers: PolarisRequestHeaders,
+    modelConfiguration?: ModelConfiguration,
+) => {
+    const findHandlerFunc = getFindHandler(headers, modelConfiguration);
     ['find', 'findOne', 'findOneAndUpdate', 'update', 'count', 'updateOne', 'updateMany'].forEach(
         middleware => {
             schema.pre(middleware, findHandlerFunc as any);
         },
     );
     schema.pre('aggregate', preAggregate);
-    schema.statics = {
-        ...schema.statics,
-        remove: softRemoveFunc,
-        deleteOne: singleSoftRemove,
-        deleteMany: softRemoveFunc,
-        findOneAndDelete: findOneAndSoftDelete,
-        findOneAndRemove: findOneAndSoftDelete,
-    };
+    if (
+        !modelConfiguration ||
+        (modelConfiguration && modelConfiguration.allowSoftDelete !== false)
+    ) {
+        schema.statics = {
+            ...schema.statics,
+            remove: softRemove,
+            deleteOne: softRemoveOne,
+            deleteMany: softRemove,
+            findOneAndDelete: findOneAndSoftDelete,
+            findOneAndRemove: findOneAndSoftDelete,
+        };
+    }
 };
 
 export const addModelMiddleware = (schema: Schema, headers: PolarisRequestHeaders) => {

diff --git a/src/schema-helpers/query-with-irrelevant-wrapper.ts b/src/schema-helpers/query-with-irrelevant-wrapper.ts
@@ -1,6 +1,6 @@
-import {QueryIrrelevantResult} from '@enigmatis/utills';
-import {Model} from 'mongoose';
-import {InnerModelType} from '../types';
+import { QueryIrrelevantResult } from '@enigmatis/utills';
+import { Model } from 'mongoose';
+import { InnerModelType } from '../types';
 
 export const QueryWithIrrelevant = async (
     model: Model<InnerModelType<any>>,
@@ -12,11 +12,11 @@ export const QueryWithIrrelevant = async (
     }
     const irrelevant = await model.find(
         {
-            _id: {$nin: result.map(x => x._id)},
-            dataVersion: {$gt: dataVersion},
-            deleted: {$in: [true, false]}
+            _id: { $nin: result.map(x => x._id) },
+            dataVersion: { $gt: dataVersion },
+            deleted: { $in: [true, false] },
         },
-        {_id: true},
+        { _id: true },
     );
 
     return new QueryIrrelevantResult(result, irrelevant.map(x => x._id));