@anjianshi/utils 2.3.5 → 2.3.6

package/env-node/prisma/extensions/exist.d.ts

@@ -0,0 +1,10 @@
+import { Prisma } from '@prisma/client';
+/**
+ * 快速检查指定条件的数据是否存在
+ * const exists = await prisma.xxx.exists({ id: '1' })
+ */
+export declare const exists: (client: any) => import("@prisma/client").PrismaClientExtends<import("@prisma/client/runtime/library").InternalArgs<{}, {
+    $allModels: {
+        exists<T>(this: T, where: Prisma.Args<T, "count">["where"], withDeleted?: boolean): Promise<boolean>;
+    };
+}, {}, {}>>;

package/env-node/prisma/extensions/exist.js

@@ -0,0 +1,16 @@
+import { Prisma } from '@prisma/client';
+/**
+ * 快速检查指定条件的数据是否存在
+ * const exists = await prisma.xxx.exists({ id: '1' })
+ */
+export const exists = Prisma.defineExtension({
+    name: 'exists',
+    model: {
+        $allModels: {
+            async exists(where, withDeleted = false) {
+                const context = Prisma.getExtensionContext(this);
+                return !!(await context.count({ where, withDeleted }));
+            },
+        },
+    },
+});

package/env-node/prisma/extensions/find-and-count.d.ts

@@ -0,0 +1,7 @@
+import { Prisma } from '@prisma/client';
+import { type SoftDeleteQueryArgs } from './soft-delete.js';
+export declare const findAndCount: (client: any) => import("@prisma/client").PrismaClientExtends<import("@prisma/client/runtime/library").InternalArgs<{}, {
+    $allModels: {
+        findAndCount<T, A>(this: T, rawArgs: Prisma.Exact<A, Prisma.Args<T, "findMany"> & SoftDeleteQueryArgs>): Promise<[Awaited<Prisma.Result<T, A, "findMany">>, Awaited<Prisma.Result<T, A, "count">>]>;
+    };
+}, {}, {}>>;

package/env-node/prisma/extensions/find-and-count.js

@@ -0,0 +1,19 @@
+import { Prisma } from '@prisma/client';
+export const findAndCount = Prisma.defineExtension({
+    name: 'findAndCount',
+    model: {
+        $allModels: {
+            findAndCount(rawArgs) {
+                const context = Prisma.getExtensionContext(this);
+                const args = rawArgs;
+                return Promise.all([
+                    context.findMany(args),
+                    context.count({
+                        where: args.where,
+                        withDeleted: args.withDeleted,
+                    }),
+                ]);
+            },
+        },
+    },
+});

package/env-node/prisma/extensions/soft-delete.d.ts

