@tstdl/base 0.93.76 → 0.93.78

package/utils/format-error.d.ts

@@ -1,31 +1,28 @@
-import type { UndefinableJson } from '../types/index.js';
+import type { Record, UndefinableJson } from '../types/index.js';
 export type FormatErrorOptions = {
-    /**
-     * Include error name in message
-     */
+    /** Include error name in message */
     includeName?: boolean;
-    /**
-     * Include all error properties beside name and message
-     */
+    /** Include all error properties beside name and message */
     includeRest?: boolean | 'if-no-extra-info';
-    /**
-     * Include extraInfo from errors implementing {@link ErrorExtraInfo}
-     */
+    /** Include extraInfo from errors implementing {@link ErrorExtraInfo} */
     includeExtraInfo?: boolean;
-    /**
-     * Include stack trace
-     */
+    /** Include stack trace */
     includeStack?: boolean;
-    /**
-     * Maximum recursion depth for nested causes and aggregate errors (default: 5)
-     */
+    /** Maximum recursion depth for nested causes and aggregate errors (default: 5) */
     depth?: number;
 };
+export type SerializedError = {
+    name?: string;
+    message: string;
+    rest?: Record;
+    extraInfo?: UndefinableJson;
+    stack?: string;
+    cause?: SerializedError;
+    aggregateErrors?: SerializedError[];
+};
 export interface ErrorExtraInfo {
     /** Format extra data (without message and stack) as JSON */
     getExtraInfo(): UndefinableJson | undefined;
 }
-/**
- * Enhanced error formatting
- */
-export declare function formatError(error: any, options?: FormatErrorOptions): string;
+export declare function serializeError(error: unknown, options?: FormatErrorOptions): SerializedError;
+export declare function formatError(error: unknown, options?: FormatErrorOptions): string;

package/utils/format-error.js

@@ -2,76 +2,134 @@ import { unwrapError } from '../errors/utils.js';
 import { decycle } from './object/decycle.js';
 import { objectKeys } from './object/object.js';
 import { tryChain } from './try-chain.js';
