@tstdl/base 0.92.130 → 0.92.132

package/injector/inject.d.ts

@@ -9,7 +9,13 @@ export type InjectArgumentOptions = {
 export type InjectionContext = {
     injector: Injector;
     argument: unknown;
-    inject<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): T;
+    inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: InjectOptions<T, A> & {
+        optional: true;
+    }): T | undefined;
+    inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A> & {
+        optional?: false;
+    }): T;
+    inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): T | undefined;
     injectAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): T[];
     injectMany<T extends InjectManyItem<any, any>[]>(...tokens: T): InjectManyReturnType<T>;
     injectAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): Promise<T>;
@@ -31,6 +37,7 @@ export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T
 export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A> & {
     optional?: false;
 }): T;
+export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): T | undefined;
 /**
  * Resolves tokens using the {@link Injector} of the current injection context
  *
@@ -47,7 +54,10 @@ export declare function injectMany<T extends InjectManyItem<any, any>[]>(...toke
 export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: InjectOptions<T, A> & {
     optional: true;
 }): Promise<T | undefined>;
-export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): Promise<T>;
+export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A> & {
+    optional?: false;
+}): Promise<T>;
+export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): Promise<T | undefined>;
 /**
  * Resolves tokens using the {@link Injector} of the current injection context
  *

package/injector/injector.d.ts

@@ -59,14 +59,14 @@ export declare class Injector implements AsyncDisposable {
      * @param provider provider used to resolve the token
      * @param options registration options
      */
-    register<T, A = any, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: RegistrationOptions<T, A, C>): void;
+    register<T, A = any, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: RegistrationOptions<T, A, C>): this;
     /**
      * Register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
      * @param token token to register
      * @param provider provider used to resolve the token
      * @param options registration options
      */
