@tstdl/base 0.93.27 → 0.93.29

package/orm/data-types/tsvector.d.ts

@@ -1,6 +1,8 @@
 /**
  * Custom Drizzle type for PostgreSQL `tsvector` columns.
+ * This type is a placeholder for the column type and does not perform
+ * any data transformation, as `tsvector` columns are typically not directly mapped to application data.
  */
 export declare const tsvector: import("./common.js").CustomTypeBuilder<{
-    data: unknown;
+    data: string;
 }>;

package/orm/data-types/tsvector.js

@@ -5,6 +5,8 @@
 import { createCustomType } from './common.js';
 /**
  * Custom Drizzle type for PostgreSQL `tsvector` columns.
+ * This type is a placeholder for the column type and does not perform
+ * any data transformation, as `tsvector` columns are typically not directly mapped to application data.
  */
 export const tsvector = createCustomType({
     dataType() {

package/orm/decorators.d.ts

@@ -4,19 +4,26 @@
  */
 import type { SQL } from 'drizzle-orm';
 import type { ExtraConfigColumn } from 'drizzle-orm/pg-core';
-import type { LiteralUnion } from 'type-fest';
+import type { LiteralUnion, SetRequired } from 'type-fest';
 import { type SpecificCreateDecoratorOptions } from '../reflection/index.js';
 import type { AbstractConstructor, Record, TypedOmit } from '../types/index.js';
 import type { ValueOrProvider } from '../utils/value-or-provider.js';
 import type { AnyEntity, BaseEntity, Entity, EntityType } from './entity.js';
-import type { Query } from './query.js';
+import type { Query } from './query/index.js';
 import type { TargetColumnPath } from './repository.types.js';
 import type { ExtraConfigColumnsFromType } from './server/types.js';
 type IndexMethod = LiteralUnion<'hash' | 'btree' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hnsw' | 'ivfflat' | 'bm25', string>;
 type NamingStrategy = 'abbreviated-table';
 type Column<T extends BaseEntity> = TargetColumnPath<T>;
 type Columns<T extends BaseEntity> = [Column<T>, ...Column<T>[]];
+export type ParadeIndexColumn<T extends BaseEntity> = TargetColumnPath<T> | SQL | ExtraConfigColumn;
+export type ParadeIndexColumnConfig<T extends BaseEntity> = ValueOrProvider<ParadeIndexColumn<T> | readonly [ParadeIndexColumn<T>, ParadeFieldOptions], ExtraConfigColumnsFromType<EntityType<T>>>;
+export type ParadeIndexCompoundColumnColumnsProvider<T extends BaseEntity> = ValueOrProvider<readonly ParadeIndexColumn<T>[], ExtraConfigColumnsFromType<EntityType<T>>>;
+export type ParadeIndexCompoundColumnConfig<T extends BaseEntity> = readonly [ParadeIndexCompoundColumnColumnsProvider<T>, SetRequired<ParadeFieldOptions, 'alias' | 'tokenizer'>];
+export type ParadeIndexExpressionProvider<T extends BaseEntity> = SqlOrBuilder<T, string>;
+export type ParadeIndexExpressionConfig<T extends BaseEntity> = readonly [ParadeIndexExpressionProvider<T>, SetRequired<ParadeFieldOptions, 'alias' | 'tokenizer'>];
 export type SqlBuilder<T extends BaseEntity = any, R = SQL> = (table: ExtraConfigColumnsFromType<EntityType<T>>) => R;
+export type SqlOrBuilder<T extends BaseEntity = any, V = unknown> = SQL<V> | SqlBuilder<T, SQL<V>>;
 /**
  * Builder function type for creating SQL check constraints.
  * @param table The Drizzle table object.
@@ -30,13 +37,14 @@ export type WhereBuilder<T extends BaseEntity = BaseEntity> = SqlBuilder<T, Quer
 /**
  * Reflection data stored for ORM table decorators.
  */
-export type OrmTableReflectionData = {
+export type OrmTableReflectionData<T extends BaseEntity = BaseEntity> = {
     name?: string;
     schema?: string;
-    compundPrimaryKeyName?: string;
-    compundPrimaryKeyNaming?: NamingStrategy;
+    compoundPrimaryKeyName?: string;
+    compoundPrimaryKeyNaming?: NamingStrategy;
     unique?: UniqueReflectionData[];
     index?: IndexReflectionData[];
+    paradeIndex?: ParadeIndexReflectionData<T>;
     checks?: CheckReflectionData[];
     foreignKeys?: ForeignKeyReflectionData[];
 };
@@ -59,6 +67,8 @@ export type OrmColumnReflectionData = {
         target: () => EntityType;
         targetColumn?: TargetColumnPath<any>;
     }[];
+    paradeField?: ParadeFieldOptions;
+    tsVector?: TsVectorOptions<any>;
     encrypted?: boolean;
     expirationField?: {
         after: number;
@@ -83,16 +93,7 @@ export type UniqueReflectionData = {
 export type IndexReflectionData<T extends BaseEntity = any> = {
     columns?: ValueOrProvider<(TargetColumnPath<T> | [TargetColumnPath<T>, 'asc' | 'desc'] | SQL | ExtraConfigColumn)[], ExtraConfigColumnsFromType<EntityType<T>>>;
     order?: 'asc' | 'desc';
-    options?: {
-        name?: string;
-        naming?: NamingStrategy;
-        using?: IndexMethod;
-        unique?: boolean;
-        where?: WhereBuilder<T>;
-        with?: Record<string, number | string | boolean | SQL>;
-        concurrently?: boolean;
-        nulls?: 'first' | 'last';
-    };
+    options?: IndexOptions<T>;
 };
 type CheckReflectionData = {
     name: string;
@@ -110,12 +111,106 @@ export type ForeignKeyReflectionData = {
         naming?: NamingStrategy;
     };
 };
+export type IndexOptions<T extends BaseEntity> = {
+    name?: string;
+    naming?: NamingStrategy;
+    using?: IndexMethod;
+    unique?: boolean;
+    where?: WhereBuilder<T>;
+    with?: Record<string, number | string | boolean | SQL>;
+    concurrently?: boolean;
+    nulls?: 'first' | 'last';
+    opclass?: string;
+};
+export type ParadeIndexReflectionData<T extends BaseEntity> = Pick<IndexOptions<T>, 'naming' | 'where' | 'concurrently'> & {
+    /**
+     * Columns to include in the Parade index.
+     */
+    columns?: readonly ParadeIndexColumnConfig<T>[];
+    /**
+     * Columns to include in the Parade index.
+     */
+    compoundColumns?: readonly ParadeIndexCompoundColumnConfig<T>[];
+    /**
+     * Expressions to include in the Parade index based on combined.
+     */
+    expressions?: readonly ParadeIndexExpressionConfig<T>[];
+    targetSegmentCount?: number;
+    layerSizes?: string;
+    backgroundLayerSizes?: string;
+    mutableSegmentRows?: number;
+};
+export type ParadeTokenizer = 'simple' | 'whitespace' | 'literal' | 'literal_normalized' | 'ngram' | 'regex_pattern' | 'source_code' | 'chinese_compatible' | 'lindera' | 'jieba' | 'icu';
+/**
+ * A type-safe object for configuring ParadeDB token filters.
+ */
+export type ParadeTokenizerFilters = {
+    /**
+     * Reduces words to their root form for a given language.
+     * Corresponds to the `stemmer` parameter.
+     */
+    stemmer?: 'arabic' | 'danish' | 'dutch' | 'english' | 'finnish' | 'french' | 'german' | 'greek' | 'hungarian' | 'italian' | 'norwegian' | 'portuguese' | 'romanian' | 'russian' | 'spanish' | 'swedish' | 'tamil' | 'turkish';
+    /**
+     * Removes language-specific stopwords from the index.
+     * Corresponds to the `stopwords_language` parameter.
+     */
+    stopwordsLanguage?: 'danish' | 'dutch' | 'english' | 'finnish' | 'french' | 'german' | 'hungarian' | 'italian' | 'norwegian' | 'portuguese' | 'russian' | 'spanish' | 'swedish';
+    /**
+     * Strips away diacritical marks (accents, umlauts, etc.).
+     * Corresponds to the `ascii_folding` parameter.
+     */
+    asciiFolding?: boolean;
+    /**
+     * Removes any tokens that contain characters that are not ASCII letters or digits.
+     * Corresponds to the `alpha_num_only` parameter.
+     */
+    alphaNumOnly?: boolean;
+    /**
+     * Converts all characters to lowercase. Enabled by default. Set to `false` to disable.
+     * Corresponds to the `lowercase` parameter.
+     */
+    lowercase?: boolean;
+    /**
+     * Removes tokens that are longer than a certain byte length.
+     * Corresponds to the `remove_long` parameter.
+     */
+    removeLong?: number;
+    /**
+     * Removes tokens that are shorter than a certain byte length.
+     * Corresponds to the `remove_short` parameter.
+     */
+    removeShort?: number;
+};
+export type ParadeTokenizerConfig = ParadeTokenizer | {
+    /** The type of tokenizer to use. */
+    type: ParadeTokenizer;
+    /**
+     * Raw parameters for the tokenizer (e.g., for ngram min/max length).
+     * For common token filters, prefer using the structured `filters` property.
+     */
+    parameters?: (string | number)[];
+    /** Type-safe configuration for common token filters. */
+    filters?: ParadeTokenizerFilters;
+};
+export type ParadeFieldOptions = {
+    /**
+     * The tokenizer configuration for this field. Can be a simple string (e.g., 'literal')
+     * or a configuration object for advanced settings.
+     */
+    tokenizer?: ParadeTokenizerConfig;
+    /**
+     * Provides an alias for this field configuration, allowing the same source column
+     * to be indexed in multiple ways. The aliased field can be queried using
+     * a `$parade` query on the original field, specifying the alias.
+     */
+    alias?: string;
+};
 /**
  * Factory function to create a class decorator for ORM table configuration.
  * Merges provided data with existing ORM reflection data on the class metadata.
  * @param data The ORM table reflection data to add.
  */
-export declare function createTableDecorator(data?: OrmTableReflectionData): ClassDecorator;
+export declare function createTableDecorator<T extends BaseEntity = BaseEntity>(data?: OrmTableReflectionData<T>): ClassDecorator;
 /**
  * Factory function to create a property decorator for ORM column configuration.
  * Merges provided data with existing ORM reflection data on the property metadata.
@@ -202,14 +297,14 @@ export declare function Unique<T extends AnyEntity>(columns: Columns<T>, options
  * @param name Optional name for the index.
  * @param options Additional index options (e.g., method, uniqueness, conditions).
  */
-export declare function Index<T extends BaseEntity = any>(options?: IndexReflectionData<T>['options']): PropertyDecorator;
+export declare function Index<T extends BaseEntity = BaseEntity>(options?: IndexReflectionData<T>['options']): PropertyDecorator;
 /**
  * Define a composite index on multiple columns.
  * @template T The entity type.
  * @param columns An array of property names (or tuples with direction) included in the index.
  * @param options Additional index options.
  */
-export declare function Index<T extends BaseEntity = any>(columns: Columns<T>, options?: IndexReflectionData<T>['options']): ClassDecorator;
+export declare function Index<T extends BaseEntity>(columns: NonNullable<IndexReflectionData<T>['columns']>, options?: IndexReflectionData<T>['options']): ClassDecorator;
 /**
  * Automatically expire records after a certain time to live (TTL) based on the createTimestamp metadata. Requires extension of {@link Entity} instead of {@link BaseEntity}.
  * @param ttl Time To Live in milliseconds.
@@ -225,4 +320,59 @@ export declare function Expires(options?: {
     after?: number;
     mode?: 'soft' | 'hard';
 }): PropertyDecorator;
+/**
+ * Define a trigram index on a text column for similarity searches.
+ * @param options Index options, like the method to use ('gin' or 'gist').
+ */
+export declare function TrigramIndex(options?: {
+    method?: 'gin' | 'gist';
+    name?: string;
+}): PropertyDecorator;
+export type TsVectorOptions<T extends BaseEntity> = {
+    /** The source columns to generate the tsvector from. */
+    sources: (TargetColumnPath<T>)[];
+    /** The text search configuration language. Defaults to 'simple'. */
+    language?: string | SQL;
+    /** Weights for different source columns. */
+    weights?: Partial<Record<TargetColumnPath<T>, 'A' | 'B' | 'C' | 'D'>>;
+    /** The index method to use on the generated column. Defaults to 'gin'. */
+    indexMethod?: 'gin' | 'gist';
+};
+/**
+ * Defines a `tsvector` column that is automatically generated from other columns.
+ * Also creates a GIN or GiST index on the column for efficient full-text search.
+ * @param options Configuration for the generated tsvector column.
+ */
+export declare function GeneratedTsVector<T extends BaseEntity>(options: TsVectorOptions<T>): PropertyDecorator;
+/**
+ * Defines a Parade BM25 full-text search index on the entity.
+ * Can be used on a class to define the index and its columns, or on a property to configure a specific field's tokenization.
+ *
+ * @example
+ * // On a class, defining index expressions
+ * @ParadeIndex({
+ *   columns: [
+ *     'description', // simple column
+ *     ['category', { tokenizer: 'literal' }], // column with options
+ *     [sql`(data->>'name')::text`, { tokenizer: 'simple' }] // expression with options
+ *   ]
+ * })
+ *
+ * @example
+ * // On a property, defining field-specific options with type-safe filters
+ * @ParadeIndex({
+ *   tokenizer: {
+ *     type: 'simple',
+ *     filters: {
+ *       stemmer: 'english',
+ *       stopwordsLanguage: 'english'
+ *     }
+ *   }
+ * })
+ * description: string;
+ */
+export declare function ParadeIndex<T extends BaseEntity>(options: ParadeIndexReflectionData<T>): ClassDecorator;
+export declare function ParadeIndex(options?: ParadeFieldOptions): PropertyDecorator;
+export declare function ParadeCompoundIndex<T extends BaseEntity>(alias: string, compoundColumns: ParadeIndexCompoundColumnColumnsProvider<T>, options?: TypedOmit<ParadeFieldOptions, 'alias'>): ClassDecorator;
+export declare function ParadeExpressionIndex<T extends BaseEntity>(alias: string, expression: ParadeIndexExpressionProvider<T>, options?: TypedOmit<ParadeFieldOptions, 'alias'>): ClassDecorator;
 export {};

package/orm/decorators.js

@@ -1,7 +1,9 @@
+import { match } from 'ts-pattern';
 import { createClassDecorator, createDecorator, createPropertyDecorator } from '../reflection/index.js';
 import { Property } from '../schema/index.js';
+import { merge } from '../utils/merge.js';
 import { filterUndefinedObjectProperties, objectEntries, propertyNameOf } from '../utils/object/index.js';
-import { isArray, isString, isUndefined } from '../utils/type-guards.js';
+import { isArray, isFunction, isString, isUndefined } from '../utils/type-guards.js';
 /**
  * Merges ORM reflection data into the target's metadata.
  * @param metadata The metadata object for the class or property.
@@ -122,7 +124,7 @@ export function Unique(columnsOrOptions, options) {
     return createColumnDecorator({ unique: { options: columnsOrOptions } });
 }
 export function Index(columnsOrOptions, options) {
-    if (isArray(columnsOrOptions)) {
+    if (isArray(columnsOrOptions) || isFunction(columnsOrOptions)) {
         return createTableDecorator({ index: [{ columns: columnsOrOptions, options }] });
     }
     return createColumnDecorator({ index: { options: columnsOrOptions } });
@@ -145,3 +147,47 @@ export function TimeToLive(ttl, mode) {
 export function Expires(options) {
     return createColumnDecorator({ expirationField: { after: options?.after ?? 0, mode: options?.mode ?? 'soft' } });
 }
+/**
+ * Define a trigram index on a text column for similarity searches.
+ * @param options Index options, like the method to use ('gin' or 'gist').
+ */
+export function TrigramIndex(options) {
+    const method = options?.method ?? 'gin';
+    return Index({
+        name: options?.name,
+        using: method,
+        opclass: `${method}_trgm_ops`,
+    });
+}
+/**
+ * Defines a `tsvector` column that is automatically generated from other columns.
+ * Also creates a GIN or GiST index on the column for efficient full-text search.
+ * @param options Configuration for the generated tsvector column.
+ */
+export function GeneratedTsVector(options) {
+    const { indexMethod = 'gin' } = options;
+    return createPropertyDecorator({
+        include: [
+            createColumnDecorator({ tsVector: options }),
+            Index({ using: indexMethod }),
+        ],
+    });
+}
+export function ParadeIndex(options) {
+    return createDecorator({ class: true, property: true }, (data, metadata) => {
+        match(metadata.metadataType)
+            .with('type', () => {
+            const existing = (metadata.data.tryGet('orm') ?? {}).paradeIndex;
+            const merged = merge(existing, options);
+            return createTableDecorator({ paradeIndex: merged })(data.constructor);
+        })
+            .with('property', () => createColumnDecorator({ paradeField: options ?? {} })(data.prototype, data.propertyKey))
+            .exhaustive();
+    });
+}
+export function ParadeCompoundIndex(alias, compoundColumns, options) {
+    return ParadeIndex({ compoundColumns: [[compoundColumns, { alias, tokenizer: 'simple', ...options }]] });
+}
+export function ParadeExpressionIndex(alias, expression, options) {
+    return ParadeIndex({ expressions: [[expression, { alias, tokenizer: 'simple', ...options }]] });
+}

package/orm/index.d.ts

@@ -5,7 +5,7 @@
  */
 export * from './decorators.js';
 export * from './entity.js';
-export * from './query.js';
+export * from './query/index.js';
 export * from './repository.types.js';
 export * from './schemas/index.js';
 export * from './sqls.js';

package/orm/index.js

@@ -5,7 +5,7 @@
  */
 export * from './decorators.js';
 export * from './entity.js';
-export * from './query.js';
+export * from './query/index.js';
 export * from './repository.types.js';
 export * from './schemas/index.js';
 export * from './sqls.js';

package/orm/{query.d.ts → query/base.d.ts}

@@ -1,10 +1,11 @@
 import type { SQL, SQLWrapper } from 'drizzle-orm';
-import type { LiteralUnion, UnionToIntersection } from 'type-fest';
-import type { Geometry } from '../types/geo-json.js';
-import type { Flatten, Record } from '../types/index.js';
-import type { UntaggedDeep } from '../types/tagged.js';
-import type { BaseEntity } from './entity.js';
-import type { TargetColumn } from './repository.types.js';
+import type { UnionToIntersection } from 'type-fest';
+import type { Geometry } from '../../types/geo-json.js';
+import type { Flatten, Record } from '../../types/index.js';
+import type { UntaggedDeep } from '../../types/tagged.js';
+import type { BaseEntity } from '../entity.js';
+import type { TargetColumnPath } from '../repository.types.js';
+import { type ParadeComparisonQuery, type ParadeSearchQuery, type ParadeSpecialQuery } from './parade.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>;
 /** Union of keys representing logical query operators ('$and', '$or', '$nor'). */
@@ -18,7 +19,7 @@ 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 & ComparisonTsVectorQuery & ComparisonTrigramQuery & ComparisonParadeMatchQuery & ComparisonParadeTantivyQuery & 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 & ComparisonTsVectorQuery & ComparisonTrigramQuery & ParadeComparisonQuery & ComparisonGeoShapeQuery & ComparisonGeoDistanceQuery>;
 export type TsVectorParser = 'raw' | 'plain' | 'phrase' | 'websearch';
 export type TsVectorWeight = 'A' | 'B' | 'C' | 'D';
 export type TrigramSimilarityType = 'phrase' | 'word' | 'strict-word';
@@ -27,8 +28,8 @@ 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. */
-export type SpecialQuery<T extends BaseEntity = BaseEntity> = FullTextSearchQuery<T>;
-export type FullTextSearchQuery<T extends BaseEntity = BaseEntity> = TsVectorSearchQuery<T> | TrigramSearchQuery<T> | ParadeDbSearchQuery<T>;
+export type SpecialQuery<T extends BaseEntity = BaseEntity> = FullTextSearchQuery<T> | ParadeSpecialQuery<T>;
+export type FullTextSearchQuery<T extends BaseEntity = BaseEntity> = TsVectorSearchQuery<T> | TrigramSearchQuery<T> | ParadeSearchQuery<T>;
 /** Union of keys representing special query operators. */
 export type SpecialQueryTypes = keyof UnionToIntersection<SpecialQuery>;
 /** Array containing all valid special query operator keys. */
@@ -40,11 +41,11 @@ export declare const allSpecialQueryTypes: SpecialQueryTypes[];
  */
 export type Query<T = any> = SQLWrapper | QueryObject<Extract<UntaggedDeep<T>, BaseEntity>>;
 /** Represents a structured query object, combining logical, comparison, and special queries. */
-export type QueryObject<T extends BaseEntity> = LogicalQuery<T> | (ComparisonQueryBody<T> & Partial<SpecialQuery<T>>);
+export type QueryObject<T extends BaseEntity> = LogicalQuery<T> | Partial<SpecialQuery<T>> | ComparisonQueryBody<T>;
 /** 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" | "$tsvector" | "$trigram" | "$match" | "$tantivy" | "$geoShape" | "$geoDistance" | "$parade")[];
+export declare const allQueryTypes: ("$parade" | "$and" | "$or" | "$nor" | "$not" | "$eq" | "$neq" | "$exists" | "$item" | "$in" | "$nin" | "$all" | "$gt" | "$gte" | "$lt" | "$lte" | "$regex" | "$tsvector" | "$trigram" | "$geoShape" | "$geoDistance")[];
 /** Represents an AND logical query. All sub-queries must be true. */
 export type LogicalAndQuery<T = any> = {
     $and: readonly Query<T>[];
@@ -148,23 +149,6 @@ export type ComparisonTrigramQuery = {
         threshold?: number;
     };
 };
-/** Represents a ParadeDB match query. */
-export type ComparisonParadeMatchQuery = {
-    $match: string | {
-        query: string;
-        distance?: number;
-        prefix?: boolean;
-        conjunctionMode?: boolean;
-    };
-};
-/** Represents a ParadeDB parse query (Tantivy syntax). */
-export type ComparisonParadeTantivyQuery = {
-    $tantivy: string | {
-        query: string;
-        conjunctionMode?: boolean;
-        lenient?: boolean;
-    };
-};
 /** Defines the possible spatial relationships for geospatial shape queries. */
 export type GeoShapeRelation = 'intersects' | 'within' | 'disjoint' | 'contains';
 /** Represents a geospatial query based on shape relationships ($geoShape). */
@@ -192,7 +176,7 @@ export type ComparisonGeoDistanceQuery = {
 /** Represents a multi-field tsvector search. */
 export type TsVectorSearchQuery<T extends BaseEntity = BaseEntity> = {
     $tsvector: {
-        fields: readonly (TargetColumn<T> | readonly [TargetColumn<T>, TsVectorWeight])[];
+        fields: readonly (TargetColumnPath<T> | readonly [TargetColumnPath<T>, TsVectorWeight])[];
         query: string | SQL<string>;
         parser?: TsVectorParser;
         language?: string | SQL<string>;
@@ -201,145 +185,9 @@ export type TsVectorSearchQuery<T extends BaseEntity = BaseEntity> = {
 /** Represents a multi-field trigram search. */
 export type TrigramSearchQuery<T extends BaseEntity = BaseEntity> = {
     $trigram: {
-        fields: readonly TargetColumn<T>[];
+        fields: readonly TargetColumnPath<T>[];
         query: string | SQL<string>;
         type?: TrigramSimilarityType;
         threshold?: number;
     };
 };
-/**
- * Represents a ParadeDB tokenizer configuration object for a `match` query.
- */
-export type ParadeDbTokenizerObject = {
-    type: LiteralUnion<'default' | 'whitespace' | 'raw' | 'keyword' | 'regex' | 'ngram' | 'source_code' | 'chinese_compatible' | 'chinese_lindera' | 'korean_lindera' | 'japanese_lindera' | 'jieba' | 'icu', string>;
-    [key: string]: any;
-};
-/**
- * Represents a bound for a ParadeDB range query.
- */
-type ParadeDbRangeBound<V> = {
-    included: V;
-} | {
-    excluded: V;
-};
-/** A recursive type representing the rich ParadeDB / Tantivy query DSL. */
-export type ParadeDbQueryObject<T extends BaseEntity = BaseEntity> = {
-    all?: null;
-    empty?: null;
-    term?: {
-        field: TargetColumn<T>;
-        value: any;
-    };
-    fuzzy_term?: {
-        field: TargetColumn<T>;
-        value: string;
-        distance?: number;
-        transposition_cost_one?: boolean;
-        prefix?: boolean;
-    };
-    regex?: {
-        field: TargetColumn<T>;
-        pattern: string;
-    };
-    phrase?: {
-        field: TargetColumn<T>;
-        phrases: readonly string[];
-        slop?: number;
-    };
-    match?: {
-        field: TargetColumn<T>;
-        value: string;
-        distance?: number;
-        prefix?: boolean;
-        conjunction_mode?: boolean;
-        tokenizer?: ParadeDbTokenizerObject;
-        transposition_cost_one?: boolean;
-    };
-    boolean?: {
-        must?: ParadeDbQueryObject<T> | readonly ParadeDbQueryObject<T>[];
-        should?: ParadeDbQueryObject<T> | readonly ParadeDbQueryObject<T>[];
-        must_not?: ParadeDbQueryObject<T> | readonly ParadeDbQueryObject<T>[];
-    };
-    boost?: {
-        query: ParadeDbQueryObject<T>;
-        factor: number;
-    };
-    const_score?: {
-        query: ParadeDbQueryObject<T>;
-        score: number;
-    };
-    disjunction_max?: {
-        disjuncts: readonly ParadeDbQueryObject<T>[];
-        tie_breaker?: number;
-    };
-    parse?: {
-        query_string: string | SQL<string>;
-        lenient?: boolean;
-        conjunction_mode?: boolean;
-    };
-    parse_with_field?: {
-        field: TargetColumn<T>;
-        query_string: string | SQL<string>;
-        lenient?: boolean;
-        conjunction_mode?: boolean;
-    };
-    exists?: {
-        field: TargetColumn<T>;
-    };
-    range?: {
-        field: TargetColumn<T>;
-        lower_bound?: ParadeDbRangeBound<any> | null;
-        upper_bound?: ParadeDbRangeBound<any> | null;
-        is_datetime?: boolean;
-    };
-    term_set?: {
-        terms: readonly ParadeDbQueryObject<T>[];
-    };
-    phrase_prefix?: {
-        field: TargetColumn<T>;
-        phrases: readonly string[];
-        max_expansions?: number;
-    };
-    regex_phrase?: {
-        field: TargetColumn<T>;
-        regexes: readonly string[];
-        slop?: number;
-        max_expansions?: number;
-    };
-    more_like_this?: {
-        key_value?: any;
-        document?: readonly [string, any][];
-        min_doc_frequency?: number;
-        max_doc_frequency?: number;
-        min_term_frequency?: number;
-        max_query_terms?: number;
-        min_word_length?: number;
-        max_word_length?: number;
-        boost_factor?: number;
-        stop_words?: readonly string[];
-    };
-    range_term?: {
-        field: TargetColumn<T>;
-        value: any;
-    };
-    range_intersects?: {
-        field: TargetColumn<T>;
-        lower_bound: ParadeDbRangeBound<any>;
-        upper_bound: ParadeDbRangeBound<any>;
-    };
-    range_contains?: {
-        field: TargetColumn<T>;
-        lower_bound: ParadeDbRangeBound<any>;
-        upper_bound: ParadeDbRangeBound<any>;
-    };
-    range_within?: {
-        field: TargetColumn<T>;
-        lower_bound: ParadeDbRangeBound<any>;
-        upper_bound: ParadeDbRangeBound<any>;
-    };
-};
-/** Represents a ParadeDB search using its native JSON-based query language. */
-export type ParadeDbSearchQuery<T extends BaseEntity = BaseEntity> = {
-    $parade: ParadeDbQueryObject<T>;
-};
-export {};

package/orm/{query.js → query/base.js}

@@ -1,8 +1,9 @@
+import { paradeComparisonQueryTypes, paradeSpecialQueryTypes } from './parade.js';
 /** 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', '$tsvector', '$trigram', '$match', '$tantivy', '$geoDistance', '$geoShape'];
+export const allComparisonQueryTypes = ['$all', '$not', '$eq', '$exists', '$gt', '$gte', '$in', '$item', '$lt', '$lte', '$neq', '$nin', '$regex', '$tsvector', '$trigram', '$geoDistance', '$geoShape', ...paradeComparisonQueryTypes];
 /** Array containing all valid special query operator keys. */
-export const allSpecialQueryTypes = ['$tsvector', '$trigram', '$parade'];
+export const allSpecialQueryTypes = ['$tsvector', '$trigram', ...paradeSpecialQueryTypes];
 /** Array containing all valid query operator keys. */
 export const allQueryTypes = [...allLogicalQueryTypes, ...allComparisonQueryTypes, ...allSpecialQueryTypes];

package/orm/query/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base.js';
+export * from './parade.js';

package/orm/query/index.js

@@ -0,0 +1,2 @@
+export * from './base.js';
+export * from './parade.js';