@tstdl/base 0.92.142 → 0.92.144

package/schema/schemas/boolean.js

@@ -24,8 +24,8 @@ export class BooleanSchema extends SimpleSchema {
                         default:
                             return { success: false };
                     }
-                }
-            }
+                },
+            },
         });
     }
 }

package/schema/schemas/number.js

@@ -17,13 +17,13 @@ export class NumberSchema extends SimpleSchema {
                         : { success: true, value: result, valid: true };
                 },
                 boolean: (value) => ({ success: true, value: globalThis.Number(value), valid: true }),
-                bigint: (value) => ({ success: true, value: globalThis.Number(value), valid: false })
+                bigint: (value) => ({ success: true, value: globalThis.Number(value), valid: false }),
             },
             constraints: [
                 (options?.integer == true) ? (value) => globalThis.Number.isInteger(value) ? ({ success: true }) : ({ success: false, error: 'Value is not an integer.' }) : null,
                 isNumber(options?.minimum) ? (value) => (value >= this.minimum) ? ({ success: true }) : ({ success: false, error: `Value must be more than or equal to ${this.minimum}.` }) : null,
-                isNumber(options?.maximum) ? (value) => (value <= this.maximum) ? ({ success: true }) : ({ success: false, error: `Value must be less than or equal to ${this.maximum}.` }) : null
-            ]
+                isNumber(options?.maximum) ? (value) => (value <= this.maximum) ? ({ success: true }) : ({ success: false, error: `Value must be less than or equal to ${this.maximum}.` }) : null,
+            ],
         });
         this.integer = options?.integer ?? false;
         this.minimum = options?.minimum ?? null;

package/schema/schemas/object.js

@@ -1,4 +1,3 @@
-/* eslint-disable max-depth */
 import { createDecorator, reflectionRegistry } from '../../reflection/index.js';
 import { SchemaError } from '../../schema/schema.error.js';
 import { toArray } from '../../utils/array/array.js';
