@roundtreasury/prisma-extension-soft-delete 1.0.0

package/dist/lib/createSoftDeleteExtension.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSoftDeleteExtension = void 0;
+const extension_1 = require("@prisma/client/extension");
+const prisma_extension_nested_operations_1 = require("prisma-extension-nested-operations");
+const createParams_1 = require("./helpers/createParams");
+const modifyResult_1 = require("./helpers/modifyResult");
+function createSoftDeleteExtension({ models, defaultConfig = {
+    field: "deleted",
+    createValue: Boolean,
+    allowToOneUpdates: false,
+    allowCompoundUniqueIndexWhere: false,
+}, }) {
+    if (!defaultConfig.field) {
+        throw new Error("prisma-extension-soft-delete: defaultConfig.field is required");
+    }
+    if (!defaultConfig.createValue) {
+        throw new Error("prisma-extension-soft-delete: defaultConfig.createValue is required");
+    }
+    const modelConfig = {};
+    Object.keys(models).forEach((model) => {
+        const modelName = model;
+        const config = models[modelName];
+        if (config) {
+            modelConfig[modelName] =
+                typeof config === "boolean" && config ? defaultConfig : config;
+        }
+    });
+    const createParamsByModel = Object.keys(modelConfig).reduce((acc, model) => {
+        const config = modelConfig[model];
+        return {
+            ...acc,
+            [model]: {
+                delete: createParams_1.createDeleteParams.bind(null, config),
+                deleteMany: createParams_1.createDeleteManyParams.bind(null, config),
+                update: createParams_1.createUpdateParams.bind(null, config),
+                updateMany: createParams_1.createUpdateManyParams.bind(null, config),
+                upsert: createParams_1.createUpsertParams.bind(null, config),
+                findFirst: createParams_1.createFindFirstParams.bind(null, config),
+                findFirstOrThrow: createParams_1.createFindFirstOrThrowParams.bind(null, config),
+                findUnique: createParams_1.createFindUniqueParams.bind(null, config),
+                findUniqueOrThrow: createParams_1.createFindUniqueOrThrowParams.bind(null, config),
+                findMany: createParams_1.createFindManyParams.bind(null, config),
+                count: createParams_1.createCountParams.bind(null, config),
+                aggregate: createParams_1.createAggregateParams.bind(null, config),
+                where: createParams_1.createWhereParams.bind(null, config),
+                include: createParams_1.createIncludeParams.bind(null, config),
+                select: createParams_1.createSelectParams.bind(null, config),
+                groupBy: createParams_1.createGroupByParams.bind(null, config),
+            },
+        };
+    }, {});
+    const modifyResultByModel = Object.keys(modelConfig).reduce((acc, model) => {
+        const config = modelConfig[model];
+        return {
+            ...acc,
+            [model]: {
+                include: modifyResult_1.modifyReadResult.bind(null, config),
+                select: modifyResult_1.modifyReadResult.bind(null, config),
+            },
+        };
+    }, {});
+    // before handling root params generate deleted value so it is consistent
+    // for the query. Add it to root params and get it from scope?
+    return extension_1.Prisma.defineExtension((client) => {
+        return client.$extends({
+            query: {
+                $allModels: {
+                    // @ts-expect-error - we don't know what the client is
+                    $allOperations: (0, prisma_extension_nested_operations_1.withNestedOperations)({
+                        async $rootOperation(initialParams) {
+                            var _a, _b;
+                            const createParams = (_a = createParamsByModel[initialParams.model || ""]) === null || _a === void 0 ? void 0 : _a[initialParams.operation];
+                            if (!createParams)
+                                return initialParams.query(initialParams.args);
+                            const { params, ctx } = createParams(initialParams);
+                            const { model } = params;
+                            const operationChanged = params.operation !== initialParams.operation;
+                            const result = operationChanged
+                                ? // @ts-expect-error - we don't know what the client is
+                                    await client[model[0].toLowerCase() + model.slice(1)][params.operation](params.args)
+                                : await params.query(params.args);
+                            const modifyResult = (_b = modifyResultByModel[params.model || ""]) === null || _b === void 0 ? void 0 : _b[params.operation];
+                            if (!modifyResult)
+                                return result;
+                            return modifyResult(result, params, ctx);
+                        },
+                        async $allNestedOperations(initialParams) {
+                            var _a, _b;
+                            const createParams = (_a = createParamsByModel[initialParams.model || ""]) === null || _a === void 0 ? void 0 : _a[initialParams.operation];
+                            if (!createParams)
+                                return initialParams.query(initialParams.args);
+                            const { params, ctx } = createParams(initialParams);
+                            const result = await params.query(params.args, params.operation);
+                            const modifyResult = (_b = modifyResultByModel[params.model || ""]) === null || _b === void 0 ? void 0 : _b[params.operation];
+                            if (!modifyResult)
+                                return result;
+                            return modifyResult(result, params, ctx);
+                        },
+                    }),
+                },
+            },
+        });
+    });
+}
+exports.createSoftDeleteExtension = createSoftDeleteExtension;

