@tstdl/base 0.92.142 → 0.92.144

package/orm/server/repository.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-non-null-asserted-optional-chain */
 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);
@@ -12,19 +11,19 @@ import { Singleton } from '../../injector/decorators.js';
 import { inject, injectArgument } from '../../injector/inject.js';
 import { resolveArgumentType } from '../../injector/interfaces.js';
 import { Schema } from '../../schema/schema.js';
-import { toArray } from '../../utils/array/array.js';
+import { distinct, toArray } from '../../utils/array/array.js';
 import { mapAsync } from '../../utils/async-iterable-helpers/map.js';
 import { toArrayAsync } from '../../utils/async-iterable-helpers/to-array.js';
 import { importSymmetricKey } from '../../utils/cryptography.js';
-import { typeExtends } from '../../utils/index.js';
 import { fromDeepObjectEntries, fromEntries, objectEntries } from '../../utils/object/object.js';
 import { assertDefinedPass, isArray, isDefined, isString, isUndefined } from '../../utils/type-guards.js';
+import { typeExtends } from '../../utils/type/index.js';
 import { Entity } from '../entity.js';
 import { TRANSACTION_TIMESTAMP } from '../sqls.js';
 import { getColumnDefinitions, getColumnDefinitionsMap, getDrizzleTableFromType } from './drizzle/schema-converter.js';
 import { convertQuery } from './query-converter.js';
 import { ENCRYPTION_SECRET } from './tokens.js';