-    registerSingleton<T, A = any, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): void;
+    registerSingleton<T, A = any, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): this;
     /**
      * Check if token has a registered provider
      * @param token token check
@@ -94,6 +94,7 @@ export declare class Injector implements AsyncDisposable {
     resolveAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): Promise<T>;
     resolveAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): Promise<T[]>;
     resolveManyAsync<T extends ResolveManyItem<any, any>[]>(...tokens: T): Promise<ResolveManyReturnType<T>>;
+    private _resolveManyTokens;
     private _resolve;
     private _resolveAll;
     private _resolveRegistration;

package/injector/injector.js

@@ -8,7 +8,7 @@ import { toArray } from '../utils/array/array.js';
 import { FactoryMap } from '../utils/factory-map.js';
 import { ForwardRef } from '../utils/object/forward-ref.js';
 import { objectEntries } from '../utils/object/object.js';
-import { assert, isArray, isBoolean, isDefined, isFunction, isNotNull, isNull, isPromise, isUndefined } from '../utils/type-guards.js';
+import { assert, isArray, isBoolean, isDefined, isFunction, isNotNull, isNotObject, isNull, isPromise, isUndefined } from '../utils/type-guards.js';
 import { setCurrentInjectionContext } from './inject.js';
 import { afterResolve } from './interfaces.js';
 import { isClassProvider, isFactoryProvider, isProviderWithInitializer, isTokenProvider, isValueProvider } from './provider.js';
@@ -61,7 +61,7 @@ export class Injector {
                 token,
                 provider,
                 providers: options.providers ?? [],
-                options: { multi, ...options }
+                options: { multi, ...options },
             };
             addRegistration(Injector.#globalRegistrations, registration);
         }
@@ -103,10 +103,11 @@ export class Injector {
                 provider,
                 providers: options.providers ?? [],
                 options: { multi, ...options },
-                resolutions: new Map()
+                resolutions: new Map(),
             };
             addRegistration(this.#registrations, registration);
         }
+        return this;
     }
     /**
      * Register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
@@ -116,6 +117,7 @@ export class Injector {
      */
     registerSingleton(token, providers, options) {
         this.register(token, providers, { ...options, lifecycle: 'singleton' });
+        return this;
     }
     /**
      * Check if token has a registered provider
@@ -162,48 +164,101 @@ export class Injector {
     resolve(token, argument, options = {}) {
         const context = newInternalResolveContext();
         const value = this._resolve(token, argument, options, context, ResolveChain.startWith(token));
-        postProcess(context);
-        context.$done.resolve();
+        try {
+            postProcess(context);
+            context.$done.resolve();
+        }
+        catch (error) {
+            context.$done.reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
+            throw error;
+        }
+        if (context.forwardRefs.has(value)) {
+            return ForwardRef.deref(value);
+        }
         return value;
     }
     resolveAll(token, argument, options = {}) {
         const context = newInternalResolveContext();
         const values = this._resolveAll(token, argument, options, context, ResolveChain.startWith(token));
-        postProcess(context);
-        context.$done.resolve();
+        try {
+            postProcess(context);
+            context.$done.resolve();
+        }
+        catch (error) {
+            context.$done.reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
+            throw error;
+        }
+        if (context.forwardRefs.has(values)) {
+            return ForwardRef.deref(values);
+        }
         return values;
     }
     resolveMany(...tokens) {
         const context = newInternalResolveContext();
-        const values = tokens.map((token) => (isArray(token)
-            ? this._resolve(token[0], token[1], token[2] ?? {}, context, ResolveChain.startWith(token[0]))
-            : this._resolve(token, undefined, {}, context, ResolveChain.startWith(token))));
-        postProcess(context);
-        context.$done.resolve();
-        return values;
+        const values = this._resolveManyTokens(tokens, context);
+        try {
+            postProcess(context);
+            context.$done.resolve();
+        }
+        catch (error) {
+            context.$done.reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
+            throw error;
+        }
+        return values.map((value) => context.forwardRefs.has(value)
+            ? ForwardRef.deref(value)
+            : value);
     }
     async resolveAsync(token, argument, options = {}) {
         const context = newInternalResolveContext();
         const value = this._resolve(token, argument, options, context, ResolveChain.startWith(token));
-        await postProcessAsync(context);
-        context.$done.resolve();
+        try {
+            await postProcessAsync(context);
+            context.$done.resolve();
+        }
+        catch (error) {
+            context.$done.reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
+            throw error;
+        }
+        if (context.forwardRefs.has(value)) {
+            return ForwardRef.deref(value);
+        }
         return value;
     }
     async resolveAllAsync(token, argument, options = {}) {
         const context = newInternalResolveContext();
         const values = this._resolveAll(token, argument, options, context, ResolveChain.startWith(token));
-        await postProcessAsync(context);
-        context.$done.resolve();
+        try {
+            await postProcessAsync(context);
+            context.$done.resolve();
+        }
+        catch (error) {
+            context.$done.reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
+            throw error;
+        }
+        if (context.forwardRefs.has(values)) {
+            return ForwardRef.deref(values);
+        }
         return values;
     }
     async resolveManyAsync(...tokens) {
         const context = newInternalResolveContext();
-        const values = tokens.map((token) => (isArray(token)
+        const values = this._resolveManyTokens(tokens, context);
+        try {
+            await postProcessAsync(context);
+            context.$done.resolve();
+        }
+        catch (error) {
+            context.$done.reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
+            throw error;
+        }
+        return values.map((value) => context.forwardRefs.has(value)
+            ? ForwardRef.deref(value)
+            : value);
+    }
+    _resolveManyTokens(tokens, context) {
+        return tokens.map((token) => (isArray(token)
             ? this._resolve(token[0], token[1], token[2] ?? {}, context, ResolveChain.startWith(token[0]))
             : this._resolve(token, undefined, {}, context, ResolveChain.startWith(token))));
-        await postProcessAsync(context);
-        context.$done.resolve();
-        return values;
     }
     _resolve(token, argument, options, context, chain) {
         this.assertNotDisposed();
@@ -259,7 +314,7 @@ export class Injector {
     _resolveRegistration(registration, argument, options, context, chain) {
         checkOverflow(chain, context);
         const { token, providers } = registration;
-        const injector = (providers.length > 0) ? this.fork('LocalProvidersInjector') : this;
+        const injector = this.fork('ResolutionInjector');
         for (const nestedProvider of providers) {
             injector.registerSingleton(nestedProvider.provide, nestedProvider, { multi: nestedProvider.multi });
         }
@@ -282,7 +337,7 @@ export class Injector {
                 return registration.resolutions.get(argumentIdentity);
             }
             const resolutionContext = {
-                afterResolveRegistrations: []
+                afterResolveRegistrations: [],
             };
             const value = injector._resolveProvider(resolutionTag, registration, resolveArgument, options, context, resolutionContext, injectionContext, chain);
             const resolution = {
@@ -292,7 +347,7 @@ export class Injector {
                 argument: injectionContext.argument,
                 afterResolveRegistrations: resolutionContext.afterResolveRegistrations,
                 afterResolveContext: injector.getAfterResolveContext(resolutionTag, context),
-                chain
+                chain,
             };
             context.resolutions.push(resolution);
             if (resolutionScoped) {
@@ -377,13 +432,9 @@ export class Injector {
         }
         const parameterResolveArgument = injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(resolutionTag, context, getChain(injectToken)));
         const { forwardRef } = injectMetadata;
-        if (isDefined(forwardRef)) {
-            context.forwardRefQueue.add(() => {
-                const forwardToken = isFunction(forwardRef) ? forwardRef() : isBoolean(forwardRef) ? injectToken : forwardRef;
-                if (isDefined(injectMetadata.mapper)) {
-                    throw new ResolveError('Cannot use inject mapper with forwardRef.', getChain(forwardToken));
-                }
-            });
+        if (isDefined(forwardRef) && isDefined(injectMetadata.mapper)) {
+            const forwardToken = isFunction(forwardRef) ? forwardRef() : isBoolean(forwardRef) ? injectToken : forwardRef;
+            throw new ResolveError('Cannot use inject mapper with forwardRef.', getChain(forwardToken));
         }
         const resolveFn = (injectMetadata.resolveAll == true) ? '_resolveAll' : '_resolve';
         const resolved = this[resolveFn](injectToken, parameterResolveArgument, { optional: injectMetadata.optional, forwardRef, forwardRefTypeHint: injectMetadata.forwardRefTypeHint }, context, getChain(injectToken));
@@ -413,7 +464,7 @@ export class Injector {
             addDisposeHandler: this.#addDisposeHandler,
             get data() {
                 return resolveContext.resolutionContextData.get(resolutionTag);
-            }
+            },
         };
         return context;
     }
@@ -423,7 +474,7 @@ export class Injector {
             addDisposeHandler: this.#addDisposeHandler,
             get data() {
                 return resolveContext.resolutionContextData.get(resolutionTag);
-            }
+            },
         };
         return context;
     }
@@ -437,7 +488,7 @@ export class Injector {
             injectMany: (...tokens) => this.resolveMany(...tokens),
             injectAsync: async (token, argument, options) => this.resolveInjectionAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
             injectAllAsync: async (token, argument, options) => this.resolveInjectionAllAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
-            injectManyAsync: async (...tokens) => this.resolveManyAsync(...tokens)
+            injectManyAsync: async (...tokens) => this.resolveManyAsync(...tokens),
         };
         return context;
     }
@@ -480,7 +531,7 @@ function newInternalResolveContext() {
         resolutionContextData: new FactoryMap(() => ({})),
         forwardRefQueue: new CircularBuffer(),
         forwardRefs: new Set(),
-        $done: new DeferredPromise()
+        $done: new DeferredPromise(),
     };
 }
 function postProcess(context) {
@@ -554,7 +605,7 @@ function checkOverflow(chain, context) {
 }
 function derefForwardRefs(context) {
     for (const resolution of context.resolutions.values()) {
-        if (!(typeof resolution.value == 'object')) {
+        if (isNotObject(resolution.value)) {
             continue;
         }
         for (const [key, value] of objectEntries(resolution.value)) {

package/injector/symbols.d.ts

@@ -1,2 +1,3 @@
 export declare const injectableMetadataSymbol: unique symbol;
+export declare const injectableOptionsSymbol: unique symbol;
 export declare const injectMetadataSymbol: unique symbol;

package/injector/symbols.js

@@ -1,2 +1,3 @@
 export const injectableMetadataSymbol = Symbol('Injectable metadata');
+export const injectableOptionsSymbol = Symbol('Injectable options');
 export const injectMetadataSymbol = Symbol('Inject metadata');

package/module/modules/web-server.module.js

@@ -15,7 +15,7 @@ import { inject, injectArgument } from '../../injector/inject.js';
 import { ModuleBase } from '../module-base.js';
 import { ModuleMetricType } from '../module.js';
 export const webServerModuleConfiguration = {
-    port: 8000
+    port: 8000,
 };
 let WebServerModule = class WebServerModule extends ModuleBase {
     config = injectArgument(this);
@@ -26,8 +26,8 @@ let WebServerModule = class WebServerModule extends ModuleBase {
     metrics = {
         connectedSockets: {
             type: ModuleMetricType.Gauge,
-            getValue: () => this.httpServer.connectedSocketsCount
-        }
+            getValue: () => this.httpServer.connectedSocketsCount,
+        },
     };
     constructor() {
         super('WebServer');
@@ -55,7 +55,7 @@ let WebServerModule = class WebServerModule extends ModuleBase {
 };
 WebServerModule = __decorate([
     Singleton({
-        defaultArgumentProvider: () => webServerModuleConfiguration
+        defaultArgumentProvider: () => webServerModuleConfiguration,
     }),
     __metadata("design:paramtypes", [])
 ], WebServerModule);

package/orm/server/database.d.ts

@@ -20,8 +20,4 @@ export type DatabaseArgument = PoolConfig;
 export declare class Database extends NodePgDatabase<any> implements Resolvable<DatabaseArgument> {
     readonly [resolveArgumentType]?: DatabaseArgument;
 }
-/**
- * Re-exports the `migrate` function from `drizzle-orm/node-postgres/migrator`
- * for running database migrations.
- */
 export { migrate };