package/dist/lib/helpers/createParams.d.ts

@@ -0,0 +1,26 @@
+import { NestedParams } from "prisma-extension-nested-operations";
+import { ModelConfig } from "../types";
+export type Params = Omit<NestedParams<any>, "operation"> & {
+    operation: string;
+};
+export type CreateParamsReturn = {
+    params: Params;
+    ctx?: any;
+};
+export type CreateParams = (config: ModelConfig, params: Params) => CreateParamsReturn;
+export declare const createDeleteParams: CreateParams;
+export declare const createDeleteManyParams: CreateParams;
+export declare const createUpdateParams: CreateParams;
+export declare const createUpdateManyParams: CreateParams;
+export declare const createUpsertParams: CreateParams;
+export declare const createFindUniqueParams: CreateParams;
+export declare const createFindUniqueOrThrowParams: CreateParams;
+export declare const createFindFirstParams: CreateParams;
+export declare const createFindFirstOrThrowParams: CreateParams;
+export declare const createFindManyParams: CreateParams;
+export declare const createGroupByParams: CreateParams;
+export declare const createCountParams: CreateParams;
+export declare const createAggregateParams: CreateParams;
+export declare const createWhereParams: CreateParams;
+export declare const createIncludeParams: CreateParams;
+export declare const createSelectParams: CreateParams;

package/dist/lib/helpers/createParams.js

