@tstdl/base 0.93.87 → 0.93.89

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

@@ -1,4 +1,4 @@
-import { sql, SQL } from 'drizzle-orm';
+import { eq, sql, SQL } from 'drizzle-orm';
 import { toCamelCase, toSnakeCase } from 'drizzle-orm/casing';
 import { boolean, check, doublePrecision, foreignKey, index, integer, jsonb, numeric, pgSchema, primaryKey, text, unique, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
 import { match, P } from 'ts-pattern';
@@ -12,6 +12,7 @@ import { decodeText, encodeUtf8 } from '../../../utils/encoding.js';
 import { enumValues } from '../../../utils/enum.js';
 import { memoize, memoizeSingle } from '../../../utils/function/memoize.js';
 import { typeExtends } from '../../../utils/index.js';
+import { merge } from '../../../utils/merge.js';
 import { compileDereferencer } from '../../../utils/object/dereference.js';
 import { fromEntries, mapObjectKeysToSnakeCase, objectEntries } from '../../../utils/object/object.js';
 import { assertDefined, assertDefinedPass, isArray, isDefined, isNotNull, isNotNullOrUndefined, isNull, isString, isUndefined } from '../../../utils/type-guards.js';
@@ -20,13 +21,19 @@ import { bytea, numericDate, timestamp, tsvector } from '../../data-types/index.
 import { TenantBaseEntity, TenantEntity } from '../../entity.js';
 import { getEnumName } from '../../enums.js';
 import { JsonSchema, NumericDateSchema, NumericSchema, TimestampSchema, TsVectorSchema, UuidSchema } from '../../schemas/index.js';
+import { getInheritanceMetadata, isChildEntity } from '../../utils.js';
 import { decryptBytes, encryptBytes } from '../encryption.js';
 import { convertQuery, resolveTargetColumn, resolveTargetColumns } from '../query-converter.js';
 const getDbSchema = memoizeSingle(pgSchema);
 export const getDrizzleTableFromType = memoize(_getDrizzleTableFromType);
 const columnDefinitionsSymbol = Symbol('columnDefinitions');
+const allColumnDefinitionsSymbol = Symbol('allColumnDefinitions');
 const columnDefinitionsMapSymbol = Symbol('columnDefinitionsMap');
 export function getColumnDefinitions(table) {
+    return table[allColumnDefinitionsSymbol]
+        ?? table[columnDefinitionsSymbol];
+}
+export function getTableColumnDefinitions(table) {
     return table[columnDefinitionsSymbol];
 }
 export function getColumnDefinitionsMap(table) {
@@ -38,10 +45,23 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
     const schema = assertDefinedPass(mergedTableReflectionData.schema ?? fallbackSchemaName, 'Table schema not provided');
     const tableName = getTableName(type);
     const dbSchema = getDbSchema(schema);
-    const columnDefinitions = getPostgresColumnEntries(type, dbSchema, tableName);
-    const columnDefinitionsMap = new Map(columnDefinitions.map((column) => [column.objectPath.path, column]));
+    const inheritanceMetadata = getInheritanceMetadata(type);
+    const allColumnDefinitions = getPostgresColumnEntries(type, dbSchema, tableName, undefined, '', { filterInherited: false }, type);
+    const columnDefinitions = allColumnDefinitions.filter((cd) => !isChildEntity(type)
+        || !cd.inherited
+        || (cd.objectPath.path == 'id')
+        || (cd.objectPath.path == 'tenantId')
+        || (cd.objectPath.path == inheritanceMetadata?.discriminatorColumn));
+    if (isDefined(inheritanceMetadata)) {
+        const discriminatorColumnName = inheritanceMetadata.discriminatorColumn;
+        const hasDiscriminator = columnDefinitions.some((cd) => (cd.name == discriminatorColumnName) || (cd.reflectionData?.name == discriminatorColumnName) || (cd.objectPath.path == discriminatorColumnName));
+        if (!hasDiscriminator) {
+            throw new Error(`Discriminator column "${discriminatorColumnName}" not found on entity "${type.name}". Inheritance requires the discriminator column to be defined as a property.`);
+        }
+    }
+    const columnDefinitionsMap = new Map(allColumnDefinitions.map((column) => [column.objectPath.path, column]));
     function getColumn(table, propertyName) {
-        return resolveTargetColumn(propertyName, table, columnDefinitionsMap);
+        return resolveTargetColumn(propertyName, table, columnDefinitionsMap, { ignorePgTable: true });
     }
     function buildIndex(table, data, columnName) {
         const resolvedColumns = resolveValueOrProvider(data.columns ?? [columnName], table);
@@ -79,6 +99,17 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
         }
         return builder;
     }
+    function buildInheritanceCompositeUniqueConstraint(table) {
+        const inheritanceMetadata = mergedTableReflectionData.inheritance;
+        const discriminatorColumn = inheritanceMetadata.discriminatorColumn;
+        const hasTenantId = isDefined(table['tenantId']);
+        const columns = [
+            ...(hasTenantId ? [table['tenantId']] : []),
+            table[discriminatorColumn],
+            table['id'],
+        ];
+        return unique(getUniqueName(tableName, columns)).on(...columns);
+    }
     function buildPrimaryKey(table) {
         const columns = primaryKeyColumnDefinitions
             .toSorted(compareByValueSelectionToOrder(['tenantId', 'id', orderRest], (columnDefinition) => columnDefinition.name))
@@ -88,6 +119,34 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
             columns,
         });
     }