package/orm/server/database.js

@@ -37,8 +37,4 @@ Injector.registerSingleton(Database, {
         return drizzle(pool);
     },
 });
-/**
- * Re-exports the `migrate` function from `drizzle-orm/node-postgres/migrator`
- * for running database migrations.
- */
 export { migrate };

package/orm/server/drizzle/schema-converter.js

@@ -68,7 +68,8 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
         const indexFn = (data.options?.unique == true) ? uniqueIndex : index;
         let builder = indexFn(data.name ?? getIndexName(tableName, columns, { naming: data.options?.naming })).using(data.options?.using ?? 'btree', ...columns);
         if (isDefined(data.options?.where)) {
-            builder = builder.where(convertQuery(data.options.where(table), table, columnDefinitionsMap));
+            const query = convertQuery(data.options.where(table), table, columnDefinitionsMap);
+            builder = builder.where(query.inlineParams());
         }
         return builder;
     }
@@ -76,7 +77,7 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
         const columns = primaryKeyColumnDefinitions.map((columnDefinition) => getColumn(table, columnDefinition.name));
         return primaryKey({
             name: mergedTableReflectionData.compundPrimaryKeyName ?? getPrimaryKeyName(tableName, columns, { naming: mergedTableReflectionData.compundPrimaryKeyNaming }),
-            columns
+            columns,
         });
     }
     const primaryKeyColumnDefinitions = columnDefinitions.filter((columnDefinition) => columnDefinition.reflectionData?.primaryKey == true);
