@tstdl/base 0.93.20 → 0.93.22

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

@@ -1,4 +1,4 @@
-import { SQL, sql } from 'drizzle-orm';
+import { 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 { match, P } from 'ts-pattern';
@@ -6,25 +6,23 @@ 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';
 import { decodeText, encodeUtf8 } from '../../../utils/encoding.js';
 import { enumValues } from '../../../utils/enum.js';
 import { memoize, memoizeSingle } from '../../../utils/function/memoize.js';
-import { iif } from '../../../utils/helpers.js';
 import { compileDereferencer } from '../../../utils/object/dereference.js';
 import { fromEntries, objectEntries } from '../../../utils/object/object.js';
 import { assertDefined, assertDefinedPass, isArray, isDefined, isNotNullOrUndefined, isNull, isString, isUndefined } from '../../../utils/type-guards.js';
 import { resolveValueOrProvider } from '../../../utils/value-or-provider.js';
-import { bytea, numericDate, timestamp, tsvector } from '../../data-types/index.js';
+import { bytea, numericDate, timestamp } from '../../data-types/index.js';
 import { JsonSchema } from '../../schemas/json.js';
 import { NumericDateSchema } from '../../schemas/numeric-date.js';
 import { TimestampSchema } from '../../schemas/timestamp.js';
 import { UuidSchema } from '../../schemas/uuid.js';
 import { decryptBytes, encryptBytes } from '../encryption.js';
-import { convertQuery } from '../query-converter.js';
+import { convertQuery, resolveTargetColumn } from '../query-converter.js';
 const getDbSchema = memoizeSingle(pgSchema);
 export const getDrizzleTableFromType = memoize(_getDrizzleTableFromType);
 const columnDefinitionsSymbol = Symbol('columnDefinitions');
@@ -53,14 +51,18 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
     const columnDefinitions = getPostgresColumnEntries(type, dbSchema, tableName);
     const columnDefinitionsMap = new Map(columnDefinitions.map((column) => [column.objectPath.path, column]));
     function getColumn(table, propertyName) {
-        return assertDefinedPass(table[propertyName], `Property "${propertyName}" does not exist on ${type.name}`);
+        return resolveTargetColumn(propertyName, table, columnDefinitionsMap);
     }
     function buildIndex(table, data, columnName) {
-        const columns = (data.columns ?? [columnName]).map((columnValue) => {
+        const resolvedColumns = resolveValueOrProvider(data.columns ?? [columnName], table);
+        const columns = resolvedColumns.map((columnValue) => {
+            if (columnValue instanceof SQL) {
+                return columnValue;
+            }
             assertDefined(columnValue, 'Missing column name for index.');
-            const [columnName, columnOrder] = isString(columnValue) ? [columnValue] : columnValue;
+            const [columnNameOrConfig, columnOrder] = isArray(columnValue) ? columnValue : [columnValue];
             const order = columnOrder ?? data.order ?? 'asc';
-            let column = getColumn(table, columnName);
+            let column = isString(columnNameOrConfig) ? getColumn(table, columnNameOrConfig) : columnNameOrConfig;
             column = column[order]();
             if (data.options?.nulls == 'first') {
                 column = column.nullsFirst();
@@ -71,15 +73,22 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
             return column;
         });
         const indexFn = (data.options?.unique == true) ? uniqueIndex : index;
+        console.log({ name: data.options?.name ?? getIndexName(tableName, columns, { naming: data.options?.naming }) });
         let builder = indexFn(data.options?.name ?? getIndexName(tableName, columns, { naming: data.options?.naming })).using(data.options?.using ?? 'btree', ...columns);
         if (isDefined(data.options?.where)) {
             const query = convertQuery(data.options.where(table), table, columnDefinitionsMap);
             builder = builder.where(query.inlineParams());
         }
+        if (isDefined(data.options?.with)) {
+            builder = builder.with(data.options.with);
+        }
+        if (data.options?.concurrently == true) {
+            builder = builder.concurrently();
+        }
         return builder;
     }
     function buildPrimaryKey(table) {
-        const columns = primaryKeyColumnDefinitions.map((columnDefinition) => getColumn(table, columnDefinition.name));
+        const columns = primaryKeyColumnDefinitions.map((columnDefinition) => table[columnDefinition.name]);
         return primaryKey({
             name: mergedTableReflectionData.compundPrimaryKeyName ?? getPrimaryKeyName(tableName, columns, { naming: mergedTableReflectionData.compundPrimaryKeyNaming }),
             columns,
@@ -88,40 +97,33 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
     const primaryKeyColumnDefinitions = columnDefinitions.filter((columnDefinition) => columnDefinition.reflectionData?.primaryKey == true);
     const skipPrimaryKey = primaryKeyColumnDefinitions.length > 1;
     const columnEntries = columnDefinitions.map((entry) => [entry.name, entry.buildType({ skipPrimaryKey })]);
-    const fullTextSearchColumnEntries = tableReflectionDatas
-        .flatMap((tableReflectionData) => tableReflectionData.fullTextSearch ?? [])
-        .flatMap((ftsData) => getFullTextSearchColumns(ftsData, () => drizzleSchema, (property) => getColumn(drizzleSchema, property)));
-    const drizzleSchema = dbSchema.table(tableName, fromEntries([
-        ...columnEntries,
-        ...fullTextSearchColumnEntries,
-    ]), (drizzleTable) => {
+    const drizzleSchema = dbSchema.table(tableName, fromEntries(columnEntries), (drizzleTable) => {
         const table = drizzleTable;
-        const indexes = tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.index).filter(isDefined).map((data) => buildIndex(drizzleTable, data));
-        const fullTextIndexes = tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.fullTextSearch ?? []).flatMap((ftsData) => getFullTextSearchIndexes(ftsData, table, (property) => getColumn(drizzleTable, property)));
+        const indexes = tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.index).filter(isDefined).map((data) => buildIndex(table, data));
         const checks = tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.checks).filter(isDefined).map((data) => check(data.name, data.builder(table)));
         return [
             ...((primaryKeyColumnDefinitions.length > 1)
-                ? [buildPrimaryKey(drizzleTable)]
+                ? [buildPrimaryKey(table)]
                 : []),
             ...(columnDefinitions.map((columnDefinition) => {
                 const indexData = columnDefinition.reflectionData?.index;
                 if (isUndefined(indexData)) {
                     return undefined;
                 }
-                return buildIndex(drizzleTable, indexData, columnDefinition.name);
+                return buildIndex(table, indexData, columnDefinition.name);
             }).filter(isDefined)),
             ...tableReflectionDatas.flatMap((tableReflectionData) => {
                 return tableReflectionData.foreignKeys?.map((foreignKeyData) => {
                     const foreignTable = getDrizzleTableFromType(foreignKeyData.target(), dbSchema.schemaName);
                     return foreignKey({
                         name: foreignKeyData.options?.name ?? getForeignKeyName(tableName, foreignKeyData.columns, { naming: foreignKeyData.options?.naming }),
-                        columns: foreignKeyData.columns.map((column) => getColumn(drizzleTable, column)),
+                        columns: foreignKeyData.columns.map((column) => getColumn(table, column)),
                         foreignColumns: foreignKeyData.foreignColumns.map((column) => getColumn(foreignTable, column)),
                     });
                 }) ?? [];
             }),
             ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.unique).filter(isDefined).map((data) => {
-                const columns = data.columns?.map((column) => getColumn(drizzleTable, column));
+                const columns = data.columns?.map((column) => getColumn(table, column));
                 let constraint = unique(data.options?.name ?? getUniqueName(tableName, columns, { naming: data.options?.naming })).on(...columns);
                 if (data.options?.nulls == 'not distinct') {
                     constraint = constraint.nullsNotDistinct();
@@ -129,7 +131,6 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
                 return constraint;
             }),
             ...indexes,
-            ...fullTextIndexes,
             ...checks,
         ];
     });
@@ -137,69 +138,6 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
     drizzleSchema[columnDefinitionsMapSymbol] = columnDefinitionsMap;
     return drizzleSchema;
 }
-function getFullTextSearchColumns(data, tableProvider, columnProvider) {
-    if (isDefined(data.vector)) {
-        const name = `fts_v_${data.name}`;
-        const generationSource = () => {
-            const table = tableProvider();
-            const source = assertDefinedPass(resolveValueOrProvider(data.source ?? data.vector?.rawVectorSource, table), 'Either "source" or "vector.rawVectorSource" must be provided for full-text search vector generation.');
-            const language = resolveValueOrProvider(data.vector?.language ?? 'simple', table);
-            return match(source)
-                .with(P.instanceOf(SQL), (sqlExpression) => sqlExpression)
-                .otherwise((paths) => {
-                const vectors = paths.map((property) => {
-                    const column = columnProvider(property);
-                    const tsVector = toTsVector(language, column);
-                    const weight = data.vector?.weights?.[property];
-                    if (isDefined(weight)) {
-                        return setweight(tsVector, weight);
-                    }
-                    return tsVector;
-                });
-                return sql `(${sql.join(vectors, sql ` || `)})`;
-            });
-        };
-        const column = tsvector(name).generatedAlwaysAs(generationSource);
-        return [[name, column]];
-    }
-    return [];
-}
-function getFullTextSearchIndexes(data, table, columnProvider) {
-    return [
-        ...iif(isDefined(data.vector), () => {
-            const indexName = `fts_${data.name}_bm25`;
-            const textSource = assertDefinedPass(data.source, 'Either "source" or "vector.rawVectorSource" must be provided for full-text search vector generation.');
-            const source = resolveValueOrProvider(textSource, table);
-            const indexExpression = match(source)
-                .with(P.instanceOf(SQL), (sqlExpression) => sqlExpression)
-                .otherwise((paths) => {
-                const columns = paths.map((property) => columnProvider(property));
-                return sql `(${sql.join(columns, sql ` || `)})`;
-            });
-            const bm25Index = index(indexName).using('bm25', indexExpression).with({ key_field: 'id' });
-            return [bm25Index];
-        }, () => []),
-        ...iif(isDefined(data.vector), () => {
-            const columnName = `fts_v_${data.name}`;
-            const indexName = `${columnName}_gin`;
-            const ginIndex = index(indexName).using('gin', columnProvider(columnName)).with({ fastupdate: 'off' });
-            return [ginIndex];
-        }, () => []),
-        ...iif(isDefined(data.trigram), () => {
-            const indexName = `fts_t_${data.name}_gist`;
-            const textSource = assertDefinedPass(data.source, 'Either "source" or "vector.rawVectorSource" must be provided for full-text search vector generation.');
-            const source = resolveValueOrProvider(textSource, table);
-            const indexExpression = match(source)
-                .with(P.instanceOf(SQL), (sqlExpression) => sqlExpression)
-                .otherwise((paths) => {
-                const columns = paths.map((property) => columnProvider(property));
-                return sql `(${sql.join(columns, sql ` || `)})`;
-            });
-            const gistIndex = index(indexName).using('gist', indexExpression).with({ fastupdate: 'off' });
-            return [gistIndex];
-        }, () => []),
-    ];
-}
 function getPostgresColumnEntries(type, dbSchema, tableName, path = new JsonPath({ dollar: false }), prefix = '') {
     const metadata = reflectionRegistry.getMetadata(type);
     assertDefined(metadata, `Type ${type.name} does not have reflection metadata (path: ${path.toString()}).`);
@@ -289,41 +227,25 @@ function getPostgresBaseColumn(columnName, dbSchema, schema, reflectionData, con
     if (reflectionData.encrypted) {
         return bytea(columnName);
     }
-    if (schema instanceof UuidSchema) {
+    return match(schema)
+        .with(P.instanceOf(UuidSchema), (s) => {
         let column = uuid(columnName);
-        if (schema.defaultRandom) {
+        if (s.defaultRandom) {
             column = column.defaultRandom();
         }
         return column;
-    }
-    if (schema instanceof TimestampSchema) {
-        return timestamp(columnName);
-    }
-    if (schema instanceof NumericDateSchema) {
-        return numericDate(columnName);
-    }
-    if (schema instanceof NumberSchema) {
-        return schema.integer
-            ? integer(columnName)
-            : doublePrecision(columnName);
-    }
-    if (schema instanceof StringSchema) {
-        return text(columnName);
-    }
-    if (schema instanceof BooleanSchema) {
-        return boolean(columnName);
-    }
-    if (schema instanceof EnumerationSchema) {
-        const pgEnum = getPgEnum(dbSchema, schema.enumeration, context);
-        return pgEnum(columnName);
-    }
-    if (schema instanceof JsonSchema) {
-        return jsonb(columnName);
-    }
-    if (schema instanceof Uint8ArraySchema) {
-        return bytea(columnName);
-    }
-    throw new NotSupportedError(`Schema "${schema.constructor.name}" not supported on type "${context.type.name}" for property "${context.property}"`);
+    })
+        .with(P.instanceOf(TimestampSchema), () => timestamp(columnName))
+        .with(P.instanceOf(NumericDateSchema), () => numericDate(columnName))
+        .with(P.instanceOf(NumberSchema), (s) => (s.integer ? integer(columnName) : doublePrecision(columnName)))
+        .with(P.instanceOf(StringSchema), () => text(columnName))
+        .with(P.instanceOf(BooleanSchema), () => boolean(columnName))
+        .with(P.instanceOf(EnumerationSchema), (s) => getPgEnum(dbSchema, s.enumeration, context)(columnName))
+        .with(P.instanceOf(JsonSchema), () => jsonb(columnName))
+        .with(P.instanceOf(Uint8ArraySchema), () => bytea(columnName))
+        .otherwise(() => {
+        throw new NotSupportedError(`Schema "${schema.constructor.name}" not supported on type "${context.type.name}" for property "${context.property}"`);
+    });
 }
 const enumNames = new Map();
 const enums = new MultiKeyMap();

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

@@ -1,7 +1,22 @@
-import { SQL } from 'drizzle-orm';
-import type { Record } from '../../types/index.js';
-import type { FtsParser, Query } from '../query.js';
-import type { ColumnDefinition, PgTableFromType } from './types.js';
+import { SQL, type SQLWrapper } from 'drizzle-orm';
+import type { BaseEntity } from '../entity.js';
+import type { Query, TsVectorParser, TsVectorWeight } from '../query.js';
+import type { TargetColumn } from '../repository.types.js';
+import type { ColumnDefinition, ExtraConfigColumnsFromType, PgTableFromType } from './types.js';
+/**
+ * Resolves a target to a Drizzle PgColumn or SQLWrapper.
+ * @param target The target to resolve.
+ * @param table The Drizzle table object.
+ * @param columnDefinitionsMap A map from property names to column definitions.
+ */
+export declare function resolveTargetColumn<T extends BaseEntity>(target: TargetColumn<T> | ColumnDefinition, table: PgTableFromType | ExtraConfigColumnsFromType, columnDefinitionsMap: Map<string, ColumnDefinition>): SQLWrapper;
+/**
+ * Resolves multiple targets to a Drizzle PgColumn or SQLWrapper.
+ * @param targets The targets to resolve.
+ * @param table The Drizzle table object.
+ * @param columnDefinitionsMap A map from property names to column definitions.
+ */
+export declare function resolveTargetColumns<T extends BaseEntity>(targets: (TargetColumn<T> | ColumnDefinition)[], table: PgTableFromType, columnDefinitionsMap: Map<string, ColumnDefinition>): SQLWrapper[];
 /**
  * Converts a query object into a Drizzle SQL condition.
  * Recursively handles nested logical operators and maps property names to database columns.
@@ -15,6 +30,5 @@ 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 getColumnConcatenation(fields: readonly string[], table: PgTableFromType, columnDefinitionsMap: Map<string, ColumnDefinition>): SQL;
+export declare function getTsQuery(text: string | SQL, language: string | SQL, parser: TsVectorParser): SQL;
+export declare function getTsVector(fields: readonly (SQLWrapper | readonly [field: SQLWrapper, weight?: TsVectorWeight])[], language: string | SQL): SQL;

package/orm/server/query-converter.js

@@ -1,10 +1,35 @@
-import { and, eq, gt, gte, inArray, isNotNull, isNull, isSQLWrapper, lt, lte, ne, not, notInArray, or, SQL, sql } from 'drizzle-orm';
+import { and, Column, eq, gt, gte, inArray, isNotNull, isNull, isSQLWrapper, lt, lte, ne, not, notInArray, or, SQL, sql } from 'drizzle-orm';
 import { match } from 'ts-pattern';
 import { NotSupportedError } from '../../errors/not-supported.error.js';
+import { toArray } from '../../utils/array/index.js';
 import { hasOwnProperty, objectEntries } from '../../utils/object/object.js';
-import { assertDefinedPass, isDefined, isPrimitive, isRegExp, isString, isUndefined } from '../../utils/type-guards.js';
-import { isSimilar, phraseToTsQuery, plainToTsQuery, setweight, toTsQuery, toTsVector, websearchToTsQuery } from '../sqls.js';
+import { assert, assertDefinedPass, isArray, isDefined, isPrimitive, isRegExp, isString, isUndefined } from '../../utils/type-guards.js';
+import { isSimilar, isStrictWordSimilar, isWordSimilar, phraseToTsQuery, plainToTsQuery, setweight, similarity, strictWordSimilarity, toTsQuery, toTsVector, websearchToTsQuery, wordSimilarity } from '../sqls.js';
 const sqlTrue = sql `true`;
+/**
+ * Resolves a target to a Drizzle PgColumn or SQLWrapper.
+ * @param target The target to resolve.
+ * @param table The Drizzle table object.
+ * @param columnDefinitionsMap A map from property names to column definitions.
+ */
+export function resolveTargetColumn(target, table, columnDefinitionsMap) {
+    if ((target instanceof SQL) || (target instanceof SQL.Aliased) || (target instanceof Column)) {
+        return target;
+    }
+    const columnDef = isString(target)
+        ? assertDefinedPass(columnDefinitionsMap.get(target), `Could not map property ${target} to column.`)
+        : target; // eslint-disable-line @typescript-eslint/no-unnecessary-type-assertion
+    return table[columnDef.name];
+}
+/**
+ * Resolves multiple targets to a Drizzle PgColumn or SQLWrapper.
+ * @param targets The targets to resolve.
+ * @param table The Drizzle table object.
+ * @param columnDefinitionsMap A map from property names to column definitions.
+ */
+export function resolveTargetColumns(targets, table, columnDefinitionsMap) {
+    return targets.map((target) => resolveTargetColumn(target, table, columnDefinitionsMap));
+}
 /**
  * Converts a query object into a Drizzle SQL condition.
  * Recursively handles nested logical operators and maps property names to database columns.
@@ -56,21 +81,41 @@ export function convertQuery(query, table, columnDefinitionsMap) {
                 }
                 break;
             }
-            case '$fts': {
-                const ftsQuery = value;
-                const method = ftsQuery.method ?? 'vector';
-                const sqlValue = match(method)
-                    .with('vector', () => {
-                    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('trigram', () => {
-                    const searchExpression = getColumnConcatenation(ftsQuery.fields, table, columnDefinitionsMap);
-                    return isSimilar(searchExpression, ftsQuery.text);
-                })
-                    .exhaustive();
-                conditions.push(sqlValue);
+            case '$tsvector': {
+                const tsvectorQuery = value.$tsvector;
+                const fields = assertDefinedPass(tsvectorQuery.fields, '`fields` is required for tsvector search.');
+                const convertedFields = fields.map((target) => {
+                    const [field, weight] = isArray(target) ? target : [target, undefined];
+                    const sqlField = resolveTargetColumn(field, table, columnDefinitionsMap);
+                    if (isDefined(weight)) {
+                        return [sqlField, weight];
+                    }
+                    return sqlField;
+                });
+                const tsquery = getTsQuery(tsvectorQuery.query, tsvectorQuery.language ?? 'simple', tsvectorQuery.parser ?? 'raw');
+                const tsvector = getTsVector(convertedFields, tsvectorQuery.language ?? 'simple');
+                conditions.push(sql `${tsvector} @@ ${tsquery}`);
+                break;
+            }
+            case '$trigram': {
+                const trigramQuery = value.$trigram;
+                const fields = isArray(trigramQuery.fields) ? trigramQuery.fields : [trigramQuery.fields];
+                const convertedFields = fields.map((target) => resolveTargetColumn(target, table, columnDefinitionsMap));
+                const searchExpression = sql `(${sql.join(convertedFields, sql ` || ' ' || `)})`;
+                if (isDefined(trigramQuery.threshold)) {
+                    const similarityFn = getTrigramSimilarityFunction(trigramQuery.type);
+                    conditions.push(sql `${similarityFn(trigramQuery.query, searchExpression)} > ${trigramQuery.threshold}`);
+                }
+                else {
+                    const isSimilarOperator = getTrigramIsSimilarOperator(trigramQuery.type);
+                    conditions.push(isSimilarOperator(trigramQuery.query, searchExpression));
+                }
+                break;
+            }
+            case '$parade': {
+                const paradeQuery = value.$parade;
+                const convertedParadeQuery = convertParadeDbQuery(paradeQuery, table, columnDefinitionsMap);
+                conditions.push(sql `${table.id} @@@ ${convertedParadeQuery}`);
                 break;
             }
             default: {
@@ -167,18 +212,53 @@ function getCondition(property, value, column, table, columnDefinitionsMap) {
         const operator = (regexp.flags?.includes('i') ?? false) ? sql.raw('~*') : sql.raw('~');
         return sql `${column} ${operator} ${regexp.value}`;
     }
-    if (hasOwnProperty(value, '$fts')) {
-        const queryValue = value.$fts;
-        const { query, method = 'vector', language = 'simple', parser = 'plain' } = isString(queryValue)
+    if (hasOwnProperty(value, '$tsvector')) {
+        const queryValue = value.$tsvector;
+        const { query, language = 'simple', parser = 'plain' } = isString(queryValue)
             ? { query: queryValue }
             : queryValue;
-        if (method == 'similarity') {
-            return isSimilar(column, query);
-        }
         const tsquery = getTsQuery(query, language, parser);
         const tsvector = toTsVector(language, column);
         return sql `${tsvector} @@ ${tsquery}`;
     }
+    if (hasOwnProperty(value, '$trigram')) {
+        const queryValue = value.$trigram;
+        const { query, type, threshold } = isString(queryValue) ? { query: queryValue } : queryValue;
+        if (isDefined(threshold)) {
+            const similarityFn = getTrigramSimilarityFunction(type);
+            return sql `${similarityFn(column, query)} > ${threshold}`;
+        }
+        return isSimilar(column, query);
+    }
+    if (hasOwnProperty(value, '$match')) {
+        const queryValue = value.$match;
+        const { query, distance, prefix, conjunctionMode } = isString(queryValue) ? { query: queryValue } : queryValue;
+        const parts = [sql `field => ${column.name}`, sql `value => ${query}`];
+        if (isDefined(distance)) {
+            parts.push(sql `distance => ${distance}`);
+        }
+        if (isDefined(prefix)) {
+            parts.push(sql `prefix => ${prefix}`);
+        }
+        if (isDefined(conjunctionMode)) {
+            parts.push(sql `conjunction_mode => ${conjunctionMode}`);
+        }
+        const searchFn = sql `paradedb.match(${sql.join(parts, sql.raw(', '))})`;
+        return sql `${table.id} @@@ ${searchFn}`;
+    }
+    if (hasOwnProperty(value, '$tantivy')) {
+        const queryValue = value.$tantivy;
+        const { query, lenient, conjunctionMode } = isString(queryValue) ? { query: queryValue } : queryValue;
+        const parts = [sql `${query}`];
+        if (isDefined(lenient)) {
+            parts.push(sql `lenient => ${lenient}`);
+        }
+        if (isDefined(conjunctionMode)) {
+            parts.push(sql `conjunction_mode => ${conjunctionMode}`);
+        }
+        const searchFn = sql `paradedb.parse(${sql.join(parts, sql.raw(', '))})`;
+        return sql `${table.id} @@@ ${searchFn}`;
+    }
     if (hasOwnProperty(value, '$geoShape')) {
         throw new NotSupportedError('$geoShape is not supported.');
     }
@@ -187,6 +267,90 @@ function getCondition(property, value, column, table, columnDefinitionsMap) {
     }
     throw new Error(`Unsupported query type "${property}".`);
 }
+function getTrigramSimilarityFunction(type = 'phrase') {
+    return match(type)
+        .with('phrase', () => similarity)
+        .with('word', () => wordSimilarity)
+        .with('strict-word', () => strictWordSimilarity)
+        .exhaustive();
+}
+function getTrigramIsSimilarOperator(type = 'phrase') {
+    return match(type)
+        .with('phrase', () => isSimilar)
+        .with('word', () => isWordSimilar)
+        .with('strict-word', () => isStrictWordSimilar)
+        .exhaustive();
+}
+/**
+ * Recursively converts a ParadeDbQueryObject into a Drizzle SQL object representing the JSONB structure.
+ */
+function convertParadeDbQuery(query, table, columnDefinitionsMap) {
+    const entries = objectEntries(query);
+    assert(entries.length == 1, 'ParadeDB query object must have exactly one key.');
+    const [key, queryValue] = entries[0];
+    const buildObject = (properties) => {
+        const chunks = [];
+        for (const [propKey, propValue] of properties) {
+            chunks.push(sql `'${sql.raw(propKey)}', ${propValue}`);
+        }
+        return sql `jsonb_build_object(${sql.join(chunks, sql `, `)})`;
+    };
+    const convertRecursive = (subQuery) => {
+        return convertParadeDbQuery(subQuery, table, columnDefinitionsMap);
+    };
+    const innerSql = match(key)
+        .with('all', 'empty', () => sql `null`)
+        .with('term', 'fuzzy_term', 'regex', 'phrase', 'match', 'parse_with_field', 'exists', 'range', 'phrase_prefix', 'regex_phrase', 'range_term', 'range_intersects', 'range_contains', 'range_within', (_) => {
+        const properties = [];
+        for (const [propKey, propValue] of objectEntries(queryValue)) {
+            if (propKey == 'field') {
+                const column = resolveTargetColumn(propValue, table, columnDefinitionsMap);
+                properties.push([propKey, column.name]);
+            }
+            else {
+                properties.push([propKey, propValue]);
+            }
+        }
+        return buildObject(properties);
+    })
+        .with('parse', 'more_like_this', () => buildObject(objectEntries(queryValue)))
+        .with('boolean', () => {
+        const properties = [];
+        for (const [propKey, propValue] of objectEntries(queryValue)) {
+            const subQueries = toArray(propValue ?? []).map(convertRecursive);
+            properties.push([propKey, sql `jsonb_build_array(${sql.join(subQueries, sql `, `)})`]);
+        }
+        return buildObject(properties);
+    })
+        .with('boost', 'const_score', () => {
+        const properties = [];
+        for (const [propKey, propValue] of objectEntries(queryValue)) {
+            if (propKey == 'query') {
+                properties.push([propKey, convertRecursive(propValue)]);
+            }
+            else {
+                properties.push([propKey, propValue]);
+            }
+        }
+        return buildObject(properties);
+    })
+        .with('disjunction_max', 'term_set', (_k) => {
+        const properties = [];
+        const subqueryArrayKey = (key == 'disjunction_max') ? 'disjuncts' : 'terms';
+        for (const [propKey, propValue] of objectEntries(queryValue)) {
+            if (propKey == subqueryArrayKey) {
+                const subQueries = propValue.map(convertRecursive);
+                properties.push([propKey, sql `jsonb_build_array(${sql.join(subQueries, sql `, `)})`]);
+            }
+            else {
+                properties.push([propKey, propValue]);
+            }
+        }
+        return buildObject(properties);
+    })
+        .exhaustive();
+    return buildObject([[key, innerSql]]);
+}
 export function getTsQuery(text, language, parser) {
     switch (parser) {
         case 'raw':
@@ -201,23 +365,15 @@ export function getTsQuery(text, language, parser) {
             throw new NotSupportedError(`Unsupported text search parser: ${parser}`);
     }
 }
-export function getTsVector(fields, language, table, columnDefinitionsMap, weights) {
-    const tsvector = sql.join(fields.map((field) => {
-        const columnDef = assertDefinedPass(columnDefinitionsMap.get(field), `Could not map property ${field} to column.`);
-        const column = table[columnDef.name];
-        const vector = toTsVector(language, column);
-        const weight = weights?.[field];
+export function getTsVector(fields, language) {
+    const sqlFields = fields.map((fieldWithWeight) => {
+        const [field, weight] = isArray(fieldWithWeight) ? fieldWithWeight : [fieldWithWeight, undefined];
+        const vector = toTsVector(language, field);
         if (isDefined(weight)) {
             return setweight(vector, weight);
         }
         return vector;
-    }), sql ` || `);
-    return tsvector;
-}
-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 `(${sql.join(columns, sql ` || ' ' || `)})`;
+    const mergedTsVector = sql.join(sqlFields, sql ` || `);
+    return mergedTsVector;
 }