@anjianshi/utils 2.7.0 → 2.8.0

package/env-node/safe-request.js

@@ -0,0 +1,40 @@
+import { success, failed } from '../lang/may-success.js';
+function defaultHandleRequestError(error) {
+    return failed('Request Error', undefined, error);
+}
+async function defaultHandleResponseError(response) {
+    return failed(`Response Error:${response.status}`, undefined, await response.text());
+}
+function defaultHandleParseFailed(error) {
+    return failed('Response Parse Failed', undefined, error);
+}
+async function safeRequest(options) {
+    const { url, method = 'GET', headers = {}, body = null, responseType = 'json' } = options;
+    try {
+        const response = await fetch(url, {
+            method,
+            headers,
+            body,
+        });
+        try {
+            if (response.status !== 200 && (response.status !== 204 || responseType !== 'text')) {
+                return await (options.handleResponseError ?? defaultHandleResponseError)(response);
+            }
+            let responseBody;
+            if (responseType === 'json')
+                responseBody = await response.json();
+            else if (responseType === 'binary')
+                responseBody = Buffer.from(await response.arrayBuffer());
+            else
+                responseBody = await response.text();
+            return success(responseBody);
+        }
+        catch (e) {
+            return (options.handleParseFailed ?? defaultHandleParseFailed)(e, response);
+        }
+    }
+    catch (e) {
+        return (options.handleRequestError ?? defaultHandleRequestError)(e);
+    }
+}
+export { safeRequest };

package/env-react/emotion.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 通过 React Hook 把 emotion css 转换成 className
+ * （不再需要 <ClassName>）
+ *
+ * 使用前提：
+ * 1. 只支持浏览器渲染
+ * 2. 用 EmotionCacheProvider 包裹 App 根元素
+ *
+ * 来自：
+ * https://github.com/emotion-js/emotion/issues/1853#issuecomment-623349622
+ */
+import { type EmotionCache } from '@emotion/react';
+import { type CSSInterpolation } from '@emotion/serialize';
+export declare const useEmotionCache: () => EmotionCache | undefined;
+export declare const EmotionCacheProvider: import("react").FC<{
+    children: React.ReactNode;
+} & import("react").RefAttributes<any>> | import("react").ForwardRefExoticComponent<{
+    children: React.ReactNode;
+} & import("react").RefAttributes<any>>;
+export declare function useEmotionClassName(): (...args: CSSInterpolation[]) => string;

package/env-react/emotion.jsx

@@ -0,0 +1,34 @@
+/**
+ * 通过 React Hook 把 emotion css 转换成 className
+ * （不再需要 <ClassName>）
+ *
+ * 使用前提：
+ * 1. 只支持浏览器渲染
+ * 2. 用 EmotionCacheProvider 包裹 App 根元素
+ *
+ * 来自：
+ * https://github.com/emotion-js/emotion/issues/1853#issuecomment-623349622
+ */
+import { withEmotionCache } from '@emotion/react';
+import { serializeStyles } from '@emotion/serialize';
+import { insertStyles } from '@emotion/utils';
+import { createContext, useContext, useCallback } from 'react';
+const CacheContext = createContext(undefined);
+export const useEmotionCache = () => useContext(CacheContext);
+export const EmotionCacheProvider = withEmotionCache(({ children }, cache) => {
+    return <CacheContext.Provider value={cache}>{children}</CacheContext.Provider>;
+});
+export function useEmotionClassName() {
+    const cache = useEmotionCache();
+    return useCallback((...args) => {
+        if (!cache) {
+            if (process.env.NODE_ENV === 'production') {
+                return 'emotion-cache-missing';
+            }
+            throw new Error('No emotion cache found!');
+        }
+        const serialized = serializeStyles(args, cache.registered);
+        insertStyles(cache, serialized, false);
+        return cache.key + '-' + serialized.name;
+    }, [cache]);
+}

