@tstdl/base 0.93.10 → 0.93.11

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/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.11",
   "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)
+]);