-import { isArray, isDefined, isFunction, isObject, isUndefined } from './type-guards.js';
-/**
- * Enhanced error formatting
- */
-export function formatError(error, options = {}) {
+import { isArray, isDefined, isFunction, isObject, isString, isUndefined } from './type-guards.js';
+export function serializeError(error, options = {}) {
     const { includeName = true, includeRest = 'if-no-extra-info', includeExtraInfo = true, includeStack = true, depth = 5, } = options;
     if (depth <= 0) {
-        return '[Max recursion depth reached]';
+        return { message: '[Max recursion depth reached]' };
     }
     const actualError = unwrapError(error);
+    // 1. Initial Property Extraction
     let name;
     let message;
     let stack;
-    let rest;
-    let extraInfo;
     let cause;
     let aggregateErrors;
+    let extraInfo;
+    let rest;
+    // Track if we treat this as a raw object (affects default name logic)
+    let isRawObjectFallback = false;
     if (isObject(actualError)) {
-        if (actualError instanceof Error) {
-            ({ name, message, stack, cause, ...rest } = actualError);
-            if (actualError instanceof AggregateError) {
-                aggregateErrors = actualError.errors;
-            }
+        const errObj = actualError;
+        // Extract standard properties
+        name = isString(errObj.name) ? errObj.name : undefined;
+        message = isString(errObj.message) ? errObj.message : undefined;
+        stack = isString(errObj.stack) ? errObj.stack : undefined;
+        cause = errObj.cause;
+        if (actualError instanceof AggregateError) {
+            aggregateErrors = actualError.errors;
         }
-        else {
-            // Handle plain objects that might have error-like properties
-            ({ name, message, stack, cause, ...rest } = actualError);
-        }
-        // Check for extra info (duck-typing)
-        if (includeExtraInfo && isFunction(actualError.getExtraInfo)) { // eslint-disable-line @typescript-eslint/unbound-method
+        // Extract Extra Info
+        if (includeExtraInfo && isFunction(actualError.getExtraInfo)) {
             extraInfo = actualError.getExtraInfo();
         }
+        // Isolate 'rest' properties via destructuring
+        const { name: _n, message: _m, stack: _s, cause: _c, errors: _agg, ...restObj } = errObj;
+        rest = restObj;
     }
-    // If no message, serialize the whole object as a fallback
-    if (isUndefined(message) || (String(message).trim().length == 0)) { // eslint-disable-line @typescript-eslint/no-unnecessary-type-conversion
-        // Handle primitives directly
-        if (!isObject(actualError)) {
-            message = String(actualError);
+    else {
+        // Primitive types (string, number, etc.)
+        message = String(actualError);
+    }
+    // 2. Message Normalization & Fallback Logic
+    const hasEmptyMessage = isUndefined(message) || (String(message).trim().length == 0);
+    if (hasEmptyMessage) {
+        if (actualError instanceof Error) {
+            // Standard Error with empty message: keep name, keep rest, ensure message is string
+            message = '';
         }
-        else {
+        else if (isObject(actualError)) {
+            // Plain Object (e.g. { code: 500 }): Serialize entire object into message
             message = tryChain([
-                () => JSON.stringify(actualError, null, 2), // Try normal serialization first
-                () => {
-                    // Fallback with decycle for objects with circular references
-                    const decycledError = decycle(actualError);
-                    return JSON.stringify(decycledError, null, 2);
-                },
+                () => JSON.stringify(actualError, null, 2),
+                () => JSON.stringify(decycle(actualError), null, 2),
                 // eslint-disable-next-line @typescript-eslint/no-base-to-string
-                () => `[Unstringifiable object: ${String(actualError)}]`, // Safe fallback if JSON.stringify still fails
+                () => `[Unstringifiable object: ${String(actualError)}]`,
             ]);
+            // Clear rest to avoid duplication since the whole object is now the message
+            rest = undefined;
+            // Flag as fallback to prevent defaulting name to "Error"
+            isRawObjectFallback = true;
+        }
+        else {
+            // Fallback for weird primitive edge cases (should be covered by initial String() conversion)
+            message = String(actualError);
         }
     }
-    // --- String Assembly ---
-    const nameString = includeName ? `${name ?? 'Error'}: ` : '';
-    let restString = '';
-    const shouldIncludeRest = (includeRest == true) || (includeRest == 'if-no-extra-info' && isUndefined(extraInfo));
-    if (shouldIncludeRest && isDefined(rest) && objectKeys(rest).length > 0) {
-        restString = `\n${JSON.stringify(decycle(rest), null, 2)}`;
+    // 3. Finalize Optional Properties
+    const shouldIncludeRest = includeRest === true || (includeRest === 'if-no-extra-info' && isUndefined(extraInfo));
+    const hasRest = isDefined(rest) && objectKeys(rest).length > 0;
+    // Determine Final Name
+    // If fallback (raw object) and no name exists, return undefined. Otherwise default to 'Error'.
+    const defaultName = isRawObjectFallback ? undefined : 'Error';
+    const finalName = includeName ? (name ?? defaultName) : undefined;
+    const nextOptions = { ...options, depth: depth - 1 };
+    return {
+        name: finalName,
+        message: message ?? '',
+        extraInfo: isDefined(extraInfo) ? extraInfo : undefined,
+        rest: shouldIncludeRest && hasRest ? decycle(rest) : undefined,
+        stack: (includeStack && isDefined(stack)) ? stack : undefined,
+        cause: (includeStack && cause)
+            ? serializeError(cause, nextOptions)
+            : undefined,
+        aggregateErrors: (isArray(aggregateErrors))
+            ? aggregateErrors.map((err) => serializeError(err, nextOptions))
+            : undefined,
+    };
+}
+export function formatError(error, options = {}) {
+    const serialized = serializeError(error, options);
+    return formatSerializedError(serialized, options);
+}
+function formatSerializedError(serialized, options) {
+    const { name, message, rest, extraInfo, stack, cause, aggregateErrors, } = serialized;
+    const { includeName = true, includeStack = true, depth = 5 } = options;
+    // 1. Header (Name: Message)
+    const prefix = includeName && name ? `${name}: ` : '';
+    const header = `${prefix}${message}`;
+    // 2. Body (Rest / Extra Info)
+    let body = '';
+    if (rest) {
+        body += `\n${JSON.stringify(rest, null, 2)}`;
+    }
+    if (extraInfo) {
+        body += `\n${JSON.stringify(extraInfo, null, 2)}`;
+    }
+    // 3. Stack Trace
+    let stackString = '';
+    if (includeStack && stack) {
+        // Deduplicate header if stack already starts with it (standard Node.js behavior)
+        if (stack.startsWith(header)) {
+            stackString = stack.slice(header.length);
+        }
+        else {
+            stackString = `\n${stack}`;
+        }
     }
-    const extraInfoString = isDefined(extraInfo) ? `\n${JSON.stringify(extraInfo, null, 2)}` : '';
-    const stackString = (includeStack && isDefined(stack)) ? `\n${stack}` : '';
-    const causeString = includeStack && cause
-        ? formatNestedError('Caused by:', cause, { ...options, depth: depth - 1 })
+    // 4. Recursion (Causes and Aggregate Errors)
+    const nextOptions = { ...options, depth: depth - 1 };
+    const causeString = (includeStack && cause)
+        ? formatNestedError('Caused by:', cause, nextOptions)
         : '';
-    const aggregateErrorsString = isArray(aggregateErrors)
-        ? aggregateErrors.map((err, i) => formatNestedError(`Sub-error #${i + 1}:`, err, { ...options, depth: depth - 1 })).join('')
+    const aggregateErrorsString = aggregateErrors
+        ? aggregateErrors
+            .map((err, i) => formatNestedError(`Sub-error #${i + 1}:`, err, nextOptions))
+            .join('')
         : '';
-    return `${nameString}${message}${restString}${extraInfoString}${stackString}${causeString}${aggregateErrorsString}`;
+    return `${header}${body}${stackString}${causeString}${aggregateErrorsString}`;
 }
-function formatNestedError(prefix, error, options) {
-    const formatted = formatError(error, options).replace(/\n/g, '\n  ');
+function formatNestedError(prefix, serializedError, options) {
+    const formatted = formatSerializedError(serializedError, options).replace(/\n/g, '\n  ');
     return `\n\n${prefix}\n  ${formatted}`;
 }

package/queue/postgres/job.model.d.ts

@@ -1,12 +0,0 @@
-import { BaseEntity, type Json, type Timestamp } from '../../orm/index.js';
-import type { ObjectLiteral } from '../../types/index.js';
-import type { Job } from '../queue.js';
-export declare class PostgresJob<T extends ObjectLiteral = ObjectLiteral> extends BaseEntity implements Job<T> {
-    queue: string;
-    tag: string | null;
-    priority: number;
-    enqueueTimestamp: Timestamp;
-    tries: number;
-    lastDequeueTimestamp: Timestamp | null;
-    data: Json<T>;
-}

package/queue/postgres/job.model.js

@@ -1,53 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { BaseEntity, JsonProperty, Table, TimestampProperty, Unique } from '../../orm/index.js';
-import { Integer, StringProperty } from '../../schema/index.js';
-let PostgresJob = class PostgresJob extends BaseEntity {
-    queue;
-    tag;
-    priority;
-    enqueueTimestamp;
-    tries;
-    lastDequeueTimestamp;
-    data;
-};
-__decorate([
-    StringProperty(),
-    __metadata("design:type", String)
-], PostgresJob.prototype, "queue", void 0);
-__decorate([
-    StringProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresJob.prototype, "tag", void 0);
-__decorate([
-    Integer(),
-    __metadata("design:type", Number)
-], PostgresJob.prototype, "priority", void 0);
-__decorate([
-    TimestampProperty(),
-    __metadata("design:type", Number)
-], PostgresJob.prototype, "enqueueTimestamp", void 0);
-__decorate([
-    Integer(),
-    __metadata("design:type", Number)
-], PostgresJob.prototype, "tries", void 0);
-__decorate([
-    TimestampProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresJob.prototype, "lastDequeueTimestamp", void 0);
-__decorate([
-    JsonProperty(),
-    __metadata("design:type", Object)
-], PostgresJob.prototype, "data", void 0);
-PostgresJob = __decorate([
-    Table('job', { schema: 'queue' }),
-    Unique(['queue', 'tag'])
-], PostgresJob);
-export { PostgresJob };

package/test6.js

@@ -1,33 +0,0 @@
-import { benchmark } from './utils/benchmark.js';
-import { isDefined } from './utils/type-guards.js';
-const numberFormatterMap = new Map();
-function getNumberFormatter1(locale, options) {
-    const key = JSON.stringify({ locale, ...options });
-    const existing = numberFormatterMap.get(key);
-    if (isDefined(existing)) {
-        return existing;
-    }
-    const formatter = new Intl.NumberFormat(locale, options);
-    numberFormatterMap.set(key, formatter);
-    return formatter;
-}
-function getNumberFormatter2(locale, options) {
-    const key = JSON.stringify({ locale, options });
-    const existing = numberFormatterMap.get(key);
-    if (isDefined(existing)) {
-        return existing;
-    }
-    const formatter = new Intl.NumberFormat(locale, options);
-    numberFormatterMap.set(key, formatter);
-    return formatter;
-}
-function format1(value, locale, format) {
-    return getNumberFormatter1(locale, format).format(value);
-}
-function format2(value, locale, format) {
-    return getNumberFormatter2(locale, format).format(value);
-}
-const result1 = benchmark(200000, (run) => format1(run, 'en-US', { maximumFractionDigits: 2 }));
-const result2 = benchmark(200000, (run) => format2(run, 'en-US', { maximumFractionDigits: 2 }));
-console.log(`format:         ${result1.operationsPerMillisecond.toFixed(2)} ops/ms`);
-console.log(`formatCached:   ${result2.operationsPerMillisecond.toFixed(2)} ops/ms`);