@tstdl/base 0.92.132 → 0.92.135

package/orm/server/repository.js

@@ -84,7 +84,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A promise that resolves to the loaded entity or `undefined` if not found.
      */
     async tryLoad(id) {
-        return this.tryLoadByQuery(eq(this.#table.id, id));
+        return await this.tryLoadByQuery(eq(this.#table.id, id));
     }
     /**
      * Loads a single entity based on a query.
@@ -122,7 +122,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row);
+        return await this.mapToEntity(row);
     }
     /**
      * Loads multiple entities by their IDs.
@@ -131,7 +131,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A promise that resolves to an array of loaded entities.
      */
     async loadMany(ids, options) {
-        return this.loadManyByQuery(inArray(this.#table.id, ids), options);
+        return await this.loadManyByQuery(inArray(this.#table.id, ids), options);
     }
     /**
      * Loads multiple entities by their IDs and returns them as an async iterable cursor.
@@ -168,7 +168,7 @@ let EntityRepository = class EntityRepository extends Transactional {
             dbQuery = dbQuery.orderBy(...this.convertOrderBy(options.order));
         }
         const rows = await dbQuery;
-        return this.mapManyToEntity(rows);
+        return await this.mapManyToEntity(rows);
     }
     /**
      * Loads multiple entities based on a query and returns them as an async iterable cursor.
@@ -186,7 +186,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A promise that resolves to an array of all entities.
      */
     async loadAll(options) {
-        return this.loadManyByQuery({}, options);
+        return await this.loadManyByQuery({}, options);
     }
     /**
      * Loads all entities of the repository's type and returns them as an async iterable cursor.
@@ -230,7 +230,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A promise that resolves to `true` if the entity exists, `false` otherwise.
      */
     async has(id) {
-        return this.hasByQuery(eq(this.#table.id, id));
+        return await this.hasByQuery(eq(this.#table.id, id));
     }
     /**
      * Checks if any entity matches the given query.
@@ -273,7 +273,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row);
+        return await this.mapToEntity(row);
     }
     /**
      * Inserts a new entity into the database.
@@ -286,7 +286,7 @@ let EntityRepository = class EntityRepository extends Transactional {
             .insert(this.#table)
             .values(columns)
             .returning();
-        return this.mapToEntity(row);
+        return await this.mapToEntity(row);
     }
     /**
      * Inserts multiple new entities into the database.
@@ -296,7 +296,7 @@ let EntityRepository = class EntityRepository extends Transactional {
     async insertMany(entities) {
         const columns = await this.mapManyToInsertColumns(entities);
         const rows = await this.session.insert(this.#table).values(columns).returning();
-        return this.mapManyToEntity(rows);
+        return await this.mapManyToEntity(rows);
     }
     /**
      * Inserts an entity or updates it if a conflict occurs based on the target columns.
@@ -317,7 +317,7 @@ let EntityRepository = class EntityRepository extends Transactional {
             set: mappedUpdate,
         })
             .returning();
-        return this.mapToEntity(row);
+        return await this.mapToEntity(row);
     }
     /**
      * Inserts multiple entities or updates them if a conflict occurs based on the target columns.
@@ -343,7 +343,7 @@ let EntityRepository = class EntityRepository extends Transactional {
             set: mappedUpdate,
         })
             .returning();
-        return this.mapManyToEntity(rows);
+        return await this.mapManyToEntity(rows);
     }
     /**
      * Updates an entity by its ID.
@@ -378,7 +378,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row);
+        return await this.mapToEntity(row);
     }
     /**
      * Updates a single entity matching a query.
@@ -413,7 +413,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row);
+        return await this.mapToEntity(row);
     }
     /**
      * Updates multiple entities by their IDs.
@@ -422,7 +422,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A promise that resolves to an array of the updated entities.
      */
     async updateMany(ids, update) {
-        return this.updateManyByQuery(inArray(this.#table.id, ids), update);
+        return await this.updateManyByQuery(inArray(this.#table.id, ids), update);
     }
     /**
      * Updates multiple entities matching a query.
@@ -438,7 +438,7 @@ let EntityRepository = class EntityRepository extends Transactional {
             .set(mappedUpdate)
             .where(sqlQuery)
             .returning();
-        return this.mapManyToEntity(rows);
+        return await this.mapManyToEntity(rows);
     }
     /**
      * Deletes an entity by its ID (soft delete if metadata is available).
@@ -464,7 +464,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      */
     async tryDelete(id, metadataUpdate) {
         if (!this.hasMetadata) {
-            return this.tryHardDelete(id);
+            return await this.tryHardDelete(id);
         }
         const sqlQuery = this.convertQuery(eq(this.#table.id, id));
         const [row] = await this.session
@@ -478,7 +478,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row);
+        return await this.mapToEntity(row);
     }
     /**
      * Deletes a single entity matching a query (soft delete if metadata is available).
@@ -504,7 +504,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      */
     async tryDeleteByQuery(query, metadataUpdate) {
         if (!this.hasMetadata) {
-            return this.tryHardDeleteByQuery(query);
+            return await this.tryHardDeleteByQuery(query);
         }
         const idQuery = this.getIdLimitSelect(query);
         const [row] = await this.session
@@ -518,7 +518,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row);
+        return await this.mapToEntity(row);
     }
     /**
      * Deletes multiple entities by their IDs (soft delete if metadata is available).
@@ -527,7 +527,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A promise that resolves to an array of the deleted entities.
      */
     async deleteMany(ids, metadataUpdate) {
-        return this.deleteManyByQuery(inArray(this.#table.id, ids), metadataUpdate);
+        return await this.deleteManyByQuery(inArray(this.#table.id, ids), metadataUpdate);
     }
     /**
      * Deletes multiple entities matching a query (soft delete if metadata is available).
@@ -537,7 +537,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      */
     async deleteManyByQuery(query, metadataUpdate) {
         if (!this.hasMetadata) {
-            return this.hardDeleteManyByQuery(query);
+            return await this.hardDeleteManyByQuery(query);
         }
         const sqlQuery = this.convertQuery(query);
         const rows = await this.session
@@ -548,7 +548,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         })
             .where(sqlQuery)
             .returning();
-        return this.mapManyToEntity(rows);
+        return await this.mapManyToEntity(rows);
     }
     /**
      * Hard deletes an entity by its ID (removes from the database).
@@ -579,7 +579,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row);
+        return await this.mapToEntity(row);
     }
     /**
      * Hard deletes a single entity matching a query (removes from the database).
@@ -610,7 +610,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row);
+        return await this.mapToEntity(row);
     }
     /**
      * Hard deletes multiple entities by their IDs (removes from the database).
@@ -618,7 +618,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A promise that resolves to an array of the hard deleted entities.
      */
     async hardDeleteMany(ids) {
-        return this.hardDeleteManyByQuery(inArray(this.#table.id, ids));
+        return await this.hardDeleteManyByQuery(inArray(this.#table.id, ids));
     }
     /**
      * Hard deletes multiple entities matching a query (removes from the database).
@@ -631,7 +631,7 @@ let EntityRepository = class EntityRepository extends Transactional {
             .delete(this.#table)
             .where(sqlQuery)
             .returning();
-        return this.mapManyToEntity(rows);
+        return await this.mapManyToEntity(rows);
     }
     /**
      * Retrieves the Drizzle PgColumn for a given object path or column definition.
@@ -693,7 +693,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      */
     async mapManyToEntity(columns) {
         const transformContext = await this.getTransformContext();
-        return this._mapManyToEntity(columns, transformContext);
+        return await this._mapManyToEntity(columns, transformContext);
     }
     /**
      * Maps a single database row to an entity.
@@ -702,7 +702,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      */
     async mapToEntity(columns) {
         const transformContext = await this.getTransformContext();
-        return this._mapToEntity(columns, transformContext);
+        return await this._mapToEntity(columns, transformContext);
     }
     /**
      * Maps multiple entity-like objects to database column values for insertion or update.
@@ -711,7 +711,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      */
     async mapManyToColumns(objects) {
         const transformContext = await this.getTransformContext();
-        return this._mapManyToColumns(objects, transformContext);
+        return await this._mapManyToColumns(objects, transformContext);
     }
     /**
      * Maps a single entity-like object to database column values for insertion or update.
@@ -720,7 +720,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      */
     async mapToColumns(obj) {
         const transformContext = await this.getTransformContext();
-        return this._mapToColumns(obj, transformContext);
+        return await this._mapToColumns(obj, transformContext);
     }
     /**
      * Maps multiple new entity objects to database column values for insertion.
@@ -729,7 +729,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      */
     async mapManyToInsertColumns(objects) {
         const transformContext = await this.getTransformContext();
-        return this._mapManyToInsertColumns(objects, transformContext);
+        return await this._mapManyToInsertColumns(objects, transformContext);
     }
     /**
      * Maps a new entity object to database column values for insertion.
@@ -738,7 +738,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      */
     async mapToInsertColumns(obj) {
         const transformContext = await this.getTransformContext();
-        return this._mapToInsertColumns(obj, transformContext);
+        return await this._mapToInsertColumns(obj, transformContext);
     }
     /**
      * Maps an entity update object to database column values for updating.
@@ -747,7 +747,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      */
     async mapUpdate(update) {
         const transformContext = await this.getTransformContext();
-        return this._mapUpdate(update, transformContext);
+        return await this._mapUpdate(update, transformContext);
     }
     /**
      * Gets a Drizzle select query for the ID of a single entity matching the provided query, limited to 1 result.
@@ -768,7 +768,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         return sql `${this.#tableWithMetadata.attributes} || ${JSON.stringify(attributes)}::jsonb`;
     }
     async _mapManyToEntity(columns, transformContext) {
-        return toArrayAsync(mapAsync(columns, async (column) => this._mapToEntity(column, transformContext)));
+        return await toArrayAsync(mapAsync(columns, async (column) => await this._mapToEntity(column, transformContext)));
     }
     async _mapToEntity(columns, transformContext) {
         const entries = [];
@@ -781,7 +781,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         return Schema.parse(this.type, obj);
     }
     async _mapManyToColumns(objects, transformContext) {
-        return toArrayAsync(mapAsync(objects, async (obj) => this._mapToColumns(obj, transformContext)));
+        return await toArrayAsync(mapAsync(objects, async (obj) => await this._mapToColumns(obj, transformContext)));
     }
     async _mapToColumns(obj, transformContext) {
         const columns = {};
@@ -792,7 +792,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         return columns;
     }
     async _mapManyToInsertColumns(objects, transformContext) {
-        return toArrayAsync(mapAsync(objects, async (obj) => this._mapToInsertColumns(obj, transformContext)));
+        return await toArrayAsync(mapAsync(objects, async (obj) => await this._mapToInsertColumns(obj, transformContext)));
     }
     async _mapToInsertColumns(obj, transformContext) {
         const mapped = await this._mapToColumns(obj, transformContext);
@@ -847,7 +847,7 @@ let EntityRepository = class EntityRepository extends Transactional {
             const transformContext = await this.#transformContext;
             this.#transformContext = transformContext;
         }
-        return this.#transformContext;
+        return await this.#transformContext;
     }
 };
 EntityRepository = __decorate([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.132",
+  "version": "0.92.135",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/schema/schema.error.js

@@ -8,8 +8,9 @@ export class SchemaError extends CustomError {
     inner;
     innerMessages;
     constructor(message, options, cause) {
-        super({ message, cause: cause ?? options.cause, fast: options.fast });
-        this.path = isString(options.path) ? options.path : options.path.path;
+        const path = isString(options.path) ? options.path : options.path.path;
+        super({ message: `${path}: ${message}`, cause: cause ?? options.cause, fast: options.fast });
+        this.path = path;
         if (isDefined(options.inner) && (!isArray(options.inner) || (options.inner.length > 0))) {
             this.inner = isArray(options.inner)
                 ? (options.inner.length == 1)
@@ -22,7 +23,6 @@ export class SchemaError extends CustomError {
             this.details = options.details;
         }
     }
-    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
     static expectedButGot(expected, got, path, options) {
         const expectedNames = toArray(expected).map((e) => isFunction(e) ? e.name : e);
         const expectedString = expectedNames.length == 1
@@ -32,7 +32,6 @@ export class SchemaError extends CustomError {
         const message = `Expected ${expectedString} but got ${got}${customMessage}`;
         return new SchemaError(message, { path, ...options });
     }
-    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
     static couldNotCoerce(expected, got, path, options) {
         const expectedNames = toArray(expected).map((e) => isFunction(e) ? e.name : e);
         const expectedString = expectedNames.length == 1
@@ -43,9 +42,7 @@ export class SchemaError extends CustomError {
         return new SchemaError(errorMessage, { path, ...options });
     }
     getExtraInfo(includeMessage = false) {
-        const obj = {
-            path: this.path
-        };
+        const obj = { path: this.path };
         if (includeMessage) {
             obj['message'] = this.message;
         }

package/search-index/elastic/module.js

@@ -8,7 +8,7 @@ import { Client } from '@elastic/elasticsearch';
 import { ElasticSearchIndexConfig } from './config.js';
 export const elasticsearchModuleConfig = {
     defaultOptions: { node: 'http://localhost:9200' },
-    logPrefix: 'ELASTIC'
+    logPrefix: 'ELASTIC',
 };
 export const ELASTIC_SEARCH_INDEX_CONFIG = injectionToken('ElasticSearchIndexConfig');
 export function configureElasticsearch(config = {}) {
@@ -20,19 +20,19 @@ Injector.registerSingleton(Client, {
         assertDefined(argument, 'missing elasticsearch client options');
         context.data.logger = inject(Logger, elasticsearchModuleConfig.logPrefix);
         const client = new Client(argument);
-        context.addDisposeHandler(async () => client.close().then(() => context.data.logger.info('closed connection')));
+        context.addDisposeHandler(async () => await client.close().then(() => context.data.logger.info('closed connection')));
         return client;
     },
     async afterResolve(client, options, { cancellationSignal, data: { logger } }) {
         const url = getUrl(options.node ?? options.nodes);
-        await connect(`elasticsearch (${url})`, async () => client.ping().then((alive) => assert(alive, 'failed to connect')), logger, cancellationSignal);
+        await connect(`elasticsearch (${url})`, async () => await client.ping().then((alive) => assert(alive, 'failed to connect')), logger, cancellationSignal);
     },
     defaultArgumentProvider() {
         return elasticsearchModuleConfig.defaultOptions;
-    }
+    },
 });
 Injector.registerSingleton(ELASTIC_SEARCH_INDEX_CONFIG, {
-    useFactory: (argument, context) => context.resolve(ElasticSearchIndexConfig, argument)
+    useFactory: (argument, context) => context.resolve(ElasticSearchIndexConfig, argument),
 });
 function getUrl(node) {
     if (isString(node)) {

package/utils/cryptography.js

@@ -14,11 +14,11 @@ export function encrypt(algorithm, key, data) {
     const bytes = isString(data) ? encodeUtf8(data) : data;
     const encryptedBuffer = globalThis.crypto.subtle.encrypt(algorithm, key, bytes);
     return {
-        toBuffer: async () => encryptedBuffer,
+        toBuffer: async () => await encryptedBuffer,
         toHex: async () => encodeHex(await encryptedBuffer),
         toBase64: async () => encodeBase64(await encryptedBuffer),
         toBase64Url: async () => encodeBase64Url(await encryptedBuffer),
-        toZBase32: async () => zBase32Encode(await encryptedBuffer)
+        toZBase32: async () => zBase32Encode(await encryptedBuffer),
     };
 }
 /**
@@ -30,12 +30,12 @@ export function encrypt(algorithm, key, data) {
 export function decrypt(algorithm, key, bytes) {
     const decryptedBuffer = globalThis.crypto.subtle.decrypt(algorithm, key, bytes);
     return {
-        toBuffer: async () => decryptedBuffer,
+        toBuffer: async () => await decryptedBuffer,
         toHex: async () => encodeHex(await decryptedBuffer),
         toBase64: async () => encodeBase64(await decryptedBuffer),
         toBase64Url: async () => encodeBase64Url(await decryptedBuffer),
         toZBase32: async () => zBase32Encode(await decryptedBuffer),
-        toUtf8: async () => decodeText(await decryptedBuffer)
+        toUtf8: async () => decodeText(await decryptedBuffer),
     };
 }
 /**
@@ -47,11 +47,11 @@ export function digest(algorithm, data) {
     const bytes = isString(data) ? encodeUtf8(data) : data;
     const arrayBufferPromise = globalThis.crypto.subtle.digest(algorithm, bytes);
     const result = {
-        toBuffer: async () => arrayBufferPromise,
+        toBuffer: async () => await arrayBufferPromise,
         toHex: async () => encodeHex(await arrayBufferPromise),
         toBase64: async () => encodeBase64(await arrayBufferPromise),
         toBase64Url: async () => encodeBase64Url(await arrayBufferPromise),
-        toZBase32: async () => zBase32Encode(await arrayBufferPromise)
+        toZBase32: async () => zBase32Encode(await arrayBufferPromise),
     };
     return result;
 }
@@ -65,11 +65,11 @@ export function sign(algorithm, key, data) {
     const bytes = isString(data) ? encodeUtf8(data) : data;
     const arrayBufferPromise = globalThis.crypto.subtle.sign(algorithm, key, bytes);
     const result = {
-        toBuffer: async () => arrayBufferPromise,
+        toBuffer: async () => await arrayBufferPromise,
         toHex: async () => encodeHex(await arrayBufferPromise),
         toBase64: async () => encodeBase64(await arrayBufferPromise),
         toBase64Url: async () => encodeBase64Url(await arrayBufferPromise),
-        toZBase32: async () => zBase32Encode(await arrayBufferPromise)
+        toZBase32: async () => zBase32Encode(await arrayBufferPromise),
     };
     return result;
 }
@@ -83,7 +83,7 @@ export function sign(algorithm, key, data) {
 export async function verify(algorithm, key, signature, data) {
     const signatureBytes = isString(signature) ? encodeUtf8(signature) : signature;
     const dataBytes = isString(data) ? encodeUtf8(data) : data;
-    return globalThis.crypto.subtle.verify(algorithm, key, signatureBytes, dataBytes);
+    return await globalThis.crypto.subtle.verify(algorithm, key, signatureBytes, dataBytes);
 }
 /**
  * Imports a HMAC CryptoKey
@@ -94,9 +94,9 @@ export async function verify(algorithm, key, signature, data) {
 export async function importHmacKey(algorithm, key, extractable = false) {
     const binaryKey = isString(key) ? encodeUtf8(key) : key;
     if (isBinaryKey(binaryKey)) {
-        return globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
+        return await globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
     }
-    return globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
+    return await globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
 }
 /**
  * Imports a CryptoKey for symmetric encryption
@@ -108,9 +108,9 @@ export async function importHmacKey(algorithm, key, extractable = false) {
 export async function importSymmetricKey(algorithm, length, key, extractable = false) {
     const binaryKey = isString(key) ? encodeUtf8(key) : key;
     if (isBinaryKey(binaryKey)) {
-        return globalThis.crypto.subtle.importKey('raw', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
+        return await globalThis.crypto.subtle.importKey('raw', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
     }
-    return globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
+    return await globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
 }
 /**
  * Imports an ECDSA CryptoKey
@@ -121,9 +121,9 @@ export async function importSymmetricKey(algorithm, length, key, extractable = f
 export async function importEcdsaKey(curve, key, extractable = false) {
     const binaryKey = isString(key) ? encodeUtf8(key) : key;
     if (isBinaryKey(binaryKey)) {
-        return globalThis.crypto.subtle.importKey('spki', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
+        return await globalThis.crypto.subtle.importKey('spki', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
     }
-    return globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
+    return await globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
 }
 /**
  * Import a pbkdf2 CryptoKey
@@ -132,7 +132,7 @@ export async function importEcdsaKey(curve, key, extractable = false) {
  */
 export async function importPbkdf2Key(key, extractable = false) {
     const binaryKey = isString(key) ? encodeUtf8(key) : key;
-    return globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'PBKDF2' }, extractable, ['deriveKey', 'deriveBits']);
+    return await globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'PBKDF2' }, extractable, ['deriveKey', 'deriveBits']);
 }
 /**
  * Generates a new ECDSA CryptoKeyPair
@@ -141,7 +141,7 @@ export async function importPbkdf2Key(key, extractable = false) {
  * @param usages whether to generate a key for signing, verifiying or both. Defaults to both
  */
 export async function generateEcdsaKey(curve, extractable = false, usages = ['sign', 'verify']) {
-    return globalThis.crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: curve }, extractable, usages);
+    return await globalThis.crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: curve }, extractable, usages);
 }
 /**
  * Generates a pbkdf2 CryptoKey
@@ -149,7 +149,7 @@ export async function generateEcdsaKey(curve, extractable = false, usages = ['si
  */
 export async function generatePbkdf2Key(extractable = false) {
     const key = getRandomBytes(16);
-    return importPbkdf2Key(key, extractable);
+    return await importPbkdf2Key(key, extractable);
 }
 /**
  * Derive byte array from key

package/utils/object/object.d.ts

@@ -13,9 +13,10 @@ export declare function objectKeys<T extends ObjectLiteral>(object: T): (keyof T
 export declare function objectValues<T extends ObjectLiteral>(object: T): (T[keyof T])[];
 export declare function fromEntries<A>(entries: A): FromEntries<A>;
 export declare function fromEntries<K extends PropertyKey, T>(entries: Iterable<readonly [K, T]>): Record<K, T>;
-export declare function mapObject<T extends ObjectLiteral, K extends string | number | symbol, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => [key: K, value: V]): Record<K, V>;
-export declare function mapObjectAsync<T extends ObjectLiteral, K extends string | number | symbol, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => Promise<[key: K, value: V]>): Promise<Record<K, V>>;
+export declare function mapObject<T extends ObjectLiteral, K extends PropertyKey, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => [key: K, value: V]): Record<K, V>;
+export declare function mapObjectAsync<T extends ObjectLiteral, K extends PropertyKey, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => Promise<[key: K, value: V]>): Promise<Record<K, V>>;
 export declare function mapObjectValues<T extends ObjectLiteral, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => V): Record<keyof T, V>;
+export declare function mapObjectKeys<T extends ObjectLiteral, K extends PropertyKey>(object: T, mapper: (key: keyof T, value: T[keyof T]) => K): Record<K, T[keyof T]>;
 export declare function mapObjectValuesAsync<T extends ObjectLiteral, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => Promise<V>): Promise<Record<keyof T, V>>;
 export declare function filterObject<T extends ObjectLiteral, U extends T[keyof T]>(object: T, predicate: (value: T[keyof T], key: keyof T) => value is U): PickBy<T, U>;
 export declare function filterObject<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;

package/utils/object/object.js

@@ -31,14 +31,17 @@ export function mapObject(object, mapper) {
 }
 export async function mapObjectAsync(object, mapper) {
     const entries = objectKeys(object);
-    const mappedEntries = await toArrayAsync(mapAsync(entries, async (key) => mapper(object[key], key)));
+    const mappedEntries = await toArrayAsync(mapAsync(entries, async (key) => await mapper(object[key], key)));
     return Object.fromEntries(mappedEntries);
 }
 export function mapObjectValues(object, mapper) {
     return mapObject(object, (value, key) => [key, mapper(value, key)]);
 }
+export function mapObjectKeys(object, mapper) {
+    return mapObject(object, (value, key) => [mapper(key, value), value]);
+}
 export async function mapObjectValuesAsync(object, mapper) {
-    return mapObjectAsync(object, async (value, key) => [key, await mapper(value, key)]);
+    return await mapObjectAsync(object, async (value, key) => [key, await mapper(value, key)]);
 }
 export function filterObject(object, predicate) {
     const mappedEntries = objectEntries(object).filter(([key, value]) => predicate(value, key));

package/utils/stream/size-limited-stream.js

@@ -8,6 +8,6 @@ export function sizeLimitTransform(maxBytes, writableStrategy, readableStrategy)
                 throw MaxBytesExceededError.fromBytes(maxBytes);
             }
             controller.enqueue(chunk);
-        }
+        },
     }, writableStrategy, readableStrategy);
 }

package/utils/type-guards.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor, BinaryData, JsonPrimitive, PascalCase, Primitive, TypedArray } from '../types.js';
+import type { AbstractConstructor, BinaryData, JsonPrimitive, PascalCase, Primitive, Type, TypedArray } from '../types.js';
 export type AssertionMessage = string | (() => string);
 export type IsFunction<T> = <U extends T = T>(value: any) => value is U;
 export type IsNotFunction<T> = <V>(value: V) => value is Exclude<V, T>;
@@ -257,3 +257,9 @@ export declare const assertReadableStream: <T = any>(value: any, message?: Asser
 export declare const assertNotReadableStream: AssertNotFunction<ReadableStream>;
 export declare const assertReadableStreamPass: <T = any>(value: any, message?: AssertionMessage) => ReadableStream<T>;
 export declare const assertNotReadableStreamPass: AssertNotPassFunction<ReadableStream>;
+export declare const isInstanceOf: <T>(value: any, type: Type<T>) => value is T;
+export declare const isNotInstanceOf: <V, T>(value: V, type: Type<T>) => value is Exclude<V, T>;
+export declare const assertInstanceOf: <T>(value: any, type: Type<T>, message?: AssertionMessage) => asserts value is T;
+export declare const assertNotInstanceOf: <V, T>(value: V, type: Type<T>, message?: AssertionMessage) => asserts value is Exclude<V, T>;
+export declare const assertInstanceOfPass: <T>(value: any, type: Type<T>, message?: AssertionMessage) => T;
+export declare const assertNotInstanceOfPass: <V, T>(value: V, type: Type<T>, message?: AssertionMessage) => Exclude<V, T>;

package/utils/type-guards.js

@@ -36,7 +36,7 @@ export function createGuards(name, testFn) {
         [`assertNot${normalizedName}Pass`](value, message = defaultNotMessage) {
             assertNot(testFn(value), message);
             return value;
-        }
+        },
     };
 }
 export function createInstanceGuards(name, type) {
@@ -335,3 +335,15 @@ export const assertReadableStream = readableStreamGuards.assertReadableStream;
 export const assertNotReadableStream = readableStreamGuards.assertNotReadableStream;
 export const assertReadableStreamPass = readableStreamGuards.assertReadableStreamPass;
 export const assertNotReadableStreamPass = readableStreamGuards.assertNotReadableStreamPass;
+export const isInstanceOf = (value, type) => value instanceof type;
+export const isNotInstanceOf = (value, type) => !isInstanceOf(value, type);
+export const assertInstanceOf = (value, type, message) => assert(isInstanceOf(value, type), message);
+export const assertNotInstanceOf = (value, type, message) => assertNot(isInstanceOf(value, type), message);
+export const assertInstanceOfPass = (value, type, message) => {
+    assert(isInstanceOf(value, type), message);
+    return value;
+};
+export const assertNotInstanceOfPass = (value, type, message) => {
+    assertNot(isInstanceOf(value, type), message);
+    return value;
+};