@tstdl/base 0.93.10 → 0.93.12

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

@@ -12,6 +12,7 @@ import { assert, isArray, isBoolean, isDefined, isFunction, isNotNull, isNotObje
 import { setCurrentInjectionContext } from './inject.js';
 import { afterResolve } from './interfaces.js';
 import { isClassProvider, isFactoryProvider, isProviderWithInitializer, isTokenProvider, isValueProvider } from './provider.js';
+import { RegistrationError } from './registration.error.js';
 import { runInResolutionContext } from './resolution.js';
 import { ResolveChain } from './resolve-chain.js';
 import { ResolveError } from './resolve.error.js';
@@ -277,7 +278,7 @@ export class Injector {
             return forwardRef;
         }
         if (isUndefined(token)) {
-            throw new ResolveError('Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.', chain);
+            throw new ResolveError('Token is undefined. This might be due to a circular dependency. Consider using an alias or forwardRef.', chain);
         }
         const registration = (options.skipSelf == true) ? undefined : this.tryGetRegistration(token);
         if (isDefined(registration)) {
@@ -302,7 +303,7 @@ export class Injector {
             return forwardRef;
         }
         if (isUndefined(token)) {
-            throw new ResolveError('Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.', chain);
+            throw new ResolveError('Token is undefined. This might be due to a circular dependency. Consider using an alias or forwardRef.', chain);
         }
         const registration = (options.skipSelf == true) ? undefined : this.tryGetRegistration(token);
         if (isDefined(registration)) {
@@ -331,8 +332,11 @@ 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)) {
+                resolveArgument = wrapInResolveError(() => registration.options.defaultArgumentProvider(injector.getResolveContext(resolutionTag, context, chain)), 'Error in defaultArgumentProvider', chain);
+            }
+            const argumentIdentity = resolveArgumentIdentity(registration, resolveArgument, chain);
             if (resolutionScoped && context.resolutionScopedResolutions.hasFlat(token, argumentIdentity)) {
                 return context.resolutionScopedResolutions.getFlat(token, argumentIdentity).value;
             }
@@ -342,9 +346,7 @@ export class Injector {
             else if (singletonScoped && registration.resolutions.has(argumentIdentity)) {
                 return registration.resolutions.get(argumentIdentity);
             }
-            const resolutionContext = {
-                afterResolveRegistrations: [],
-            };
+            const resolutionContext = { afterResolveRegistrations: [] };
             const value = injector._resolveProvider(resolutionTag, registration, resolveArgument, options, context, resolutionContext, injectionContext, chain);
             const resolution = {
                 tag: resolutionTag,
@@ -381,23 +383,16 @@ export class Injector {
                 const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
                 injectionContext.argument = arg;
                 if ((provider.useClass.length > 0) && (isUndefined(typeMetadata) || !typeMetadata.data.has(injectableMetadataSymbol))) {
-                    throw new ResolveError(`${provider.useClass.name} has constructor parameters but is not injectable.`, chain);
+                    throw new ResolveError(`${provider.useClass.name} has constructor parameters but is not decorated with @Injectable.`, chain);
                 }
                 const parameters = (typeMetadata?.parameters ?? []).map((metadata) => this.resolveClassInjection(resolutionTag, context, provider.useClass, metadata, arg, chain));
-                try {
-                    result = { value: runInResolutionContext(resolutionContext, () => Reflect.construct(provider.useClass, parameters)) };
-                }
-                catch (error) {
-                    if (error instanceof ResolveError) {
-                        throw error;
-                    }
-                    throw new ResolveError('Error in class constructor.', chain, error);
-                }
+                const value = wrapInResolveError(() => runInResolutionContext(resolutionContext, () => Reflect.construct(provider.useClass, parameters)), `Error during construction of '${provider.useClass.name}'`, chain);
+                result = { value };
             }
-            if (isValueProvider(provider)) {
+            else if (isValueProvider(provider)) {
                 result = { value: provider.useValue };
             }
-            if (isTokenProvider(provider)) {
+            else if (isTokenProvider(provider)) {
                 const innerToken = (provider.useToken ?? provider.useTokenProvider());
                 const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
                 injectionContext.argument = arg;
@@ -406,17 +401,13 @@ export class Injector {
                 }
                 result = { value: this._resolve(innerToken, arg, options, context, chain.addToken(innerToken)) };
             }
-            if (isFactoryProvider(provider)) {
+            else if (isFactoryProvider(provider)) {
                 const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
                 injectionContext.argument = arg;
-                try {
-                    result = { value: runInResolutionContext(resolutionContext, () => provider.useFactory(arg, this.getResolveContext(resolutionTag, context, chain))) };
-                }
-                catch (error) {
-                    throw new ResolveError('Error in provider factory.', chain, error);
-                }
+                const value = wrapInResolveError(() => runInResolutionContext(resolutionContext, () => provider.useFactory(arg, this.getResolveContext(resolutionTag, context, chain))), 'Error in provider factory', chain);
+                result = { value };
             }
-            if (isUndefined(result)) {
+            else {
                 throw new Error('Unsupported provider.');
             }
             if (isSyncOrAsyncDisposable(result.value) && !this.#disposableStackRegistrations.has(result.value)) {
@@ -434,9 +425,9 @@ export class Injector {
         const injectMetadata = metadata.data.tryGet(injectMetadataSymbol) ?? {};
         const injectToken = (injectMetadata.injectToken ?? metadata.type);
         if (isDefined(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || isDefined(resolveArgument) || isUndefined(injectToken))) {
-            return injectMetadata.injectArgumentMapper(resolveArgument);
+            return wrapInResolveError(() => injectMetadata.injectArgumentMapper(resolveArgument), 'Error in injectArgumentMapper', getChain(injectToken));
         }
-        const parameterResolveArgument = injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(resolutionTag, context, getChain(injectToken)));
+        const parameterResolveArgument = wrapInResolveError(() => injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(resolutionTag, context, getChain(injectToken))), 'Error in parameter argument provider (forwardArgumentMapper or resolveArgumentProvider)', getChain(injectToken));
         const { forwardRef } = injectMetadata;
         if (isDefined(forwardRef) && isDefined(injectMetadata.mapper)) {
             const forwardToken = isFunction(forwardRef) ? forwardRef() : isBoolean(forwardRef) ? injectToken : forwardRef;
@@ -444,7 +435,10 @@ 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)) {
+            return wrapInResolveError(() => injectMetadata.mapper(resolved), 'Error in inject mapper', getChain(injectToken));
+        }
+        return resolved;
     }
     resolveInjection(token, argument, options, context, injectIndex, chain) {
         return this._resolve(token, argument, options, context, chain.addInject(token, injectIndex));
@@ -463,7 +457,7 @@ export class Injector {
         return values;
     }
     getResolveContext(resolutionTag, resolveContext, chain) {
-        const context = {
+        return {
             resolve: (token, argument, options) => this._resolve(token, argument, options ?? {}, resolveContext, chain.addToken(token)),
             resolveAll: (token, argument, options) => this._resolveAll(token, argument, options ?? {}, resolveContext, chain.addToken(token)),
             cancellationSignal: this.#disposeToken,
@@ -472,21 +466,19 @@ export class Injector {
                 return resolveContext.resolutionContextData.get(resolutionTag);
             },
         };
-        return context;
     }
     getAfterResolveContext(resolutionTag, resolveContext) {
-        const context = {
+        return {
             cancellationSignal: this.#disposeToken,
             addDisposeHandler: this.#addDisposeHandler,
             get data() {
                 return resolveContext.resolutionContextData.get(resolutionTag);
             },
         };
-        return context;
     }
     getInjectionContext(resolveContext, resolveArgument, chain) {
         let injectIndex = 0;
-        const context = {
+        return {
             injector: this,
             argument: resolveArgument,
             inject: (token, argument, options) => this.resolveInjection(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
@@ -496,7 +488,6 @@ export class Injector {
             injectAllAsync: async (token, argument, options) => await this.resolveInjectionAllAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
             injectManyAsync: async (...tokens) => await this.resolveManyAsync(...tokens),
         };
-        return context;
     }
     assertNotDisposed() {
         if (this.disposed) {
@@ -511,7 +502,7 @@ function addRegistration(registrations, registration) {
     if (isClassProvider(registration.provider)) {
         const injectable = reflectionRegistry.getMetadata(registration.provider.useClass)?.data.has(injectableMetadataSymbol) ?? false;
         if (!injectable) {
-            throw new Error(`${registration.provider.useClass.name} is not injectable.`);
+            throw new RegistrationError(`${registration.provider.useClass.name} is not decorated with Injectable and cannot be registered.`);
         }
     }
     const multi = registration.options.multi ?? false;
@@ -519,7 +510,8 @@ function addRegistration(registrations, registration) {
     const hasExistingRegistration = isDefined(existingRegistration);
     const existingIsMulti = hasExistingRegistration && isArray(existingRegistration);
     if (hasExistingRegistration && (existingIsMulti != multi)) {
-        throw new Error('Cannot mix multi and non-multi registrations.');
+        const tokenName = getTokenName(registration.token);
+        throw new RegistrationError(`Cannot mix multi and non-multi registrations for token: ${tokenName}.`);
     }
     if (multi && existingIsMulti) {
         existingRegistration.push(registration);
@@ -546,21 +538,31 @@ 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);
-        }
-        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);
+        const { registration, value, argument, afterResolveContext, afterResolveRegistrations, chain } = resolution;
+        const provider = registration.provider;
+        for (const afterResolveHandler of afterResolveRegistrations) {
+            wrapInResolveError(() => {
+                const returnValue = afterResolveHandler(argument, afterResolveContext);
+                throwOnPromise(returnValue, 'registerAfterResolve()', chain);
+            }, 'Error in registered afterResolve handler', chain);
+        }
+        if (!isTokenProvider(provider) && isFunction(value?.[afterResolve])) {
+            wrapInResolveError(() => {
+                const returnValue = value[afterResolve](argument, afterResolveContext);
+                throwOnPromise(returnValue, '[afterResolve] method', chain);
+            }, 'Error in [afterResolve] method', chain);
+        }
+        if (isProviderWithInitializer(provider)) {
+            wrapInResolveError(() => {
+                const returnValue = provider.afterResolve?.(value, argument, afterResolveContext);
+                throwOnPromise(returnValue, 'provider afterResolve handler', chain);
+            }, 'Error in providers afterResolve handler', chain);
+        }
+        if (isDefined(registration.options.afterResolve)) {
+            wrapInResolveError(() => {
+                const returnValue = registration.options.afterResolve(value, argument, afterResolveContext);
+                throwOnPromise(returnValue, 'registration afterResolve handler', resolution.chain);
+            }, `Error in registration afterResolve handler`, chain);
         }
     }
 }
@@ -570,29 +572,31 @@ async function postProcessAsync(context) {
     }
     derefForwardRefs(context);
     for (const resolution of context.resolutions) {
-        for (const afterResolveHandler of resolution.afterResolveRegistrations) {
-            await afterResolveHandler(resolution.argument, resolution.afterResolveContext);
+        const { registration, value, argument, afterResolveContext, afterResolveRegistrations, chain } = resolution;
+        const provider = registration.provider;
+        for (const afterResolveHandler of afterResolveRegistrations) {
+            await wrapInResolveErrorAsync(async () => await afterResolveHandler(argument, afterResolveContext), 'Error in registered async afterResolve handler', chain);
         }
-        if (!isTokenProvider(resolution.registration.provider) && isFunction(resolution.value?.[afterResolve])) {
-            await resolution.value[afterResolve](resolution.argument, resolution.afterResolveContext);
+        if (!isTokenProvider(provider) && isFunction(value?.[afterResolve])) {
+            await wrapInResolveErrorAsync(async () => await value[afterResolve](argument, afterResolveContext), 'Error in async [afterResolve] method', chain);
         }
-        if (isProviderWithInitializer(resolution.registration.provider)) {
-            await resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolution.afterResolveContext);
+        if (isProviderWithInitializer(provider)) {
+            await wrapInResolveErrorAsync(async () => await provider.afterResolve?.(value, argument, afterResolveContext), 'Error in providers async afterResolve handler', chain);
         }
-        if (isDefined(resolution.registration.options.afterResolve)) {
-            await resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolution.afterResolveContext);
+        if (isDefined(registration.options.afterResolve)) {
+            await wrapInResolveErrorAsync(() => registration.options.afterResolve(value, argument, afterResolveContext), 'Error in registration async afterResolve handler', chain);
         }
     }
 }
-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);
+        return wrapInResolveError(() => registration.options.argumentIdentityProvider(resolveArgument), 'Error in argumentIdentityProvider', chain);
     }
     return resolveArgument;
 }
 function setResolving(token, context, chain) {
     if (context.resolving.has(token)) {
-        throw new ResolveError('Circular dependency to itself detected. Please check your registrations and providers. ForwardRef might be a solution.', chain);
+        throw new ResolveError('Circular dependency detected. Use forwardRef for circular dependencies between classes.', chain);
     }
     context.resolving.add(token);
 }
@@ -601,12 +605,12 @@ function deleteResolving(token, context) {
 }
 function throwOnPromise(value, type, chain) {
     if (isPromise(value)) {
-        throw new ResolveError(`Cannot evaluate async ${type} in synchronous resolve, use resolveAsync() instead.`, chain);
+        throw new ResolveError(`Cannot evaluate async ${type} in a synchronous resolve. Use resolveAsync() instead.`, chain);
     }
 }
 function checkOverflow(chain, context) {
     if ((chain.length > 100) || (++context.resolves > 7500)) {
-        throw new ResolveError('Resolve stack overflow. This can happen on circular dependencies with transient lifecycles and self reference. Use scoped or singleton lifecycle or forwardRef instead.', chain);
+        throw new ResolveError('Resolve stack overflow. This may indicate a circular dependency with transient lifecycles. Consider using a scoped or singleton lifecycle, or forwardRef.', chain);
     }
 }
 function derefForwardRefs(context) {
@@ -615,10 +619,31 @@ function derefForwardRefs(context) {
             continue;
         }
         for (const [key, value] of objectEntries(resolution.value)) {
-            if (!context.forwardRefs.has(value)) {
-                continue;
+            if (context.forwardRefs.has(value)) {
+                resolution.value[key] = ForwardRef.deref(value);
             }
-            resolution.value[key] = ForwardRef.deref(value);
         }
     }
 }
+function wrapInResolveError(action, errorMessage, chain) {
+    try {
+        return action();
+    }
+    catch (error) {
+        if (error instanceof ResolveError) {
+            throw error;
+        }
+        throw new ResolveError(errorMessage, chain, error);
+    }
+}
+async function wrapInResolveErrorAsync(action, errorMessage, chain) {
+    try {
+        return await action();
+    }
+    catch (error) {
+        if (error instanceof ResolveError) {
+            throw error;
+        }
+        throw new ResolveError(errorMessage, chain, error);
+    }
+}

package/injector/registration.error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from '../errors/custom.error.js';
+/**
+ * Represents an error that occurs during the provider registration phase.
+ * This indicates a configuration or setup issue, rather than a runtime resolution failure.
+ */
+export declare class RegistrationError extends CustomError {
+    constructor(message: string);
+}

package/injector/registration.error.js

@@ -0,0 +1,11 @@
+import { CustomError } from '../errors/custom.error.js';
+/**
+ * Represents an error that occurs during the provider registration phase.
+ * This indicates a configuration or setup issue, rather than a runtime resolution failure.
+ */
+export class RegistrationError extends CustomError {
+    constructor(message) {
+        super({ message });
+        this.name = 'RegistrationError';
+    }
+}

package/injector/resolve.error.js

@@ -1,12 +1,9 @@
 import { CustomError } from '../errors/custom.error.js';
-import { isDefined } from '../utils/type-guards.js';
 export class ResolveError extends CustomError {
     constructor(message, chain, cause) {
-        const causeMessage = isDefined(cause) ? `\n  cause: ${cause.message}` : '';
         super({
-            message: `${message}${causeMessage}\n  chain: ${chain.format(15)}`,
+            message: `${message}\n  chain: ${chain.format(15)}`,
             cause,
-            stack: cause?.stack,
         });
     }
 }

package/orm/query.d.ts

@@ -166,26 +166,42 @@ export type ComparisonGeoDistanceQuery = {
 export type FullTextSearchQuery<T = any> = {
     $fts: {
         fields: readonly (Extract<keyof T, string>)[];
-        query: string | SQL<string>;
+        text: string | SQL<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<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.
+         * - 'trigram': Trigram-based similarity search using the pg_trgm extension.
          */
-        weights?: Partial<Record<Extract<keyof T, string>, 'A' | 'B' | 'C' | 'D'>>;
+        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/repository.types.d.ts

@@ -3,12 +3,12 @@
  * Defines types used by ORM repositories for operations like loading, updating, and creating entities.
  * Includes types for ordering, loading options, and entity data structures for create/update operations.
  */
-import type { Paths, Record, TypedOmit } from '../types/index.js';
+import type { Paths, Record, SimplifyObject, TypedOmit } from '../types/index.js';
 import type { UntaggedDeep } from '../types/tagged.js';
 import type { SQL, SQLWrapper } from 'drizzle-orm';
 import type { PartialDeep } from 'type-fest';
 import type { Entity, EntityMetadata, EntityWithoutMetadata } from './entity.js';
-import type { Query } from './query.js';
+import type { FullTextSearchQuery, Query } from './query.js';
 import type { TsHeadlineOptions } from './sqls.js';
 type WithSql<T> = {
     [P in keyof T]: T[P] extends Record ? WithSql<T[P]> : (T[P] | SQL);
@@ -84,31 +84,44 @@ export type HighlightOptions<T extends EntityWithoutMetadata> = {
  * Options for the `search` method.
  * @template T - The entity type.
  */
-export type SearchOptions<T extends EntityWithoutMetadata> = Omit<LoadManyOptions<T>, 'order'> & {
+export type SearchOptions<T extends EntityWithoutMetadata> = SimplifyObject<FullTextSearchQuery<T>['$fts'] & TypedOmit<LoadManyOptions<T>, 'order'> & {
     /**
      * An additional filter to apply to the search query.
      */
     filter?: Query<T>;
+    /**
+     * How to order the search results.
+     */
+    order?: Order<T> | ((columns: {
+        score: SQL | SQL.Aliased<number>;
+    }) => Order<T>);
+    /**
+     * Whether to include a relevance score with each result. Only applicable for vector searches.
+     * - If `true`, the default score is included.
+     * - If a function is provided, it customizes the score calculation using the original score.
+     * - If no order is specified, results are ordered by score descending, when score is enabled.
+     * @default true
+     */
+    score?: boolean | ((originalScore: SQL<number>) => SQL<number>);
     /**
      * Enable and configure ranking of search results.
      * - If `true` (default), results are ordered by score descending using default ranking options.
      * - If an `RankOptions` object is provided, ranking is customized.
-     * - If an `SQL` object is provided, it's used as a custom scoring expression.
      * @default true
      */
-    rank?: boolean | RankOptions | SQL;
+    rank?: boolean | RankOptions;
     /**
      * Enable and configure highlighting of search results.
      */
     highlight?: TargetColumnPaths<T> | SQL<string> | HighlightOptions<T>;
-};
+}>;
 /**
  * Represents a single result from a full-text search operation.
  * @template T - The entity type.
  */
 export type SearchResult<T extends EntityWithoutMetadata> = {
     entity: T;
-    score: number;
+    score?: number;
     highlight?: string;
 };
 /**

package/orm/server/query-converter.d.ts

@@ -17,4 +17,4 @@ import type { ColumnDefinition, PgTableFromType } from './types.js';
 export declare function convertQuery(query: Query, table: PgTableFromType, columnDefinitionsMap: Map<string, ColumnDefinition>): SQL;
 export declare function getTsQuery(text: string | SQL, language: string | SQL, parser: FtsParser): SQL;
 export declare function getTsVector(fields: readonly string[], language: string | SQL, table: PgTableFromType, columnDefinitionsMap: Map<string, ColumnDefinition>, weights?: Partial<Record<string, 'A' | 'B' | 'C' | 'D'>>): SQL;
-export declare function getSimilaritySearchExpression(fields: readonly string[], table: PgTableFromType, columnDefinitionsMap: Map<string, ColumnDefinition>): SQL;
+export declare function getColumnConcatenation(fields: readonly string[], table: PgTableFromType, columnDefinitionsMap: Map<string, ColumnDefinition>): SQL;

package/orm/server/query-converter.js

@@ -61,13 +61,13 @@ export function convertQuery(query, table, columnDefinitionsMap) {
                 const method = ftsQuery.method ?? 'vector';
                 const sqlValue = match(method)
                     .with('vector', () => {
-                    const tsquery = getTsQuery(ftsQuery.query, ftsQuery.language ?? 'simple', ftsQuery.parser ?? 'raw');
-                    const tsvector = getTsVector(ftsQuery.fields, ftsQuery.language ?? 'simple', table, columnDefinitionsMap, ftsQuery.weights);
+                    const tsquery = getTsQuery(ftsQuery.text, ftsQuery.vector?.language ?? 'simple', ftsQuery.vector?.parser ?? 'raw');
+                    const tsvector = getTsVector(ftsQuery.fields, ftsQuery.vector?.language ?? 'simple', table, columnDefinitionsMap, ftsQuery.vector?.weights);
                     return sql `${tsvector} @@ ${tsquery}`;
                 })
-                    .with('similarity', () => {
-                    const searchExpression = getSimilaritySearchExpression(ftsQuery.fields, table, columnDefinitionsMap);
-                    return isSimilar(searchExpression, ftsQuery.query);
+                    .with('trigram', () => {
+                    const searchExpression = getColumnConcatenation(ftsQuery.fields, table, columnDefinitionsMap);
+                    return isSimilar(searchExpression, ftsQuery.text);
                 })
                     .exhaustive();
                 conditions.push(sqlValue);
@@ -214,10 +214,10 @@ export function getTsVector(fields, language, table, columnDefinitionsMap, weigh
     }), sql ` || `);
     return tsvector;
 }
-export function getSimilaritySearchExpression(fields, table, columnDefinitionsMap) {
+export function getColumnConcatenation(fields, table, columnDefinitionsMap) {
     const columns = fields.map((field) => {
         const columnDef = assertDefinedPass(columnDefinitionsMap.get(field), `Could not map property ${field} to column.`);
         return table[columnDef.name];
     });
-    return sql.join(columns, sql ` || ' ' || `);
+    return sql `(${sql.join(columns, sql ` || ' ' || `)})`;
 }

package/orm/server/repository.d.ts

@@ -1,10 +1,10 @@
 import { SQL } from 'drizzle-orm';
-import type { PgColumn, PgInsertValue, PgUpdateSetSource } from 'drizzle-orm/pg-core';
+import type { PgColumn, PgInsertValue, PgSelectBuilder, PgUpdateSetSource, SelectedFields } from 'drizzle-orm/pg-core';
 import { afterResolve, resolveArgumentType, type Resolvable } from '../../injector/interfaces.js';
-import type { DeepPartial, OneOrMany, Paths, Type, UntaggedDeep } from '../../types/index.js';
+import type { DeepPartial, Function, OneOrMany, Paths, Record, Type, UntaggedDeep } from '../../types/index.js';
 import { Entity, type EntityMetadataAttributes, type EntityType, type EntityWithoutMetadata } from '../entity.js';
 import type { FullTextSearchQuery, Query } from '../query.js';
-import type { EntityMetadataUpdate, EntityUpdate, LoadManyOptions, LoadOptions, NewEntity, Order, SearchOptions, SearchResult, TargetColumnPaths } from '../repository.types.js';
+import type { EntityMetadataUpdate, EntityUpdate, LoadManyOptions, LoadOptions, NewEntity, Order, SearchOptions, SearchResult, TargetColumn, TargetColumnPaths } from '../repository.types.js';
 import type { Database } from './database.js';
 import type { PgTransaction } from './transaction.js';
 import { Transactional } from './transactional.js';
@@ -40,6 +40,8 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
     [afterResolve](): void;
     private expirationLoop;
     protected getTransactionalContextData(): EntityRepositoryContext;
+    vectorSearch(options: SearchOptions<T>): Promise<SearchResult<T>[]>;
+    trigramSearch(options: SearchOptions<T>): Promise<SearchResult<T>[]>;
     /**
      * Performs a full-text search and returns entities ranked by relevance.
      * This method is a convenience wrapper around `loadManyByQuery` with the `$fts` operator.
@@ -47,7 +49,7 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
      * @param options Search options including ranking, and highlighting configuration.
      * @returns A promise that resolves to an array of search results, including the entity, score, and optional highlight.
      */
-    search(query: FullTextSearchQuery<T>['$fts'], options?: SearchOptions<T>): Promise<SearchResult<T>[]>;
+    search(_query: FullTextSearchQuery<T>['$fts'], _options?: SearchOptions<T>): Promise<SearchResult<T>[]>;
     /**
      * Loads a single entity by its ID.
      * Throws `NotFoundError` if the entity is not found.
@@ -445,6 +447,8 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
             generated: undefined;
         }, {}, {}>;
     }>, "limit" | "where">;
+    applySelect<TApplyTo extends Record<'select' | 'selectDistinct' | 'selectDistinctOn', Function<any[], PgSelectBuilder<any, any>>>>(applyTo: TApplyTo, distinct?: boolean | TargetColumn<T>[]): PgSelectBuilder<undefined, ReturnType<TApplyTo['selectDistinct']> extends PgSelectBuilder<any, infer TResult> ? TResult : never>;
+    applySelect<TApplyTo extends Record<'select' | 'selectDistinct' | 'selectDistinctOn', Function<any[], PgSelectBuilder<any, any>>>, TSelection extends SelectedFields>(applyTo: TApplyTo, selection: TSelection, distinct?: boolean | TargetColumn<T>[]): PgSelectBuilder<TSelection, ReturnType<TApplyTo['selectDistinct']> extends PgSelectBuilder<any, infer TResult> ? TResult : never>;
     protected getAttributesUpdate(attributes: SQL | EntityMetadataAttributes | undefined): SQL<unknown> | undefined;
     protected _mapManyToEntity(columns: InferSelect[], transformContext: TransformContext): Promise<T[]>;
     protected _mapToEntity(columns: InferSelect, transformContext: TransformContext): Promise<T>;

package/orm/server/repository.js

@@ -8,7 +8,7 @@ import { and, asc, count, desc, eq, inArray, isNull, isSQLWrapper, lte, or, SQL,
 import { match, P } from 'ts-pattern';
 import { CancellationSignal } from '../../cancellation/token.js';
 import { NotFoundError } from '../../errors/not-found.error.js';
-import { NotSupportedError } from '../../errors/not-supported.error.js';
+import { NotImplementedError } from '../../errors/not-implemented.error.js';
 import { Singleton } from '../../injector/decorators.js';
 import { inject, injectArgument } from '../../injector/inject.js';
 import { afterResolve, resolveArgumentType } from '../../injector/interfaces.js';
@@ -20,16 +20,17 @@ import { importSymmetricKey } from '../../utils/cryptography.js';
 import { fromDeepObjectEntries, fromEntries, objectEntries } from '../../utils/object/object.js';
 import { cancelableTimeout } from '../../utils/timing.js';
 import { tryIgnoreAsync } from '../../utils/try-ignore.js';
-import { assertDefined, assertDefinedPass, isArray, isBoolean, isDefined, isInstanceOf, isString, isUndefined } from '../../utils/type-guards.js';
+import { assertDefined, assertDefinedPass, isArray, isBoolean, isDefined, isFunction, isInstanceOf, isString, isUndefined } from '../../utils/type-guards.js';
 import { typeExtends } from '../../utils/type/index.js';
 import { millisecondsPerSecond } from '../../utils/units.js';
 import { Entity } from '../entity.js';
-import { isSimilar, similarity, TRANSACTION_TIMESTAMP, tsHeadline, tsRankCd } from '../sqls.js';
+import { TRANSACTION_TIMESTAMP, tsHeadline, tsRankCd } from '../sqls.js';
 import { getColumnDefinitions, getColumnDefinitionsMap, getDrizzleTableFromType } from './drizzle/schema-converter.js';
-import { convertQuery, getSimilaritySearchExpression, getTsQuery, getTsVector } from './query-converter.js';
+import { convertQuery, getColumnConcatenation, getTsQuery, getTsVector } from './query-converter.js';
 import { ENCRYPTION_SECRET } from './tokens.js';
 import { getTransactionalContextData, injectTransactional, injectTransactionalAsync, isInTransactionalContext, Transactional } from './transactional.js';
 const searchScoreColumn = '__tsl_score';
+const searchDistanceColumn = '__tsl_distance';
 const searchHighlightColumn = '__tsl_highlight';
 export const repositoryType = Symbol('repositoryType');
 /**
@@ -95,97 +96,59 @@ let EntityRepository = class EntityRepository extends Transactional {
         };
         return context;
     }
-    /**
-     * Performs a full-text search and returns entities ranked by relevance.
-     * This method is a convenience wrapper around `loadManyByQuery` with the `$fts` operator.
-     * @param query The search query using the `$fts` operator.
-     * @param options Search options including ranking, and highlighting configuration.
-     * @returns A promise that resolves to an array of search results, including the entity, score, and optional highlight.
-     */
-    async search(query, options) {
-        const { method = 'vector' } = query;
-        let whereClause;
-        let rankExpression;
-        let highlightExpression;
-        const rankEnabled = options?.rank ?? true;
-        match(method)
-            .with('similarity', () => {
-            if (isDefined(query.weights) || isDefined(query.parser) || isDefined(options?.highlight)) {
-                throw new NotSupportedError('`weights`, `parser`, and `highlight` are not applicable to similarity search.');
-            }
-            const searchExpression = getSimilaritySearchExpression(query.fields, this.table, this.#columnDefinitionsMap);
-            whereClause = isSimilar(searchExpression, query.query);
-            if (rankEnabled) {
-                rankExpression = isInstanceOf(options?.rank, SQL)
-                    ? options.rank
-                    : similarity(searchExpression, query.query);
-            }
-        })
-            .with('vector', () => {
-            const { language = 'simple' } = query;
-            const languageSql = isString(language) ? language : sql `${language}`;
-            const tsquery = getTsQuery(query.query, languageSql, query.parser ?? 'raw');
-            const tsvector = getTsVector(query.fields, languageSql, this.table, this.#columnDefinitionsMap, query.weights);
-            whereClause = sql `${tsvector} @@ ${tsquery}`;
-            if (rankEnabled) {
-                if (isInstanceOf(options?.rank, SQL)) {
-                    rankExpression = options.rank;
-                }
-                else {
-                    const rankOptions = isBoolean(options?.rank) ? undefined : options?.rank;
-                    rankExpression = tsRankCd(tsvector, tsquery, rankOptions);
-                }
-            }
-            if (isDefined(options?.highlight)) {
-                const { source, ...headlineOptions } = (isString(options.highlight) || isInstanceOf(options.highlight, SQL))
-                    ? { source: options.highlight }
-                    : options.highlight;
-                const document = match(source)
-                    .with(P.instanceOf(SQL), (s) => s)
-                    .otherwise((paths) => {
-                    const columns = this.getColumns(paths);
-                    return sql.join(columns, sql ` || ' ' || `);
-                });
-                highlightExpression = tsHeadline(languageSql, document, tsquery, headlineOptions);
-            }
-        })
-            .exhaustive();
-        if (isDefined(options?.filter)) {
-            const filter = this.convertQuery(options.filter);
-            whereClause = and(whereClause, filter);
-        }
+    async vectorSearch(options) {
+        const { vector: { language = 'simple' } = {} } = options;
+        const languageSql = isString(language) ? language : sql `${language}`;
+        const tsquery = getTsQuery(options.text, languageSql, options.vector?.parser ?? 'raw');
+        const tsvector = getTsVector(options.fields, languageSql, this.table, this.#columnDefinitionsMap, options.vector?.weights);
+        const rawScore = (options.score != false) ? tsRankCd(tsvector, tsquery, isBoolean(options.rank) ? undefined : options.rank) : undefined;
+        const score = (isFunction(options.score) ? options.score(rawScore) : rawScore)?.as(searchScoreColumn);
+        const vectorClause = sql `${tsvector} @@ ${tsquery}`;
         const selection = fromEntries(this.#columnDefinitions.map((column) => [column.name, this.getColumn(column)]));
-        if (isDefined(rankExpression)) {
-            selection[searchScoreColumn] = rankExpression.as(searchScoreColumn);
+        if (isDefined(score)) {
+            selection[searchScoreColumn] = score;
         }
-        if (isDefined(highlightExpression)) {
-            selection[searchHighlightColumn] = highlightExpression.as(searchHighlightColumn);
+        if (isDefined(options.highlight)) {
+            const { source, ...headlineOptions } = (isString(options.highlight) || isInstanceOf(options.highlight, SQL))
+                ? { source: options.highlight }
+                : options.highlight;
+            const document = match(source)
+                .with(P.instanceOf(SQL), (s) => s)
+                .otherwise((paths) => {
+                const columns = this.getColumns(paths);
+                return sql.join(columns, sql ` || ' ' || `);
+            });
+            selection[searchHighlightColumn] = tsHeadline(languageSql, document, tsquery, headlineOptions).as(searchHighlightColumn);
         }
-        let dbQuery = match(options?.distinct ?? false)
-            .with(false, () => this.session.select(selection))
-            .with(true, () => this.session.selectDistinct(selection))
-            .otherwise((targets) => {
-            const ons = targets.map((target) => isString(target) ? this.getColumn(target) : target);
-            return this.session.selectDistinctOn(ons, selection);
-        })
+        const whereClause = isDefined(options.filter)
+            ? and(this.convertQuery(options.filter), vectorClause)
+            : vectorClause;
+        let dbQuery = this
+            .applySelect(this.session, selection, options.distinct)
             .from(this.#table)
             .where(whereClause)
             .$dynamic();
-        if (isDefined(options?.offset)) {
+        if (isDefined(options.offset)) {
             dbQuery = dbQuery.offset(options.offset);
         }
-        if (isDefined(options?.limit)) {
+        if (isDefined(options.limit)) {
             dbQuery = dbQuery.limit(options.limit);
         }
-        if (rankEnabled) {
-            const orderByExpressions = [];
-            if (isArray(options?.distinct)) {
-                const ons = options.distinct.map((target) => isString(target) ? this.getColumn(target) : target.getSQL());
-                orderByExpressions.push(...ons);
-            }
-            orderByExpressions.push(desc(sql.identifier(searchScoreColumn)));
-            dbQuery = dbQuery.orderBy(...orderByExpressions);
+        const orderByExpressions = [];
+        if (isDefined(options.order)) {
+            const order = isFunction(options.order)
+                ? options.order({
+                    get score() {
+                        return assertDefinedPass(score, 'Score is disabled.');
+                    },
+                })
+                : options.order;
+            orderByExpressions.push(...this.convertOrderBy(order));
         }
+        else if (isDefined(score)) {
+            orderByExpressions.push(desc(score));
+        }
+        dbQuery = dbQuery.orderBy(...orderByExpressions);
         const transformContext = await this.getTransformContext();
         const rows = await dbQuery;
         return await toArrayAsync(mapAsync(rows, async ({ [searchScoreColumn]: score, [searchHighlightColumn]: highlight, ...row }) => ({
@@ -194,6 +157,67 @@ let EntityRepository = class EntityRepository extends Transactional {
             highlight: highlight,
         })));
     }
+    async trigramSearch(options) {
+        const distanceOperator = match(options.trigram?.type ?? 'phrase')
+            .with('phrase', () => '<->')
+            .with('word', () => '<<->')
+            .with('strict-word', () => '<<<->')
+            .exhaustive();
+        const distanceThresholdOperator = match(options.trigram?.type ?? 'phrase')
+            .with('phrase', () => '%')
+            .with('word', () => '<%')
+            .with('strict-word', () => '<<%')
+            .exhaustive();
+        // TODO: set similarity_threshold, word_similarity_threshold, strict_word_similarity_threshold
+        const searchExpression = getColumnConcatenation(options.fields, this.table, this.#columnDefinitionsMap);
+        const distance = sql `(${options.text} ${sql.raw(distanceOperator)} ${searchExpression})`.as(searchDistanceColumn);
+        const trigramClause = sql `(${options.text} ${sql.raw(distanceThresholdOperator)} ${searchExpression})`;
+        const selection = fromEntries(this.#columnDefinitions.map((column) => [column.name, this.getColumn(column)]));
+        selection[searchDistanceColumn] = distance;
+        const whereClause = isDefined(options.filter)
+            ? and(this.convertQuery(options.filter), trigramClause)
+            : trigramClause;
+        let dbQuery = this
+            .applySelect(this.session, selection, options.distinct)
+            .from(this.#table)
+            .where(whereClause)
+            .$dynamic();
+        if (isDefined(options.offset)) {
+            dbQuery = dbQuery.offset(options.offset);
+        }
+        if (isDefined(options.limit)) {
+            dbQuery = dbQuery.limit(options.limit);
+        }
+        const orderByExpressions = [];
+        if (isDefined(options.order)) {
+            const order = isFunction(options.order)
+                ? options.order({ score: sql `1 - ${distance}` })
+                : options.order;
+            orderByExpressions.push(...this.convertOrderBy(order));
+        }
+        else if (options.rank != false) {
+            orderByExpressions.push(distance);
+        }
+        dbQuery = dbQuery.orderBy(...orderByExpressions);
+        console.log(dbQuery.toSQL());
+        const transformContext = await this.getTransformContext();
+        const rows = await dbQuery;
+        return await toArrayAsync(mapAsync(rows, async ({ [searchDistanceColumn]: distance, [searchHighlightColumn]: highlight, ...row }) => ({
+            entity: await this._mapToEntity(row, transformContext),
+            score: (1 - distance),
+            highlight: highlight,
+        })));
+    }
+    /**
+     * Performs a full-text search and returns entities ranked by relevance.
+     * This method is a convenience wrapper around `loadManyByQuery` with the `$fts` operator.
+     * @param query The search query using the `$fts` operator.
+     * @param options Search options including ranking, and highlighting configuration.
+     * @returns A promise that resolves to an array of search results, including the entity, score, and optional highlight.
+     */
+    async search(_query, _options) {
+        throw new NotImplementedError('EntityRepository.search is not implemented yet.');
+    }
     /**
      * Loads a single entity by its ID.
      * Throws `NotFoundError` if the entity is not found.
@@ -288,13 +312,7 @@ let EntityRepository = class EntityRepository extends Transactional {
      */
     async loadManyByQuery(query, options) {
         const sqlQuery = this.convertQuery(query);
-        let dbQuery = match(options?.distinct ?? false)
-            .with(false, () => this.session.select())
-            .with(true, () => this.session.selectDistinct())
-            .otherwise((targets) => {
-            const ons = targets.map((target) => isString(target) ? this.getColumn(target) : target);
-            return this.session.selectDistinctOn(ons);
-        })
+        let dbQuery = this.applySelect(this.session, options?.distinct)
             .from(this.#table)
             .where(sqlQuery)
             .$dynamic();
@@ -957,6 +975,19 @@ let EntityRepository = class EntityRepository extends Transactional {
             .where(sqlQuery)
             .limit(1);
     }
+    applySelect(applyTo, selectionOrDistinct, distinctOrNothing) {
+        const firstParameterIsDistinct = isBoolean(selectionOrDistinct) || isArray(selectionOrDistinct);
+        const selection = firstParameterIsDistinct ? undefined : selectionOrDistinct;
+        const distinct = firstParameterIsDistinct ? selectionOrDistinct : distinctOrNothing;
+        const selectBuilder = match(distinct ?? false)
+            .with(false, () => applyTo.select(selection))
+            .with(true, () => applyTo.selectDistinct(selection))
+            .otherwise((targets) => {
+            const ons = targets.map((target) => isString(target) ? this.getColumn(target) : target);
+            return applyTo.selectDistinctOn(ons, selection);
+        });
+        return selectBuilder;
+    }
     getAttributesUpdate(attributes) {
         if (isUndefined(attributes)) {
             return undefined;

package/orm/sqls.d.ts

@@ -116,7 +116,9 @@ export declare function greatest<T extends (Column | SQL | number)[]>(...values:
     [P in keyof T]: T[P] extends number ? Exclude<T[P], number> | SQL<number> : T[P];
 }[number]>>;
 export declare function greatest<T>(...values: T[]): SQL<SelectResultField<T>>;
-export declare function toTsVector(language: string | SQL, column: Column | SQLChunk): SQL<string>;
+export declare function unnest<T>(array: SQL<readonly T[]>): SQL<T>;
+export declare function toTsVector(language: string | SQL, text: string | Column | SQLChunk): SQL<string>;
+export declare function tsvectorToArray(tsvector: SQL): SQL<string[]>;
 /**
  * Creates a PostgreSQL `to_tsquery` function call.
  * This function parses text into a tsquery, respecting operators like & (AND), | (OR), and ! (NOT).
@@ -183,7 +185,7 @@ export declare function tsRankCd(tsvector: SQL, tsquery: SQL, options?: {
  * Cross-Site Scripting (XSS) vulnerabilities. Ensure the `document` content is
  * properly sanitized before rendering it in a browser if it comes from an untrusted source.
  */
-export declare function tsHeadline(language: string | SQL, document: string | SQL | AnyColumn, tsquery: SQL, options?: TsHeadlineOptions): SQL<string>;
+export declare function tsHeadline(language: string | SQL, document: string | SQL | SQL.Aliased | AnyColumn, tsquery: SQL, options?: TsHeadlineOptions): SQL<string>;
 /**
  * Creates a PostgreSQL `similarity` function call (from pg_trgm extension).
  * Calculates the similarity between two strings based on trigram matching.
@@ -191,7 +193,15 @@ export declare function tsHeadline(language: string | SQL, document: string | SQ
  * @param right The second text value or expression to compare against.
  * @returns A Drizzle SQL object representing the similarity score (0 to 1).
  */
-export declare function similarity(left: string | SQL | AnyColumn, right: string | SQL | AnyColumn): SQL<number>;
+export declare function similarity(left: string | SQL | SQL.Aliased | AnyColumn, right: string | SQL | SQL.Aliased | AnyColumn): SQL<number>;
+/**
+ * Creates a PostgreSQL `word_similarity` function call (from pg_trgm extension).
+ * Calculates the word similarity between two strings based on trigram matching.
+ * @param left The first text column or expression.
+ * @param right The second text value or expression to compare against.
+ * @returns A Drizzle SQL object representing the similarity score (0 to 1).
+ */
+export declare function wordSimilarity(left: string | SQL | SQL.Aliased | AnyColumn, right: string | SQL | SQL.Aliased | AnyColumn): SQL<number>;
 /**
  * Creates a PostgreSQL `%` operator call (from pg_trgm extension) for similarity check.
  * Returns true if the similarity between the two arguments is greater than the current similarity threshold.
@@ -199,7 +209,7 @@ export declare function similarity(left: string | SQL | AnyColumn, right: string
  * @param right The text value or expression to compare against.
  * @returns A Drizzle SQL object representing a boolean similarity check.
  */
-export declare function isSimilar(left: string | SQL | AnyColumn, right: string | SQL | AnyColumn): SQL<boolean>;
+export declare function isSimilar(left: string | SQL | SQL.Aliased | AnyColumn, right: string | SQL | SQL.Aliased | AnyColumn): SQL<boolean>;
 /**
  * Creates a PostgreSQL `<->` operator call (from pg_trgm extension) for similarity distance.
  * Returns the "distance" between the arguments, that is one minus the similarity() value.
@@ -208,4 +218,4 @@ export declare function isSimilar(left: string | SQL | AnyColumn, right: string
  * @param right The text value or expression to compare against.
  * @returns A Drizzle SQL object representing the similarity distance.
  */
-export declare function similarityDistance(left: string | SQL | AnyColumn, right: string | SQL | AnyColumn): SQL<number>;
+export declare function similarityDistance(left: string | SQL | SQL.Aliased | AnyColumn, right: string | SQL | SQL.Aliased | AnyColumn): SQL<number>;

package/orm/sqls.js

@@ -95,11 +95,17 @@ export function greatest(...values) {
     const sqlValues = values.map((value) => isNumber(value) ? sql.raw(String(value)) : value);
     return sql `greatest(${sql.join(sqlValues, sql.raw(', '))})`;
 }
+export function unnest(array) {
+    return sql `unnest(${array})`;
+}
 function getLanguageSql(language) {
     return isString(language) ? sql `'${sql.raw(language)}'` : sql `${language}`;
 }
-export function toTsVector(language, column) {
-    return sql `to_tsvector(${getLanguageSql(language)}, ${column})`;
+export function toTsVector(language, text) {
+    return sql `to_tsvector(${getLanguageSql(language)}, ${text})`;
+}
+export function tsvectorToArray(tsvector) {
+    return sql `tsvector_to_array(${tsvector})`;
 }
 /**
  * Creates a PostgreSQL `to_tsquery` function call.
@@ -205,6 +211,18 @@ export function similarity(left, right) {
     const rightSql = isString(right) ? sql `${right}` : right;
     return sql `similarity(${leftSql}, ${rightSql})`;
 }
+/**
+ * Creates a PostgreSQL `word_similarity` function call (from pg_trgm extension).
+ * Calculates the word similarity between two strings based on trigram matching.
+ * @param left The first text column or expression.
+ * @param right The second text value or expression to compare against.
+ * @returns A Drizzle SQL object representing the similarity score (0 to 1).
+ */
+export function wordSimilarity(left, right) {
+    const leftSql = isString(left) ? sql `${left}` : left;
+    const rightSql = isString(right) ? sql `${right}` : right;
+    return sql `word_similarity(${leftSql}, ${rightSql})`;
+}
 /**
  * Creates a PostgreSQL `%` operator call (from pg_trgm extension) for similarity check.
  * Returns true if the similarity between the two arguments is greater than the current similarity threshold.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.10",
+  "version": "0.93.12",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -162,7 +162,7 @@
     }
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin": "5.4",
+    "@stylistic/eslint-plugin": "5.5",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.7",
     "@types/mjml": "4.7",
@@ -171,7 +171,7 @@
     "@types/pg": "8.15",
     "concurrently": "9.2",
     "drizzle-kit": "0.31",
-    "eslint": "9.37",
+    "eslint": "9.38",
     "globals": "16.4",
     "tsc-alias": "1.8",
     "typedoc-github-wiki-theme": "2.1",

package/test/test.model.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { EntityWithoutMetadata, GinIndex, Table } from '../orm/index.js';
+import { EntityWithoutMetadata, GinIndex, Index, Table } from '../orm/index.js';
 import { StringProperty } from '../schema/index.js';
 let Test = class Test extends EntityWithoutMetadata {
     title;

package/test1.js

@@ -41,10 +41,13 @@ async function bootstrap() {
 }
 async function main(_cancellationSignal) {
     const repository = injectRepository(Test);
-    // await repository.insertMany(testData);
-    const result = await repository.search({
+    if (await repository.count() == 0) {
+        await repository.insertMany(testData);
+    }
+    const result = await repository.trigramSearch({
         fields: ['title', 'content', 'tags'],
-        query: 'smoothie',
+        text: 'Optimizing PostgreSQL Full-Text Search with GIN Indexes A deep dive into GIN index performance.',
+        trigram: { type: 'phrase', threshold: 0.1 },
     });
     console.log(result);
 }

package/test2.d.ts

@@ -0,0 +1 @@
+export {};

package/test2.js

@@ -0,0 +1,32 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { inject, Singleton } from './injector/index.js';
+import { Application } from './application/application.js';
+import { provideModule } from './application/providers.js';
+import { PrettyPrintLogFormatter, provideConsoleLogTransport } from './logger/index.js';
+let Foo = class Foo {
+    bar = inject(Bar);
+};
+Foo = __decorate([
+    Singleton()
+], Foo);
+let Bar = class Bar {
+};
+Bar = __decorate([
+    Singleton({
+        argumentIdentityProvider() {
+            throw new Error('haha');
+        }
+    })
+], Bar);
+function main() {
+    const foo = inject(Foo);
+}
+Application.run('Test', [
+    provideModule(main),
+    provideConsoleLogTransport(PrettyPrintLogFormatter)
+]);