@anjianshi/utils 3.1.2 → 3.2.0

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

@@ -5,5 +5,5 @@ export declare const withTransaction: (client: any) => import("@prisma/client/ex
 }>>;
 export type GetPrismaClientInTransaction<PrismaClient> = Omit<PrismaClient, ITXClientDenyList>;
 export type WithTransactionMethod = typeof $withTransaction;
-declare function $withTransaction<That extends object, R extends Result<unknown, unknown>>(this: That, callback: (dbInTransaction: GetPrismaClientInTransaction<That>) => Promise<R>): Promise<Failed<any> | R>;
+declare function $withTransaction<That extends object, R extends Result>(this: That, callback: (dbInTransaction: GetPrismaClientInTransaction<That>) => Promise<R>): Promise<R | Failed<unknown, any>>;
 export {};

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

@@ -26,8 +26,10 @@ class FailedInTransaction extends Error {
         this.failed = failed;
     }
 }
-// 注意：此函数的返回值为 `R | Failed<any>`，例如实际可能为 `Result<xxx, xxx> | Failed<any>`，这是有意为之的，`Failed<any>` 并不多余。
-// 因为有时 callback() 只会返回 success 结果，此时 R=Success<xxx>，但是 $withTransaction 整体的返回值仍有可能有 Failed<any>，所以不能用 R 作为整体返回值。
+// 注意：此函数的返回值为 `R | Failed<unknown, any>`，例如实际可能为 `Result<xxx, xxx> | Failed<unknown, any>`，
+// 这是有意为之的，`Failed<unknown, any>` 并不多余。
+// 因为有时 callback() 只会返回 success 结果，此时 R=Success<xxx>，
+// 但是 $withTransaction 整体的返回值仍有可能有 Failed<unknown, any>，所以不能用 R 作为整体返回值。
 async function $withTransaction(callback) {
     const executeCallback = async (dbInTransaction) => {
         const result = await callback(dbInTransaction);

package/lang/result.d.ts

@@ -16,34 +16,37 @@ export interface Success<T = void> {
     success: true;
     data: T;
 }
-export interface Failed<T = unknown> {
+export interface Failed<CodeT = unknown, DataT = unknown> {
     success: false;
     message: string;
-    code?: string | number;
-    data: T;
+    code: CodeT;
+    data: DataT;
 }
-export type Result<T = void, FailedT = unknown> = Success<T> | Failed<FailedT>;
+export type Result<DataT = unknown, FailedT extends Failed = Failed> = Success<DataT> | FailedT;
+export type SuccessDataTypeOfResult<ResultT extends Result> = ResultT extends Success<infer DataT> ? DataT : never;
+export type FailedTypeOfResult<ResultT extends Result> = ResultT extends Failed ? ResultT : never;
 /** 生成 Success 数据 */
 declare function success(): Success;
 declare function success<T>(data: T): Success<T>;
 export { success };
 /** 生成 Failed 数据 */
-declare function failed(message: string, code?: string | number): Failed;
-declare function failed<T>(message: string, code: string | number | undefined, data: T): Failed<T>;
+declare function failed(message: string): Failed;
+declare function failed<CodeT>(message: string, code: CodeT): Failed<CodeT>;
+declare function failed<CodeT, DataT>(message: string, code: CodeT, data: DataT): Failed<CodeT, DataT>;
 export { failed };
 /**
  * 若传入值为 Success，格式化其 data；否则原样返回错误。
  *
  */
-declare function formatSuccess<T1, T2, FT = void>(value: Result<T1, FT>, formatter: (value: T1) => T2): Result<T2, FT>;
-declare function formatSuccess<T1, T2, FT = void>(value: Promise<Result<T1, FT>>, formatter: (value: T1) => T2): Promise<Result<T2, FT>>;
+declare function formatSuccess<FormattedDataT, ResultT extends Result>(result: ResultT, formatter: (value: SuccessDataTypeOfResult<ResultT>) => FormattedDataT): Result<FormattedDataT, FailedTypeOfResult<ResultT>>;
+declare function formatSuccess<FormattedDataT, ResultT extends Result>(result: Promise<ResultT>, formatter: (value: SuccessDataTypeOfResult<ResultT>) => FormattedDataT): Promise<Result<FormattedDataT, FailedTypeOfResult<ResultT>>>;
 export { formatSuccess };
 /**
  * 若传入值为 Failed，格式化其内容；否则原样返回。
  * 支持传入会返回 Result 的 Promise。
  */
-declare function formatFailed<T, FT>(value: Result<T>, formatter: (result: Failed) => Failed<FT>): Result<T, FT>;
-declare function formatFailed<T, FT>(value: Promise<Result<T>>, formatter: (result: Failed) => Failed<FT>): Promise<Result<T, FT>>;
+declare function formatFailed<ResultT extends Result, FormattedFailedT extends Failed>(result: ResultT, formatter: (result: FailedTypeOfResult<ResultT>) => FormattedFailedT): Result<SuccessDataTypeOfResult<ResultT>, FormattedFailedT>;
+declare function formatFailed<ResultT extends Result, FormattedFailedT extends Failed>(result: Promise<ResultT>, formatter: (result: FailedTypeOfResult<ResultT>) => FormattedFailedT): Promise<Result<SuccessDataTypeOfResult<ResultT>, FormattedFailedT>>;
 export { formatFailed };
 /**
  * 把可能抛出异常的 Promise 转换为返回 Result 的 Promise。
@@ -51,4 +54,4 @@ export { formatFailed };
  *
  * 通过此函数可避免写一长串嵌套的 try catch 语句。
  */
-export declare function exceptionToFailed<T>(promise: Promise<T>): Promise<Result<T>>;
+export declare function exceptionToFailed<T>(promise: Promise<T>): Promise<Result<T, Failed<undefined>>>;

package/lang/result.js

@@ -16,19 +16,21 @@ function success(data) {
 }
 export { success };
 function failed(message, code, data) {
-    return { success: false, message, code, data: data };
+    return { success: false, message, code: code, data: data };
 }
 export { failed };
-function formatSuccess(value, formatter) {
-    if ('then' in value)
-        return value.then(finalValue => formatSuccess(finalValue, formatter));
-    return value.success ? success(formatter(value.data)) : value;
+function formatSuccess(result, formatter) {
+    if ('then' in result)
+        return result.then(finalValue => formatSuccess(finalValue, formatter));
+    return result.success
+        ? success(formatter(result.data))
+        : result;
 }
 export { formatSuccess };
-function formatFailed(value, formatter) {
-    if ('then' in value)
-        return value.then(finalValue => formatFailed(finalValue, formatter));
-    return value.success ? value : formatter(value);
+function formatFailed(result, formatter) {
+    if ('then' in result)
+        return result.then(finalResult => formatFailed(finalResult, formatter));
+    return result.success ? result : formatter(result);
 }
 export { formatFailed };
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anjianshi/utils",
-  "version": "3.1.2",
+  "version": "3.2.0",
   "description": "Common JavaScript Utils",
   "homepage": "https://github.com/anjianshi/js-packages/utils",
   "bugs": {
@@ -31,10 +31,10 @@
     "redis": "^5.5.6",
     "typescript": "^5.8.3",
     "vconsole": "^3.15.1",
+    "@anjianshi/presets-eslint-base": "6.0.0",
     "@anjianshi/presets-eslint-node": "6.0.0",
-    "@anjianshi/presets-eslint-typescript": "6.0.0",
     "@anjianshi/presets-eslint-react": "6.0.0",
-    "@anjianshi/presets-eslint-base": "6.0.0",
+    "@anjianshi/presets-eslint-typescript": "6.0.0",
     "@anjianshi/presets-typescript": "3.2.5",
     "@anjianshi/presets-prettier": "3.0.5"
   },

package/request/client.d.ts

@@ -1,9 +1,9 @@
 import { type Result, type Failed } from '../lang/result.js';
 import { type Logger } from '../logging/index.js';
-import { type RequestError } from './error.js';
+import { type RequestFailed } from './error.js';
 import type { Options, PredefinedOptions, FormattedOptions } from './options.js';
 /** 此基类不可直接使用，因其未对错误格式进行具体约定 */
-export declare abstract class BaseRequestClient<FailedT> {
+export declare abstract class BaseRequestClient<FailedT extends Failed> {
     readonly logger: Logger;
     readonly prefefinedOptions: PredefinedOptions;
     constructor(options?: PredefinedOptions & {
@@ -25,11 +25,11 @@ export declare abstract class BaseRequestClient<FailedT> {
      *   - 其他情况，返回纯文本结果
      */
     protected parseResponse(options: FormattedOptions, response: Response): Promise<Result<unknown, FailedT>>;
-    protected handleError(error: RequestError): Failed<FailedT>;
+    protected handleError(result: RequestFailed): FailedT;
     /** 生成符合 FailedT 约定的失败结果 */
-    protected abstract makeFailedResult(error: RequestError): Failed<FailedT>;
+    protected abstract makeFailedResult(result: RequestFailed): FailedT;
 }
 /** 默认的 RequestClient 实现。出现错误时，会把错误对象原样放入错误信息中。 */
-export declare class RequestClient extends BaseRequestClient<RequestError> {
-    protected makeFailedResult(error: RequestError): Failed<RequestError>;
+export declare class RequestClient extends BaseRequestClient<RequestFailed> {
+    protected makeFailedResult(result: RequestFailed): RequestFailed;
 }

package/request/client.js

@@ -6,7 +6,6 @@ import pick from 'lodash/pick.js';
 import { success, failed, formatFailed, exceptionToFailed, } from '../lang/result.js';
 import { getLogger } from '../logging/index.js';
 import { combineUrl } from '../url.js';
-import { SendRequestFailed, RequestAborted, RequestTimedOut, NonSuccessStatus, ParseResponseBodyFailed, } from './error.js';
 /** 此基类不可直接使用，因其未对错误格式进行具体约定 */
 export class BaseRequestClient {
     logger;
@@ -41,21 +40,26 @@ export class BaseRequestClient {
             // 失败情形“手动取消”
             if (manualSignal && manualSignal.aborted && manualSignal.reason === error) {
                 const reason = error instanceof DOMException && error.name === 'AbortError' ? null : error;
-                return this.handleError(new RequestAborted(reason, options));
+                return this.handleError(failed('Request Aborted', 'RequestAborted', { options, reason }));
             }
             // 失败情形“请求超时”
             if (error instanceof DOMException && error.name === 'TimeoutError') {
-                return this.handleError(new RequestTimedOut(options));
+                return this.handleError(failed('Request Timeouted Out', 'RequestTimedOut', { options }));
             }
             // 失败情形“请求发起失败”
-            return this.handleError(new SendRequestFailed(error, options));
+            return this.handleError(failed('Request Timeouted Out', 'RequestTimedOut', { options, originalError: error }));
         }
         // 失败情形“失败状态码”
         if (!response.status.toString().startsWith('2')) {
             // 此时服务端仍可能输出一些内容，试着解析出来
             const responseDataRes = await this.parseResponse(options, response);
             const responseData = responseDataRes.success ? responseDataRes.data : undefined;
-            return this.handleError(new NonSuccessStatus(response, responseData, options));
+            return this.handleError(failed('Non-Success Status', 'NonSuccessStatus', {
+                options,
+                status: response.status,
+                response,
+                responseData,
+            }));
         }
         // 解析响应内容
         const result = await this.parseResponse(options, response);
@@ -118,11 +122,21 @@ export class BaseRequestClient {
         const contentType = (response.headers.get('Content-Type') ?? '').toLowerCase().trim();
         if (options.binary) {
             const blobResult = await exceptionToFailed(response.blob());
-            return formatFailed(blobResult, result => this.handleError(new ParseResponseBodyFailed(result.data, response, options, 'Parse Blob Body Failed')));
+            return formatFailed(blobResult, result => this.handleError(failed('Parse Blob Body Failed', 'ParseResponseBodyFailed', {
+                options,
+                status: response.status,
+                originalError: result.data,
+                response,
+            })));
         }
         const textResult = await exceptionToFailed(response.text());
         if (contentType.startsWith('text/') || !textResult.success) {
-            return formatFailed(textResult, result => this.handleError(new ParseResponseBodyFailed(result.data, response, options, 'Parse Text Body Failed')));
+            return formatFailed(textResult, result => this.handleError(failed('Parse Text Body Failed', 'ParseResponseBodyFailed', {
+                options,
+                status: response.status,
+                originalError: result.data,
+                response,
+            })));
         }
         let jsonParseError;
         try {
@@ -132,23 +146,28 @@ export class BaseRequestClient {
             jsonParseError = error;
         }
         if (contentType.startsWith('application/json')) {
-            return this.handleError(new ParseResponseBodyFailed(jsonParseError, response, options, 'Parse JSON Body Failed'));
+            return this.handleError(failed('Parse JSON Body Failed', 'ParseResponseBodyFailed', {
+                options,
+                status: response.status,
+                originalError: jsonParseError,
+                response,
+            }));
         }
         return textResult;
     }
-    handleError(error) {
-        const info = pick(error.options, ['url', 'method']);
+    handleError(result) {
+        const info = pick(result.data.options, ['url', 'method']);
         for (const key of ['originalError', 'status', 'responseData']) {
-            if (key in error)
-                Object.assign(info, pick(error, [key]));
+            if (key in result.data)
+                Object.assign(info, pick(result.data, [key]));
         }
-        this.logger.error(error.message, info);
-        return this.makeFailedResult(error);
+        this.logger.error(result.code, info);
+        return this.makeFailedResult(result);
     }
 }
 /** 默认的 RequestClient 实现。出现错误时，会把错误对象原样放入错误信息中。 */
 export class RequestClient extends BaseRequestClient {
-    makeFailedResult(error) {
-        return failed(error.message, undefined, error);
+    makeFailedResult(result) {
+        return result;
     }
 }

package/request/error.d.ts

@@ -6,37 +6,43 @@
  * 2. 请求本身成功，但相应内容表达了业务上的失败，例如登录接口返回密码错误。
  * 如有需要，可继承子类来处理这些失败情形。
  */
+import { type Failed } from '../lang/result.js';
 import { type FormattedOptions } from './options.js';
-export declare class RequestError extends Error {
-    readonly options: FormattedOptions;
-    constructor(message: string, options: FormattedOptions);
+export type RequestFailed = SendRequestFailed | RequestAborted | RequestTimedOut | NonSuccessStatus | ParseResponseBodyFailed;
+export interface RequestFailedInfo {
+    options: FormattedOptions;
 }
 /** 手动取消 */
-export declare class RequestAborted extends RequestError {
+export type RequestAborted = Failed<'RequestAborted', RequestAbortedInfo>;
+export interface RequestAbortedInfo extends RequestFailedInfo {
     /** 取消原因，即调用 abortController.abort() 时传入的值，若未传值则为 null */
-    readonly reason: unknown;
-    constructor(reason: unknown, options: FormattedOptions);
+    reason: unknown;
 }
 /** 请求超时 */
-export declare class RequestTimedOut extends RequestError {
-    constructor(options: FormattedOptions);
-}
+export type RequestTimedOut = Failed<'RequestTimedOut', RequestFailedInfo>;
 /** 请求发起失败（如网络异常） */
-export declare class SendRequestFailed extends RequestError {
-    readonly originalError: unknown;
-    constructor(originalError: unknown, options: FormattedOptions);
+export type SendRequestFailed = Failed<'SendRequestFailed', SendRequestFailedInfo>;
+export interface SendRequestFailedInfo extends RequestFailedInfo {
+    /** 原始错误对象 */
+    originalError: unknown;
 }
 /** 失败状态码（服务端响应了代表失败的状态码，如 500） */
-export declare class NonSuccessStatus extends RequestError {
-    readonly response: Response;
-    readonly responseData: unknown;
-    readonly status: number;
-    constructor(response: Response, responseData: unknown, options: FormattedOptions);
+export type NonSuccessStatus = Failed<'NonSuccessStatus', NonSuccessStatusInfo>;
+export interface NonSuccessStatusInfo extends RequestFailedInfo {
+    /** HTTP Status */
+    status: number;
+    /** Response 对象 */
+    response: Response;
+    /** 尝试着从 response body 中解析出的数据 */
+    responseData: unknown;
 }
 /** 响应体解析失败 */
-export declare class ParseResponseBodyFailed extends RequestError {
-    readonly originalError: unknown;
-    readonly response: Response;
-    readonly status: number;
-    constructor(originalError: unknown, response: Response, options: FormattedOptions, message?: string);
+export type ParseResponseBodyFailed = Failed<'ParseResponseBodyFailed', ParseResponseBodyFailedInfo>;
+export interface ParseResponseBodyFailedInfo extends RequestFailedInfo {
+    /** HTTP Status */
+    status: number;
+    /** 原始错误对象 */
+    originalError: unknown;
+    /** Response 对象 */
+    response: Response;
 }

package/request/error.js

@@ -1,54 +1 @@
-export class RequestError extends Error {
-    options;
-    constructor(message, options) {
-        super(message);
-        this.options = options;
-    }
-}
-/** 手动取消 */
-export class RequestAborted extends RequestError {
-    /** 取消原因，即调用 abortController.abort() 时传入的值，若未传值则为 null */
-    reason;
-    constructor(reason, options) {
-        super('Request Aborted', options);
-        this.reason = reason;
-    }
-}
-/** 请求超时 */
-export class RequestTimedOut extends RequestError {
-    constructor(options) {
-        super('Request Timed Out', options);
-    }
-}
-/** 请求发起失败（如网络异常） */
-export class SendRequestFailed extends RequestError {
-    originalError;
-    constructor(originalError, options) {
-        super('Send Request Failed', options);
-        this.originalError = originalError;
-    }
-}
-/** 失败状态码（服务端响应了代表失败的状态码，如 500） */
-export class NonSuccessStatus extends RequestError {
-    response;
-    responseData;
-    status;
-    constructor(response, responseData, options) {
-        super('Non-Success Status', options);
-        this.response = response;
-        this.responseData = responseData;
-        this.status = response.status;
-    }
-}
-/** 响应体解析失败 */
-export class ParseResponseBodyFailed extends RequestError {
-    originalError;
-    response;
-    status;
-    constructor(originalError, response, options, message) {
-        super(message ?? 'Parse Response Body Failed', options);
-        this.originalError = originalError;
-        this.response = response;
-        this.status = response.status;
-    }
-}
+export {};

package/request/instance.d.ts

@@ -1,4 +1,4 @@
 import { RequestClient } from './client.js';
 /** 提供一个即取即用的 RequestClient 实例及其函数版本 */
 export declare const client: RequestClient;
-export declare const request: <T>(inputUrl: string, inputOptions?: import("./options.js").Options) => Promise<import("../index.js").Result<T, import("./error.js").RequestError>>;
+export declare const request: <T>(inputUrl: string, inputOptions?: import("./options.js").Options) => Promise<import("../index.js").Result<T, import("./error.js").RequestFailed>>;