@tstdl/base 0.93.9 → 0.93.11

package/audit/module.d.ts

@@ -1,6 +1,6 @@
 import { type DatabaseConfig } from '../orm/server/index.js';
 /**
- * Configuration for {@link configureAuditServer}.
+ * Configuration for {@link configureAudit}.
  */
 export declare class AuditModuleConfig {
     /**
@@ -13,10 +13,10 @@ export declare class AuditModuleConfig {
  * Configures audit server services.
  * @param config Configuration.
  */
-export declare function configureAuditServer(config: AuditModuleConfig): void;
+export declare function configureAudit(config: AuditModuleConfig): void;
 /**
  * Migrates the audit database schema to the latest version.
- * It uses the database connection provided with {@link configureAuditServer},
+ * It uses the database connection provided with {@link configureAudit},
  * or falls back to the globally configured database if no specific configuration is provided.
  */
 export declare function migrateAuditSchema(): Promise<void>;

package/audit/module.js

@@ -1,7 +1,7 @@
 import { inject, Injector } from '../injector/index.js';
 import { Database, migrate } from '../orm/server/index.js';
 /**
- * Configuration for {@link configureAuditServer}.
+ * Configuration for {@link configureAudit}.
  */
 export class AuditModuleConfig {
     /**
@@ -14,12 +14,12 @@ export class AuditModuleConfig {
  * Configures audit server services.
  * @param config Configuration.
  */
-export function configureAuditServer(config) {
+export function configureAudit(config) {
     Injector.register(AuditModuleConfig, { useValue: config });
 }
 /**
  * Migrates the audit database schema to the latest version.
- * It uses the database connection provided with {@link configureAuditServer},
+ * It uses the database connection provided with {@link configureAudit},
  * or falls back to the globally configured database if no specific configuration is provided.
  */
 export async function migrateAuditSchema() {

package/document-management/api/document-management.api.d.ts

@@ -127,8 +127,8 @@ export declare const documentManagementApiDefinition: {
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
                 date?: import("../../orm/types.js").NumericDate | null | undefined;
-                typeId?: import("../../orm/types.js").Uuid | null | undefined;
                 title?: string | null | undefined;
+                typeId?: import("../../orm/types.js").Uuid | null | undefined;
                 subtitle?: string | null | undefined;
                 summary?: string | null | undefined;
                 comment?: string | null | undefined;
@@ -326,8 +326,8 @@ export declare const documentManagementApiDefinition: {
             parameters: import("../../schema/index.js").ObjectSchema<{
                 id: import("../../orm/types.js").IsPrimaryKey<import("../../orm/types.js").HasDefault<import("../../orm/types.js").Uuid>>;
                 date?: import("../../orm/types.js").NumericDate | null | undefined;
-                typeId?: import("../../orm/types.js").Uuid | null | undefined;
                 title?: string | null | undefined;
+                typeId?: import("../../orm/types.js").Uuid | null | undefined;
                 subtitle?: string | null | undefined;
                 comment?: string | null | undefined;
                 properties?: {
@@ -337,11 +337,11 @@ export declare const documentManagementApiDefinition: {
                         attributes: import("../../orm/types.js").HasDefault<import("../../orm/types.js").Json<import("../../orm/entity.js").EntityMetadataAttributes>>;
                     }> | undefined;
                 }[] | undefined;
+                tags?: string[] | undefined;
                 collections?: {
                     assign?: string[] | undefined;
                     archive?: string[] | undefined;
                 } | undefined;
-                tags?: string[] | undefined;
                 metadata?: Partial<{
                     attributes: import("../../orm/types.js").HasDefault<import("../../orm/types.js").Json<import("../../orm/entity.js").EntityMetadataAttributes>>;
                 }> | undefined;
@@ -527,8 +527,8 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
                 date?: import("../../orm/types.js").NumericDate | null | undefined;
-                typeId?: import("../../orm/types.js").Uuid | null | undefined;
                 title?: string | null | undefined;
+                typeId?: import("../../orm/types.js").Uuid | null | undefined;
                 subtitle?: string | null | undefined;
                 summary?: string | null | undefined;
                 comment?: string | null | undefined;
@@ -726,8 +726,8 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
             parameters: import("../../schema/index.js").ObjectSchema<{
                 id: import("../../orm/types.js").IsPrimaryKey<import("../../orm/types.js").HasDefault<import("../../orm/types.js").Uuid>>;
                 date?: import("../../orm/types.js").NumericDate | null | undefined;
-                typeId?: import("../../orm/types.js").Uuid | null | undefined;
                 title?: string | null | undefined;
+                typeId?: import("../../orm/types.js").Uuid | null | undefined;
                 subtitle?: string | null | undefined;
                 comment?: string | null | undefined;
                 properties?: {
@@ -737,11 +737,11 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
                         attributes: import("../../orm/types.js").HasDefault<import("../../orm/types.js").Json<import("../../orm/entity.js").EntityMetadataAttributes>>;
                     }> | undefined;
                 }[] | undefined;
+                tags?: string[] | undefined;
                 collections?: {
                     assign?: string[] | undefined;
                     archive?: string[] | undefined;
                 } | undefined;
-                tags?: string[] | undefined;
                 metadata?: Partial<{
                     attributes: import("../../orm/types.js").HasDefault<import("../../orm/types.js").Json<import("../../orm/entity.js").EntityMetadataAttributes>>;
                 }> | undefined;

package/document-management/service-models/document.service-model.d.ts

@@ -20,8 +20,8 @@ export declare const updateDocumentCollectionsParametersSchema: import("../../sc
 }>;
 export declare const createDocumentParametersSchema: import("../../schema/index.js").ObjectSchema<{
     date?: import("../../orm/index.js").NumericDate | null | undefined;
-    typeId?: import("../../orm/index.js").Uuid | null | undefined;
     title?: string | null | undefined;
+    typeId?: import("../../orm/index.js").Uuid | null | undefined;
     subtitle?: string | null | undefined;
     summary?: string | null | undefined;
     comment?: string | null | undefined;
@@ -53,8 +53,8 @@ export declare const createDocumentParametersSchema: import("../../schema/index.
 export declare const updateDocumentParametersSchema: import("../../schema/index.js").ObjectSchema<{
     id: import("../../orm/index.js").IsPrimaryKey<import("../../orm/index.js").HasDefault<import("../../orm/index.js").Uuid>>;
     date?: import("../../orm/index.js").NumericDate | null | undefined;
-    typeId?: import("../../orm/index.js").Uuid | null | undefined;
     title?: string | null | undefined;
+    typeId?: import("../../orm/index.js").Uuid | null | undefined;
     subtitle?: string | null | undefined;
     comment?: string | null | undefined;
     properties?: {
@@ -64,11 +64,11 @@ export declare const updateDocumentParametersSchema: import("../../schema/index.
             attributes: import("../../orm/index.js").HasDefault<import("../../orm/index.js").Json<import("../../orm/index.js").EntityMetadataAttributes>>;
         }> | undefined;
     }[] | undefined;
+    tags?: string[] | undefined;
     collections?: {
         assign?: string[] | undefined;
         archive?: string[] | undefined;
     } | undefined;
-    tags?: string[] | undefined;
     metadata?: Partial<{
         attributes: import("../../orm/index.js").HasDefault<import("../../orm/index.js").Json<import("../../orm/index.js").EntityMetadataAttributes>>;
     }> | undefined;

package/injector/decorators.d.ts

@@ -10,6 +10,13 @@ export type InjectableOptions<T, A, C extends Record = Record> = RegistrationOpt
     alias?: OneOrMany<InjectionToken>;
     /** Custom provider. Useful for example if initialization is required */
     provider?: Provider<T, A, C>;
+    /**
+     * Which InjectableOptions to inherit from the parent (class which is extended from).
+     * If true (default), all options are inherited.
+     * If false, no options are inherited.
+     * If array of keys, only the provided options are inherited.
+     */
+    inheritOptions?: boolean | (keyof InjectableOptions<T, A, C>)[];
 };
 export type InjectableOptionsWithoutLifecycle<T, A, C extends Record = Record> = Simplify<TypedOmit<InjectableOptions<T, A, C>, 'lifecycle'>>;
 /**

package/injector/decorators.js

@@ -1,7 +1,8 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { createClassDecorator, createDecorator, reflectionRegistry } from '../reflection/index.js';
 import { toArray } from '../utils/array/array.js';
-import { isDefined, isFunction, isNotNull } from '../utils/type-guards.js';
+import { filterObject } from '../utils/object/object.js';
+import { isArray, isDefined, isFunction, isNotNull } from '../utils/type-guards.js';
 import { Injector } from './injector.js';
 import { injectMetadataSymbol, injectableMetadataSymbol, injectableOptionsSymbol } from './symbols.js';
 /**
@@ -33,20 +34,23 @@ export function Injectable(options = {}) {
             const { alias: aliases, provider, ...registrationOptions } = options;
             const token = data.constructor;
             let mergedRegistationOptions = registrationOptions;
-            if (isNotNull(metadata.parent)) {
+            if (isNotNull(metadata.parent) && (options.inheritOptions != false)) {
                 const parentOptions = reflectionRegistry.getMetadata(metadata.parent)?.data.tryGet(injectableOptionsSymbol);
                 if (isDefined(parentOptions)) {
                     const { alias: _, provider: __, ...parentRegistrationOptions } = parentOptions;
+                    const optionsToInherit = isArray(options.inheritOptions)
+                        ? filterObject(parentRegistrationOptions, (_value, key) => options.inheritOptions.includes(key))
+                        : parentRegistrationOptions;
                     mergedRegistationOptions = {
-                        ...parentRegistrationOptions,
+                        ...optionsToInherit,
                         ...registrationOptions,
-                        providers: [...(parentRegistrationOptions.providers ?? []), ...(registrationOptions.providers ?? [])],
+                        providers: [...(optionsToInherit.providers ?? []), ...(registrationOptions.providers ?? [])],
                         afterResolve: (instance, argument, context) => {
-                            parentRegistrationOptions.afterResolve?.(instance, argument, context);
+                            optionsToInherit.afterResolve?.(instance, argument, context);
                             registrationOptions.afterResolve?.(instance, argument, context);
                         },
                         metadata: {
-                            ...parentRegistrationOptions.metadata,
+                            ...optionsToInherit.metadata,
                             ...registrationOptions.metadata,
                         },
                     };

package/injector/injector.js

@@ -331,8 +331,16 @@ export class Injector {
             const resolutionScoped = registration.options.lifecycle == 'resolution';
             const injectorScoped = registration.options.lifecycle == 'injector';
             const singletonScoped = registration.options.lifecycle == 'singleton';
-            const resolveArgument = argument ?? registration.options.defaultArgument ?? (registration.options.defaultArgumentProvider?.(injector.getResolveContext(resolutionTag, context, chain)));
-            const argumentIdentity = resolveArgumentIdentity(registration, resolveArgument);
+            let resolveArgument = argument ?? registration.options.defaultArgument;
+            if (isUndefined(resolveArgument) && isFunction(registration.options.defaultArgumentProvider)) {
+                try {
+                    resolveArgument = registration.options.defaultArgumentProvider(injector.getResolveContext(resolutionTag, context, chain));
+                }
+                catch (error) {
+                    throw new ResolveError('Error in defaultArgumentProvider.', chain, error);
+                }
+            }
+            const argumentIdentity = resolveArgumentIdentity(registration, resolveArgument, chain);
             if (resolutionScoped && context.resolutionScopedResolutions.hasFlat(token, argumentIdentity)) {
                 return context.resolutionScopedResolutions.getFlat(token, argumentIdentity).value;
             }
@@ -436,7 +444,13 @@ export class Injector {
         if (isDefined(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || isDefined(resolveArgument) || isUndefined(injectToken))) {
             return injectMetadata.injectArgumentMapper(resolveArgument);
         }
-        const parameterResolveArgument = injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(resolutionTag, context, getChain(injectToken)));
+        let parameterResolveArgument;
+        try {
+            parameterResolveArgument = injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(resolutionTag, context, getChain(injectToken)));
+        }
+        catch (error) {
+            throw new ResolveError('Error in parameter argument provider (forwardArgumentMapper or resolveArgumentProvider).', getChain(injectToken), error);
+        }
         const { forwardRef } = injectMetadata;
         if (isDefined(forwardRef) && isDefined(injectMetadata.mapper)) {
             const forwardToken = isFunction(forwardRef) ? forwardRef() : isBoolean(forwardRef) ? injectToken : forwardRef;
@@ -444,7 +458,15 @@ export class Injector {
         }
         const resolveFn = (injectMetadata.resolveAll == true) ? '_resolveAll' : '_resolve';
         const resolved = this[resolveFn](injectToken, parameterResolveArgument, { optional: injectMetadata.optional, forwardRef, forwardRefTypeHint: injectMetadata.forwardRefTypeHint }, context, getChain(injectToken));
-        return isDefined(injectMetadata.mapper) ? injectMetadata.mapper(resolved) : resolved;
+        if (isDefined(injectMetadata.mapper)) {
+            try {
+                return injectMetadata.mapper(resolved);
+            }
+            catch (error) {
+                throw new ResolveError('Error in inject mapper.', getChain(injectToken), error);
+            }
+        }
+        return resolved;
     }
     resolveInjection(token, argument, options, context, injectIndex, chain) {
         return this._resolve(token, argument, options, context, chain.addInject(token, injectIndex));
@@ -546,21 +568,29 @@ function postProcess(context) {
     }
     derefForwardRefs(context);
     for (const resolution of context.resolutions) {
-        for (const afterResolveHandler of resolution.afterResolveRegistrations) {
-            const returnValue = afterResolveHandler(resolution.argument, resolution.afterResolveContext);
-            throwOnPromise(returnValue, 'registerAfterResolve()', resolution.chain);
-        }
-        if (!isTokenProvider(resolution.registration.provider) && isFunction(resolution.value?.[afterResolve])) {
-            const returnValue = resolution.value[afterResolve](resolution.argument, resolution.afterResolveContext);
-            throwOnPromise(returnValue, '[afterResolve]', resolution.chain);
-        }
-        if (isProviderWithInitializer(resolution.registration.provider)) {
-            const returnValue = resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolution.afterResolveContext);
-            throwOnPromise(returnValue, 'provider afterResolve handler', resolution.chain);
+        try {
+            for (const afterResolveHandler of resolution.afterResolveRegistrations) {
+                const returnValue = afterResolveHandler(resolution.argument, resolution.afterResolveContext);
+                throwOnPromise(returnValue, 'registerAfterResolve()', resolution.chain);
+            }
+            if (!isTokenProvider(resolution.registration.provider) && isFunction(resolution.value?.[afterResolve])) {
+                const returnValue = resolution.value[afterResolve](resolution.argument, resolution.afterResolveContext);
+                throwOnPromise(returnValue, '[afterResolve]', resolution.chain);
+            }
+            if (isProviderWithInitializer(resolution.registration.provider)) {
+                const returnValue = resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolution.afterResolveContext);
+                throwOnPromise(returnValue, 'provider afterResolve handler', resolution.chain);
+            }
+            if (isDefined(resolution.registration.options.afterResolve)) {
+                const returnValue = resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolution.afterResolveContext);
+                throwOnPromise(returnValue, 'registration afterResolve handler', resolution.chain);
+            }
         }
-        if (isDefined(resolution.registration.options.afterResolve)) {
-            const returnValue = resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolution.afterResolveContext);
-            throwOnPromise(returnValue, 'registration afterResolve handler', resolution.chain);
+        catch (error) {
+            if (error instanceof ResolveError) {
+                throw error;
+            }
+            throw new ResolveError('Error in afterResolve hook.', resolution.chain, error);
         }
     }
 }
@@ -570,23 +600,36 @@ async function postProcessAsync(context) {
     }
     derefForwardRefs(context);
     for (const resolution of context.resolutions) {
-        for (const afterResolveHandler of resolution.afterResolveRegistrations) {
-            await afterResolveHandler(resolution.argument, resolution.afterResolveContext);
-        }
-        if (!isTokenProvider(resolution.registration.provider) && isFunction(resolution.value?.[afterResolve])) {
-            await resolution.value[afterResolve](resolution.argument, resolution.afterResolveContext);
-        }
-        if (isProviderWithInitializer(resolution.registration.provider)) {
-            await resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolution.afterResolveContext);
+        try {
+            for (const afterResolveHandler of resolution.afterResolveRegistrations) {
+                await afterResolveHandler(resolution.argument, resolution.afterResolveContext);
+            }
+            if (!isTokenProvider(resolution.registration.provider) && isFunction(resolution.value?.[afterResolve])) {
+                await resolution.value[afterResolve](resolution.argument, resolution.afterResolveContext);
+            }
+            if (isProviderWithInitializer(resolution.registration.provider)) {
+                await resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolution.afterResolveContext);
+            }
+            if (isDefined(resolution.registration.options.afterResolve)) {
+                await resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolution.afterResolveContext);
+            }
         }
-        if (isDefined(resolution.registration.options.afterResolve)) {
-            await resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolution.afterResolveContext);
+        catch (error) {
+            if (error instanceof ResolveError) {
+                throw error;
+            }
+            throw new ResolveError('Error in async afterResolve hook.', resolution.chain, error);
         }
     }
 }
-function resolveArgumentIdentity(registration, resolveArgument) {
+function resolveArgumentIdentity(registration, resolveArgument, chain) {
     if (isDefined(registration.options.argumentIdentityProvider) && ((registration.options.lifecycle == 'resolution') || (registration.options.lifecycle == 'singleton'))) {
-        return registration.options.argumentIdentityProvider(resolveArgument);
+        try {
+            return registration.options.argumentIdentityProvider(resolveArgument);
+        }
+        catch (error) {
+            throw new ResolveError('Error in argumentIdentityProvider.', chain, error);
+        }
     }
     return resolveArgument;
 }

package/orm/decorators.d.ts

@@ -5,14 +5,15 @@
 import type { SQL } from 'drizzle-orm';
 import type { LiteralUnion } from 'type-fest';
 import { type SpecificCreateDecoratorOptions } from '../reflection/index.js';
-import type { AbstractConstructor, TypedOmit } from '../types/index.js';
+import type { AbstractConstructor, Record, TypedOmit } from '../types/index.js';
 import type { AnyEntity, Entity, EntityType, EntityWithoutMetadata } from './entity.js';
 import type { Query } from './query.js';
 import type { TargetColumnPaths } from './repository.types.js';
 import type { PgTableFromType } from './server/types.js';
 type IndexMethod = LiteralUnion<'hash' | 'btree' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hnsw' | 'ivfflat', string>;
 type NamingStrategy = 'abbreviated-table';
-type Columns<T> = [Extract<keyof T, string>, ...Extract<keyof T, string>[]];
+type Column<T> = Extract<keyof T, string>;
+type Columns<T> = [Column<T>, ...Column<T>[]];
 /**
  * Builder function type for creating SQL check constraints.
  * @param table The Drizzle table object.
@@ -77,7 +78,7 @@ export type UniqueReflectionData = {
  * @template T The entity type.
  */
 export type IndexReflectionData<T extends Entity | EntityWithoutMetadata = any> = {
-    columns?: (string | [string, 'asc' | 'desc'])[];
+    columns?: (string | [string, 'asc' | 'desc'] | SQL)[];
     order?: 'asc' | 'desc';
     options?: {
         name?: string;
@@ -86,6 +87,22 @@ export type IndexReflectionData<T extends Entity | EntityWithoutMetadata = any>
         unique?: boolean;
         where?: WhereBuilder<T>;
         nulls?: 'first' | 'last';
+        /**
+         * For full-text search indexes (e.g., GIN), specifies the text search configuration language (e.g., 'english').
+         * Can also be a SQL object for dynamic configuration.
+         */
+        language?: string | SQL;
+        /**
+         * For multi-column full-text search indexes, specifies how to create the tsvector.
+         * - 'concat': (Default) Concatenate columns into a single tsvector.
+         * - 'separate': Create a separate tsvector for each column, useful for indexing columns with different languages or weights.
+         */
+        vectors?: 'concat' | 'separate';
+        /**
+         * For multi-column full-text search indexes, specifies weights for columns.
+         * Keys are column names, values are 'A', 'B', 'C', or 'D'.
+         */
+        weights?: Partial<Record<TargetColumnPaths<any>, 'A' | 'B' | 'C' | 'D'>>;
     };
 };
 type CheckReflectionData = {
@@ -104,6 +121,10 @@ export type ForeignKeyReflectionData = {
         naming?: NamingStrategy;
     };
 };
+export type GinIndexOptions<T extends Entity | EntityWithoutMetadata = any> = TypedOmit<NonNullable<IndexReflectionData<T>['options']>, 'using' | 'weights'> & {
+    weights?: Partial<Record<TargetColumnPaths<any>, 'A' | 'B' | 'C' | 'D'>>;
+    language?: string | SQL;
+};
 /**
  * Factory function to create a class decorator for ORM table configuration.
  * Merges provided data with existing ORM reflection data on the class metadata.
@@ -204,6 +225,17 @@ export declare function Index<T extends Entity | EntityWithoutMetadata = any>(op
  * @param options Additional index options.
  */
 export declare function Index<T extends Entity | EntityWithoutMetadata = any>(columns: Columns<T>, options?: IndexReflectionData<T>['options']): ClassDecorator;
+/**
+ * Defines a GIN index on a single column, often for full-text search.
+ * @param options GIN index options. For full-text search, `language` is required.
+ */
+export declare function GinIndex<T extends Entity | EntityWithoutMetadata = any>(options: GinIndexOptions<T>): PropertyDecorator;
+/**
+ * Defines a composite GIN index on multiple columns, often for full-text search.
+ * @param columnsOrSql The columns to include in the index.
+ * @param options GIN index options. For full-text search, providing a `language` is highly recommended.
+ */
+export declare function GinIndex<T extends Entity | EntityWithoutMetadata = any>(columnsOrSql: (Column<T> | SQL)[], options?: GinIndexOptions<T>): ClassDecorator;
 /**
  * Automatically expire records after a certain time to live (TTL) based on the createTimestamp metadata. Requires extension of {@link Entity} instead of {@link EntityWithoutMetadata}.
  * @param ttl Time To Live in milliseconds.

package/orm/decorators.js

@@ -137,6 +137,12 @@ export function Index(columnsOrOptions, options) {
     }
     return createColumnDecorator({ index: { options: columnsOrOptions } });
 }
+export function GinIndex(columnsOrSqlOrOptions, options) {
+    if (isArray(columnsOrSqlOrOptions)) {
+        return createTableDecorator({ index: [{ columns: columnsOrSqlOrOptions, options: { ...options, using: 'gin' } }] });
+    }
+    return createColumnDecorator({ index: { options: { ...columnsOrSqlOrOptions, using: 'gin' } } });
+}
 /**
  * Automatically expire records after a certain time to live (TTL) based on the createTimestamp metadata. Requires extension of {@link Entity} instead of {@link EntityWithoutMetadata}.
  * @param ttl Time To Live in milliseconds.

package/orm/query.d.ts

@@ -1,11 +1,6 @@
-/**
- * @module
- * Defines types for constructing database queries using a MongoDB-like syntax.
- * Supports logical operators, comparison operators, and specialized queries like text search and geospatial queries.
- */
-import type { SQLWrapper } from 'drizzle-orm';
-import type { Flatten, Record } from '../types/index.js';
+import type { SQL, SQLWrapper } from 'drizzle-orm';
 import type { Geometry } from '../types/geo-json.js';
+import type { Flatten, Record } from '../types/index.js';
 import type { UntaggedDeep } from '../types/tagged.js';
 /** Represents a logical query combining multiple sub-queries (e.g., $and, $or, $nor). */
 export type LogicalQuery<T = any> = LogicalAndQuery<T> | LogicalOrQuery<T> | LogicalNorQuery<T>;
@@ -20,13 +15,14 @@ export type ComparisonQueryBody<T = any> = {
 /** Represents either a full comparison query object or a direct value for equality comparison. */
 export type ComparisonQueryOrValue<T = any> = ComparisonQuery<T> | ComparisonValue<T>;
 /** Represents a comparison query using various operators like $eq, $ne, $gt, $in, etc. */
-export type ComparisonQuery<T = any> = Partial<ComparisonAndQuery<T> & ComparisonOrQuery<T> & ComparisonNotQuery<T> & ComparisonEqualsQuery<T> & ComparisonNotEqualsQuery<T> & ComparisonExistsQuery & ComparisonItemQuery<T> & ComparisonInQuery<T> & ComparisonNotInQuery<T> & ComparisonAllQuery<T> & ComparisonGreaterThanQuery<T> & ComparisonGreaterThanOrEqualsQuery<T> & ComparisonLessThanQuery<T> & ComparisonLessThanOrEqualsQuery<T> & ComparisonRegexQuery & ComparisonTextQuery & ComparisonGeoShapeQuery & ComparisonGeoDistanceQuery>;
+export type ComparisonQuery<T = any> = Partial<ComparisonAndQuery<T> & ComparisonOrQuery<T> & ComparisonNotQuery<T> & ComparisonEqualsQuery<T> & ComparisonNotEqualsQuery<T> & ComparisonExistsQuery & ComparisonItemQuery<T> & ComparisonInQuery<T> & ComparisonNotInQuery<T> & ComparisonAllQuery<T> & ComparisonGreaterThanQuery<T> & ComparisonGreaterThanOrEqualsQuery<T> & ComparisonLessThanQuery<T> & ComparisonLessThanOrEqualsQuery<T> & ComparisonRegexQuery & ComparisonFtsQuery & ComparisonGeoShapeQuery & ComparisonGeoDistanceQuery>;
+export type FtsParser = 'raw' | 'plain' | 'phrase' | 'websearch';
 /** Union of keys representing comparison query operators. */
 export type ComparisonQueryTypes = keyof ComparisonQuery;
 /** Array containing all valid comparison query operator keys. */
 export declare const allComparisonQueryTypes: ComparisonQueryTypes[];
-/** Represents specialized query types beyond simple comparisons (e.g., $textSpan). */
-export type SpecialQuery<T = any> = Partial<TextSpanQuery<T>>;
+/** Represents specialized query types beyond simple comparisons. */
+export type SpecialQuery<T = any> = Partial<FullTextSearchQuery<T>>;
 /** Union of keys representing special query operators. */
 export type SpecialQueryTypes = keyof SpecialQuery;
 /** Array containing all valid special query operator keys. */
@@ -42,11 +38,7 @@ export type QueryObject<T> = LogicalQuery<T> | (ComparisonQueryBody<T> & Special
 /** 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: ("$and" | "$or" | "$nor" | "$not" | "$eq" | "$neq" | "$exists" | "$item" | "$in" | "$nin" | "$all" | "$gt" | "$gte" | "$lt" | "$lte" | "$regex" | "$text" | "$geoShape" | "$geoDistance" | "$textSpan")[];
-/** Logical operators used within certain query types like $text. */
-export type Operator = 'and' | 'or';
-/** Array containing all valid logical operators ('and', 'or'). */
-export declare const allOperators: Operator[];
+export declare const allQueryTypes: ("$and" | "$or" | "$nor" | "$not" | "$eq" | "$neq" | "$exists" | "$item" | "$in" | "$nin" | "$all" | "$gt" | "$gte" | "$lt" | "$lte" | "$regex" | "$fts" | "$geoShape" | "$geoDistance")[];
 /** Represents an AND logical query. All sub-queries must be true. */
 export type LogicalAndQuery<T = any> = {
     $and: readonly Query<T>[];
@@ -126,11 +118,24 @@ export type ComparisonRegexQuery = {
         flags: string;
     };
 };
-/** Represents a full-text search query ($text). */
-export type ComparisonTextQuery = {
-    $text: string | {
-        text: string;
-        operator?: Operator;
+/** Represents a full-text search query. */
+export type ComparisonFtsQuery = {
+    $fts: string | {
+        query: string;
+        /**
+         * The search method to use.
+         * - 'vector': (Default) Standard full-text search using tsvector and tsquery.
+         * - 'similarity': Trigram-based similarity search using the pg_trgm extension.
+         */
+        method?: 'vector' | 'similarity';
+        /**
+         * The parser to use for the query. Only applicable for 'vector' method.
+         */
+        parser?: FtsParser;
+        /**
+         * The text search configuration (e.g., 'english', 'simple'). Can also be a SQL object for dynamic configuration. Only applicable for 'vector' method.
+         */
+        language?: string | SQL;
     };
 };
 /** Defines the possible spatial relationships for geospatial shape queries. */
@@ -157,16 +162,46 @@ export type ComparisonGeoDistanceQuery = {
         minDistance?: number;
     };
 };
-/** Defines the modes for text span queries, affecting how multiple field matches are handled. */
-export type TextSpanQueryMode = 'best' | 'most' | 'cross';
-/** Array containing all valid text span query modes. */
-export declare const allTextSpanQueryModes: TextSpanQueryMode[];
-/** Represents a text span query ($textSpan), searching for text across multiple fields. */
-export type TextSpanQuery<T = any> = {
-    $textSpan: {
+/** Represents a full-text search query across one or more fields. Used by the `search` repository method. */
+export type FullTextSearchQuery<T = any> = {
+    $fts: {
         fields: readonly (Extract<keyof T, string>)[];
-        text: string;
-        mode?: TextSpanQueryMode;
-        operator?: Operator;
+        text: string | SQL<string>;
+        /**
+         * The search method to use.
+         * - 'vector': (Default) Standard full-text search using tsvector and tsquery.
+         * - 'trigram': Trigram-based similarity search using the pg_trgm extension.
+         */
+        method?: 'vector' | 'trigram';
+        vector?: {
+            /**
+             * The parser to use for the query. Only applicable for 'vector' method.
+             */
+            parser?: FtsParser;
+            /**
+             * The text search configuration (e.g., 'english', 'simple'). Can also be a SQL object for dynamic configuration. Only applicable for 'vector' method.
+             */
+            language?: string | SQL<string>;
+            /**
+             * Assigns weights to fields for ranking.
+             * Keys are field names from `fields`, values are 'A', 'B', 'C', or 'D'.
+             * Fields without a specified weight will use the default. Only applicable for 'vector' method.
+             */
+            weights?: Partial<Record<Extract<keyof T, string>, 'A' | 'B' | 'C' | 'D'>>;
+        };
+        trigram?: {
+            /**
+             * Type of similarity to use for 'trigram' search.
+             * - 'normal': Standard trigram similarity (default).
+             * - 'word': Word-based similarity.
+             * - 'strict-word': Strict word-based similarity.
+             * @default 'normal'
+             */
+            type?: 'phrase' | 'word' | 'strict-word';
+            /**
+             * Threshold for similarity matching (0 to 1). Only applicable for 'trigram' method.
+             */
+            threshold?: number | SQL<number>;
+        };
     };
 };

package/orm/query.js

@@ -1,12 +1,8 @@
 /** 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', '$text', '$geoDistance', '$geoShape'];
+export const allComparisonQueryTypes = ['$all', '$not', '$eq', '$exists', '$gt', '$gte', '$in', '$item', '$lt', '$lte', '$neq', '$nin', '$regex', '$fts', '$geoDistance', '$geoShape'];
 /** Array containing all valid special query operator keys. */
-export const allSpecialQueryTypes = ['$textSpan'];
+export const allSpecialQueryTypes = ['$fts'];
 /** Array containing all valid query operator keys. */
 export const allQueryTypes = [...allLogicalQueryTypes, ...allComparisonQueryTypes, ...allSpecialQueryTypes];
-/** Array containing all valid logical operators ('and', 'or'). */
-export const allOperators = ['and', 'or'];
-/** Array containing all valid text span query modes. */
-export const allTextSpanQueryModes = ['best', 'most', 'cross'];