@@ -0,0 +1,52 @@
+/**
+ * 扩展 Prisma 实现软删除
+ *
+ * 1. 有 deleteTime 字段的 model 支持软删除。
+ * 2. 执行 delete() 和 deleteMany() 时默认是进行软删除；可指定 soft 为 false 来彻底删除；执行软删除时可指定要额外更新的 data。
+ * 2. 查询时会忽略被软删除的记录；可指定 withDeleted 为 true 来包含它们。
+ * 4. 可通过 restore() 和 restoreMany() 恢复软删除的记录。
+ *
+ * 扩展实现方式参考：
+ * https://www.prisma.io/docs/orm/prisma-client/client-extensions/type-utilities#add-a-custom-property-to-a-method
+ * https://www.npmjs.com/package/@prisma/extension-accelerate?activeTab=code  =>  @prisma/extension-accelerate/dist/esm/extension.js
+ *
+ * 此扩展修改了 Prisma 的原生方法。
+ * 为保证其他扩展也应用到修改过的这些方法，此扩展应尽可能放在最前面。
+ */
+import { Prisma } from '@prisma/client';
+import type { Operation } from '@prisma/client/runtime/library.js';
+import { type OptionalFields } from '../../../index.js';
+type DeleteArgs<T> = Prisma.Args<T, 'delete'> & {
+    soft?: boolean;
+    data?: Prisma.Args<T, 'update'>['data'];
+};
+type DeleteReturn<T, A> = Promise<Prisma.Result<T, A, 'delete'>>;
+type DeleteManyArgs<T> = Prisma.Args<T, 'deleteMany'> & {
+    soft?: boolean;
+    data?: Prisma.Args<T, 'updateMany'>['data'];
+};
+type DeleteManyReturn<T, A> = Promise<Prisma.Result<T, A, 'deleteMany'>>;
+type RestoreArgs<T> = OptionalFields<Prisma.Args<T, 'update'>, 'data'>;
+type RestoreManyArgs<T> = OptionalFields<Prisma.Args<T, 'updateMany'>, 'data'>;
+interface QueryExtraArgs {
+    withDeleted?: boolean;
+}
+export type { QueryExtraArgs as SoftDeleteQueryArgs };
+type QueryInputArgs<T, A, K extends Operation> = Prisma.Exact<A, Prisma.Args<T, K> & QueryExtraArgs>;
+export declare const softDelete: (client: any) => import("@prisma/client").PrismaClientExtends<import("@prisma/client/runtime/library").InternalArgs<{}, {
+    $allModels: {
+        withSoftDeleteExtension: boolean;
+        delete<T, A>(this: T, rawArgs: Prisma.Exact<A, DeleteArgs<T>>): DeleteReturn<T, A>;
+        deleteMany<T, A>(this: T, rawArgs: Prisma.Exact<A, DeleteManyArgs<T>>): DeleteManyReturn<T, A>;
+        restore<T, A>(this: T, rawArgs: Prisma.Exact<A, RestoreArgs<T>>): Promise<Prisma.Result<T, A, "update">>;
+        restoreMany<T, A>(this: T, rawArgs: Prisma.Exact<A, RestoreManyArgs<T>>): Promise<Prisma.Result<T, A, "updateMany">>;
+        aggregate<T, A>(this: T, inputArgs: QueryInputArgs<T, A, "aggregate">): Promise<Prisma.Result<T, A, "aggregate">>;
+        count<T, A>(this: T, inputArgs: QueryInputArgs<T, A, "count">): Promise<Prisma.Result<T, A, "count">>;
+        findFirst<T, A>(this: T, inputArgs: QueryInputArgs<T, A, "findFirst">): Promise<Prisma.Result<T, A, "findFirst">>;
+        findFirstOrThrow<T, A>(this: T, inputArgs: QueryInputArgs<T, A, "findFirstOrThrow">): Promise<Prisma.Result<T, A, "findFirstOrThrow">>;
+        findMany<T, A>(this: T, inputArgs: QueryInputArgs<T, A, "findMany">): Promise<Prisma.Result<T, A, "findMany">>;
+        findUnique<T, A>(this: T, inputArgs: QueryInputArgs<T, A, "findUnique">): Promise<Prisma.Result<T, A, "findUnique">>;
+        findUniqueOrThrow<T, A>(this: T, inputArgs: QueryInputArgs<T, A, "findUniqueOrThrow">): Promise<Prisma.Result<T, A, "findUniqueOrThrow">>;
+        groupBy<T, A>(this: T, inputArgs: QueryInputArgs<T, A, "groupBy">): Promise<Prisma.Result<T, A, "groupBy">>;
+    };
+}, {}, {}>>;

package/env-node/prisma/extensions/soft-delete.js