+    function buildInheritanceConstraints(table) {
+        const constraints = [];
+        const childEntityMetadata = tableReflectionDatas[0]?.childEntity;
+        const discriminatorColumn = inheritanceMetadata?.discriminatorColumn;
+        if (isDefined(mergedTableReflectionData.inheritance)) {
+            constraints.push(buildInheritanceCompositeUniqueConstraint(table));
+        }
+        if (isDefined(inheritanceMetadata) && isDefined(childEntityMetadata)) {
+            const hasTenantId = isDefined(table['tenantId']);
+            constraints.push(check(getIdentifier(tableName, discriminatorColumn, 'check'), eq(table[discriminatorColumn], sql.raw(`'${childEntityMetadata.discriminatorValue}'`))), foreignKey({
+                name: getForeignKeyName(tableName, getTableName(reflectionRegistry.getMetadata(type).parent), [...(hasTenantId ? ['tenantId'] : []), discriminatorColumn, 'id']),
+                columns: [
+                    ...(hasTenantId ? [table['tenantId']] : []),
+                    table[discriminatorColumn],
+                    table['id'],
+                ],
+                foreignColumns: (() => {
+                    const parentTable = getDrizzleTableFromType(reflectionRegistry.getMetadata(type).parent, schema);
+                    return [
+                        ...(hasTenantId ? [parentTable['tenantId']] : []),
+                        parentTable[discriminatorColumn],
+                        parentTable.id,
+                    ];
+                })(),
+            }).onDelete('cascade'));
+        }
+        return constraints;
+    }
     function buildParadeCast(columnSql, paradeOptions) {
         const { tokenizer, alias } = paradeOptions;
         const { type, parameters: rawParameters = [], filters = {} } = isString(tokenizer) ? { type: tokenizer, parameters: [], filters: undefined } : (tokenizer ?? {});
@@ -161,11 +220,12 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
         });
         return builder;
     }
-    const primaryKeyColumnDefinitions = columnDefinitions.filter((columnDefinition) => columnDefinition.reflectionData?.primaryKey == true);
+    const primaryKeyColumnDefinitions = columnDefinitions.filter((columnDefinition) => (columnDefinition.reflectionData?.primaryKey == true) || (columnDefinition.objectPath.path == 'id' && columnDefinition.reflectionData?.primaryKey != false));
     const skipPrimaryKey = primaryKeyColumnDefinitions.length > 1;
     const columnEntries = columnDefinitions.map((entry) => [entry.name, entry.buildType({ skipPrimaryKey })]);
     const drizzleSchema = dbSchema.table(tableName, fromEntries(columnEntries), (drizzleTable) => {
         const table = drizzleTable;
+        table[columnDefinitionsMapSymbol] = columnDefinitionsMap;
         const indexes = tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.index).filter(isDefined).map((data) => buildIndex(table, data));
         const bm25Index = buildParadeIndex(table);
         const checks = tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.checks).filter(isDefined).map((data) => check(data.name, data.builder(table)));