@@ -102,7 +103,7 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
             return constraint;
         }),
         ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.index).filter(isDefined).map((data) => buildIndex(table, data)),
-        ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.checks).filter(isDefined).map((data) => check(data.name, data.builder(table)))
+        ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.checks).filter(isDefined).map((data) => check(data.name, data.builder(table))),
     ]);
     drizzleSchema[columnDefinitionsSymbol] = columnDefinitions;
     drizzleSchema[columnDefinitionsMapSymbol] = columnDefinitionsMap;
@@ -144,7 +145,7 @@ function getPostgresColumnEntries(type, dbSchema, tableName, path = new JsonPath
                 buildType: (options) => getPostgresColumn(tableName, toSnakeCase(prefixedColumnName), dbSchema, schema, columnReflectionData ?? {}, options, { type, property }),
                 dereferenceObjectPath: compileDereferencer(objectPath, { optional: true }),
                 toDatabase,
-                fromDatabase
+                fromDatabase,
             }];
     });
     return entries;

package/orm/server/module.d.ts

@@ -8,19 +8,15 @@ import type { PoolConfig } from 'pg';
 import { EntityRepositoryConfig } from './repository.js';
 /**
  * Configuration class for the database connection.
- * Holds the `pg.PoolConfig`.
  */
 export declare class DatabaseConfig {
-    /** Optional PostgreSQL pool configuration. */
     connection?: PoolConfig;
 }
 /**
  * Options for configuring the ORM module using `configureOrm`.
  */
 export type OrmModuleOptions = {
-    /** Optional PostgreSQL pool configuration. */
     connection?: PoolConfig;
-    /** Optional configuration for entity repositories. */
     repositoryConfig?: EntityRepositoryConfig;
 };
 /**

package/orm/server/module.js

@@ -4,10 +4,8 @@ import { EntityRepositoryConfig } from './repository.js';
 import { ENCRYPTION_SECRET } from './tokens.js';
 /**
  * Configuration class for the database connection.
- * Holds the `pg.PoolConfig`.
  */
 export class DatabaseConfig {
-    /** Optional PostgreSQL pool configuration. */
     connection;
 }
 /**

package/orm/server/query-converter.js

@@ -8,7 +8,6 @@ import { and, eq, gt, gte, inArray, isNotNull, isNull, isSQLWrapper, lt, lte, ne
 import { NotSupportedError } from '../../errors/not-supported.error.js';
 import { hasOwnProperty, objectEntries } from '../../utils/object/object.js';
 import { assertDefinedPass, isPrimitive, isRegExp, isString, isUndefined } from '../../utils/type-guards.js';
-/** SQL fragment representing `true`. */
 const sqlTrue = sql `true`;
 /**
  * Converts a query object into a Drizzle SQL condition.
@@ -22,65 +21,53 @@ const sqlTrue = sql `true`;
  * @throws {Error} If an unsupported query type is encountered.
  */
 export function convertQuery(query, table, columnDefinitionsMap) {
-    // If the query is already a Drizzle SQL object, return it directly.
     if (query instanceof SQL) {
         return query;
     }
-    // If the query is a SQLWrapper, convert it to a Drizzle SQL object.
     if (isSQLWrapper(query)) {
         return sql `${query}`;
     }
     const queryEntries = objectEntries(query);
-    // If the query object is empty, return true.
     if (queryEntries.length == 0) {
         return sqlTrue;
     }
     const conditions = [];
     for (const [property, value] of queryEntries) {
-        // Handle logical AND operator
         if (property == '$and') {
             if (queryEntries.length > 1) {
                 throw new Error('only one logical operator per level allowed');
             }
             const andQuery = and(...query.$and.map((item) => convertQuery(item, table, columnDefinitionsMap)));
-            // If $and array is empty or results in no conditions, return true.
             if (isUndefined(andQuery)) {
                 return sqlTrue;
             }
             return andQuery;
         }
-        // Handle logical OR operator
         if (property == '$or') {
             if (queryEntries.length > 1) {
                 throw new Error('only one logical operator per level allowed');
             }
             const orQuery = or(...query.$or.map((item) => convertQuery(item, table, columnDefinitionsMap)));
-            // If $or array is empty or results in no conditions, return true.
             if (isUndefined(orQuery)) {
                 return sqlTrue;
             }
             return orQuery;
         }
-        // Handle logical NOR operator
         if (property == '$nor') {
             if (queryEntries.length > 1) {
                 throw new Error('only one logical operator per level allowed');
             }
             const orQuery = or(...query.$nor.map((item) => convertQuery(item, table, columnDefinitionsMap)));
-            // If $nor array is empty or results in no conditions, return true (NOT false -> true).
             if (isUndefined(orQuery)) {
                 return sqlTrue;
             }
             return not(orQuery);
         }
-        // Map property name to column definition and get the Drizzle column object.
         const columnDef = assertDefinedPass(columnDefinitionsMap.get(property), `Could not map property ${property} to column.`);
         const column = table[columnDef.name];
-        // Get the condition for the current property and value.
         const condition = getCondition(property, value, column);
         conditions.push(condition);
     }
-    // Combine all conditions with AND.
     return and(...conditions);
 }
 /**
@@ -95,79 +82,65 @@ export function convertQuery(query, table, columnDefinitionsMap) {
  */
 function getCondition(property, value, column) {
     const isPrimitiveValue = isPrimitive(value);
-    // Handle equality ($eq or direct primitive value)
     if (isPrimitiveValue || hasOwnProperty(value, '$eq')) {
         const queryValue = isPrimitiveValue ? value : value.$eq;
         if (queryValue === null) {
-            return isNull(column); // IS NULL
+            return isNull(column);
         }
-        return eq(column, queryValue); // = value
+        return eq(column, queryValue);
     }
-    // Handle inequality ($neq)
     if (hasOwnProperty(value, '$neq')) {
         const queryValue = value.$neq;
         if (queryValue === null) {
-            return isNotNull(column); // IS NOT NULL
+            return isNotNull(column);
         }
-        return ne(column, queryValue); // != value
+        return ne(column, queryValue);
     }
     // $exists is not supported
     if (hasOwnProperty(value, '$exists')) {
         throw new NotSupportedError('$exists is not supported.');
     }
-    // Handle $in operator
     if (hasOwnProperty(value, '$in')) {
         const queryValue = value.$in;
-        return inArray(column, queryValue); // IN (values)
+        return inArray(column, queryValue);
     }
-    // Handle $nin operator
     if (hasOwnProperty(value, '$nin')) {
         const queryValue = value.$nin;
-        return notInArray(column, queryValue); // NOT IN (values)
+        return notInArray(column, queryValue);
     }
-    // Handle $lt operator
     if (hasOwnProperty(value, '$lt')) {
         const queryValue = value.$lt;
-        return lt(column, queryValue); // < value
+        return lt(column, queryValue);
     }
-    // Handle $lte operator
     if (hasOwnProperty(value, '$lte')) {
         const queryValue = value.$lte;
-        return lte(column, queryValue); // <= value
+        return lte(column, queryValue);
     }
-    // Handle $gt operator
     if (hasOwnProperty(value, '$gt')) {
         const queryValue = value.$gt;
-        return gt(column, queryValue); // > value
+        return gt(column, queryValue);
     }
-    // Handle $gte operator
     if (hasOwnProperty(value, '$gte')) {
         const queryValue = value.$gte;
-        return gte(column, queryValue); // >= value
+        return gte(column, queryValue);
     }
-    // Handle $regex operator (using PostgreSQL regexp_like)
     if (hasOwnProperty(value, '$regex')) {
         const queryValue = value.$regex;
-        // Normalize RegExp or string input
         const regexp = isString(queryValue)
             ? ({ value: queryValue })
             : isRegExp(queryValue)
                 ? ({ flags: queryValue.flags, value: queryValue.source })
                 : ({ flags: queryValue.flags, value: queryValue.pattern });
-        return sql `regexp_like(${column}, ${regexp.value}, ${regexp.flags})`; // Uses regexp_like function
+        return sql `regexp_like(${column}, ${regexp.value}, ${regexp.flags})`;
     }
-    // $text is not supported
     if (hasOwnProperty(value, '$text')) {
         throw new NotSupportedError('$text is not supported.');
     }
-    // $geoShape is not supported
     if (hasOwnProperty(value, '$geoShape')) {
         throw new NotSupportedError('$geoShape is not supported.');
     }
-    // $geoDistance is not supported
     if (hasOwnProperty(value, '$geoDistance')) {
         throw new NotSupportedError('$geoDistance is not supported.');
     }
-    // Throw if the query structure is unrecognized
     throw new Error(`Unsupported query type "${property}".`);
 }