@@ -0,0 +1,393 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSelectParams = exports.createIncludeParams = exports.createWhereParams = exports.createAggregateParams = exports.createCountParams = exports.createGroupByParams = exports.createFindManyParams = exports.createFindFirstOrThrowParams = exports.createFindFirstParams = exports.createFindUniqueOrThrowParams = exports.createFindUniqueParams = exports.createUpsertParams = exports.createUpdateManyParams = exports.createUpdateParams = exports.createDeleteManyParams = exports.createDeleteParams = void 0;
+const client_1 = require("@prisma/client");
+const nestedReads_1 = require("../utils/nestedReads");
+const uniqueFieldsByModel = {};
+const uniqueIndexFieldsByModel = {};
+client_1.Prisma.dmmf.datamodel.models.forEach((model) => {
+    // add unique fields derived from indexes
+    const uniqueIndexFields = [];
+    model.uniqueFields.forEach((field) => {
+        uniqueIndexFields.push(field.join("_"));
+    });
+    uniqueIndexFieldsByModel[model.name] = uniqueIndexFields;
+    // add id field and unique fields from @unique decorator
+    const uniqueFields = [];
+    model.fields.forEach((field) => {
+        if (field.isId || field.isUnique) {
+            uniqueFields.push(field.name);
+        }
+    });
+    uniqueFieldsByModel[model.name] = uniqueFields;
+});
+const createDeleteParams = ({ field, createValue }, params) => {
+    var _a, _b;
+    if (!params.model ||
+        // do nothing for delete: false
+        (typeof params.args === "boolean" && !params.args) ||
+        // do nothing for root delete without where to allow Prisma to throw
+        (!params.scope && !((_a = params.args) === null || _a === void 0 ? void 0 : _a.where))) {
+        return {
+            params,
+        };
+    }
+    if (typeof params.args === "boolean") {
+        return {
+            params: {
+                ...params,
+                operation: "update",
+                args: {
+                    __passUpdateThrough: true,
+                    [field]: createValue(true),
+                },
+            },
+        };
+    }
+    return {
+        params: {
+            ...params,
+            operation: "update",
+            args: {
+                where: ((_b = params.args) === null || _b === void 0 ? void 0 : _b.where) || params.args,
+                data: {
+                    [field]: createValue(true),
+                },
+            },
+        },
+    };
+};
+exports.createDeleteParams = createDeleteParams;
+const createDeleteManyParams = (config, params) => {
+    var _a;
+    if (!params.model)
+        return { params };
+    const where = ((_a = params.args) === null || _a === void 0 ? void 0 : _a.where) || params.args;
+    return {
+        params: {
+            ...params,
+            operation: "updateMany",
+            args: {
+                where: {
+                    ...where,
+                    [config.field]: config.createValue(false),
+                },
+                data: {
+                    [config.field]: config.createValue(true),
+                },
+            },
+        },
+    };
+};
+exports.createDeleteManyParams = createDeleteManyParams;
+const createUpdateParams = (config, params) => {
+    var _a, _b, _c, _d;
+    if (((_a = params.scope) === null || _a === void 0 ? void 0 : _a.relations) &&
+        !params.scope.relations.to.isList &&
+        !config.allowToOneUpdates &&
+        !((_b = params.args) === null || _b === void 0 ? void 0 : _b.__passUpdateThrough)) {
+        throw new Error(`prisma-extension-soft-delete: update of model "${params.model}" through "${(_c = params.scope) === null || _c === void 0 ? void 0 : _c.parentParams.model}.${params.scope.relations.to.name}" found. Updates of soft deleted models through a toOne relation is not supported as it is possible to update a soft deleted record.`);
+    }
+    // remove __passUpdateThrough from args
+    if ((_d = params.args) === null || _d === void 0 ? void 0 : _d.__passUpdateThrough) {
+        delete params.args.__passUpdateThrough;
+    }
+    return { params };
+};
+exports.createUpdateParams = createUpdateParams;
+const createUpdateManyParams = (config, params) => {
+    var _a, _b, _c;
+    // do nothing if args are not defined to allow Prisma to throw an error
+    if (!params.args)
+        return { params };
+    return {
+        params: {
+            ...params,
+            args: {
+                ...params.args,
+                where: {
+                    ...(_a = params.args) === null || _a === void 0 ? void 0 : _a.where,
+                    // allow overriding the deleted field in where
+                    [config.field]: ((_c = (_b = params.args) === null || _b === void 0 ? void 0 : _b.where) === null || _c === void 0 ? void 0 : _c[config.field]) || config.createValue(false),
+                },
+            },
+        },
+    };
+};
+exports.createUpdateManyParams = createUpdateManyParams;
+const createUpsertParams = (_, params) => {
+    var _a, _b;
+    if (((_a = params.scope) === null || _a === void 0 ? void 0 : _a.relations) && !params.scope.relations.to.isList) {
+        throw new Error(`prisma-extension-soft-delete: upsert of model "${params.model}" through "${(_b = params.scope) === null || _b === void 0 ? void 0 : _b.parentParams.model}.${params.scope.relations.to.name}" found. Upserts of soft deleted models through a toOne relation is not supported as it is possible to update a soft deleted record.`);
+    }
+    return { params };
+};
+exports.createUpsertParams = createUpsertParams;
+function validateFindUniqueParams(params, config) {
+    var _a;
+    const uniqueIndexFields = uniqueIndexFieldsByModel[params.model || ""] || [];
+    const uniqueIndexField = Object.keys(((_a = params.args) === null || _a === void 0 ? void 0 : _a.where) || {}).find((key) => uniqueIndexFields.includes(key));
+    // when unique index field is found it is not possible to use findFirst.
+    // Instead warn the user that soft-deleted models will not be excluded from
+    // this query unless warnForUniqueIndexes is false.
+    if (uniqueIndexField && !config.allowCompoundUniqueIndexWhere) {
+        throw new Error(`prisma-extension-soft-delete: query of model "${params.model}" through compound unique index field "${uniqueIndexField}" found. Queries of soft deleted models through a unique index are not supported. Set "allowCompoundUniqueIndexWhere" to true to override this behaviour.`);
+    }
+}
+function shouldPassFindUniqueParamsThrough(params, config) {
+    var _a, _b;
+    const uniqueFields = uniqueFieldsByModel[params.model || ""] || [];
+    const uniqueIndexFields = uniqueIndexFieldsByModel[params.model || ""] || [];
+    const uniqueIndexField = Object.keys(((_a = params.args) === null || _a === void 0 ? void 0 : _a.where) || {}).find((key) => uniqueIndexFields.includes(key));
+    // pass through invalid args so Prisma throws an error
+    return (
+    // findUnique must have a where object
+    !((_b = params.args) === null || _b === void 0 ? void 0 : _b.where) ||
+        typeof params.args.where !== "object" ||
+        // where object must have at least one defined unique field
+        !Object.entries(params.args.where).some(([key, val]) => (uniqueFields.includes(key) || uniqueIndexFields.includes(key)) &&
+            typeof val !== "undefined") ||
+        // pass through if where object has a unique index field and allowCompoundUniqueIndexWhere is true
+        !!(uniqueIndexField && config.allowCompoundUniqueIndexWhere));
+}
+const createFindUniqueParams = (config, params) => {
+    var _a, _b, _c;
+    if (shouldPassFindUniqueParamsThrough(params, config)) {
+        return { params };
+    }
+    validateFindUniqueParams(params, config);
+    return {
+        params: {
+            ...params,
+            operation: "findFirst",
+            args: {
+                ...params.args,
+                where: {
+                    ...(_a = params.args) === null || _a === void 0 ? void 0 : _a.where,
+                    // allow overriding the deleted field in where
+                    [config.field]: ((_c = (_b = params.args) === null || _b === void 0 ? void 0 : _b.where) === null || _c === void 0 ? void 0 : _c[config.field]) || config.createValue(false),
+                },
+            },
+        },
+    };
+};
+exports.createFindUniqueParams = createFindUniqueParams;
+const createFindUniqueOrThrowParams = (config, params) => {
+    var _a, _b, _c;
+    if (shouldPassFindUniqueParamsThrough(params, config)) {
+        return { params };
+    }
+    validateFindUniqueParams(params, config);
+    return {
+        params: {
+            ...params,
+            operation: "findFirstOrThrow",
+            args: {
+                ...params.args,
+                where: {
+                    ...(_a = params.args) === null || _a === void 0 ? void 0 : _a.where,
+                    // allow overriding the deleted field in where
+                    [config.field]: ((_c = (_b = params.args) === null || _b === void 0 ? void 0 : _b.where) === null || _c === void 0 ? void 0 : _c[config.field]) || config.createValue(false),
+                },
+            },
+        },
+    };
+};
+exports.createFindUniqueOrThrowParams = createFindUniqueOrThrowParams;
+const createFindFirstParams = (config, params) => {
+    var _a, _b, _c;
+    return {
+        params: {
+            ...params,
+            operation: "findFirst",
+            args: {
+                ...params.args,
+                where: {
+                    ...(_a = params.args) === null || _a === void 0 ? void 0 : _a.where,
+                    // allow overriding the deleted field in where
+                    [config.field]: ((_c = (_b = params.args) === null || _b === void 0 ? void 0 : _b.where) === null || _c === void 0 ? void 0 : _c[config.field]) || config.createValue(false),
+                },
+            },
+        },
+    };
+};
+exports.createFindFirstParams = createFindFirstParams;
+const createFindFirstOrThrowParams = (config, params) => {
+    var _a, _b, _c;
+    return {
+        params: {
+            ...params,
+            operation: "findFirstOrThrow",
+            args: {
+                ...params.args,
+                where: {
+                    ...(_a = params.args) === null || _a === void 0 ? void 0 : _a.where,
+                    // allow overriding the deleted field in where
+                    [config.field]: ((_c = (_b = params.args) === null || _b === void 0 ? void 0 : _b.where) === null || _c === void 0 ? void 0 : _c[config.field]) || config.createValue(false),
+                },
+            },
+        },
+    };
+};
+exports.createFindFirstOrThrowParams = createFindFirstOrThrowParams;
+const createFindManyParams = (config, params) => {
+    var _a, _b, _c;
+    return {
+        params: {
+            ...params,
+            operation: "findMany",
+            args: {
+                ...params.args,
+                where: {
+                    ...(_a = params.args) === null || _a === void 0 ? void 0 : _a.where,
+                    // allow overriding the deleted field in where
+                    [config.field]: ((_c = (_b = params.args) === null || _b === void 0 ? void 0 : _b.where) === null || _c === void 0 ? void 0 : _c[config.field]) || config.createValue(false),
+                },
+            },
+        },
+    };
+};
+exports.createFindManyParams = createFindManyParams;
+/*GroupBy */
+const createGroupByParams = (config, params) => {
+    var _a, _b, _c;
+    return {
+        params: {
+            ...params,
+            operation: "groupBy",
+            args: {
+                ...params.args,
+                where: {
+                    ...(_a = params.args) === null || _a === void 0 ? void 0 : _a.where,
+                    // allow overriding the deleted field in where
+                    [config.field]: ((_c = (_b = params.args) === null || _b === void 0 ? void 0 : _b.where) === null || _c === void 0 ? void 0 : _c[config.field]) || config.createValue(false),
+                },
+            },
+        },
+    };
+};
+exports.createGroupByParams = createGroupByParams;
+const createCountParams = (config, params) => {
+    const args = params.args || {};
+    const where = args.where || {};
+    return {
+        params: {
+            ...params,
+            args: {
+                ...args,
+                where: {
+                    ...where,
+                    // allow overriding the deleted field in where
+                    [config.field]: where[config.field] || config.createValue(false),
+                },
+            },
+        },
+    };
+};
+exports.createCountParams = createCountParams;
+const createAggregateParams = (config, params) => {
+    const args = params.args || {};
+    const where = args.where || {};
+    return {
+        params: {
+            ...params,
+            args: {
+                ...args,
+                where: {
+                    ...where,
+                    // allow overriding the deleted field in where
+                    [config.field]: where[config.field] || config.createValue(false),
+                },
+            },
+        },
+    };
+};
+exports.createAggregateParams = createAggregateParams;
+const createWhereParams = (config, params) => {
+    var _a;
+    if (!params.scope)
+        return { params };
+    // customise list queries with every modifier unless the deleted field is set
+    if (((_a = params.scope) === null || _a === void 0 ? void 0 : _a.modifier) === "every" && !params.args[config.field]) {
+        return {
+            params: {
+                ...params,
+                args: {
+                    OR: [
+                        { [config.field]: { not: config.createValue(false) } },
+                        params.args,
+                    ],
+                },
+            },
+        };
+    }
+    return {
+        params: {
+            ...params,
+            args: {
+                ...params.args,
+                [config.field]: params.args[config.field] || config.createValue(false),
+            },
+        },
+    };
+};
+exports.createWhereParams = createWhereParams;
+const createIncludeParams = (config, params) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    // includes of toOne relation cannot filter deleted records using params
+    // instead ensure that the deleted field is selected and filter the results
+    if (((_b = (_a = params.scope) === null || _a === void 0 ? void 0 : _a.relations) === null || _b === void 0 ? void 0 : _b.to.isList) === false) {
+        if (((_c = params.args) === null || _c === void 0 ? void 0 : _c.select) && !((_d = params.args) === null || _d === void 0 ? void 0 : _d.select[config.field])) {
+            return {
+                params: (0, nestedReads_1.addDeletedToSelect)(params, config),
+                ctx: { deletedFieldAdded: true },
+            };
+        }
+        return { params };
+    }
+    return {
+        params: {
+            ...params,
+            args: {
+                ...params.args,
+                where: {
+                    ...(_e = params.args) === null || _e === void 0 ? void 0 : _e.where,
+                    // allow overriding the deleted field in where
+                    [config.field]: ((_g = (_f = params.args) === null || _f === void 0 ? void 0 : _f.where) === null || _g === void 0 ? void 0 : _g[config.field]) || config.createValue(false),
+                },
+            },
+        },
+    };
+};
+exports.createIncludeParams = createIncludeParams;
+const createSelectParams = (config, params) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    // selects in includes are handled by createIncludeParams
+    if (((_a = params.scope) === null || _a === void 0 ? void 0 : _a.parentParams.operation) === "include") {
+        return { params };
+    }
+    // selects of toOne relation cannot filter deleted records using params
+    if (((_c = (_b = params.scope) === null || _b === void 0 ? void 0 : _b.relations) === null || _c === void 0 ? void 0 : _c.to.isList) === false) {
+        if (((_d = params.args) === null || _d === void 0 ? void 0 : _d.select) && !params.args.select[config.field]) {
+            return {
+                params: (0, nestedReads_1.addDeletedToSelect)(params, config),
+                ctx: { deletedFieldAdded: true },
+            };
+        }
+        return { params };
+    }
+    return {
+        params: {
+            ...params,
+            args: {
+                ...params.args,
+                where: {
+                    ...(_e = params.args) === null || _e === void 0 ? void 0 : _e.where,
+                    // allow overriding the deleted field in where
+                    [config.field]: ((_g = (_f = params.args) === null || _f === void 0 ? void 0 : _f.where) === null || _g === void 0 ? void 0 : _g[config.field]) || config.createValue(false),
+                },
+            },
+        },
+    };
+};
+exports.createSelectParams = createSelectParams;