@@ -0,0 +1,121 @@
+/**
+ * 扩展 Prisma 实现软删除
+ *
+ * 1. 有 deleteTime 字段的 model 支持软删除。
+ * 2. 执行 delete() 和 deleteMany() 时默认是进行软删除；可指定 soft 为 false 来彻底删除；执行软删除时可指定要额外更新的 data。
+ * 2. 查询时会忽略被软删除的记录；可指定 withDeleted 为 true 来包含它们。
+ * 4. 可通过 restore() 和 restoreMany() 恢复软删除的记录。
+ *
+ * 扩展实现方式参考：
+ * https://www.prisma.io/docs/orm/prisma-client/client-extensions/type-utilities#add-a-custom-property-to-a-method
+ * https://www.npmjs.com/package/@prisma/extension-accelerate?activeTab=code  =>  @prisma/extension-accelerate/dist/esm/extension.js
+ *
+ * 此扩展修改了 Prisma 的原生方法。
+ * 为保证其他扩展也应用到修改过的这些方法，此扩展应尽可能放在最前面。
+ */
+import { Prisma } from '@prisma/client';
+function getModel(that) {
+    const context = Prisma.getExtensionContext(that);
+    // 1. 此扩展修改了 Prisma 原生的方法，所以要通过 context.$parent[context.$name] 获取上一层的 model，不然会自己调用自己导致死循环。
+    // 2. 如果此扩展后面还应用了其他扩展，那么仅仅一层 $parent 取得的 model 还是这个扩展修改过的版本而不是原生的。
+    //    此时需要递归向上，直到取得未经此扩展修改过的 model。不然此扩展的业务逻辑会被重复执行，
+    //    而因为第一次执行时已经把定制参数消解掉了，第二次执行时会误以为没有传入定制参数，最终导致定制参数失效。
+    let model = context;
+    do {
+        model = model.$parent[context.$name];
+    } while ('withSoftDeleteExtension' in model);
+    const supportSoftDelete = 'deleteTime' in model.fields;
+    return { model, supportSoftDelete };
+}
+function query(that, inputArgs, method) {
+    const { model, supportSoftDelete } = getModel(that);
+    const { withDeleted = false, ...args } = inputArgs;
+    return model[method]({
+        ...args,
+        where: !supportSoftDelete || withDeleted ? args.where : { ...args.where, deleteTime: null },
+    });
+}
+export const softDelete = Prisma.defineExtension({
+    name: 'softDeleted',
+    model: {
+        $allModels: {
+            withSoftDeleteExtension: true,
+            // -----------------------------
+            // 操作
+            // -----------------------------
+            delete(rawArgs) {
+                const { model, supportSoftDelete } = getModel(this);
+                const { soft = true, data, ...args } = rawArgs;
+                if (supportSoftDelete && soft) {
+                    return model.update({
+                        ...args, // .delete() 的参数 .update() 也都支持
+                        data: { ...(data ?? {}), deleteTime: new Date() },
+                    }); // .update() 的返回值和 .delete() 一样
+                }
+                else {
+                    return model.delete(args);
+                }
+            },
+            deleteMany(rawArgs) {
+                const { model, supportSoftDelete } = getModel(this);
+                const { soft = true, data, ...args } = rawArgs;
+                if (supportSoftDelete && soft) {
+                    return model.updateMany({
+                        ...args, // .deleteMany() 的参数 .updateMany() 也都支持
+                        data: { ...(data ?? {}), deleteTime: new Date() },
+                    }); // .updateMany() 的返回值和 .deleteMany() 一样
+                }
+                else {
+                    return model.deleteMany(args);
+                }
+            },
+            restore(rawArgs) {
+                const { data, ...args } = rawArgs;
+                const { model, supportSoftDelete } = getModel(this);
+                if (!supportSoftDelete)
+                    throw new Error('当前模型不支持软删除，不能执行恢复');
+                return model.update({
+                    ...args,
+                    data: { ...(data ?? {}), deleteTime: null },
+                });
+            },
+            restoreMany(rawArgs) {
+                const { data, ...args } = rawArgs;
+                const { model, supportSoftDelete } = getModel(this);
+                if (!supportSoftDelete)
+                    throw new Error('当前模型不支持软删除，不能执行恢复');
+                return model.updateMany({
+                    ...args,
+                    data: { ...(data ?? {}), deleteTime: new Date() },
+                });
+            },
+            // -----------------------------
+            // 查询
+            // -----------------------------
+            aggregate(inputArgs) {
+                return query(this, inputArgs, 'aggregate');
+            },
+            count(inputArgs) {
+                return query(this, inputArgs, 'count');
+            },
+            findFirst(inputArgs) {
+                return query(this, inputArgs, 'findFirst');
+            },
+            findFirstOrThrow(inputArgs) {
+                return query(this, inputArgs, 'findFirstOrThrow');
+            },
+            findMany(inputArgs) {
+                return query(this, inputArgs, 'findMany');
+            },
+            findUnique(inputArgs) {
+                return query(this, inputArgs, 'findUnique');
+            },
+            findUniqueOrThrow(inputArgs) {
+                return query(this, inputArgs, 'findUniqueOrThrow');
+            },
+            groupBy(inputArgs) {
+                return query(this, inputArgs, 'groupBy');
+            },
+        },
+    },
+});

package/env-node/prisma/extensions/with-transaction.d.ts

@@ -0,0 +1,9 @@
+import { type ITXClientDenyList } from '@prisma/client/runtime/library.js';
+import type { MaySuccess } from '../../../index.js';
+export declare const withTransaction: (client: any) => import("@prisma/client").PrismaClientExtends<import("@prisma/client/runtime/library").InternalArgs<{}, {}, {}, {
+    $withTransaction: typeof $withTransaction;
+}>>;
+export type GetPrismaClientInTransaction<PrismaClient> = Omit<PrismaClient, ITXClientDenyList>;
+export type WithTransactionMethod = typeof $withTransaction;
+declare function $withTransaction<That extends object, R extends MaySuccess<unknown, unknown>>(this: That, callback: (dbInTransaction: GetPrismaClientInTransaction<That>) => Promise<R>): Promise<R>;
+export {};