package/orm/server/repository.d.ts

@@ -1,7 +1,8 @@
 import { SQL } from 'drizzle-orm';
 import type { PgColumn, PgInsertValue, PgUpdateSetSource } from 'drizzle-orm/pg-core';
+import { type InjectOptions } from '../../injector/inject.js';
 import { type Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
-import type { DeepPartial, OneOrMany, Paths, Type } from '../../types.js';
+import type { DeepPartial, OneOrMany, Paths, Type, TypedOmit } from '../../types.js';
 import type { UntaggedDeep } from '../../types/index.js';
 import { Entity, type EntityMetadataAttributes, type EntityType, type EntityWithoutMetadata } from '../entity.js';
 import type { Query } from '../query.js';
@@ -476,7 +477,7 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
  * @param type The entity type.
  * @returns An EntityRepository instance for the specified type.
  */
-export declare function injectRepository<T extends Entity | EntityWithoutMetadata>(type: EntityType<T>): EntityRepository<T>;
+export declare function injectRepository<T extends Entity | EntityWithoutMetadata>(type: EntityType<T>, options?: TypedOmit<InjectOptions<EntityRepository<T>, undefined>, 'optional'>): EntityRepository<T>;
 /**
  * Gets or creates a singleton EntityRepository class for the specified entity type.
  * @template T The entity type.

package/orm/server/repository.js

@@ -860,8 +860,8 @@ export { EntityRepository };
  * @param type The entity type.
  * @returns An EntityRepository instance for the specified type.
  */
-export function injectRepository(type) {
-    return inject((EntityRepository), type);
+export function injectRepository(type, options) {
+    return inject((EntityRepository), type, options);
 }
 /**
  * Gets or creates a singleton EntityRepository class for the specified entity type.

package/orm/server/transaction.d.ts

@@ -4,19 +4,20 @@ import type { Record } from '../../types.js';
 import type { Database } from './database.js';
 export type PgTransaction = DrizzlePgTransaction<PgQueryResultHKT, Record, Record>;
 export type TransactionConfig = PgTransactionConfig;
-export declare abstract class Transaction {
+export declare abstract class Transaction implements AsyncDisposable {
     #private;
     readonly afterCommit$: import("rxjs").Observable<void>;
     manualCommit: boolean;
+    [Symbol.asyncDispose](): Promise<void>;
     withManualCommit(): void;
     /**
      * Enters automatic transaction handling. Transaction will be commited when all use-calls are done or rolled back when one throws.
      */
     use<T>(handler: () => Promise<T>): Promise<T>;
     commit(): Promise<void>;
-    rollback(): void;
-    protected abstract _commit(): Promise<void>;
-    protected abstract _rollback(): void;
+    rollback(): Promise<void>;
+    protected abstract _commit(): void | Promise<void>;
+    protected abstract _rollback(): void | Promise<void>;
 }
 export declare class DrizzleTransaction extends Transaction {
     readonly pgTransaction: PgTransaction;