@roundtreasury/prisma-extension-soft-delete 1.0.0

package/dist/esm/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./lib/types";
+export { createSoftDeleteExtension } from "./lib/createSoftDeleteExtension";

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+export * from "./lib/types";
+export { createSoftDeleteExtension } from "./lib/createSoftDeleteExtension";

package/dist/esm/lib/createSoftDeleteExtension.d.ts

@@ -0,0 +1,2 @@
+import { Config } from "./types";
+export declare function createSoftDeleteExtension({ models, defaultConfig, }: Config): (client: any) => import("@prisma/client/extension").PrismaClientExtends<import("@prisma/client/runtime/library").InternalArgs<{}, {}, {}, {}> & import("@prisma/client/runtime/library").DefaultArgs>;

package/dist/esm/lib/createSoftDeleteExtension.js

@@ -0,0 +1,102 @@
+import { Prisma as PrismaExtensions } from "@prisma/client/extension";
+import { withNestedOperations, } from "prisma-extension-nested-operations";
+import { createAggregateParams, createCountParams, createDeleteManyParams, createDeleteParams, createFindFirstParams, createFindFirstOrThrowParams, createFindManyParams, createFindUniqueParams, createFindUniqueOrThrowParams, createIncludeParams, createSelectParams, createUpdateManyParams, createUpdateParams, createUpsertParams, createWhereParams, createGroupByParams, } from "./helpers/createParams";
+import { modifyReadResult } from "./helpers/modifyResult";
+export 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: createDeleteParams.bind(null, config),
+                deleteMany: createDeleteManyParams.bind(null, config),
+                update: createUpdateParams.bind(null, config),
+                updateMany: createUpdateManyParams.bind(null, config),
+                upsert: createUpsertParams.bind(null, config),
+                findFirst: createFindFirstParams.bind(null, config),
+                findFirstOrThrow: createFindFirstOrThrowParams.bind(null, config),
+                findUnique: createFindUniqueParams.bind(null, config),
+                findUniqueOrThrow: createFindUniqueOrThrowParams.bind(null, config),
+                findMany: createFindManyParams.bind(null, config),
+                count: createCountParams.bind(null, config),
+                aggregate: createAggregateParams.bind(null, config),
+                where: createWhereParams.bind(null, config),
+                include: createIncludeParams.bind(null, config),
+                select: createSelectParams.bind(null, config),
+                groupBy: createGroupByParams.bind(null, config),
+            },
+        };
+    }, {});
+    const modifyResultByModel = Object.keys(modelConfig).reduce((acc, model) => {
+        const config = modelConfig[model];
+        return {
+            ...acc,
+            [model]: {
+                include: modifyReadResult.bind(null, config),
+                select: 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 PrismaExtensions.defineExtension((client) => {
+        return client.$extends({
+            query: {
+                $allModels: {
+                    // @ts-expect-error - we don't know what the client is
+                    $allOperations: 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);
+                        },
+                    }),
+                },
+            },
+        });
+    });
+}

package/dist/esm/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/esm/lib/helpers/createParams.js

@@ -0,0 +1,374 @@
+import { Prisma } from "@prisma/client";
+import { addDeletedToSelect } from "../utils/nestedReads";
+const uniqueFieldsByModel = {};
+const uniqueIndexFieldsByModel = {};
+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;
+});
+export 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),
+                },
+            },
+        },
+    };
+};
+export 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),
+                },
+            },
+        },
+    };
+};
+export 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 };
+};
+export 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),
+                },
+            },
+        },
+    };
+};
+export 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 };
+};
+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));
+}
+export 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),
+                },
+            },
+        },
+    };
+};
+export 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),
+                },
+            },
+        },
+    };
+};
+export 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),
+                },
+            },
+        },
+    };
+};
+export 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),
+                },
+            },
+        },
+    };
+};
+export 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),
+                },
+            },
+        },
+    };
+};
+/*GroupBy */
+export 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),
+                },
+            },
+        },
+    };
+};
+export 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),
+                },
+            },
+        },
+    };
+};
+export 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),
+                },
+            },
+        },
+    };
+};
+export 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),
+            },
+        },
+    };
+};
+export 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: 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),
+                },
+            },
+        },
+    };
+};
+export 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: 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),
+                },
+            },
+        },
+    };
+};

package/dist/esm/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/esm/lib/helpers/modifyResult.js

@@ -0,0 +1,12 @@
+import { stripDeletedFieldFromResults } from "../utils/nestedReads";
+import { filterSoftDeletedResults, shouldFilterDeletedFromReadResult, } from "../utils/resultFiltering";
+export function modifyReadResult(config, result, params, ctx) {
+    if (shouldFilterDeletedFromReadResult(params, config)) {
+        const filteredResults = filterSoftDeletedResults(result, config);
+        if (ctx === null || ctx === void 0 ? void 0 : ctx.deletedFieldAdded) {
+            stripDeletedFieldFromResults(filteredResults, config);
+        }
+        return filteredResults;
+    }
+    return result;
+}

package/dist/esm/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/esm/lib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/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/esm/lib/utils/nestedReads.js

@@ -0,0 +1,26 @@
+export 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;
+}
+export 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;
+}

package/dist/esm/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/esm/lib/utils/resultFiltering.js

@@ -0,0 +1,17 @@
+// Maybe this should return true for non-list relations only?
+export function shouldFilterDeletedFromReadResult(params, config) {
+    return (!params.args.where ||
+        typeof params.args.where[config.field] === "undefined" ||
+        !params.args.where[config.field]);
+}
+export 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;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./lib/types";
+export { createSoftDeleteExtension } from "./lib/createSoftDeleteExtension";

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSoftDeleteExtension = void 0;
+__exportStar(require("./lib/types"), exports);
+var createSoftDeleteExtension_1 = require("./lib/createSoftDeleteExtension");
+Object.defineProperty(exports, "createSoftDeleteExtension", { enumerable: true, get: function () { return createSoftDeleteExtension_1.createSoftDeleteExtension; } });

package/dist/lib/createSoftDeleteExtension.d.ts

@@ -0,0 +1,2 @@
+import { Config } from "./types";
+export declare function createSoftDeleteExtension({ models, defaultConfig, }: Config): (client: any) => import("@prisma/client/extension").PrismaClientExtends<import("@prisma/client/runtime/library").InternalArgs<{}, {}, {}, {}> & import("@prisma/client/runtime/library").DefaultArgs>;