-import { getTransactionalContextData, isInTransactionalContext, Transactional } from './transactional.js';
+import { getTransactionalContextData, injectTransactional, injectTransactionalAsync, isInTransactionalContext, Transactional } from './transactional.js';
 export const repositoryType = Symbol('repositoryType');
 /**
  * Configuration class for EntityRepository.
@@ -113,8 +112,11 @@ let EntityRepository = class EntityRepository extends Transactional {
         let dbQuery = this.session.select()
             .from(this.#table)
             .where(sqlQuery)
-            .offset(options?.offset)
+            .limit(1)
             .$dynamic();
+        if (isDefined(options?.offset)) {
+            dbQuery = dbQuery.offset(options.offset);
+        }
         if (isDefined(options?.order)) {
             dbQuery = dbQuery.orderBy(...this.convertOrderBy(options.order));
         }
@@ -131,6 +133,9 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A promise that resolves to an array of loaded entities.
      */
     async loadMany(ids, options) {
+        if (ids.length === 0) {
+            return [];
+        }
         return await this.loadManyByQuery(inArray(this.#table.id, ids), options);
     }
     /**
@@ -159,11 +164,14 @@ let EntityRepository = class EntityRepository extends Transactional {
             return this.session.selectDistinctOn(ons);
         })
             .from(this.#table)
-            .$dynamic();
-        dbQuery = dbQuery
             .where(sqlQuery)
-            .offset(options?.offset)
-            .limit(options?.limit);
+            .$dynamic();
+        if (isDefined(options?.offset)) {
+            dbQuery = dbQuery.offset(options.offset);
+        }
+        if (isDefined(options?.limit)) {
+            dbQuery = dbQuery.limit(options.limit);
+        }
         if (isDefined(options?.order)) {
             dbQuery = dbQuery.orderBy(...this.convertOrderBy(options.order));
         }
@@ -202,11 +210,9 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A promise that resolves to the total count.
      */
     async count() {
-        const sqlQuery = this.convertQuery({});
         const dbQuery = this.session
             .select({ count: count() })
-            .from(this.#table)
-            .where(sqlQuery);
+            .from(this.#table);
         const [result] = await dbQuery;
         return assertDefinedPass(result).count;
     }
@@ -239,24 +245,26 @@ let EntityRepository = class EntityRepository extends Transactional {
      */
     async hasByQuery(query) {
         const sqlQuery = this.convertQuery(query);
-        const dbQuery = this.session
-            .select({ exists: sql `SELECT EXISTS(SELECT 1 FROM ${this.#table} WHERE ${sqlQuery})` })
-            .from(this.#table);
-        const [result] = await dbQuery;
-        return assertDefinedPass(result).exists;
+        const result = await this.session.execute(sql `SELECT EXISTS(SELECT 1 FROM ${this.#table} WHERE ${sqlQuery}) AS exists`);
+        console.log(result);
+        throw new Error('handle result');
     }
     /**
      * Checks if all entities with the given IDs exist.
      * @param ids An array of entity IDs to check.
-     * @returns A promise that resolves to `true` if all entities exist, `false` otherwise.
+     * @returns A promise that resolves to `true` if all entities exist, `false` otherwise. If `ids` is empty, returns `false`.
      */
     async hasAll(ids) {
-        const sqlQuery = this.convertQuery({});
+        const uniqueIds = distinct(ids);
+        if (uniqueIds.length === 0) {
+            return false;
+        }
         const result = await this.session
-            .select({ contains: sql `array_agg(${this.#table.id}) @> ${ids}`.as('contains') })
+            .select({ count: count() })
             .from(this.#table)
-            .where(sqlQuery);
-        return assertDefinedPass(result[0]).contains;
+            .where(inArray(this.#table.id, uniqueIds));
+        const foundCount = result[0]?.count ?? 0;
+        return foundCount == uniqueIds.length;
     }
     /**
      * Tries to insert using ON CONFLICT DO NOTHING
@@ -294,10 +302,51 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A promise that resolves to an array of the inserted entities.
      */
     async insertMany(entities) {
+        if (entities.length === 0) {
+            return [];
+        }
         const columns = await this.mapManyToInsertColumns(entities);
         const rows = await this.session.insert(this.#table).values(columns).returning();
         return await this.mapManyToEntity(rows);
     }
+    /**
+     * Inserts an entity if it does not already exist based on the target columns.
+     * @param target The column(s) to use for conflict detection.
+     * @param entity The entity to insert.
+     * @returns A promise that resolves to the inserted or existing entity.
+     */
+    async insertIfNotExists(target, entity) {
+        const targetColumns = toArray(target).map((path) => this.getColumn(path));
+        const columns = await this.mapToInsertColumns(entity);
+        const [row] = await this.session
+            .insert(this.#table)
+            .values(columns)
+            .onConflictDoNothing({ target: targetColumns })
+            .returning();
+        if (isUndefined(row)) {
+            return undefined;
+        }
+        return await this.mapToEntity(row);
+    }
+    /**
+     * Inserts many entities if they do not already exist based on the target columns.
+     * @param target The column(s) to use for conflict detection.
+     * @param entities The entities to insert.
+     * @returns A promise that resolves to the inserted or existing entities.
+     */
+    async insertManyIfNotExists(target, entities) {
+        if (entities.length === 0) {
+            return [];
+        }
+        const targetColumns = toArray(target).map((path) => this.getColumn(path));
+        const columns = await this.mapManyToInsertColumns(entities);
+        const rows = await this.session
+            .insert(this.#table)
+            .values(columns)
+            .onConflictDoNothing({ target: targetColumns })
+            .returning();
+        return await this.mapManyToEntity(rows);
+    }
     /**
      * Inserts an entity or updates it if a conflict occurs based on the target columns.
      * @param target The column(s) to use for conflict detection.
@@ -327,6 +376,9 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A promise that resolves to an array of the inserted or updated entities.
      */
     async upsertMany(target, entities, update) {
+        if (entities.length === 0) {
+            return [];
+        }
         const targetColumns = toArray(target).map((path) => this.getColumn(path));
         const columns = await this.mapManyToInsertColumns(entities);
         const mappedUpdate = isDefined(update)
@@ -404,11 +456,11 @@ let EntityRepository = class EntityRepository extends Transactional {
      */
     async tryUpdateByQuery(query, update) {
         const mappedUpdate = await this.mapUpdate(update);
-        const idQuery = this.getIdLimitSelect(query);
+        const idQuery = this.getIdLimitQuery(query).for('update');
         const [row] = await this.session
             .update(this.#table)
             .set(mappedUpdate)
-            .where(inArray(this.#table.id, idQuery.for('update')))
+            .where(inArray(this.#table.id, idQuery))
             .returning();
         if (isUndefined(row)) {
             return undefined;
@@ -422,6 +474,9 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A promise that resolves to an array of the updated entities.
      */
     async updateMany(ids, update) {
+        if (ids.length === 0) {
+            return [];
+        }
         return await this.updateManyByQuery(inArray(this.#table.id, ids), update);
     }
     /**
@@ -506,14 +561,14 @@ let EntityRepository = class EntityRepository extends Transactional {
         if (!this.hasMetadata) {
             return await this.tryHardDeleteByQuery(query);
         }
-        const idQuery = this.getIdLimitSelect(query);
+        const idQuery = this.getIdLimitQuery(query).for('update');
         const [row] = await this.session
             .update(this.#tableWithMetadata)
             .set({
             deleteTimestamp: TRANSACTION_TIMESTAMP,
             attributes: this.getAttributesUpdate(metadataUpdate?.attributes),
         })
-            .where(inArray(this.#table.id, idQuery.for('update')))
+            .where(inArray(this.#table.id, idQuery))
             .returning();
         if (isUndefined(row)) {
             return undefined;
@@ -527,6 +582,9 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A promise that resolves to an array of the deleted entities.
      */
     async deleteMany(ids, metadataUpdate) {
+        if (ids.length === 0) {
+            return [];
+        }
         return await this.deleteManyByQuery(inArray(this.#table.id, ids), metadataUpdate);
     }
     /**
@@ -602,10 +660,10 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A promise that resolves to the hard deleted entity or `undefined` if not found.
      */
     async tryHardDeleteByQuery(query) {
-        const idQuery = this.getIdLimitSelect(query);
+        const idQuery = this.getIdLimitQuery(query).for('update');
         const [row] = await this.session
             .delete(this.#table)
-            .where(inArray(this.#table.id, idQuery.for('update')))
+            .where(inArray(this.#table.id, idQuery))
             .returning();
         if (isUndefined(row)) {
             return undefined;
@@ -618,6 +676,9 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A promise that resolves to an array of the hard deleted entities.
      */
     async hardDeleteMany(ids) {
+        if (ids.length === 0) {
+            return [];
+        }
         return await this.hardDeleteManyByQuery(inArray(this.#table.id, ids));
     }
     /**
@@ -756,7 +817,11 @@ let EntityRepository = class EntityRepository extends Transactional {
      * @returns A Drizzle select query for the entity ID.
      */
     getIdLimitQuery(query) {
-        return this.getIdLimitSelect(query);
+        const sqlQuery = this.convertQuery(query);
+        return this.session.select({ id: this.#table.id })
+            .from(this.#table)
+            .where(sqlQuery)
+            .limit(1);
     }
     getAttributesUpdate(attributes) {
         if (isUndefined(attributes)) {
@@ -830,13 +895,6 @@ let EntityRepository = class EntityRepository extends Transactional {
             }
             : undefined;
     }
-    getIdLimitSelect(query) {
-        const sqlQuery = this.convertQuery(query);
-        return this.session.select({ id: this.#table.id })
-            .from(this.#table)
-            .where(sqlQuery)
-            .limit(1);
-    }
     async getTransformContext() {
         if (isUndefined(this.#transformContext)) {
             if (isUndefined(this.#encryptionSecret)) {
@@ -860,8 +918,17 @@ export { EntityRepository };
  * @param type The entity type.
  * @returns An EntityRepository instance for the specified type.
  */
-export function injectRepository(type, options) {
-    return inject((EntityRepository), type, options);
+export function injectRepository(type, session) {
+    return injectTransactional((EntityRepository), session, type);
+}
+/**
+ * Injects an EntityRepository instance for the specified entity type.
+ * @template T The entity type.
+ * @param type The entity type.
+ * @returns An EntityRepository instance for the specified type.
+ */
+export async function injectRepositoryAsync(type, session) {
+    return await injectTransactionalAsync((EntityRepository), session, type);
 }
 /**
  * Gets or creates a singleton EntityRepository class for the specified entity type.
@@ -870,7 +937,7 @@ export function injectRepository(type, options) {
  * @returns A singleton EntityRepository class for the specified type.
  */
 export function getRepository(type) {
-    const className = `${type.name}Service`;
+    const className = `${type.name}Repository`;
     const entityRepositoryClass = {
         [className]: class extends EntityRepository {
             static [entityTypeToken] = type;

package/orm/server/transaction.d.ts

@@ -1,8 +1,9 @@
-import type { PgTransaction as DrizzlePgTransaction, PgQueryResultHKT, PgTransactionConfig } from 'drizzle-orm/pg-core';
+import { PgTransaction as DrizzlePgTransaction, type PgQueryResultHKT, type PgTransactionConfig } from 'drizzle-orm/pg-core';
 import { DeferredPromise } from '../../promise/deferred-promise.js';
 import type { Record } from '../../types.js';
 import type { Database } from './database.js';
 export type PgTransaction = DrizzlePgTransaction<PgQueryResultHKT, Record, Record>;
+export { DrizzlePgTransaction };
 export type TransactionConfig = PgTransactionConfig;
 export declare abstract class Transaction implements AsyncDisposable {
     #private;

package/orm/server/transaction.js

@@ -1,5 +1,7 @@
+import { PgTransaction as DrizzlePgTransaction } from 'drizzle-orm/pg-core';
 import { Subject } from 'rxjs';
 import { DeferredPromise } from '../../promise/deferred-promise.js';
+export { DrizzlePgTransaction };
 export class Transaction {
     #afterCommitSubject = new Subject();
     #useCounter = 0;
@@ -37,6 +39,7 @@ export class Transaction {
     }
     async rollback() {
         this.#done = true;
+        this.#afterCommitSubject.complete();
         await this._rollback();
     }
 }

package/orm/server/transactional.d.ts

@@ -1,5 +1,6 @@
+import { type InjectionToken, type ResolveArgument } from '../../injector/index.js';
 import { Database } from './database.js';
-import { type PgTransaction, type Transaction, type TransactionConfig } from './transaction.js';
+import { Transaction, type PgTransaction, type TransactionConfig } from './transaction.js';
 export type TransactionInitOptions = TransactionConfig & {
     /**
      * Indicates that an existing transaction should be used if available instead of creating a new one.
@@ -73,3 +74,6 @@ export declare abstract class Transactional<ContextData = unknown> {
 }
 export declare function tryGetTransactionalContextData<T>(_instance?: Transactional<T>): T | undefined;
 export declare function getTransactionalContextData<T>(_instance?: Transactional<T>): T;
+export declare function tryGetTstdlTransaction(transactionOrSession: Transaction | Database | PgTransaction | undefined): Transaction | undefined;
+export declare function injectTransactional<T extends Transactional, A = unknown>(token: InjectionToken<T, A>, session?: Database | PgTransaction | null, argument?: ResolveArgument<T, A>): T;
+export declare function injectTransactionalAsync<T extends Transactional, A = unknown>(token: InjectionToken<T, A>, session?: Database | PgTransaction | null, argument?: ResolveArgument<T, A>): Promise<T>;

package/orm/server/transactional.js

@@ -1,10 +1,10 @@
 import { PgTransaction as DrizzlePgTransaction } from 'drizzle-orm/pg-core';
 import { createContextProvider } from '../../context/context.js';
 import { Injector } from '../../injector/index.js';
-import { inject, runInInjectionContext } from '../../injector/inject.js';
-import { isDefined, isUndefined } from '../../utils/type-guards.js';
+import { inject, injectAsync, runInInjectionContext } from '../../injector/inject.js';
+import { isDefined, isNull, isUndefined } from '../../utils/type-guards.js';
 import { Database } from './database.js';
-import { DrizzleTransaction } from './transaction.js';
+import { DrizzleTransaction, Transaction } from './transaction.js';
 const transactionCache = new WeakMap();
 const { getCurrentTransactionalContext, runInTransactionalContext, isInTransactionalContext } = createContextProvider('Transactional');
 export { getCurrentTransactionalContext, isInTransactionalContext, runInTransactionalContext };
@@ -29,8 +29,8 @@ const transactionalContextDataGuard = new Proxy({}, {
 export class Transactional {
     #injector = inject(Injector);
     #classConstructor;
-    #instanceCache = getCurrentTransactionalContext()?.cache ?? new WeakMap();
     #context = getCurrentTransactionalContext() ?? {};
+    #instanceCache = this.#context.cache ?? new WeakMap();
     session = this.#context.session ?? inject(Database);
     isInTransaction = this.session instanceof DrizzlePgTransaction;
     constructor() {
@@ -132,3 +132,33 @@ export function tryGetTransactionalContextData(_instance) {
 export function getTransactionalContextData(_instance) {
     return getCurrentTransactionalContext(true, getTransactionalContextData).data;
 }
+export function tryGetTstdlTransaction(transactionOrSession) {
+    if (isUndefined(transactionOrSession)) {
+        return undefined;
+    }
+    if (transactionOrSession instanceof Transaction) {
+        return transactionOrSession;
+    }
+    if (transactionOrSession instanceof DrizzlePgTransaction) {
+        return transactionCache.get(transactionOrSession);
+    }
+    return undefined;
+}
+export function injectTransactional(token, session, argument) {
+    const transactional = inject(token, argument);
+    return handleInjectedTransactional(transactional, session);
+}
+export async function injectTransactionalAsync(token, session, argument) {
+    const transactional = await injectAsync(token, argument);
+    return handleInjectedTransactional(transactional, session);
+}
+function handleInjectedTransactional(transactional, session) {
+    if (isNull(session)) {
+        return transactional;
+    }
+    const newSession = session ?? getCurrentTransactionalContext()?.session;
+    if (isDefined(newSession) && (transactional.session != newSession)) {
+        return transactional.withSession(newSession);
+    }
+    return transactional;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.142",
+  "version": "0.92.144",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -17,16 +17,18 @@
     "pub": "npm run build:production && rm -vf dist/test* && rm -vrf dist/tools/ && npm publish dist/",
     "tsc:watch": "tsc --watch",
     "tsc-alias:watch": "tsc-alias --watch",
-    "generate:migration": "npm run generate:migration:document-management && npm run generate:migration:authentication && npm run generate:migration:mail && npm run generate:migration:queue",
+    "generate:migration": "npm run generate:migration:document-management && npm run generate:migration:authentication && npm run generate:migration:mail && npm run generate:migration:queue && npm run generate:migration:key-value-store",
     "generate:migration:document-management": "drizzle-kit generate --config dist/document-management/server/drizzle.config.js",
     "generate:migration:authentication": "drizzle-kit generate --config dist/authentication/server/drizzle.config.js",
     "generate:migration:mail": "drizzle-kit generate --config dist/mail/drizzle.config.js",
     "generate:migration:queue": "drizzle-kit generate --config dist/queue/postgres/drizzle.config.js",
-    "copy:orm": "npm run copy:orm:document-management && npm run copy:orm:authentication && npm run copy:orm:mail && npm run copy:orm:queue",
+    "generate:migration:key-value-store": "drizzle-kit generate --config dist/key-value-store/postgres/drizzle.config.js",
+    "copy:orm": "npm run copy:orm:document-management && npm run copy:orm:authentication && npm run copy:orm:mail && npm run copy:orm:queue && npm run copy:orm:key-value-store",
     "copy:orm:document-management": "rm -rf ./dist/document-management/server/drizzle && cp -r ./source/document-management/server/drizzle ./dist/document-management/server/",
     "copy:orm:authentication": "rm -rf ./dist/authentication/server/drizzle && cp -r ./source/authentication/server/drizzle ./dist/authentication/server/",
     "copy:orm:mail": "rm -rf ./dist/mail/drizzle && cp -r ./source/mail/drizzle ./dist/mail/",
-    "copy:orm:queue": "rm -rf ./dist/queue/postgres/drizzle && cp -r ./source/queue/postgres/drizzle ./dist/queue/postgres/"
+    "copy:orm:queue": "rm -rf ./dist/queue/postgres/drizzle && cp -r ./source/queue/postgres/drizzle ./dist/queue/postgres/",
+    "copy:orm:key-value-store": "rm -rf ./dist/key-value-store/postgres/drizzle && cp -r ./source/key-value-store/postgres/drizzle ./dist/key-value-store/postgres/"
   },
   "exports": {
     "./tsconfig.json": "./tsconfig.json",
@@ -136,6 +138,7 @@
   },
   "dependencies": {
     "disposablestack": "^1.1",
+    "jsondiffpatch": "^0.7",
     "luxon": "^3.6",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
@@ -145,22 +148,22 @@
   "peerDependencies": {
     "@elastic/elasticsearch": "^9.0",
     "@google-cloud/storage": "7.16",
-    "@google/genai": "^1.1",
+    "@google/genai": "^1.5",
     "@tstdl/angular": "^0.92",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
     "@zxcvbn-ts/language-de": "^3.0",
     "@zxcvbn-ts/language-en": "^3.0",
     "chroma-js": "^2.6",
-    "drizzle-orm": "^0.43",
+    "drizzle-orm": "^0.44",
     "file-type": "^21.0",
     "handlebars": "^4.7",
     "minio": "^8.0",
     "mjml": "^4.15",
-    "mongodb": "^6.16",
+    "mongodb": "^6.17",
     "nodemailer": "^7.0",
     "pg": "^8.16",
-    "playwright": "^1.52",
+    "playwright": "^1.53",
     "preact": "^10.26",
     "preact-render-to-string": "^6.5",
     "sharp": "^0.34",
@@ -179,17 +182,17 @@
     "@types/luxon": "3.6",
     "@types/minio": "7.1",
     "@types/mjml": "4.7",
-    "@types/node": "22",
+    "@types/node": "24",
     "@types/nodemailer": "6.4",
     "@types/pg": "8.15",
     "concurrently": "9.1",
     "drizzle-kit": "0.31",
-    "eslint": "9.27",
+    "eslint": "9.29",
     "globals": "16.2",
     "tsc-alias": "1.8",
     "typedoc-plugin-missing-exports": "4.0",
     "typescript": "5.8",
-    "typescript-eslint": "8.32"
+    "typescript-eslint": "8.34"
   },
   "overrides": {
     "drizzle-kit": {

package/process/spawn.js

@@ -61,7 +61,6 @@ export async function spawnCommand(command, args) {
     async function handleNonZeroExitCode() {
         const error = await nonZeroExitCodeError;
         if (error) {
-            console.log('ERROR HAPPENED', error);
             await writable.abort(error).catch(() => { });
             await readable.cancel(error).catch(() => { });
         }

package/promise/deferred-promise.d.ts

@@ -15,10 +15,11 @@ export declare class DeferredPromise<T = void> extends Promise<T> {
     get pending(): boolean;
     get settled(): boolean;
     constructor(executor?: PromiseExecutor<T>);
-    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
-    finally(onfinally?: (() => void) | null | undefined): Promise<T>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<T>;
     resolve(value: T | PromiseLike<T>): void;
+    resolveIfPending(value: T | PromiseLike<T>): void;
     resolveAndReset(value: T | PromiseLike<T>): void;
     reject(reason?: unknown): void;
     reset(): void;

package/promise/deferred-promise.js

@@ -30,18 +30,23 @@ export class DeferredPromise extends Promise {
         }
     }
     async then(onfulfilled, onrejected) {
-        return this.backingPromise.then(onfulfilled, onrejected);
+        return await this.backingPromise.then(onfulfilled, onrejected);
     }
     async catch(onrejected) {
-        return this.backingPromise.catch(onrejected);
+        return await this.backingPromise.catch(onrejected);
     }
     async finally(onfinally) {
-        return this.backingPromise.finally(onfinally);
+        return await this.backingPromise.finally(onfinally);
     }
     resolve(value) {
         this.ensurePendingState();
-        this.resolvePromise(value);
-        this.state = PromiseState.Resolved;
+        this.resolveIfPending(value);
+    }
+    resolveIfPending(value) {
+        if (this.pending) {
+            this.resolvePromise(value);
+            this.state = PromiseState.Resolved;
+        }
     }
     resolveAndReset(value) {
         this.resolve(value);
@@ -53,6 +58,9 @@ export class DeferredPromise extends Promise {
         this.state = PromiseState.Rejected;
     }
     reset() {
+        if (this.pending) {
+            return;
+        }
         this.backingPromise = new Promise((resolve, reject) => {
             this.resolvePromise = resolve;
             this.rejectPromise = reject;

package/queue/postgres/queue.js

@@ -67,19 +67,19 @@ let PostgresQueue = class PostgresQueue extends Queue {
         return jobs;
     }
     async has(id) {
-        return this.#repository.hasByQuery({ queue: this.#queueName, id });
+        return await this.#repository.hasByQuery({ queue: this.#queueName, id });
     }
     async countByTag(tag) {
-        return this.#repository.countByQuery({ queue: this.#queueName, tag });
+        return await this.#repository.countByQuery({ queue: this.#queueName, tag });
     }
     async get(id) {
-        return this.#repository.tryLoadByQuery({ queue: this.#queueName, id });
+        return await this.#repository.tryLoadByQuery({ queue: this.#queueName, id });
     }
     async getByTag(tag) {
-        return this.#repository.loadManyByQuery({ queue: this.#queueName, tag });
+        return await this.#repository.loadManyByQuery({ queue: this.#queueName, tag });
     }
     async getByTags(tags) {
-        return this.#repository.loadManyByQuery({ queue: this.#queueName, tag: { $in: tags } });
+        return await this.#repository.loadManyByQuery({ queue: this.#queueName, tag: { $in: tags } });
     }
     async cancel(id) {
         await this.#repository.hardDeleteByQuery({ queue: this.#queueName, id });
@@ -120,14 +120,14 @@ let PostgresQueue = class PostgresQueue extends Queue {
             .set(this.#dequeueUpdate)
             .where(inArray(job.id, this.#repository.session.select().from(selection)))
             .returning();
-        return this.#repository.mapManyToEntity(rows);
+        return await this.#repository.mapManyToEntity(rows);
     }
     async acknowledge(job) {
-        return this.cancel(job.id);
+        await this.cancel(job.id);
     }
     async acknowledgeMany(jobs) {
         const ids = jobs.map((job) => job.id);
-        return this.cancelMany(ids);
+        await this.cancelMany(ids);
     }
     async *getConsumer(cancellationSignal) {
         const continue$ = merge(this.#messageBus.allMessages$, cancellationSignal);

package/reflection/utils.js

@@ -20,7 +20,7 @@ export function createDecorator(options, handler = noop) {
         const result = handler(data, metadata, args);
         if (isDefined(options.include)) {
             for (const include of toArray(options.include)) {
-                include(...args); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+                include(...args);
             }
         }
         return result;
@@ -66,7 +66,7 @@ export function wrapDecorator(decorator, options) {
         parameter: true,
         methodParameter: true,
         constructorParameter: true,
-        ...options
+        ...options,
     }, (data, metadata, args) => {
         options?.handler?.(data, metadata, args);
         return decorator(...args); // eslint-disable-line @typescript-eslint/no-unsafe-argument
@@ -105,5 +105,5 @@ export function getTypeInfoString(type) {
 }
 export function printType(type) {
     const text = getTypeInfoString(type);
-    console.log(text); // eslint-disable-line no-console
+    console.log(text);
 }

package/schema/decorators/class.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/naming-convention */
 import { createClassDecorator } from '../../reflection/index.js';
 export function Class(options = {}) {
     return createClassDecorator({ data: { schema: options }, mergeData: true });

package/schema/decorators/schema.js

@@ -9,7 +9,7 @@ export function createSchemaDecorator(data = {}) {
         method: true,
         parameter: true,
         data: { schema: filterUndefinedObjectProperties(data) },
-        mergeData: true
+        mergeData: true,
     });
 }
 export function SchemaDecorator(schemaOrOptions, optionsOrNothing) {

package/schema/schemas/boolean.d.ts

@@ -1,4 +1,4 @@
-import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type BooleanSchemaOptions = SimpleSchemaOptions<boolean>;
 export declare class BooleanSchema extends SimpleSchema<boolean> {