package/env-node/prisma/extensions/with-transaction.js

@@ -0,0 +1,52 @@
+/**
+ * 在事务中执行回调。与 $transaction 有几点不同：
+ * 1. 回调必须返回 MaySuccess 值
+ * 2. 回调返回 Failed 值或抛出异常都会触发回滚。
+ *    如果是返回 Failed，会作为此方法的返回值；如果是抛出异常，则异常会继续向上传递，直到被捕获或触发请求失败。
+ * 3. 如果已经处于事务中，会沿用上层事务，且回调返回 Failed 或抛出异常会触发上层事务的回滚。
+ *
+ * const result: MaySuccess = await db.$withTransaction(
+ *   async (dbInTransaction) => {
+ *     // do something
+ *     return success()
+ *   }
+ * )
+ */
+import { Prisma } from '@prisma/client';
+export const withTransaction = Prisma.defineExtension({
+    name: 'withTransaction',
+    client: {
+        $withTransaction,
+    },
+});
+class FailedInTransaction extends Error {
+    failed;
+    constructor(failed) {
+        super(failed.message);
+        this.failed = failed;
+    }
+}
+async function $withTransaction(callback) {
+    const executeCallback = async (dbInTransaction) => {
+        const result = await callback(dbInTransaction);
+        if (result.success)
+            return result;
+        else
+            throw new FailedInTransaction(result);
+    };
+    if ('$transaction' in this && this.$transaction) {
+        // 如果当前不在事务中，开启新事务并执行回调
+        try {
+            return await this.$transaction(async (dbInTransaction) => executeCallback(dbInTransaction));
+        }
+        catch (e) {
+            if (e instanceof FailedInTransaction)
+                return e.failed;
+            throw e;
+        }
+    }
+    else {
+        // 已经在事务中，直接执行回调（如果有异常，上层开启事务的代码会捕获）
+        return executeCallback(this);
+    }
+}

package/env-node/prisma/index.d.ts

@@ -0,0 +1,5 @@
+export * from './extensions/exist.js';
+export * from './extensions/find-and-count.js';
+export * from './extensions/soft-delete.js';
+export * from './extensions/with-transaction.js';
+export * from './transaction-contexted.js';

package/env-node/prisma/index.js

@@ -0,0 +1,5 @@
+export * from './extensions/exist.js';
+export * from './extensions/find-and-count.js';
+export * from './extensions/soft-delete.js';
+export * from './extensions/with-transaction.js';
+export * from './transaction-contexted.js';

package/env-node/prisma/transaction-contexted.d.ts

@@ -0,0 +1,11 @@
+import type { WithTransactionMethod } from './extensions/with-transaction.js';
+/**
+ * 返回一个可以在事务内和事务外通用的 PrismaClient 代理对象。
+ * 当前在事务内时，调用它是调用事务内的 client；当前不在事务内时，调用它是调用全局 client。
+ * 这样当一个事务涉及多个函数调用时，就不用把事务内 client 传递来传递去了。
+ * 注意：应给每个线性流程（例如一个请求）单独生成一个此对象，不能作为全局对象使用，不然可能出现事务冲突。
+ */
+export declare function getTransactionContextedPrismaClient<AppPrismaClient extends {
+    $transaction: (...args: unknown[]) => Promise<unknown>;
+    $withTransaction: WithTransactionMethod;
+}>(prisma: AppPrismaClient): AppPrismaClient;

package/env-node/prisma/transaction-contexted.js