@@ -173,6 +233,7 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
             ...((primaryKeyColumnDefinitions.length > 1)
                 ? [buildPrimaryKey(table)]
                 : []),
+            ...buildInheritanceConstraints(table),
             ...(columnDefinitions.map((columnDefinition) => {
                 const indexData = columnDefinition.reflectionData?.index;
                 if (isUndefined(indexData)) {
@@ -193,7 +254,8 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
             }),
             ...tableReflectionDatas.flatMap((tableReflectionData) => {
                 return tableReflectionData.foreignKeys?.map((foreignKeyData) => {
-                    const foreignTable = getDrizzleTableFromType(foreignKeyData.target(), dbSchema.schemaName);
+                    const foreignKeyTarget = foreignKeyData.target();
+                    const foreignTable = getDrizzleTableFromType(foreignKeyTarget, dbSchema.schemaName);
                     return foreignKey({
                         name: foreignKeyData.options?.name ?? getForeignKeyName(tableName, getTableName(foreignKeyData.target()), foreignKeyData.columns, { naming: foreignKeyData.options?.naming }),
                         columns: foreignKeyData.columns.map((column) => getColumn(table, column)),
@@ -215,7 +277,14 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
         ];
     });
     drizzleSchema[columnDefinitionsSymbol] = columnDefinitions;
+    drizzleSchema[allColumnDefinitionsSymbol] = allColumnDefinitions;
     drizzleSchema[columnDefinitionsMapSymbol] = columnDefinitionsMap;
+    // Patch the table reference for own columns
+    for (const def of allColumnDefinitions) {
+        if (isUndefined(def.table)) {
+            def.table = drizzleSchema;
+        }
+    }
     return drizzleSchema;
 }
 function unwrapSchema(schema) {
@@ -237,21 +306,54 @@ function unwrapSchema(schema) {
     }
     return { schema: currentSchema, nullable, array };
 }
-function getPostgresColumnEntries(type, dbSchema, tableName, path = new JsonPath({ dollar: false }), prefix = '') {
+export function isTableOwning(type) {
+    const ormData = reflectionRegistry.getMetadata(type)?.data.tryGet('orm');
+    return isDefined(ormData?.inheritance) || isDefined(ormData?.childEntity) || isDefined(ormData?.name);
+}
+function getPostgresColumnEntries(type, dbSchema, tableName, path = new JsonPath({ dollar: false }), prefix = '', options = {}, rootType = type) {
     const metadata = reflectionRegistry.getMetadata(type);
     assertDefined(metadata, `Type ${type.name} does not have reflection metadata (path: ${path.toString()}).`);
     const objectSchema = getObjectSchema(type);
-    const entries = objectEntries(objectSchema.properties).toSorted(compareByValueSelectionToOrder(['id', orderRest, 'metadata'], (item) => item[0])).flatMap(([property, schema]) => {
-        const columnReflectionData = metadata.properties.get(property)?.data.tryGet('orm');
+    const inheritanceMetadata = getInheritanceMetadata(type);
+    const discriminatorColumn = inheritanceMetadata?.discriminatorColumn;
+    const entries = objectEntries(objectSchema.properties)
+        .toSorted(compareByValueSelectionToOrder(['id', orderRest, 'metadata'], (item) => item[0]))
+        .flatMap(([property, schema]) => {
+        const propertyMetadata = metadata.properties.get(property);
+        const inherited = (options.inherited == true) || (propertyMetadata?.inherited == true);
+        if ((options.filterInherited == true) && inherited && (property != 'id') && (property != discriminatorColumn)) {
+            return [];
+        }
+        const objectPath = path.add(property);
+        let columnReflectionData = propertyMetadata?.data.tryGet('orm');
+        const rootOrmTableData = reflectionRegistry.getMetadata(rootType)?.data.tryGet('orm');
+        const override = rootOrmTableData?.propertyOverrides?.[objectPath.path];
+        if (isDefined(override)) {
+            columnReflectionData = merge(columnReflectionData, override);
+        }
         const columnName = columnReflectionData?.name ?? toSnakeCase(property);
+        let table = options.table;
+        if (isUndefined(table) && (property != 'id') && (property != discriminatorColumn)) {
+            let currentParent = metadata.parent;
+            let highestTableOwningParentWithProperty;
+            while (isNotNull(currentParent)) {
+                const parentMetadata = reflectionRegistry.getMetadata(currentParent);
+                const hasProperty = parentMetadata?.properties.has(property);
+                if (hasProperty && isTableOwning(currentParent)) {
+                    highestTableOwningParentWithProperty = currentParent;
+                }
+                currentParent = parentMetadata?.parent ?? null;
+            }
+            if (isDefined(highestTableOwningParentWithProperty)) {
+                table = getDrizzleTableFromType(highestTableOwningParentWithProperty, dbSchema.schemaName);
+            }
+        }
         if ((schema instanceof ObjectSchema) && !(schema instanceof JsonSchema)) {
-            const propertyMetadata = reflectionRegistry.getMetadata(type)?.properties.get(property);
             assertDefined(propertyMetadata, `Property "${property}" of type "${type.name}" does not have reflection metadata (path: ${path.toString()}).`);
             const propertyPrefix = columnReflectionData?.embedded?.prefix;
             const nestedPrefix = [prefix, isNull(propertyPrefix) ? '' : propertyPrefix ?? `${columnName}_`].join('');
-            return getPostgresColumnEntries(columnReflectionData?.embedded?.type ?? propertyMetadata.type, dbSchema, tableName, path.add(property), nestedPrefix);
+            return getPostgresColumnEntries(columnReflectionData?.embedded?.type ?? propertyMetadata.type, dbSchema, tableName, path.add(property), nestedPrefix, { ...options, inherited, table }, rootType);
         }
-        const objectPath = path.add(property);
         const encrypted = columnReflectionData?.encrypted == true;
         const toDatabase = encrypted
             ? async (value, context) => {
@@ -270,6 +372,8 @@ function getPostgresColumnEntries(type, dbSchema, tableName, path = new JsonPath
                 name: toCamelCase(prefixedColumnName),
                 objectPath,
                 reflectionData: columnReflectionData,
+                inherited,
+                table: table, // Will be patched later if undefined
                 buildType: (options) => getPostgresColumn(tableName, toSnakeCase(prefixedColumnName), dbSchema, schema, columnReflectionData ?? {}, options, { type, property }),
                 dereferenceObjectPath: compileDereferencer(objectPath, { optional: true }),
                 toDatabase,
@@ -290,7 +394,7 @@ function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, refl
     if (isDefined(reflectionData.unique)) {
         column = column.unique(reflectionData.unique.options?.name ?? getUniqueName(tableName, [columnName], { naming: reflectionData.unique.options?.naming }), isString(reflectionData.unique.options?.nulls) ? { nulls: reflectionData.unique.options.nulls } : undefined);
     }
-    if ((reflectionData.primaryKey == true) && (options.skipPrimaryKey != true)) {
+    if (((reflectionData.primaryKey == true) || (context.property == 'id' && reflectionData.primaryKey != false)) && (options.skipPrimaryKey != true)) {
         column = column.primaryKey();
     }
     for (const { target, targetColumn, excludeTenant } of reflectionData.references ?? []) {
@@ -313,6 +417,9 @@ function getPostgresBaseColumn(columnName, dbSchema, schema, reflectionData, con
     if (reflectionData.encrypted) {
         return bytea(columnName);
     }
+    if (isDefined(reflectionData.tsVector)) {
+        return tsvector(columnName);
+    }
     return match(schema)
         .with(P.instanceOf(UuidSchema), (s) => {
         let column = uuid(columnName);
@@ -375,7 +482,6 @@ function getForeignKeyName(tableName, foreignTableName, columnsOrBaseName, optio
         }
         throw new Error(`Identifier "${identifier}" for table "${tableName}" is too long. Maximum length is 63 characters.`);
     }
-    console.log(tableName, foreignTableName, columnsOrBaseName, 'Foreign key name:', identifier);
     return identifier;
 }
 function getTableName(type) {

package/orm/server/index.d.ts

@@ -8,6 +8,7 @@ export * from './database-schema.js';
 export * from './database.js';
 export * from './module.js';
 export * from './query-converter.js';
+export * from './repository-config.js';
 export * from './repository.js';
 export * from './transaction.js';
 export * from './transactional.js';

package/orm/server/index.js

@@ -8,6 +8,7 @@ export * from './database-schema.js';
 export * from './database.js';
 export * from './module.js';
 export * from './query-converter.js';
+export * from './repository-config.js';
 export * from './repository.js';
 export * from './transaction.js';
 export * from './transactional.js';

package/orm/server/module.d.ts

@@ -5,7 +5,8 @@
  * via dependency injection.
  */
 import type { PoolConfig } from 'pg';
-import { EntityRepositoryConfig } from './repository.js';
+import { Injector } from '../../injector/injector.js';
+import { EntityRepositoryConfig } from './repository-config.js';
 /**
  * Configuration class for the database connection.
  */
@@ -23,6 +24,7 @@ export type OrmModuleOptions = {
  * Configures the ORM module by registering necessary providers in the dependency injector.
  * @param options - Configuration options including connection details, repository settings, and the encryption secret.
  */
-export declare function configureOrm(options: OrmModuleOptions & {
+export declare function configureOrm({ injector, ...options }?: OrmModuleOptions & {
     encryptionSecret?: Uint8Array;
+    injector?: Injector;
 }): void;

package/orm/server/module.js

@@ -1,6 +1,6 @@
 import { Injector } from '../../injector/injector.js';
 import { isDefined } from '../../utils/type-guards.js';
-import { EntityRepositoryConfig } from './repository.js';
+import { EntityRepositoryConfig } from './repository-config.js';
 import { ENCRYPTION_SECRET } from './tokens.js';
 /**
  * Configuration class for the database connection.
@@ -12,14 +12,15 @@ export class DatabaseConfig {
  * Configures the ORM module by registering necessary providers in the dependency injector.
  * @param options - Configuration options including connection details, repository settings, and the encryption secret.
  */
-export function configureOrm(options) {
+export function configureOrm({ injector, ...options } = {}) {
+    const targetInjector = injector ?? Injector;
     if (isDefined(options.connection)) {
-        Injector.register(DatabaseConfig, { useValue: { connection: options.connection } });
+        targetInjector.register(DatabaseConfig, { useValue: { connection: options.connection } });
     }
     if (isDefined(options.repositoryConfig)) {
-        Injector.register(EntityRepositoryConfig, { useValue: options.repositoryConfig });
+        targetInjector.register(EntityRepositoryConfig, { useValue: options.repositoryConfig });
     }
     if (isDefined(options.encryptionSecret)) {
-        Injector.register(ENCRYPTION_SECRET, { useValue: options.encryptionSecret });
+        targetInjector.register(ENCRYPTION_SECRET, { useValue: options.encryptionSecret });
     }
 }

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

@@ -3,20 +3,23 @@ import type { BaseEntity } from '../entity.js';
 import type { Query, TsVectorParser, TsVectorWeight } from '../query/index.js';
 import type { TargetColumn } from '../repository.types.js';
 import type { ColumnDefinition, ExtraConfigColumnsFromType, PgTableFromType } from './types.js';
+export type ResolveTargetColumnOptions = {
+    ignorePgTable?: boolean;
+};
 /**
  * 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;
+export declare function resolveTargetColumn<T extends BaseEntity>(target: TargetColumn<T> | ColumnDefinition, table: PgTableFromType | ExtraConfigColumnsFromType, columnDefinitionsMap: Map<string, ColumnDefinition>, { ignorePgTable }?: ResolveTargetColumnOptions): 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: readonly (TargetColumn<T> | ColumnDefinition)[], table: PgTableFromType | ExtraConfigColumnsFromType, columnDefinitionsMap: Map<string, ColumnDefinition>): SQLWrapper[];
+export declare function resolveTargetColumns<T extends BaseEntity>(targets: readonly (TargetColumn<T> | ColumnDefinition)[], table: PgTableFromType | ExtraConfigColumnsFromType, columnDefinitionsMap: Map<string, ColumnDefinition>, options?: ResolveTargetColumnOptions): SQLWrapper[];
 /**
  * Converts a query object into a Drizzle SQL condition.
  * Recursively handles nested logical operators and maps property names to database columns.
@@ -29,6 +32,6 @@ export declare function resolveTargetColumns<T extends BaseEntity>(targets: read
  * @throws {Error} If a property cannot be mapped to a column.
  * @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 convertQuery(query: Query, table: PgTableFromType, columnDefinitionsMap: Map<string, ColumnDefinition>, options?: ResolveTargetColumnOptions): 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,9 +1,9 @@
 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 { hasOwnProperty, mapObject, mapObjectKeysToSnakeCase, objectEntries } from '../../utils/object/object.js';
+import { fromEntries, hasOwnProperty, mapObject, mapObjectKeysToSnakeCase, objectEntries } from '../../utils/object/object.js';
 import { toSnakeCase } from '../../utils/string/index.js';
-import { assert, assertDefinedPass, isArray, isDefined, isPrimitive, isRegExp, isString, isUndefined } from '../../utils/type-guards.js';
+import { assert, assertDefinedPass, isArray, isDefined, isFunction, isObject, isPrimitive, isRegExp, isString, isUndefined } from '../../utils/type-guards.js';
 import { array, isSimilar, isStrictWordSimilar, isWordSimilar, jsonbBuildObject, phraseToTsQuery, plainToTsQuery, setweight, similarity, strictWordSimilarity, toTsQuery, toTsVector, websearchToTsQuery, wordSimilarity } from '../sqls/index.js';
 const sqlTrue = sql `true`;
 /**
@@ -12,13 +12,16 @@ const sqlTrue = sql `true`;
  * @param table The Drizzle table object.
  * @param columnDefinitionsMap A map from property names to column definitions.
  */
-export function resolveTargetColumn(target, table, columnDefinitionsMap) {
+export function resolveTargetColumn(target, table, columnDefinitionsMap, { ignorePgTable = false } = {}) {
     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
+    if (isDefined(columnDef.table) && !ignorePgTable) {
+        return columnDef.table[columnDef.name];
+    }
     return table[columnDef.name];
 }
 /**
@@ -27,8 +30,8 @@ export function resolveTargetColumn(target, table, columnDefinitionsMap) {
  * @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));
+export function resolveTargetColumns(targets, table, columnDefinitionsMap, options) {
+    return targets.map((target) => resolveTargetColumn(target, table, columnDefinitionsMap, options));
 }
 /**
  * Converts a query object into a Drizzle SQL condition.
@@ -42,7 +45,7 @@ export function resolveTargetColumns(targets, table, columnDefinitionsMap) {
  * @throws {Error} If a property cannot be mapped to a column.
  * @throws {Error} If an unsupported query type is encountered.
  */
-export function convertQuery(query, table, columnDefinitionsMap) {
+export function convertQuery(query, table, columnDefinitionsMap, options) {
     if (query instanceof SQL) {
         return query;
     }
@@ -57,7 +60,7 @@ export function convertQuery(query, table, columnDefinitionsMap) {
     for (const [property, value] of queryEntries) {
         switch (property) {
             case '$and': {
-                const subQueries = value.map((item) => convertQuery(item, table, columnDefinitionsMap));
+                const subQueries = value.map((item) => convertQuery(item, table, columnDefinitionsMap, options));
                 const andCondition = and(...subQueries);
                 if (isDefined(andCondition)) {
                     conditions.push(andCondition);
@@ -65,7 +68,7 @@ export function convertQuery(query, table, columnDefinitionsMap) {
                 break;
             }
             case '$or': {
-                const subQueries = value.map((item) => convertQuery(item, table, columnDefinitionsMap));
+                const subQueries = value.map((item) => convertQuery(item, table, columnDefinitionsMap, options));
                 const orCondition = or(...subQueries);
                 if (isDefined(orCondition)) {
                     conditions.push(orCondition);
@@ -73,7 +76,7 @@ export function convertQuery(query, table, columnDefinitionsMap) {
                 break;
             }
             case '$nor': {
-                const subQueries = value.map((item) => convertQuery(item, table, columnDefinitionsMap));
+                const subQueries = value.map((item) => convertQuery(item, table, columnDefinitionsMap, options));
                 const orCondition = or(...subQueries);
                 if (isDefined(orCondition)) {
                     const norCondition = not(orCondition);
@@ -86,7 +89,7 @@ export function convertQuery(query, table, columnDefinitionsMap) {
                 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);
+                    const sqlField = resolveTargetColumn(field, table, columnDefinitionsMap, options);
                     if (isDefined(weight)) {
                         return [sqlField, weight];
                     }
@@ -100,7 +103,7 @@ export function convertQuery(query, table, columnDefinitionsMap) {
             case '$trigram': {
                 const trigramQuery = value;
                 const fields = isArray(trigramQuery.fields) ? trigramQuery.fields : [trigramQuery.fields];
-                const convertedFields = fields.map((target) => resolveTargetColumn(target, table, columnDefinitionsMap));
+                const convertedFields = fields.map((target) => resolveTargetColumn(target, table, columnDefinitionsMap, options));
                 const searchExpression = sql `(${sql.join(convertedFields, sql ` || ' ' || `)})`;
                 if (isDefined(trigramQuery.threshold)) {
                     const similarityFn = getTrigramSimilarityFunction(trigramQuery.type);
@@ -117,7 +120,7 @@ export function convertQuery(query, table, columnDefinitionsMap) {
                 if (hasOwnProperty(paradeQuery, 'fields')) {
                     const { fields, query: searchQuery, conjunction, distance, prefix, transpositionCostOne } = paradeQuery;
                     const operator = (conjunction == true) ? sql `&&&` : sql `|||`;
-                    const convertedFields = fields.map((target) => resolveTargetColumn(target, table, columnDefinitionsMap));
+                    const convertedFields = fields.map((target) => resolveTargetColumn(target, table, columnDefinitionsMap, options));
                     const searchExpression = sql `(${sql.join(convertedFields, sql ` || ' ' || `)})`;
                     const casts = [];
                     if (isDefined(distance) && (distance > 0)) {
@@ -133,14 +136,22 @@ export function convertQuery(query, table, columnDefinitionsMap) {
                     conditions.push(condition);
                 }
                 else {
-                    const convertedParadeQuery = convertParadeSpecialQuery(paradeQuery, table, columnDefinitionsMap);
+                    const convertedParadeQuery = convertParadeSpecialQuery(paradeQuery, table, columnDefinitionsMap, options);
                     conditions.push(sql `${table.id} @@@ ${convertedParadeQuery}::pdb.query`);
                 }
                 break;
             }
             default: {
-                const columnDef = assertDefinedPass(columnDefinitionsMap.get(property), `Could not map property ${property} to column.`);
-                const column = table[columnDef.name];
+                const columnDef = columnDefinitionsMap.get(property);
+                if (isUndefined(columnDef)) {
+                    if (isObject(value) && !isArray(value) && !isSQLWrapper(value)) {
+                        const subQuery = fromEntries(objectEntries(value).map(([key, val]) => [`${property}.${key}`, val]));
+                        conditions.push(convertQuery(subQuery, table, columnDefinitionsMap, options));
+                        continue;
+                    }
+                    throw new Error(`Could not map property ${property} to column.`);
+                }
+                const column = resolveTargetColumn(columnDef, table, columnDefinitionsMap, options);
                 const condition = getCondition(property, value, column, table, columnDefinitionsMap);
                 conditions.push(condition);
                 break;
@@ -252,7 +263,7 @@ function getCondition(property, value, column, table, columnDefinitionsMap) {
     }
     if (hasOwnProperty(value, '$parade')) {
         const queryValue = value.$parade;
-        if (isDefined(queryValue.match)) {
+        if (isDefined(queryValue.match) && isUndefined(queryValue.match.tokenizer)) {
             const { value: matchValue, conjunctionMode, ...options } = queryValue.match;
             const operator = (conjunctionMode == true) ? sql `&&&` : sql `|||`;
             const casts = buildParadeCasts(options);
@@ -354,7 +365,7 @@ function convertParadeComparisonQuery(query) {
 /**
  * Converts a ParadeSpecialQueryObject into a Drizzle SQL object representing the JSONB structure.
  */
-function convertParadeSpecialQuery(query, table, columnDefinitionsMap) {
+function convertParadeSpecialQuery(query, table, columnDefinitionsMap, options) {
     const entries = objectEntries(query);
     assert(entries.length == 1, 'ParadeDB special query object must have exactly one key.');
     const [key, queryValue] = entries[0];
@@ -363,10 +374,10 @@ function convertParadeSpecialQuery(query, table, columnDefinitionsMap) {
         .with('all', 'empty', () => sql `null`)
         .with('moreLikeThis', () => {
         const { fields, document, ...properties } = mapObjectKeysToSnakeCase(queryValue);
-        const resolvedFields = fields.map((field) => resolveTargetColumn(field, table, columnDefinitionsMap));
+        const resolvedFields = fields.map((field) => resolveTargetColumn(field, table, columnDefinitionsMap, options));
         const columnNames = resolvedFields.map((field) => (field instanceof Column) ? sql `${field.name}` : field);
         const fieldsArraySql = (columnNames.length > 0) ? array(columnNames) : undefined;
-        const documentJson = isDefined(document) ? JSON.stringify(mapObject(document, (key, value) => [resolveTargetColumn(key, table, columnDefinitionsMap).name, value])) : undefined;
+        const documentJson = isDefined(document) ? JSON.stringify(mapObject(document, (key, value) => [resolveTargetColumn(key, table, columnDefinitionsMap, options).name, value])) : undefined;
         return jsonbBuildObject({
             ...properties,
             fields: fieldsArraySql,
@@ -414,7 +425,8 @@ export function getTsQuery(text, language, parser) {
 export function getTsVector(fields, language) {
     const sqlFields = fields.map((fieldWithWeight) => {
         const [field, weight] = isArray(fieldWithWeight) ? fieldWithWeight : [fieldWithWeight, undefined];
-        const vector = toTsVector(language, field);
+        const isTsVector = (field instanceof Column) && (field.getSQLType() == 'tsvector');
+        const vector = isTsVector ? sql `${field}` : toTsVector(language, field);
         if (isDefined(weight)) {
             return setweight(vector, weight);
         }

package/orm/server/repository-config.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Configuration class for EntityRepository.
+ * Specifies the database schema to be used.
+ */
+export declare class EntityRepositoryConfig {
+    /** The name of the database schema. */
+    schema: string;
+}

package/orm/server/repository-config.js

@@ -0,0 +1,8 @@
+/**
+ * Configuration class for EntityRepository.
+ * Specifies the database schema to be used.
+ */
+export class EntityRepositoryConfig {
+    /** The name of the database schema. */
+    schema;
+}