@tstdl/base 0.93.86 → 0.93.89

package/logger/logger.js

@@ -11,7 +11,7 @@ import { toArray } from '../utils/array/array.js';
 import { now } from '../utils/date-time.js';
 import { getCachedDereference } from '../utils/object/dereference.js';
 import { hasOwnProperty } from '../utils/object/object.js';
-import { isArray, isNotArray, isObject, isString } from '../utils/type-guards.js';
+import { isArray, isError, isNotArray, isObject, isString } from '../utils/type-guards.js';
 import { LogLevel } from './level.js';
 import { LogManager } from './manager.js';
 const { getCurrentLoggerCreationContext, runInLoggerCreationContext, isInLoggerCreationContext } = createContextProvider('LoggerCreation');
@@ -21,14 +21,12 @@ let Logger = Logger_1 = class Logger {
     module = getCurrentLoggerCreationContext()?.module ?? moduleFromArgument(this.#argument);
     context = getCurrentLoggerCreationContext()?.context ?? ((isObject(this.#argument) && isNotArray(this.#argument)) ? (this.#argument.context ?? {}) : {});
     level = isInLoggerCreationContext() ? getCurrentLoggerCreationContext().level : (isObject(this.#argument) && isNotArray(this.#argument)) ? this.#argument.level : undefined;
-    error(errorOrMessage, context) {
-        if (isString(errorOrMessage)) {
-            this._log(LogLevel.Error, errorOrMessage, context);
-        }
-        else {
-            const message = (errorOrMessage instanceof Error) ? errorOrMessage.message : 'Error';
-            this._log(LogLevel.Error, message, { ...context, error: errorOrMessage });
-        }
+    error(messageOrError, errorOrContext, contextOrNothing) {
+        const messageOrErrorIsString = isString(messageOrError);
+        const message = messageOrErrorIsString ? messageOrError : isError(messageOrError) ? messageOrError.message : 'Error';
+        const error = messageOrErrorIsString ? errorOrContext : messageOrError;
+        const context = messageOrErrorIsString ? contextOrNothing : errorOrContext;
+        this._log(LogLevel.Error, message, context, error);
     }
     warn(message, context) {
         this._log(LogLevel.Warn, message, context);
@@ -66,19 +64,21 @@ let Logger = Logger_1 = class Logger {
         };
         return runInLoggerCreationContext(creationContext, () => new Logger_1());
     }
-    _log(level, message, context = {}) {
+    _log(level, message, context = {}, error) {
         const moduleLevel = this.level ?? this.#manager.getModuleLevel(this.module);
         if (level > moduleLevel) {
             return;
         }
         const effectiveContext = { ...this.context, ...context };
-        const finalMessage = interpolateMessage(message, effectiveContext);
+        const { keys, interpolated: finalMessage } = interpolateMessage(message, effectiveContext);
         const payload = {
             timestamp: now(),
             level,
             module: this.module,
             message: finalMessage,
+            interpolationKeys: keys,
             context: effectiveContext,
+            error,
         };
         this.#manager.log(payload);
     }
@@ -101,11 +101,14 @@ function moduleFromArgument(argument) {
 }
 const cachedDereference = getCachedDereference({ optional: true });
 function interpolateMessage(message, context) {
-    return message.replace(/{([^{}]+)}/g, (match, key) => {
+    const keys = [];
+    const interpolated = message.replace(/{([^{}]+)}/g, (match, key) => {
+        keys.push(key);
         if (hasOwnProperty(context, key)) {
             const value = cachedDereference(context, key);
             return String(value);
         }
         return match;
     });
+    return { keys, interpolated };
 }

package/message-bus/local/module.d.ts

@@ -1,4 +1,7 @@
+import { Injector } from '../../injector/injector.js';
 /**
- * registers {@link LocalMessageBus} and {@link LocalMessageBusProvider} in global container
+ * registers {@link LocalMessageBus} and {@link LocalMessageBusProvider} in container
  */
-export declare function configureLocalMessageBus(): void;
+export declare function configureLocalMessageBus({ injector }?: {
+    injector?: Injector;
+}): void;

package/message-bus/local/module.js

@@ -4,9 +4,10 @@ import { MessageBus } from '../message-bus.js';
 import { LocalMessageBusProvider } from './local-message-bus-provider.js';
 import { LocalMessageBus } from './local-message-bus.js';
 /**
- * registers {@link LocalMessageBus} and {@link LocalMessageBusProvider} in global container
+ * registers {@link LocalMessageBus} and {@link LocalMessageBusProvider} in container
  */
-export function configureLocalMessageBus() {
-    Injector.register(MessageBus, { useToken: LocalMessageBus });
-    Injector.registerSingleton(MessageBusProvider, { useToken: LocalMessageBusProvider });
+export function configureLocalMessageBus({ injector } = {}) {
+    const targetInjector = injector ?? Injector;
+    targetInjector.register(MessageBus, { useToken: LocalMessageBus });
+    targetInjector.registerSingleton(MessageBusProvider, { useToken: LocalMessageBusProvider });
 }

package/module/module.d.ts

@@ -8,7 +8,7 @@ export declare const ModuleState: {
     readonly Erroneous: 3;
 };
 export type ModuleState = EnumType<typeof ModuleState>;
-export declare abstract class Module {
+export declare abstract class Module implements AsyncDisposable {
     private runPromise;
     private _state;
     protected readonly cancellationToken: CancellationToken;
@@ -16,6 +16,7 @@ export declare abstract class Module {
     get state(): ModuleState;
     private get stateString();
     constructor(name: string);
+    [Symbol.asyncDispose](): Promise<void>;
     run(): Promise<void>;
     stop(): Promise<void>;
     protected abstract _run(cancellationSignal: CancellationSignal): Promise<void>;

package/module/module.js

@@ -24,6 +24,9 @@ export class Module {
         this._state = ModuleState.Stopped;
         this.cancellationToken = new CancellationToken();
     }
+    async [Symbol.asyncDispose]() {
+        await this.stop();
+    }
     async run() {
         if (this._state != ModuleState.Stopped) {
             throw new Error(`cannot start module, it is ${this.stateString}`);

package/module/modules/web-server.module.d.ts

@@ -1,11 +1,11 @@
 import type { CancellationSignal } from '../../cancellation/index.js';
-import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
+import { Injector } from '../../injector/injector.js';
+import type { resolveArgumentType } from '../../injector/interfaces.js';
 import { Module } from '../module.js';
-export type WebServerModuleConfiguration = {
+export declare class WebServerModuleConfiguration {
     port: number;
-};
-export declare const webServerModuleConfiguration: WebServerModuleConfiguration;
-export declare class WebServerModule extends Module implements Resolvable<WebServerModuleConfiguration> {
+}
+export declare class WebServerModule extends Module {
     private readonly config;
     private readonly httpServer;
     private readonly apiGateway;
@@ -16,4 +16,9 @@ export declare class WebServerModule extends Module implements Resolvable<WebSer
     initialize(): void;
     protected _run(cancellationSignal: CancellationSignal): Promise<void>;
 }
-export declare function configureWebServerModule(config?: Partial<WebServerModuleConfiguration>): void;
+/**
+ * registers {@link WebServerModule} in container
+ */
+export declare function configureWebServerModule({ injector, ...config }?: Partial<WebServerModuleConfiguration> & {
+    injector?: Injector;
+}): void;

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

@@ -10,13 +10,15 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { API_CONTROLLERS, ApiGateway, getApiControllerDefinition } from '../../api/server/index.js';
 import { HttpServer } from '../../http/server/http-server.js';
 import { Singleton } from '../../injector/decorators.js';
-import { inject, injectArgument } from '../../injector/inject.js';
+import { inject } from '../../injector/inject.js';
+import { Injector } from '../../injector/injector.js';
 import { Module } from '../module.js';
-export const webServerModuleConfiguration = {
-    port: 8000,
-};
+export class WebServerModuleConfiguration {
+    port;
+}
+;
 let WebServerModule = class WebServerModule extends Module {
-    config = injectArgument(this);
+    config = inject(WebServerModuleConfiguration);
     httpServer = inject(HttpServer);
     apiGateway = inject(ApiGateway);
     apiControllers = inject(API_CONTROLLERS);
@@ -46,12 +48,15 @@ let WebServerModule = class WebServerModule extends Module {
     }
 };
 WebServerModule = __decorate([
-    Singleton({
-        defaultArgumentProvider: () => webServerModuleConfiguration,
-    }),
+    Singleton(),
     __metadata("design:paramtypes", [])
 ], WebServerModule);
 export { WebServerModule };
-export function configureWebServerModule(config) {
-    webServerModuleConfiguration.port = config?.port ?? webServerModuleConfiguration.port;
+/**
+ * registers {@link WebServerModule} in container
+ */
+export function configureWebServerModule({ injector, ...config } = {}) {
+    const targetInjector = injector ?? Injector;
+    targetInjector.register(WebServerModuleConfiguration, { useValue: config });
+    targetInjector.registerSingleton(WebServerModule, { useClass: WebServerModule });
 }

package/orm/decorators.d.ts

@@ -10,7 +10,7 @@ import type { AbstractConstructor, Record, TypedOmit } from '../types/index.js';
 import type { ValueOrProvider } from '../utils/value-or-provider.js';
 import type { AnyEntity, BaseEntity, Entity, EntityType } from './entity.js';
 import type { Query } from './query/index.js';
-import type { TargetColumnPath } from './repository.types.js';
+import type { TargetColumn, TargetColumnPath } from './repository.types.js';
 import type { ExtraConfigColumnsFromType } from './server/types.js';
 type IndexMethod = LiteralUnion<'hash' | 'btree' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hnsw' | 'ivfflat' | 'bm25', string>;
 type NamingStrategy = 'abbreviated-table';
@@ -45,8 +45,18 @@ export type OrmTableReflectionData<T extends BaseEntity = BaseEntity> = {
     unique?: UniqueReflectionData[];
     index?: IndexReflectionData[];
     paradeIndex?: ParadeIndexReflectionData<T>;
+    propertyOverrides?: Record<string, OrmColumnReflectionData>;
     checks?: CheckReflectionData[];
     foreignKeys?: ForeignKeyReflectionData[];
+    inheritance?: InheritanceMetadata<T>;
+    childEntity?: ChildEntityMetadata;
+};
+export type InheritanceMetadata<T extends BaseEntity = BaseEntity> = {
+    discriminatorColumn: TargetColumn<T>;
+    subclasses: EntityType[];
+};
+export type ChildEntityMetadata = {
+    discriminatorValue: string;
 };
 /**
  * Reflection data stored for ORM column decorators.
@@ -387,3 +397,16 @@ export declare function ParadeIndex<T extends BaseEntity>(options: ParadeIndexRe
 export declare function ParadeIndex(options?: ParadeFieldOptions): PropertyDecorator;
 export declare function ParadeCompoundIndex<T extends BaseEntity>(alias: string, compoundColumns: ParadeIndexCompoundColumnColumnsProvider<T>, options?: TypedOmit<ParadeFieldOptions, 'alias'>): ClassDecorator;
 export declare function ParadeExpressionIndex<T extends BaseEntity>(alias: string, expression: ParadeIndexExpressionProvider<T>, options?: TypedOmit<ParadeFieldOptions, 'alias'>): ClassDecorator;
+/**
+ * Configures inheritance for the entity.
+ * @param options Inheritance configuration.
+ */
+export declare function Inheritance<T extends BaseEntity>(options: {
+    strategy: 'joined';
+    discriminatorColumn?: TargetColumn<T>;
+}): ClassDecorator;
+/**
+ * Marks the entity as a child entity in an inheritance hierarchy.
+ * @param discriminatorValue The value identifying this subclass.
+ */
+export declare function ChildEntity(discriminatorValue: string): ClassDecorator;

package/orm/decorators.js

@@ -1,9 +1,9 @@
 import { match } from 'ts-pattern';
-import { createClassDecorator, createDecorator, createPropertyDecorator } from '../reflection/index.js';
+import { createClassDecorator, createDecorator, createPropertyDecorator, reflectionRegistry } from '../reflection/index.js';
 import { Property } from '../schema/index.js';
 import { merge } from '../utils/merge.js';
 import { filterUndefinedObjectProperties, objectEntries, propertyNameOf } from '../utils/object/index.js';
-import { isArray, isFunction, isString, isUndefined } from '../utils/type-guards.js';
+import { isArray, isDefined, isFunction, isNotNullOrUndefined, isString, isUndefined } from '../utils/type-guards.js';
 /**
  * Merges ORM reflection data into the target's metadata.
  * @param metadata The metadata object for the class or property.
@@ -143,8 +143,10 @@ export function Index(columnsOrOptions, options) {
  * @param mode Whether to delete soft or hard.
  */
 export function TimeToLive(ttl, mode) {
-    return createClassDecorator({
-        handler: (data) => Expires({ after: ttl, mode })(data.prototype, propertyNameOf((entity) => entity.metadata.createTimestamp)),
+    return createTableDecorator({
+        propertyOverrides: {
+            [propertyNameOf((entity) => entity.metadata.createTimestamp)]: { expirationField: { after: ttl, mode } },
+        },
     });
 }
 /**
@@ -199,3 +201,37 @@ export function ParadeCompoundIndex(alias, compoundColumns, options) {
 export function ParadeExpressionIndex(alias, expression, options) {
     return ParadeIndex({ expressions: [[expression, { alias, tokenizer: 'simple', ...options }]] });
 }
+/**
+ * Configures inheritance for the entity.
+ * @param options Inheritance configuration.
+ */
+export function Inheritance(options) {
+    return createTableDecorator({
+        inheritance: {
+            discriminatorColumn: options.discriminatorColumn ?? 'type',
+            subclasses: [],
+        },
+    });
+}
+/**
+ * Marks the entity as a child entity in an inheritance hierarchy.
+ * @param discriminatorValue The value identifying this subclass.
+ */
+export function ChildEntity(discriminatorValue) {
+    return createClassDecorator({
+        handler: (data, metadata) => {
+            let currentMetadata = metadata;
+            while (isNotNullOrUndefined(currentMetadata?.parent)) {
+                const parentMetadata = reflectionRegistry.getMetadata(currentMetadata.parent);
+                const parentOrmData = parentMetadata?.data.tryGet('orm');
+                if (isDefined(parentOrmData?.inheritance) && !parentOrmData.inheritance.subclasses.includes(data.constructor)) {
+                    parentOrmData.inheritance.subclasses.push(data.constructor);
+                }
+                currentMetadata = parentMetadata;
+            }
+            const ormData = metadata.data.tryGet('orm') ?? {};
+            ormData.childEntity = { discriminatorValue };
+            metadata.data.set('orm', ormData, true);
+        },
+    });
+}

package/orm/index.d.ts

@@ -8,6 +8,6 @@ export * from './entity.js';
 export * from './query/index.js';
 export * from './repository.types.js';
 export * from './schemas/index.js';
-export * from './sqls.js';
+export * from './sqls/index.js';
 export * from './types.js';
 export * from './utils.js';

package/orm/index.js

@@ -8,6 +8,6 @@ export * from './entity.js';
 export * from './query/index.js';
 export * from './repository.types.js';
 export * from './schemas/index.js';
-export * from './sqls.js';
+export * from './sqls/index.js';
 export * from './types.js';
 export * from './utils.js';

package/orm/query/base.d.ts

@@ -45,7 +45,7 @@ export type QueryObject<T extends BaseEntity> = LogicalQuery<T> | Partial<Specia
 /** Union of all possible query operator keys (logical, comparison, special). */
 export type QueryTypes = LogicalQueryTypes | ComparisonQueryTypes | SpecialQueryTypes;
 /** Array containing all valid query operator keys. */
-export declare const allQueryTypes: ("$parade" | "$and" | "$or" | "$nor" | "$not" | "$eq" | "$neq" | "$exists" | "$item" | "$in" | "$nin" | "$all" | "$gt" | "$gte" | "$lt" | "$lte" | "$regex" | "$tsvector" | "$trigram" | "$geoShape" | "$geoDistance")[];
+export declare const allQueryTypes: ("$parade" | "$and" | "$or" | "$nor" | "$not" | "$eq" | "$neq" | "$exists" | "$item" | "$in" | "$nin" | "$contains" | "$gt" | "$gte" | "$lt" | "$lte" | "$regex" | "$tsvector" | "$trigram" | "$geoShape" | "$geoDistance")[];
 /** Represents an AND logical query. All sub-queries must be true. */
 export type LogicalAndQuery<T = any> = {
     $and: readonly Query<T>[];
@@ -61,7 +61,7 @@ export type LogicalNorQuery<T = any> = {
 /** Represents a value used in comparisons, can be a direct value, a flattened value, or a Drizzle SQLWrapper. */
 export type ComparisonValue<T> = T | Flatten<T> | SQLWrapper;
 /** Represents a comparison value that can also include a RegExp for string comparisons. */
-export type ComparisonValueWithRegex<T> = T extends string ? ComparisonValue<T | RegExp> : T extends readonly string[] ? ComparisonValue<readonly (Flatten<T> | RegExp)[]> : (T | Flatten<T>);
+export type ComparisonValueWithRegex<T> = T extends string ? ComparisonValue<T | RegExp> : T extends readonly string[] ? ComparisonValue<readonly (Flatten<T> | RegExp)[]> : ComparisonValue<T>;
 /** Represents a logical AND query. All sub-queries must be true. */
 export type ComparisonAndQuery<T = any> = {
     $and: readonly ComparisonQueryOrValue<T>[];
@@ -74,51 +74,51 @@ export type ComparisonOrQuery<T = any> = {
 export type ComparisonNotQuery<T = any> = {
     $not: ComparisonQueryOrValue<T>;
 };
-/** Represents an equality comparison query ($eq). */
+/** Represents an equality comparison query. */
 export type ComparisonEqualsQuery<T = any> = {
     $eq: ComparisonValueWithRegex<T>;
 };
-/** Represents a non-equality comparison query ($neq). */
+/** Represents a non-equality comparison query. */
 export type ComparisonNotEqualsQuery<T = any> = {
     $neq: ComparisonValueWithRegex<T>;
 };
-/** Represents an existence check query ($exists). Checks if a field exists (or not). */
+/** Represents an existence check query. Checks if a field exists (or not). */
 export type ComparisonExistsQuery = {
     $exists: ComparisonValue<boolean>;
 };
-/** Represents a query targeting elements within an array field ($item). */
+/** Represents a query targeting elements within an array field. */
 export type ComparisonItemQuery<T = any> = {
     $item: T extends readonly (infer U)[] ? U extends Record ? Query<U> : ComparisonQuery<U> : never;
 };
-/** Represents an "in list" comparison query ($in). Checks if a field value is within a specified array. */
+/** Represents an "in list" comparison query. Checks if a field value is within a specified array. */
 export type ComparisonInQuery<T = any> = {
     $in: readonly ComparisonValueWithRegex<T>[];
 };
-/** Represents a "not in list" comparison query ($nin). Checks if a field value is not within a specified array. */
+/** Represents a "not in list" comparison query. Checks if a field value is not within a specified array. */
 export type ComparisonNotInQuery<T = any> = {
     $nin: readonly ComparisonValueWithRegex<T>[];
 };
-/** Represents an "all elements match" query ($all). Checks if an array field contains all specified values. */
+/** Represents an "all elements match" query. Checks if an array field contains all specified values. */
 export type ComparisonAllQuery<T = any> = {
-    $all: readonly ComparisonValueWithRegex<T>[];
+    $contains: readonly ComparisonValueWithRegex<T>[];
 };
-/** Represents a "greater than" comparison query ($gt). */
+/** Represents a "greater than" comparison query. */
 export type ComparisonGreaterThanQuery<T = any> = {
     $gt: ComparisonValue<T>;
 };
-/** Represents a "greater than or equals" comparison query ($gte). */
+/** Represents a "greater than or equals" comparison query. */
 export type ComparisonGreaterThanOrEqualsQuery<T = any> = {
     $gte: ComparisonValue<T>;
 };
-/** Represents a "less than" comparison query ($lt). */
+/** Represents a "less than" comparison query. */
 export type ComparisonLessThanQuery<T = any> = {
     $lt: ComparisonValue<T>;
 };
-/** Represents a "less than or equals" comparison query ($lte). */
+/** Represents a "less than or equals" comparison query. */
 export type ComparisonLessThanOrEqualsQuery<T = any> = {
     $lte: ComparisonValue<T>;
 };
-/** Represents a regular expression comparison query ($regex). */
+/** Represents a regular expression comparison query. */
 export type ComparisonRegexQuery = {
     $regex: string | RegExp | {
         pattern: string;
@@ -151,14 +151,14 @@ export type ComparisonTrigramQuery = {
 };
 /** Defines the possible spatial relationships for geospatial shape queries. */
 export type GeoShapeRelation = 'intersects' | 'within' | 'disjoint' | 'contains';
-/** Represents a geospatial query based on shape relationships ($geoShape). */
+/** Represents a geospatial query based on shape relationships. */
 export type ComparisonGeoShapeQuery = {
     $geoShape: {
         geometry: Geometry;
         relation: GeoShapeRelation;
     };
 };
-/** Represents a geospatial query based on distance from a point ($geoDistance). */
+/** Represents a geospatial query based on distance from a point. */
 export type ComparisonGeoDistanceQuery = {
     $geoDistance: {
         longitude: number;

package/orm/query/base.js

@@ -2,7 +2,7 @@ import { paradeComparisonQueryTypes, paradeSpecialQueryTypes } from './parade.js
 /** Array containing all valid logical query operator keys. */
 export const allLogicalQueryTypes = ['$and', '$or', '$nor'];
 /** Array containing all valid comparison query operator keys. */
-export const allComparisonQueryTypes = ['$all', '$not', '$eq', '$exists', '$gt', '$gte', '$in', '$item', '$lt', '$lte', '$neq', '$nin', '$regex', '$tsvector', '$trigram', '$geoDistance', '$geoShape', ...paradeComparisonQueryTypes];
+export const allComparisonQueryTypes = ['$contains', '$not', '$eq', '$exists', '$gt', '$gte', '$in', '$item', '$lt', '$lte', '$neq', '$nin', '$regex', '$tsvector', '$trigram', '$geoDistance', '$geoShape', ...paradeComparisonQueryTypes];
 /** Array containing all valid special query operator keys. */
 export const allSpecialQueryTypes = ['$tsvector', '$trigram', ...paradeSpecialQueryTypes];
 /** Array containing all valid query operator keys. */

package/orm/repository.types.d.ts

@@ -7,9 +7,9 @@ import type { Path, Record, SimplifyObject, TypedOmit } from '../types/index.js'
 import type { UntaggedDeep } from '../types/tagged.js';
 import type { AnyColumn, SQL, SQLWrapper } from 'drizzle-orm';
 import type { PartialDeep } from 'type-fest';
-import type { BaseEntity, Entity, EntityMetadata } from './entity.js';
+import type { BaseEntity, Entity, EntityMetadata, EntityType } from './entity.js';
 import type { FullTextSearchQuery, Query } from './query/index.js';
-import type { TsHeadlineOptions } from './sqls.js';
+import type { TsHeadlineOptions } from './sqls/index.js';
 type WithSql<T> = {
     [P in keyof T]: T[P] extends Record ? WithSql<T[P]> : (T[P] | SQL);
 };
@@ -40,12 +40,40 @@ export type Order<T extends BaseEntity> = TargetColumn<T> | (TargetColumn<T> | [
 export type OrderOptions<T extends BaseEntity> = {
     order?: Order<T>;
 };
+export type CountOptions<_T extends BaseEntity> = {
+    /**
+     * Whether to include soft-deleted entities in the count.
+     * @default false
+     */
+    withDeleted?: boolean;
+    for?: LockMode | LockOptions;
+};
+export type HasOptions<_T extends BaseEntity> = {
+    /**
+     * Whether to include soft-deleted entities in the check.
+     * @default false
+     */
+    withDeleted?: boolean;
+};
+export type LockMode = 'update' | 'no key update' | 'share' | 'key share';
+export type LockOptions = {
+    mode: LockMode;
+    skipLocked?: boolean;
+    noWait?: boolean;
+};
 /**
  * Options for loading a single entity, including ordering and offset.
  * @template T - The entity type.
  */
 export type LoadOptions<T extends BaseEntity> = OrderOptions<T> & {
     offset?: number;
+    includeSubclasses?: boolean | EntityType[];
+    /**
+     * Whether to include soft-deleted entities in the results.
+     * @default false
+     */
+    withDeleted?: boolean;
+    for?: LockMode | LockOptions;
 };
 /**
  * Options for loading multiple entities, including ordering, offset, and limit.
@@ -55,6 +83,22 @@ export type LoadManyOptions<T extends BaseEntity> = LoadOptions<T> & {
     limit?: number;
     distinct?: boolean | TargetColumn<T>[];
 };
+/**
+ * Options for delete operations.
+ * @template T - The entity type.
+ */
+export type DeleteOptions<_T extends BaseEntity> = {
+    /**
+     * Whether to include soft-deleted entities (e.g. for hard delete).
+     * @default false
+     */
+    withDeleted?: boolean;
+};
+/**
+ * Options for delete many operations.
+ * @template T - The entity type.
+ */
+export type DeleteManyOptions<T extends BaseEntity> = DeleteOptions<T>;
 /**
  * Options for ranking search results.
  */

package/orm/schemas/tsvector.js

@@ -4,7 +4,7 @@ export class TsVectorSchema extends Schema {
     _test(_value, _path, _options) {
         return {
             valid: false,
-            error: SchemaError.expectedButGot('nothing', 'value', _path, { customMessage: `TSVectorSchema does not support validation as tsvector columns are not directly mapped to application data.` })
+            error: SchemaError.expectedButGot('nothing', 'value', _path, { customMessage: `TSVectorSchema does not support validation as tsvector columns are not directly mapped to application data.` }),
         };
     }
 }

package/orm/server/drizzle/schema-converter.d.ts

@@ -1,5 +1,5 @@
 import { type PgEnum, type PgSchema, type PgTableWithColumns } from 'drizzle-orm/pg-core';
-import type { Enumeration } from '../../../types/index.js';
+import type { AbstractConstructor, Enumeration } from '../../../types/index.js';
 import { type EntityType } from '../../entity.js';
 import type { ColumnDefinition, ColumnDefinitionsMap, PgTableFromType } from '../types.js';
 type ConverterContext = {
@@ -8,7 +8,9 @@ type ConverterContext = {
 };
 export declare const getDrizzleTableFromType: typeof _getDrizzleTableFromType;
 export declare function getColumnDefinitions(table: PgTableWithColumns<any>): ColumnDefinition[];
+export declare function getTableColumnDefinitions(table: PgTableWithColumns<any>): ColumnDefinition[];
 export declare function getColumnDefinitionsMap(table: PgTableWithColumns<any>): ColumnDefinitionsMap;
 export declare function _getDrizzleTableFromType<T extends EntityType, S extends string>(type: T, fallbackSchemaName?: S): PgTableFromType<T, S>;
+export declare function isTableOwning(type: AbstractConstructor): boolean;
 export declare function getPgEnum(schema: string | PgSchema, enumeration: Enumeration, context?: ConverterContext): PgEnum<[string, ...string[]]>;
 export {};