package/dist/lib/helpers/modifyResult.d.ts

@@ -0,0 +1,4 @@
+import { ModelConfig } from "../types";
+import { CreateParamsReturn } from "./createParams";
+export type ModifyResult = (config: ModelConfig, result: any, params: CreateParamsReturn["params"], ctx?: any) => any;
+export declare function modifyReadResult(config: ModelConfig, result: any, params: CreateParamsReturn["params"], ctx?: any): CreateParamsReturn;

package/dist/lib/helpers/modifyResult.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modifyReadResult = void 0;
+const nestedReads_1 = require("../utils/nestedReads");
+const resultFiltering_1 = require("../utils/resultFiltering");
+function modifyReadResult(config, result, params, ctx) {
+    if ((0, resultFiltering_1.shouldFilterDeletedFromReadResult)(params, config)) {
+        const filteredResults = (0, resultFiltering_1.filterSoftDeletedResults)(result, config);
+        if (ctx === null || ctx === void 0 ? void 0 : ctx.deletedFieldAdded) {
+            (0, nestedReads_1.stripDeletedFieldFromResults)(filteredResults, config);
+        }
+        return filteredResults;
+    }
+    return result;
+}
+exports.modifyReadResult = modifyReadResult;

package/dist/lib/types.d.ts

@@ -0,0 +1,11 @@
+import { Prisma } from "@prisma/client";
+export type ModelConfig = {
+    field: string;
+    createValue: (deleted: boolean) => any;
+    allowToOneUpdates?: boolean;
+    allowCompoundUniqueIndexWhere?: boolean;
+};
+export type Config = {
+    models: Partial<Record<Prisma.ModelName, ModelConfig | boolean>>;
+    defaultConfig?: ModelConfig;
+};