package/env-service/controllers.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 把业务功能整理成各个 Controller，
+ * 并整合成一个 controllers 对象方便外部引用和 Controller 之间互相引用。
+ *
+ * 支持自定义 Controller 类，例如把 context 中的内容定义成属性。
+ */
+export type AnyObject = Record<string, unknown>;
+export type AnyController<Context> = Controller<Context, any>;
+type AnyControllerClass<Context> = typeof Controller<Context, any>;
+export type ControllersFrom<Context, T extends AnyObject> = {
+    [K in keyof T]: T[K] extends AnyControllerClass<Context> ? InstanceType<T[K]> : never;
+};
+/**
+ * Controller 基类
+ */
+export declare class Controller<Context, AllControllers extends Record<string, AnyController<Context>>> {
+    /** 调用其他 controllers */
+    protected readonly controllers: AllControllers;
+    protected readonly context: Context;
+    protected readonly name: string;
+    constructor(
+    /** 调用其他 controllers */
+    controllers: AllControllers, context: Context, name?: string);
+}
+/**
+ * 传入 Controller 类列表，返回 controller 实例集合。
+ * 为优化性能，每个 controller 只有在被使用到时才会实例化。
+ */
+export declare function initializeControllers<Context, T extends AnyObject>(controllerClasses: T, context: Context): ControllersFrom<Context, T>;
+export {};

package/env-service/controllers.js

@@ -0,0 +1,41 @@
+/**
+ * 把业务功能整理成各个 Controller，
+ * 并整合成一个 controllers 对象方便外部引用和 Controller 之间互相引用。
+ *
+ * 支持自定义 Controller 类，例如把 context 中的内容定义成属性。
+ */
+/**
+ * Controller 基类
+ */
+export class Controller {
+    controllers;
+    context;
+    name;
+    constructor(
+    /** 调用其他 controllers */
+    controllers, context, name = this.constructor.name) {
+        this.controllers = controllers;
+        this.context = context;
+        this.name = name;
+    }
+}
+/**
+ * 传入 Controller 类列表，返回 controller 实例集合。
+ * 为优化性能，每个 controller 只有在被使用到时才会实例化。
+ */
+export function initializeControllers(controllerClasses, context) {
+    const proxy = new Proxy({}, {
+        get(controllers, prop) {
+            if (typeof prop !== 'string')
+                return;
+            if (prop in controllers)
+                return controllers[prop];
+            if (prop in controllerClasses) {
+                const Class = controllerClasses[prop];
+                controllers[prop] = new Class(proxy, context, prop);
+                return controllers[prop];
+            }
+        },
+    });
+    return proxy;
+}

package/env-service/env-reader.d.ts

@@ -0,0 +1,55 @@
+import * as dotenv from 'dotenv';
+type EnvValue = string | number | boolean | unknown[] | Record<string, unknown>;
+type TypeDef = 'string' | 'number' | 'boolean' | unknown[] | Record<string, unknown>;
+type TypeFrom<D extends TypeDef> = D extends 'string' ? string : D extends 'number' ? number : D extends 'boolean' ? boolean : D;
+type ResultFrom<Defs extends Record<string, TypeDef>> = {
+    [K in keyof Defs]: TypeFrom<Defs[K]>;
+};
+/**
+ * 读取 .env 文件，并获取格式化后的数据
+ * 注意：依赖 dotenv 包
+ */
+export declare class EnvReader {
+    protected loadedEnvs: Record<string, string>;
+    constructor(options?: dotenv.DotenvConfigOptions);
+    protected toNumber(raw: string): number | undefined;
+    protected toBoolean(raw: string): boolean | undefined;
+    getRaw(key: string): string | undefined;
+    /**
+     * 获取指定 env 的值，并转换成与 defaults 匹配的类型。
+     * 若值不存在，返回 defaults。
+     */
+    get(key: string, defaults: string): string;
+    get(key: string, defaults: number): number;
+    get(key: string, defaults: boolean): boolean;
+    get<T extends unknown[] | Record<string, unknown>>(key: string, defaults: T): T;
+    /**
+     * 获取指定 env 的值，并转换成指定类型，无需提供默认值。
+     * 值不存在或转换失败时，返回 undefined。
+     */
+    getByType(key: string, type?: 'string'): string | undefined;
+    getByType(key: string, type: 'number'): number | undefined;
+    getByType(key: string, type: 'boolean'): boolean | undefined;
+    getByType<T extends unknown[] | Record<string, unknown>>(key: string, type: 'json'): T | undefined;
+    /**
+     * 同 envReader.get()，只不过是通过对象指定各 env 的默认值来批量获取
+     * envReader.batchGet({ port: 8000, debug: false, mobiles: ['123', '456'] }
+     */
+    batchGet<Defs extends Record<string, EnvValue>>(definitions: Defs): { [K in keyof Defs]: Defs[K] extends string ? string : Defs[K] extends number ? number : Defs[K] extends boolean ? boolean : Defs[K]; };
+    /**
+     * 同 envReader.getByType()，只不过是通过对象指定各 env 的类型来批量获取。
+     *
+     * - required=false（默认）时，不存在或值为 undefined 的 env 不会出现在返回对象里，以保证 { ...defaults, ...envReader.batchGetByType(...) } 的用法能正常保留默认值。
+     * - required=true 时要求所有 env 都必须有值，否则会抛出异常
+     *
+     * envReader.batchGetByType({
+     *   port: 'number',
+     *   debug: 'boolean',
+     *   mobiles: [] as string[],  // 用此格式定义内容是数组的 JSON 值
+     *   obj: {} as { a: number, b: string } // 用此格式定义内容是对象的 JSON 值
+     * })
+     */
+    batchGetByType<Defs extends Record<string, TypeDef>>(definitions: Defs, required?: false): Partial<ResultFrom<Defs>>;
+    batchGetByType<Defs extends Record<string, TypeDef>>(definitions: Defs, required: true): ResultFrom<Defs>;
+}
+export {};

