@tstdl/base 0.93.8 → 0.93.10

package/audit/module.d.ts

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

package/audit/module.js

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

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

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

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

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

package/orm/decorators.d.ts

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

package/orm/decorators.js

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

package/orm/query.d.ts

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

package/orm/query.js

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

package/orm/repository.types.d.ts

@@ -8,6 +8,8 @@ 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 { TsHeadlineOptions } from './sqls.js';
 type WithSql<T> = {
     [P in keyof T]: T[P] extends Record ? WithSql<T[P]> : (T[P] | SQL);
 };
@@ -53,6 +55,62 @@ export type LoadManyOptions<T extends EntityWithoutMetadata> = LoadOptions<T> &
     limit?: number;
     distinct?: boolean | TargetColumn<T>[];
 };
+/**
+ * Options for ranking search results.
+ */
+export type RankOptions = {
+    /**
+     * Array of four numbers to weight D, C, B, and A labels respectively.
+     * Defaults to PostgreSQL's default {0.1, 0.2, 0.4, 1.0}.
+     */
+    weights?: [number, number, number, number];
+    /**
+     * Specifies how a document's length should impact its rank.
+     * It's a bitmask, e.g., 0 (default) ignores length, 2 divides by document length.
+     * See PostgreSQL documentation for `ts_rank_cd` for more details.
+     */
+    normalization?: number;
+};
+/**
+ * Options for highlighting search results.
+ */
+export type HighlightOptions<T extends EntityWithoutMetadata> = {
+    /**
+     * The source to generate the highlight from. Can be one or more property paths or a raw SQL expression.
+     */
+    source: TargetColumnPaths<T> | SQL<string>;
+} & TsHeadlineOptions;
+/**
+ * Options for the `search` method.
+ * @template T - The entity type.
+ */
+export type SearchOptions<T extends EntityWithoutMetadata> = Omit<LoadManyOptions<T>, 'order'> & {
+    /**
+     * An additional filter to apply to the search query.
+     */
+    filter?: Query<T>;
+    /**
+     * 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;
+    /**
+     * 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;
+    highlight?: string;
+};
 /**
  * Options for update operations (currently inherits from LoadOptions, primarily for ordering).
  * @template T - The entity type.

package/orm/server/database.js

@@ -14,6 +14,7 @@ import { migrate } from 'drizzle-orm/node-postgres/migrator';
 import { Pool } from 'pg';
 import { inject, Injector, ReplaceClass } from '../../injector/index.js';
 import { isUndefined } from '../../utils/type-guards.js';
+import { millisecondsPerMinute } from '../../utils/units.js';
 import { DatabaseConfig } from './module.js';
 /**
  * Represents the application's database connection.
@@ -33,7 +34,7 @@ Injector.registerSingleton(Database, {
             throw new Error('Missing postgres connection. Provide it either via injection argument or a provider for DatabaseConfig.');
         }
         const pool = new Pool({
-            idle_in_transaction_session_timeout: 10000,
+            idle_in_transaction_session_timeout: 10 * millisecondsPerMinute,
             ...connection,
         });
         context.addDisposeHandler(async () => await pool.end());

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

@@ -1,9 +1,11 @@
+import { sql, SQL } from 'drizzle-orm';
 import { toCamelCase, toSnakeCase } from 'drizzle-orm/casing';
 import { boolean, check, doublePrecision, foreignKey, index, integer, jsonb, pgSchema, primaryKey, text, unique, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
 import { MultiKeyMap } from '../../../data-structures/multi-key-map.js';
 import { tryGetEnumName } from '../../../enumeration/enumeration.js';
 import { NotSupportedError } from '../../../errors/not-supported.error.js';
 import { JsonPath } from '../../../json-path/json-path.js';
+import { setweight, toTsVector } from '../../../orm/sqls.js';
 import { reflectionRegistry } from '../../../reflection/registry.js';
 import { ArraySchema, BooleanSchema, DefaultSchema, EnumerationSchema, getObjectSchema, NullableSchema, NumberSchema, ObjectSchema, OptionalSchema, StringSchema, Uint8ArraySchema } from '../../../schema/index.js';
 import { compareByValueSelectionToOrder, orderRest } from '../../../utils/comparison.js';
@@ -53,9 +55,12 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
     function buildIndex(table, data, columnName) {
         const columns = (data.columns ?? [columnName]).map((columnValue) => {
             assertDefined(columnValue, 'Missing column name for index.');
+            if (columnValue instanceof SQL) {
+                return columnValue;
+            }
             const [columnName, columnOrder] = isString(columnValue) ? [columnValue] : columnValue;
-            const order = columnOrder ?? data.order ?? 'asc';
             let column = getColumn(table, columnName);
+            const order = columnOrder ?? data.order ?? 'asc';
             column = column[order]();
             if (data.options?.nulls == 'first') {
                 column = column.nullsFirst();
@@ -66,13 +71,37 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
             return column;
         });
         const indexFn = (data.options?.unique == true) ? uniqueIndex : index;
-        let builder = indexFn(data.options?.name ?? getIndexName(tableName, columns, { naming: data.options?.naming })).using(data.options?.using ?? 'btree', ...columns);
+        const containsSql = columns.some((column) => column instanceof SQL);
+        const indexName = data.options?.name ?? (containsSql
+            ? assertDefinedPass(data.options?.name, 'Index with SQL expressions must have a name.')
+            : getIndexName(tableName, columns, { naming: data.options?.naming }));
+        const indexColumns = (data.options?.using == 'gin'
+            ? buildGinIndexColumns(columns, data.options)
+            : columns);
+        let builder = indexFn(indexName).using(data.options?.using ?? 'btree', ...indexColumns);
         if (isDefined(data.options?.where)) {
             const query = convertQuery(data.options.where(table), table, columnDefinitionsMap);
             builder = builder.where(query.inlineParams());
         }
         return builder;
     }
+    function buildGinIndexColumns(columns, options) {
+        const vectors = columns.map((column) => {
+            if (column instanceof SQL) {
+                return column;
+            }
+            const tsVector = toTsVector(options.language ?? 'simple', column);
+            const weight = options.weights?.[column.name];
+            if (isDefined(weight)) {
+                return setweight(tsVector, weight);
+            }
+            return tsVector;
+        });
+        if (options.vectors == 'separate') {
+            return vectors;
+        }
+        return [sql `(${sql.join(vectors, sql ` || `)})`];
+    }
     function buildPrimaryKey(table) {
         const columns = primaryKeyColumnDefinitions.map((columnDefinition) => getColumn(table, columnDefinition.name));
         return primaryKey({

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

@@ -1,11 +1,6 @@
-/**
- * @module
- * Converts a generic query object structure into a Drizzle ORM SQL condition.
- * Supports logical operators ($and, $or, $nor) and various comparison operators
- * ($eq, $neq, $in, $nin, $lt, $lte, $gt, $gte, $regex).
- */
 import { SQL } from 'drizzle-orm';
-import type { Query } from '../query.js';
+import type { Record } from '../../types/index.js';
+import type { FtsParser, Query } from '../query.js';
 import type { ColumnDefinition, PgTableFromType } from './types.js';
 /**
  * Converts a query object into a Drizzle SQL condition.
@@ -20,3 +15,6 @@ import type { ColumnDefinition, PgTableFromType } from './types.js';
  * @throws {Error} If an unsupported query type is encountered.
  */
 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;