package/dist/lib/types.js

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

package/dist/lib/utils/nestedReads.d.ts

@@ -0,0 +1,5 @@
+import { ModelConfig } from "../types";
+export declare function addDeletedToSelect<T extends {
+    args?: any;
+}>(params: T, config: ModelConfig): T;
+export declare function stripDeletedFieldFromResults(results: any, config: ModelConfig): any;

package/dist/lib/utils/nestedReads.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripDeletedFieldFromResults = exports.addDeletedToSelect = void 0;
+function addDeletedToSelect(params, config) {
+    if (params.args.select && !params.args.select[config.field]) {
+        return {
+            ...params,
+            args: {
+                ...params.args,
+                select: {
+                    ...params.args.select,
+                    [config.field]: true,
+                },
+            },
+        };
+    }
+    return params;
+}
+exports.addDeletedToSelect = addDeletedToSelect;
+function stripDeletedFieldFromResults(results, config) {
+    if (Array.isArray(results)) {
+        results === null || results === void 0 ? void 0 : results.forEach((item) => {
+            delete item[config.field];
+        });
+    }
+    else if (results) {
+        delete results[config.field];
+    }
+    return results;
+}
+exports.stripDeletedFieldFromResults = stripDeletedFieldFromResults;

package/dist/lib/utils/resultFiltering.d.ts

@@ -0,0 +1,5 @@
+import { ModelConfig } from "../types";
+export declare function shouldFilterDeletedFromReadResult(params: {
+    args: any;
+}, config: ModelConfig): boolean;
+export declare function filterSoftDeletedResults(result: any, config: ModelConfig): any;

package/dist/lib/utils/resultFiltering.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterSoftDeletedResults = exports.shouldFilterDeletedFromReadResult = void 0;
+// Maybe this should return true for non-list relations only?
+function shouldFilterDeletedFromReadResult(params, config) {
+    return (!params.args.where ||
+        typeof params.args.where[config.field] === "undefined" ||
+        !params.args.where[config.field]);
+}
+exports.shouldFilterDeletedFromReadResult = shouldFilterDeletedFromReadResult;
+function filterSoftDeletedResults(result, config) {
+    // filter out deleted records from array results
+    if (result && Array.isArray(result)) {
+        return result.filter((item) => !item[config.field]);
+    }
+    // if the result is deleted return null
+    if (result && result[config.field]) {
+        return null;
+    }
+    return result;
+}
+exports.filterSoftDeletedResults = filterSoftDeletedResults;