package/env-service/env-reader.js

@@ -0,0 +1,79 @@
+import * as dotenv from 'dotenv';
+import { safeParseJSON } from '../lang/string.js';
+/**
+ * 读取 .env 文件，并获取格式化后的数据
+ * 注意：依赖 dotenv 包
+ */
+export class EnvReader {
+    loadedEnvs = {};
+    constructor(options = {}) {
+        dotenv.config({
+            ...options,
+            // 把从 .env 文件读到的内容写入此变量，而不是 process.env，以避免污染 process.env。
+            processEnv: this.loadedEnvs,
+        });
+    }
+    toNumber(raw) {
+        const num = parseInt(raw, 10);
+        return isFinite(num) ? num : undefined;
+    }
+    toBoolean(raw) {
+        const formatted = raw.toLowerCase().trim();
+        if (['1', 'true', 'on'].includes(formatted))
+            return true;
+        if (['0', 'false', 'off'].includes(formatted))
+            return false;
+        return undefined;
+    }
+    getRaw(key) {
+        return this.loadedEnvs[key] ?? process.env[key];
+    }
+    get(key, defaults) {
+        const raw = this.getRaw(key);
+        if (raw === undefined)
+            return defaults;
+        if (typeof defaults === 'number')
+            return this.toNumber(raw) ?? defaults;
+        else if (typeof defaults === 'boolean')
+            return this.toBoolean(raw) ?? defaults;
+        else if (Array.isArray(defaults) || typeof defaults === 'object') {
+            return safeParseJSON(raw) ?? defaults;
+        }
+        return raw;
+    }
+    getByType(key, type = 'string') {
+        const raw = this.getRaw(key);
+        if (raw === undefined)
+            return raw;
+        if (type === 'number')
+            return this.toNumber(raw);
+        if (type === 'boolean')
+            return this.toBoolean(raw);
+        if (type === 'json')
+            return safeParseJSON(raw);
+        return raw;
+    }
+    /**
+     * 同 envReader.get()，只不过是通过对象指定各 env 的默认值来批量获取
+     * envReader.batchGet({ port: 8000, debug: false, mobiles: ['123', '456'] }
+     */
+    batchGet(definitions) {
+        const result = {};
+        for (const [key, defaults] of Object.entries(definitions)) {
+            result[key] = this.get(key, defaults);
+        }
+        // 保证返回的值类型是“通用化”的，例如不是 `false` 而是 `boolean`
+        return result;
+    }
+    batchGetByType(definitions, required = false) {
+        const result = {};
+        for (const [key, def] of Object.entries(definitions)) {
+            const value = typeof def === 'string' ? this.getByType(key, def) : this.getByType(key, 'json');
+            if (value !== undefined)
+                result[key] = value;
+            else if (required)
+                throw new Error(`env ${key} needs a value`);
+        }
+        return result;
+    }
+}

