@anjianshi/utils 2.5.0 → 2.6.0

package/env-service/env-reader.js

@@ -1,79 +0,0 @@
-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

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

package/env-service/index.js

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

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

@@ -1,21 +0,0 @@
-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

@@ -1,30 +0,0 @@
-/**
- * 对接 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

@@ -1,10 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,52 +0,0 @@
-/**
- * 扩展 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

@@ -1,123 +0,0 @@
-/**
- * 扩展 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

@@ -1,9 +0,0 @@
-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 {};

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

@@ -1,54 +0,0 @@
-/**
- * 在事务中执行回调。与 $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/extension.js';
-export const withTransaction = Prisma.defineExtension({
-    name: 'withTransaction',
-    client: {
-        $withTransaction,
-    },
-});
-class FailedInTransaction extends Error {
-    failed;
-    constructor(failed) {
-        super(failed.message);
-        this.failed = failed;
-    }
-}
-// 注意：此函数的返回值为 `R | Failed<any>`，例如实际可能为 `MaySuccess<xxx, xxx> | Failed<any>`，这是有意为之的，`Failed<any>` 并不多余。
-// 因为有时 callback() 只会返回 success 结果，此时 R=Success<xxx>，但是 $withTransaction 整体的返回值仍有可能有 Failed<any>，所以不能用 R 作为整体返回值。
-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-service/prisma/index.d.ts

@@ -1,6 +0,0 @@
-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';
-export * from './adapt-logging.js';

package/env-service/prisma/index.js

@@ -1,6 +0,0 @@
-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';
-export * from './adapt-logging.js';

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

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

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

@@ -1,52 +0,0 @@
-/**
- * 返回一个可以在事务内和事务外通用的 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/env-service/redis-cache.d.ts

@@ -1,39 +0,0 @@
-import { type RedisClientType } from 'redis';
-import { type Logger } from '../logging/index.js';
-export declare function initRedisLogging(redis: RedisClientType, logger?: Logger): void;
-export interface CacheOptions {
-    logger: Logger;
-    /** 数据有效期，单位秒。默认为 10 分钟。小于等于 0 代表不设有效期 */
-    expires: number;
-    /** 读取时是否自动刷新有效期，仅设置了 expire 时有效，默认为 true */
-    refreshOnRead: boolean;
-    /** 若为 true，读取数据后会立即将其删除，默认为 false */
-    oneTime: boolean;
-}
-/**
- * 维护缓存数据
- * 1. 每个 Cache 实例只维护一个主题的数据，且需明确定义数据类型，这样设计可明确对每一项缓存的使用、避免混乱。
- * 2. 值在存储时会 JSON 化，读取时再进行 JSON 解析（支持 JSON 化 Date 对象）。
- */
-export declare class Cache<T> {
-    readonly redis: RedisClientType;
-    readonly topic: string;
-    readonly options: CacheOptions;
-    constructor(redis: RedisClientType, topic: string, options?: Partial<CacheOptions>);
-    get logger(): Logger;
-    protected jsonStringify(value: T): string;
-    protected jsonParse(redisValue: string): T;
-    protected getRedisKey(identity: string): string;
-    /** 读取一项内容 */
-    get(identity: string, defaults: T): Promise<T>;
-    get(identity?: string): Promise<T | undefined>;
-    /** 写入/更新一项内容 */
-    set(value: T): Promise<void>;
-    set(identity: string, value: T): Promise<void>;
-    /** 移除一项内容 */
-    delete(identity?: string | string[]): Promise<number>;
-    /** 刷新一项内容的过期时间 */
-    refresh(identity?: string): Promise<number | false>;
-    /** 确认一项内容是否存在  */
-    exists(identity?: string): Promise<boolean>;
-}