@@ -0,0 +1,52 @@
+/**
+ * 返回一个可以在事务内和事务外通用的 PrismaClient 代理对象。
+ * 当前在事务内时，调用它是调用事务内的 client；当前不在事务内时，调用它是调用全局 client。
+ * 这样当一个事务涉及多个函数调用时，就不用把事务内 client 传递来传递去了。
+ * 注意：应给每个线性流程（例如一个请求）单独生成一个此对象，不能作为全局对象使用，不然可能出现事务冲突。
+ */
+export function getTransactionContextedPrismaClient(prisma) {
+    let client = prisma;
+    async function callCallbackInTransaction(callback, clientInTransaction) {
+        const prevClient = client;
+        const currentClient = clientInTransaction;
+        client = currentClient;
+        function restoreClient() {
+            if (client !== currentClient)
+                throw new Error('事务冲突，必须等一个事务结束后再开启另一个事务');
+            client = prevClient;
+        }
+        try {
+            const res = await callback(client);
+            restoreClient();
+            return res;
+        }
+        catch (e) {
+            restoreClient();
+            throw e;
+        }
+    }
+    async function $transaction(arg, ...restArgs) {
+        if (typeof arg === 'function') {
+            const wrappedCallback = callCallbackInTransaction.bind(null, arg);
+            return client.$transaction(wrappedCallback, ...restArgs);
+        }
+        else {
+            return client.$transaction(arg, ...restArgs);
+        }
+    }
+    async function $withTransaction(callback) {
+        return client.$withTransaction(async (clientInTransaction) => callCallbackInTransaction(callback, clientInTransaction));
+    }
+    return new Proxy({}, {
+        has(_, prop) {
+            return prop in client;
+        },
+        get(_, prop) {
+            if (prop === '$transaction')
+                return $transaction;
+            if (prop === '$withTransaction')
+                return $withTransaction;
+            return client[prop];
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anjianshi/utils",
-  "version": "2.3.5",
+  "version": "2.3.6",
   "description": "Common JavaScript Utils",
   "homepage": "https://github.com/anjianshi/js-packages/utils",
   "bugs": {
@@ -24,43 +24,45 @@
     "@types/node": "^20.16.2",
     "@types/react": "^18.3.5",
     "dotenv": "^16.4.5",
-    "typeorm": "^0.3.20",
     "typescript": "^5.5.4",
     "vconsole": "^3.15.1",
-    "@anjianshi/presets-eslint-node": "4.0.8",
+    "@anjianshi/presets-prettier": "3.0.1",
     "@anjianshi/presets-eslint-typescript": "5.0.5",
-    "@anjianshi/presets-eslint-react": "4.0.7",
+    "@anjianshi/presets-eslint-node": "4.0.8",
     "@anjianshi/presets-typescript": "3.2.2",
-    "@anjianshi/presets-prettier": "3.0.1"
+    "@anjianshi/presets-eslint-react": "4.0.7"
   },
   "peerDependencies": {
     "@emotion/react": "^11.13.3",
     "@emotion/serialize": "^1.3.1",
     "@emotion/utils": "^1.4.0",
+    "@prisma/client": "^5.20.0",
     "chalk": "^5.3.0",
     "dayjs": "^1.11.10",
     "react": "^18.3.1"
   },
   "peerDependenciesMeta": {
-    "chalk": {
+    "@emotion/react": {
       "optional": true
     },
-    "dayjs": {
+    "@emotion/serialize": {
       "optional": true
     },
-    "@emotion/react": {
+    "@emotion/utils": {
       "optional": true
     },
-    "@emotion/serialize": {
+    "@prisma/client": {
       "optional": true
     },
-    "@emotion/utils": {
+    "chalk": {
+      "optional": true
+    },
+    "dayjs": {
       "optional": true
     },
     "react": {
       "optional": true
     }
   },
-  "eslintIgnore": [],
   "prettier": "@anjianshi/presets-prettier/prettierrc"
 }

package/env-node/typeorm/adapt-logging.d.ts

@@ -1,11 +0,0 @@
-import { AbstractLogger, type LogLevel as TypeORMLogLevel, type LogMessage, type LoggerOptions } from 'typeorm';
-import { type Logger as UtilsLogger } from '../logging/index.js';
-/**
- * 把 TypeORM 的日志导入到 js-utils 的 logger 中
- * 用法参考 https://typeorm.io/logging
- */
-export declare class AdaptedTypeORMLogger extends AbstractLogger {
-    readonly utilsLogger: UtilsLogger;
-    constructor(utilsLogger: UtilsLogger, options?: LoggerOptions);
-    protected writeLog(typeORMLevel: TypeORMLogLevel, logMessage: LogMessage | LogMessage[]): void;
-}

package/env-node/typeorm/adapt-logging.js

@@ -1,42 +0,0 @@
-import { AbstractLogger, } from 'typeorm';
-/**
- * 把 TypeORM 的日志导入到 js-utils 的 logger 中
- * 用法参考 https://typeorm.io/logging
- */
-export class AdaptedTypeORMLogger extends AbstractLogger {
-    utilsLogger;
-    constructor(utilsLogger, options) {
-        super(options);
-        this.utilsLogger = utilsLogger;
-    }
-    writeLog(typeORMLevel, logMessage) {
-        const messages = this.prepareLogMessages(logMessage, {
-            highlightSql: true,
-        });
-        for (const message of messages) {
-            const args = message.prefix ?? '' ? [message.prefix, message.message] : [message.message];
-            switch (message.type ?? typeORMLevel) {
-                case 'log':
-                case 'schema':
-                case 'schema-build':
-                case 'migration':
-                    this.utilsLogger.debug(...args);
-                    break;
-                case 'info':
-                case 'query':
-                    this.utilsLogger.info(...args);
-                    break;
-                case 'warn':
-                case 'query-slow':
-                    this.utilsLogger.warn(...args);
-                    break;
-                case 'error':
-                case 'query-error':
-                    this.utilsLogger.error(...args);
-                    break;
-                default:
-                    this.utilsLogger.debug(...args);
-            }
-        }
-    }
-}

package/env-node/typeorm/index.d.ts

@@ -1,31 +0,0 @@
-/**
- * TypeORM 相关工具函数
- */
-import { type FindOptionsWhere, type BaseEntity } from 'typeorm';
-import { type ExcluceMethods } from '../../lang/index.js';
-export * from './adapt-logging.js';
-/**
- * 返回 Entity 对应的纯数据类型
- */
-export type DataOnly<T extends BaseEntity> = Omit<ExcluceMethods<T>, 'hasId'>;
-/**
- * 转义字符串以安全地进行 SQL LIKE 匹配
- */
-export declare function escapeLikeString(raw: string, escapeChar?: string): string;
-/**
- * 返回 instances 里没有出现的 id
- */
-export declare function getNotExistIds<T extends {
-    id: string;
-}>(instances: T[], ids: string[]): string[];
-/**
- * TypeORM 的 find({ where: {} }) 里不支持 AND 和 OR 并列使用
- * 例如：is_disabled IS NULL AND (name LIKE '%ab%' OR nickname LIKE '%ab%')
- * 只能蹩脚地写成 `where: [{ name: LIKE('xx'), is_disabled: xx }, { nickname: LIKE('xx'), is_disabled: xx }]`
- *
- * 此函数简化了这一转换步骤，使得可以逻辑直观地并列书写 AND 和 OR。
- * 在 `where: {}` 里，`or_` 开头且值是数组的项被组织为一个 OR，其 key 会被忽略，内容转换为上面的形式。
- */
-declare function smartWhere<Entity>(where: FindOptionsWhere<Entity>): FindOptionsWhere<Entity>;
-declare function smartWhere<Entity>(where: FindOptionsWhere<Entity>[]): FindOptionsWhere<Entity>[];
-export { smartWhere };

package/env-node/typeorm/index.js

@@ -1,39 +0,0 @@
-export * from './adapt-logging.js';
-/**
- * 转义字符串以安全地进行 SQL LIKE 匹配
- */
-export function escapeLikeString(raw, escapeChar = '\\') {
-    return raw.replace(/[\\%_]/g, match => escapeChar + match);
-}
-/**
- * 返回 instances 里没有出现的 id
- */
-export function getNotExistIds(instances, ids) {
-    return ids.filter(id => !instances.find(inst => inst.id === id));
-}
-function smartWhere(where) {
-    if (Array.isArray(where))
-        return where.map(item => smartWhere(item));
-    const orPrefix = 'or_';
-    const orContent = {};
-    const andContent = {};
-    for (const [key, value] of Object.entries(where)) {
-        if (value === undefined)
-            continue;
-        if (key.startsWith(orPrefix) && Array.isArray(value)) {
-            orContent[key] = value;
-        }
-        else {
-            ;
-            andContent[key] = value;
-        }
-    }
-    const nextWhere = { ...where };
-    const currentOr = Object.entries(nextWhere).find(([key, value]) => key.startsWith(orPrefix) && Array.isArray(value));
-    if (currentOr === undefined)
-        return nextWhere;
-    delete nextWhere[currentOr[0]];
-    const result = currentOr[1].map(subWhere => ({ ...subWhere, ...smartWhere(nextWhere) }));
-    return result;
-}
-export { smartWhere };