package/env-service/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 开发后端服务能用到的工具库
+ */
+export * from './env-reader.js';
+export * from './controllers.js';
+export * from './tasks.js';

package/env-service/index.js

@@ -0,0 +1,6 @@
+/**
+ * 开发后端服务能用到的工具库
+ */
+export * from './env-reader.js';
+export * from './controllers.js';
+export * from './tasks.js';

package/env-service/prisma/adapt-logging.d.ts

@@ -0,0 +1,21 @@
+import type { getPrismaClient } from '@prisma/client/runtime/library.js';
+import { type Logger } from '../../logging/index.js';
+type PrismalClient = ReturnType<typeof getPrismaClient> extends new () => infer T ? T : never;
+export declare function getPrismaLoggingOptions(debug: boolean): {
+    errorFormat: "pretty";
+    log: ({
+        readonly emit: "event";
+        readonly level: "query";
+    } | {
+        emit: "event";
+        level: "info";
+    } | {
+        emit: "event";
+        level: "warn";
+    } | {
+        emit: "event";
+        level: "error";
+    })[];
+};
+export declare function adaptPrismaLogging<T extends Pick<PrismalClient, '$on'>>(prisma: T, baseLogger: Logger): void;
+export {};

package/env-service/prisma/adapt-logging.js

@@ -0,0 +1,30 @@
+/**
+ * 对接 Prisma 的日志记录
+ *
+ * 注意：Prisma 的 debugging 日志是直接输出到 console 的，没有提供处理渠道，所以无法记录进日志文件。
+ * 理论上可以重写 console.log/debug... 等方法来实现捕获，但这牵扯面太广，暂不这样做。
+ */
+import nodeUtil from 'node:util';
+import chalk from 'chalk';
+export function getPrismaLoggingOptions(debug) {
+    return {
+        errorFormat: 'pretty',
+        log: [
+            ...(debug ? [{ emit: 'event', level: 'query' }] : []),
+            { emit: 'event', level: 'info' },
+            { emit: 'event', level: 'warn' },
+            { emit: 'event', level: 'error' },
+        ],
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+export function adaptPrismaLogging(prisma, baseLogger) {
+    // 记录 Prisma 相关日志
+    const queryLogger = baseLogger.getChild('query');
+    prisma.$on('query', e => {
+        queryLogger.debug(e.query, chalk.green(nodeUtil.format(e.params) + ` +${e.duration}ms`));
+    });
+    prisma.$on('info', e => baseLogger.info(e.message));
+    prisma.$on('warn', e => baseLogger.warn(e.message));
+    prisma.$on('error', e => baseLogger.error(e.message));
+}

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

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

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

@@ -0,0 +1,16 @@
+import { Prisma } from '@prisma/client/extension';
+/**
+ * 快速检查指定条件的数据是否存在
+ * 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-service/prisma/extensions/find-and-count.d.ts

@@ -0,0 +1,7 @@
+import { Prisma } from '@prisma/client/extension';
+import { type SoftDeleteQueryArgs } from './soft-delete.js';
+export declare const findAndCount: (client: any) => import("@prisma/client/extension").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-service/prisma/extensions/find-and-count.js

@@ -0,0 +1,19 @@
+import { Prisma } from '@prisma/client/extension';
+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-service/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/extension';
+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/extension").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-service/prisma/extensions/soft-delete.js

@@ -0,0 +1,123 @@
+/**
+ * 扩展 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/extension';
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+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);
+    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    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-service/prisma/extensions/with-transaction.d.ts

@@ -0,0 +1,9 @@
+import { type ITXClientDenyList } from '@prisma/client/runtime/library.js';
+import type { MaySuccess, Failed } from '../../../index.js';
+export declare const withTransaction: (client: any) => import("@prisma/client/extension").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<Failed<any> | R>;
+export {};