@@ -93,7 +92,7 @@ export function assign(...schemasOrTypes) {
         mask: schemas.findLast((schema) => isNotNull(schema.mask))?.mask,
         unknownProperties: schemas.findLast((schema) => isNotNull(schema.unknownProperties))?.unknownProperties,
         unknownPropertiesKey: schemas.findLast((schema) => isNotNull(schema.unknownPropertiesKey))?.unknownPropertiesKey,
-        description: schemas.findLast((schema) => isNotNull(schema.description))?.description
+        description: schemas.findLast((schema) => isNotNull(schema.description))?.description,
     });
 }
 export function partial(schemaOrType, keyOrKeys) {
@@ -105,7 +104,7 @@ export function partial(schemaOrType, keyOrKeys) {
     return object(mapObjectValues(schema.properties, mapper), {
         mask: schema.mask,
         unknownProperties: schema.unknownProperties,
-        unknownPropertiesKey: schema.unknownPropertiesKey
+        unknownPropertiesKey: schema.unknownPropertiesKey,
     });
 }
 export function pick(schemaOrType, keys) {
@@ -114,7 +113,7 @@ export function pick(schemaOrType, keys) {
     return object(filterObject(schema.properties, (_, key) => keyArray.includes(key)), {
         mask: schema.mask,
         unknownProperties: schema.unknownProperties,
-        unknownPropertiesKey: schema.unknownPropertiesKey
+        unknownPropertiesKey: schema.unknownPropertiesKey,
     });
 }
 export function omit(schemaOrType, keys) {
@@ -123,7 +122,7 @@ export function omit(schemaOrType, keys) {
     return object(filterObject(schema.properties, (_, key) => !keysArray.includes(key)), {
         mask: schema.mask,
         unknownProperties: schema.unknownProperties,
-        unknownPropertiesKey: schema.unknownPropertiesKey
+        unknownPropertiesKey: schema.unknownPropertiesKey,
     });
 }
 export function getSchemaFromReflection(type) {
@@ -152,7 +151,7 @@ function _tryGetSchemaFromReflection(type) {
         unknownProperties: typeData.unknownProperties,
         unknownPropertiesKey: typeData.unknownPropertiesKey,
         description: typeData.description,
-        example: typeData.example
+        example: typeData.example,
     });
     const prototype = Reflect.getPrototypeOf(type);
     if (isNotNull(prototype) && reflectionRegistry.hasType(prototype)) {

package/sse/server-sent-events-source.js

@@ -15,7 +15,10 @@ export class ServerSentEventsSource {
         this.#writer = this.#writable.getWriter();
         this.#writer.closed
             .then(() => (this.#closed.set(true)))
-            .catch((error) => this.#error.set(error));
+            .catch((error) => {
+            this.#error.set(error);
+            this.#closed.set(true);
+        });
     }
     async close() {
         await this.#writer.close();

package/utils/compression.js

@@ -11,24 +11,24 @@ export function compressString(input, algorithm, options) {
 export function compress(buffer, algorithm, options) {
     const compressedBuffer = _compress(buffer, algorithm, options);
     return {
-        toBuffer: async () => compressedBuffer,
+        toBuffer: async () => await compressedBuffer,
         toHex: async () => encodeHex(await compressedBuffer),
         toBase64: async () => encodeBase64(await compressedBuffer),
         toBase64Url: async () => encodeBase64Url(await compressedBuffer),
-        toZBase32: async () => zBase32Encode(await compressedBuffer)
+        toZBase32: async () => zBase32Encode(await compressedBuffer),
     };
 }
 const compressFunction = {
     'gzip': 'gzip',
     'brotli': 'brotliCompress',
     'deflate': 'deflate',
-    'deflate-raw': 'deflateRaw'
+    'deflate-raw': 'deflateRaw',
 };
 async function _compress(buffer, algorithm, options) {
     const zlib = await dynamicImport('zlib');
     const compressor = zlib[compressFunction[algorithm]];
     assertDefined(compressor, `Unsupported algorithm ${algorithm}`);
-    return new Promise((resolve, reject) => {
+    return await new Promise((resolve, reject) => {
         const callback = (error, result) => {
             if (isNotNullOrUndefined(error)) {
                 reject(error);
@@ -52,12 +52,12 @@ export function decompressString(input, encoding, algorithm, options) {
 export function decompress(buffer, algorithm, options) {
     const decompressedBuffer = _decompress(buffer, algorithm, options);
     return {
-        toBuffer: async () => decompressedBuffer,
+        toBuffer: async () => await decompressedBuffer,
         toHex: async () => encodeHex(await decompressedBuffer),
         toBase64: async () => encodeBase64(await decompressedBuffer),
         toBase64Url: async () => encodeBase64Url(await decompressedBuffer),
         toZBase32: async () => zBase32Encode(await decompressedBuffer),
-        toUtf8: async () => decodeText(await decompressedBuffer)
+        toUtf8: async () => decodeText(await decompressedBuffer),
     };
 }
 export function decompressStream(stream, algorithm, options) {
@@ -68,13 +68,13 @@ const decompressFunction = {
     'gzip': 'gunzip',
     'brotli': 'brotliDecompress',
     'deflate': 'inflate',
-    'deflate-raw': 'inflateRaw'
+    'deflate-raw': 'inflateRaw',
 };
 async function _decompress(buffer, algorithm, options) {
     const zlib = await dynamicImport('zlib');
     const decompressor = zlib[decompressFunction[algorithm]];
     assertDefined(decompressor, `Unsupported algorithm ${algorithm}`);
-    return new Promise((resolve, reject) => {
+    return await new Promise((resolve, reject) => {
         const callback = (error, result) => {
             if (isNotNullOrUndefined(error)) {
                 reject(error);
@@ -95,7 +95,7 @@ const decompressStreamFunction = {
     'gzip': 'createGunzip',
     'brotli': 'createBrotliDecompress',
     'deflate': 'createInflate',
-    'deflate-raw': 'createInflateRaw'
+    'deflate-raw': 'createInflateRaw',
 };
 async function _decompressStream(stream, algorithm, options) {
     const zlib = await dynamicImport('zlib');

package/utils/date-time.d.ts

@@ -50,6 +50,7 @@ export declare function numericDateToDateObject(numericDate: number): {
 };
 export declare function numericDateTimeToTimestamp({ date, time }: NumericDateTime): number;
 export declare function dateObjectToDateTime(dateObject: ZonedDateObject, units?: DateObjectUnits, options?: DateTimeJSOptions): DateTime;
+export declare function tryDateObjectToNumericDate(dateObject: DateObject): number | null;
 export declare function dateObjectToNumericDate(dateObject: DateObject): number;
 export declare function dateTimeToNumericDate(dateTime: DateTime): number;
 export declare function numericDateToDateTime(numericDate: number, units?: DateObjectUnits, options?: DateTimeJSOptions): DateTime;

package/utils/date-time.js

@@ -60,13 +60,13 @@ export function numericTimeToTimeObject(time) {
         hour: Math.floor(time / millisecondsPerHour),
         minute: Math.floor((time % millisecondsPerHour) / millisecondsPerMinute),
         second: Math.floor((time % millisecondsPerMinute) / millisecondsPerSecond),
-        millisecond: Math.floor(time % millisecondsPerSecond)
+        millisecond: Math.floor(time % millisecondsPerSecond),
     };
 }
 export function timestampToNumericDateAndTime(timestamp) {
     return {
         date: timestampToNumericDate(timestamp),
-        time: timestampToTime(timestamp)
+        time: timestampToTime(timestamp),
     };
 }
 export function numericDateToTimestamp(numericDate) {
@@ -81,17 +81,31 @@ export function numericDateToDateObject(numericDate) {
     return {
         year: date.getUTCFullYear(),
         month: date.getUTCMonth() + 1,
-        day: date.getUTCDate()
+        day: date.getUTCDate(),
     };
 }
 export function numericDateTimeToTimestamp({ date, time }) {
     return numericDateToTimestamp(date) + time;
 }
 export function dateObjectToDateTime(dateObject, units, options) {
-    return DateTime.fromObject({ ...dateObject, ...units }, options);
+    const dateTime = DateTime.fromObject({ ...dateObject, ...units }, options);
+    if (!dateTime.isValid) {
+        throw new Error(`Invalid date object: ${dateTime.invalidExplanation}`);
+    }
+    return dateTime;
+}
+export function tryDateObjectToNumericDate(dateObject) {
+    const dateTime = DateTime.fromObject({ ...dateObject }, { zone: 'UTC' });
+    if (!dateTime.isValid) {
+        return null;
+    }
+    return dateTimeToNumericDate(dateTime);
 }
 export function dateObjectToNumericDate(dateObject) {
     const dateTime = DateTime.fromObject({ ...dateObject }, { zone: 'UTC' });
+    if (!dateTime.isValid) {
+        throw new Error(`Invalid date: ${dateTime.invalidExplanation}`);
+    }
     return dateTimeToNumericDate(dateTime);
 }
 export function dateTimeToNumericDate(dateTime) {

package/utils/equals.d.ts

@@ -27,4 +27,11 @@ export declare function equals(a: any, b: any, options?: EqualsOptions, __intern
  * compares to binary types for equal content
  */
 export declare function binaryEquals(bufferA: BinaryData, bufferB: BinaryData): boolean;
+/**
+ * Compares two buffers in a way that is resistant to timing attacks.
+ * @param untrusted The first buffer to compare. It's length is used to determine the iterations of the comparison. This should be the untrusted input to minimize information leakage.
+ * @param trusted The second buffer to compare. This should be the secret.
+ * @returns True if the buffers are equal, false otherwise.
+ */
+export declare function timingSafeBinaryEquals(untrusted: BinaryData, trusted: BinaryData): boolean;
 export {};

package/utils/equals.js

@@ -5,9 +5,8 @@ import { sort } from './iterable-helpers/sort.js';
 import { objectKeys } from './object/object.js';
 import { isDefined, isNotNull, isNull } from './type-guards.js';
 const equalsSymbol = Symbol('equals');
-// eslint-disable-next-line @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention
 export const Equals = {
-    symbol: equalsSymbol
+    symbol: equalsSymbol,
 };
 export function strictEquals(a, b) {
     return a === b;
@@ -115,3 +114,19 @@ export function binaryEquals(bufferA, bufferB) {
     }
     return true;
 }
+/**
+ * Compares two buffers in a way that is resistant to timing attacks.
+ * @param untrusted The first buffer to compare. It's length is used to determine the iterations of the comparison. This should be the untrusted input to minimize information leakage.
+ * @param trusted The second buffer to compare. This should be the secret.
+ * @returns True if the buffers are equal, false otherwise.
+ */
+export function timingSafeBinaryEquals(untrusted, trusted) {
+    const a = toUint8Array(untrusted, false);
+    const b = toUint8Array(trusted, false);
+    const compareTarget = (a.length > b.length) ? a : b;
+    let diff = a.length ^ b.length;
+    for (let i = 0; i < a.length; i++) {
+        diff |= a[i] ^ compareTarget[i];
+    }
+    return diff == 0;
+}

package/utils/function/memoize.js

@@ -1,7 +1,7 @@
 import { IterableWeakMap } from '../../data-structures/iterable-weak-map.js';
 import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
 import { createAccessorDecorator } from '../../reflection/index.js';
-import { assertDefinedPass } from '../type-guards.js';
+import { assertDefinedPass, isDefined } from '../type-guards.js';
 /**
  * Memoizes a function with an arbitrary number of parameters. If you only need a single parameter, {@link memoizeSingle} is faster
  * @param fn function memoize
@@ -67,6 +67,7 @@ export function Memoize() {
     return createAccessorDecorator({
         handler: (data) => {
             const getter = assertDefinedPass(data.descriptor.get, 'Memoize requires an getter for accessors.'); // eslint-disable-line @typescript-eslint/unbound-method
+            const setter = data.descriptor.set; // eslint-disable-line @typescript-eslint/unbound-method
             function cachedGetter() {
                 if (cache.has(this)) {
                     return cache.get(this); // eslint-disable-line @typescript-eslint/no-unsafe-return
@@ -75,7 +76,14 @@ export function Memoize() {
                 cache.set(this, value);
                 return value; // eslint-disable-line @typescript-eslint/no-unsafe-return
             }
-            return { get: cachedGetter };
+            function cachedSetter(value) {
+                setter?.call(this, value);
+                cache.delete(this);
+            }
+            return {
+                get: cachedGetter,
+                set: isDefined(setter) ? cachedSetter : undefined,
+            };
         },
     });
 }

package/utils/jwt.js

@@ -3,7 +3,7 @@ import { toArray } from './array/array.js';
 import { decodeBase64Url, encodeBase64Url } from './base64.js';
 import { importHmacKey, sign } from './cryptography.js';
 import { encodeUtf8 } from './encoding.js';
-import { binaryEquals } from './equals.js';
+import { timingSafeBinaryEquals } from './equals.js';
 export function parseJwtTokenString(tokenString) {
     const splits = tokenString.split('.');
     if (splits.length != 3) {
@@ -64,7 +64,7 @@ export async function parseAndValidateJwtTokenString(tokenString, allowedAlgorit
             throw new InvalidTokenError('Invalid signature algorithm');
         }
         const calculatedSignature = await getSignature(encodeUtf8(`${encoded.header}.${encoded.payload}`), token.header.alg, key);
-        const validSignature = binaryEquals(calculatedSignature, bytes.signature);
+        const validSignature = timingSafeBinaryEquals(bytes.signature, calculatedSignature);
         if (!validSignature) {
             throw new InvalidTokenError('Invalid token signature');
         }
@@ -81,7 +81,7 @@ async function getSignature(data, algorithm, secret) {
     const hashAlgorithm = getHmacHashAlgorithm(algorithm);
     const hmacKey = await importHmacKey(hashAlgorithm, secret, false);
     const hmacSignature = sign('HMAC', hmacKey, data);
-    return hmacSignature.toBuffer();
+    return await hmacSignature.toBuffer();
 }
 function getHmacHashAlgorithm(algorithm) {
     return algorithm.replace('HS', 'SHA-');

package/utils/object/property-name.d.ts

@@ -16,8 +16,8 @@ export type PropertyNameOfExpressionObject<T> = {
     };
 };
 export type FlatPropertyNameOfExpressionObject<T> = {
-    [P in keyof DeepFlatten<T>]: FlatPropertyNameOfExpressionObject<DeepFlatten<DeepNonNullable<T>>[P]> & {
-        [cast]<U extends DeepFlatten<T>[P]>(): FlatPropertyNameOfExpressionObject<DeepNonNullable<U>>;
+    [P in keyof DeepFlatten<DeepNonNullable<T>>]: FlatPropertyNameOfExpressionObject<DeepFlatten<DeepNonNullable<T>>[P]> & {
+        [cast]<U extends DeepFlatten<DeepNonNullable<T>>[P]>(): FlatPropertyNameOfExpressionObject<DeepNonNullable<U>>;
     };
 };
 export declare function getPropertyName(name: string): PropertyName;

package/utils/timing.d.ts

@@ -8,9 +8,9 @@ export declare function timeout(milliseconds?: number, options?: {
 /** Timeout until specified time */
 export declare function timeoutUntil(timestamp: number | Date): Promise<void>;
 /** Timeout for specified duration */
-export declare function cancelableTimeout(milliseconds: number, cancelSignal: Observable<void> | CancellationSignal): Promise<boolean>;
+export declare function cancelableTimeout(milliseconds: number, cancelSignal: Observable<void> | CancellationSignal): Promise<'timeout' | 'canceled'>;
 /** Timeout until specified time */
-export declare function cancelableTimeoutUntil(timestamp: number | Date, cancelSignal: Observable<void> | CancellationSignal): Promise<boolean>;
+export declare function cancelableTimeoutUntil(timestamp: number | Date, cancelSignal: Observable<void> | CancellationSignal): Promise<'timeout' | 'canceled'>;
 export declare function withTimeout<T>(milliseconds: number, promiseOrProvider: ValueOrProvider<Promise<T>>, options?: {
     errorMessage?: string;
 }): Promise<T>;

package/utils/timing.js

@@ -5,7 +5,7 @@ import { _throw } from './throw.js';
 import { resolveValueOrProvider } from './value-or-provider.js';
 /** Timeout for specified duration */
 export async function timeout(milliseconds = 0, options) {
-    return new Promise((resolve) => {
+    await new Promise((resolve) => {
         const abortListener = () => clearTimeout(timeoutRef);
         const timeoutRef = setTimeout(() => {
             options?.abortSignal?.removeEventListener('abort', abortListener);
@@ -17,39 +17,39 @@ export async function timeout(milliseconds = 0, options) {
 /** Timeout until specified time */
 export async function timeoutUntil(timestamp) {
     const left = timestamp.valueOf() - Date.now();
-    return timeout(left);
+    await timeout(left);
 }
 /** Timeout for specified duration */
 export async function cancelableTimeout(milliseconds, cancelSignal) {
     const observable = (cancelSignal instanceof CancellationSignal) ? cancelSignal.set$ : cancelSignal;
-    return firstValueFrom(race([
-        timer(milliseconds).pipe(map(() => false)),
-        observable.pipe(map(() => true))
+    return await firstValueFrom(race([
+        timer(milliseconds).pipe(map(() => 'timeout')),
+        observable.pipe(map(() => 'canceled')),
     ]));
 }
 /** Timeout until specified time */
 export async function cancelableTimeoutUntil(timestamp, cancelSignal) {
     const left = timestamp.valueOf() - Date.now();
-    return cancelableTimeout(left, cancelSignal);
+    return await cancelableTimeout(left, cancelSignal);
 }
 export async function withTimeout(milliseconds, promiseOrProvider, options) {
     const abortController = new AbortController();
     const promise = resolveValueOrProvider(promiseOrProvider);
     void promise.then(() => abortController.abort());
-    return Promise.race([
+    return await Promise.race([
         promise,
-        timeout(milliseconds, { abortSignal: abortController.signal }).then(() => _throw(new TimeoutError(options?.errorMessage)))
+        timeout(milliseconds, { abortSignal: abortController.signal }).then(() => _throw(new TimeoutError(options?.errorMessage))),
     ]);
 }
 export async function immediate() {
-    return new Promise(setImmediate);
+    await new Promise(setImmediate);
 }
 export async function nextTick() {
-    return new Promise((resolve) => process.nextTick(resolve));
+    await new Promise((resolve) => process.nextTick(resolve));
 }
 export async function animationFrame() {
-    return new Promise(requestAnimationFrame);
+    return await new Promise(requestAnimationFrame);
 }
 export async function idle(timeout) {
-    return new Promise((resolve) => requestIdleCallback(resolve, { timeout }));
+    return await new Promise((resolve) => requestIdleCallback(resolve, { timeout }));
 }

package/document-management/models/document-request-submission.model.d.ts

@@ -1,7 +0,0 @@
-import { Entity } from '../../orm/entity.js';
-import { Uuid } from '../../orm/types.js';
-export declare class DocumentRequestSubmission extends Entity {
-    static readonly entityName: 'DocumentRequestSubmission';
-    requestId: Uuid;
-    documentId: Uuid;
-}