@prisma-next/extension-paradedb 0.5.0-dev.9 → 0.5.0

package/README.md

@@ -4,21 +4,21 @@ ParadeDB full-text search extension pack for Prisma Next.
 
 ## Overview
 
-This extension pack adds support for [ParadeDB](https://docs.paradedb.com/) BM25 full-text search indexes in the contract authoring layer. It keeps BM25 metadata inside extension-owned index `config` payloads, so `contract.json` and `contract.d.ts` carry the full search schema without hard-coding ParadeDB types into core SQL index IR.
+This extension pack registers a `'bm25'` index type with the SQL family's index-type registry, so contracts can author BM25 full-text search indexes via the standard `constraints.index(...)` surface and the Postgres adapter emits `CREATE INDEX ... USING bm25 WITH (...)` DDL.
 
-This is the **contract-only foundation**. Query-plane support (`@@@` operator, `pdb.*` functions) and migration-plane support (`CREATE INDEX ... USING bm25` DDL generation) are planned as follow-up work.
+The v1 surface covers the `key_field` storage parameter only. Per-field tokenizer and column configuration is deferred to expression-index support.
 
 ## Responsibilities
 
-- **BM25 Index Authoring**: Typed `bm25.*` field builders for defining BM25 indexes in `contract.ts`
-- **Tokenizer Catalog**: `TokenizerId` type union covering all 12 built-in ParadeDB tokenizers
-- **Extension Descriptor**: Declares `paradedb/bm25` capability for contract-level feature detection
-- **Pack Ref Export**: Ships a pure `/pack` entrypoint for TypeScript contract authoring
+- **bm25 index registration**: declares a `'bm25'` entry via `defineIndexTypes()` carrying an arktype validator for the bm25 options shape
+- **Extension descriptor**: declares the `paradedb/bm25` capability for contract-level feature detection
+- **Pack ref export**: ships a pure `/pack` entrypoint for TypeScript contract authoring
 
 ## Dependencies
 
-- **`@prisma-next/contract`**: Core contract types
-- **`@prisma-next/contract-authoring`**: Column type descriptor interface
+- **`@prisma-next/sql-contract`**: index-type registry primitive
+- **`@prisma-next/contract`** / **`@prisma-next/contract-authoring`**: core contract types
+- **`arktype`**: option-shape validation
 
 ## Installation
 
@@ -28,15 +28,14 @@ pnpm add @prisma-next/extension-paradedb
 
 ## Usage
 
-### Contract Definition
+### Contract definition
 
-Define BM25 indexes on your tables using `bm25` field builders plus `bm25Index()`:
+Author bm25 indexes via the standard `constraints.index(...)` surface; the registered `'bm25'` entry narrows `options` per-`type`:
 
 ```typescript
-import { int4Column, textColumn, jsonbColumn } from '@prisma-next/adapter-postgres/column-types';
+import { int4Column, textColumn } from '@prisma-next/adapter-postgres/column-types';
 import sqlFamily from '@prisma-next/family-sql/pack';
 import { defineContract, field, model } from '@prisma-next/sql-contract-ts/contract-builder';
-import { bm25, bm25Index } from '@prisma-next/extension-paradedb/index-types';
 import paradedb from '@prisma-next/extension-paradedb/pack';
 import postgres from '@prisma-next/target-postgres/pack';
 
@@ -48,121 +47,40 @@ export const contract = defineContract({
     Item: model('Item', {
       fields: {
         id: field.column(int4Column).id(),
-        description: field.column(textColumn),
-        category: field.column(textColumn),
-        rating: field.column(int4Column),
-        metadata: field.column(jsonbColumn),
+        body: field.column(textColumn),
       },
-    }).sql({
+    }).sql(({ cols, constraints }) => ({
       table: 'items',
       indexes: [
-        bm25Index({
-          keyField: 'id',
-          fields: [
-            bm25.text('description', { tokenizer: 'simple', stemmer: 'english' }),
-            bm25.text('category'),
-            bm25.numeric('rating'),
-            bm25.json('metadata', { tokenizer: 'ngram', min: 2, max: 3 }),
-          ],
-          name: 'search_idx',
+        constraints.index([cols.body], {
+          name: 'item_body_bm25_idx',
+          type: 'bm25',
+          options: { key_field: 'id' },
         }),
       ],
-    }),
+    })),
   },
 });
 ```
 
-### Field Builders
+### key_field
 
-The `bm25` namespace provides typed field builders that produce `Bm25FieldConfig` objects:
-
-| Builder | Description | Tokenizer support |
-|---------|-------------|-------------------|
-| `bm25.text(column, opts?)` | Text field (`text`, `varchar`) | Yes — any tokenizer + stemmer, remove_emojis |
-| `bm25.numeric(column)` | Numeric field (filterable, sortable) | No |
-| `bm25.boolean(column)` | Boolean field | No |
-| `bm25.json(column, opts?)` | JSON/JSONB field | Yes — tokenizer + ngram params |
-| `bm25.datetime(column)` | Timestamp/date field | No |
-| `bm25.range(column)` | Range field | No |
-| `bm25.expression(sql, opts)` | Raw SQL expression | Yes — `alias` required |
-
-### Expression-Based Fields
-
-For computed or JSON sub-field indexing, use `bm25.expression()` with a raw SQL string:
-
-```typescript
-.index(
-  bm25Index({
-    keyField: 'id',
-    fields: [
-      bm25.text('description'),
-      bm25.expression("description || ' ' || category", {
-        alias: 'concat',
-        tokenizer: 'simple',
-      }),
-      bm25.expression("(metadata->>'color')", {
-        alias: 'meta_color',
-        tokenizer: 'ngram',
-        min: 2,
-        max: 3,
-      }),
-    ],
-  }),
-)
-```
-
-### keyField Behavior
-
-ParadeDB BM25 indexes require a `key_field` — a unique column that identifies each document:
-
-- **Required**: Set `keyField` explicitly in `bm25Index(...)`.
-- **Recommended**: Use the table primary key in most cases.
-- **Override**: You can choose another unique column when needed.
-
-```typescript
-.index(bm25Index({ keyField: 'id', fields: [bm25.text('body')] }))
-.index(bm25Index({ keyField: 'uuid', fields: [bm25.text('body')] }))
-```
-
-## Tokenizers
-
-All 12 built-in ParadeDB tokenizers are available via the `TokenizerId` type:
-
-| Tokenizer | Description |
-|-----------|-------------|
-| `unicode_words` | Default. Unicode word boundaries (UAX #29). Lowercases. |
-| `simple` | Splits on non-alphanumeric. Lowercases. |
-| `ngram` | Character n-grams of configurable length. |
-| `icu` | ICU Unicode standard segmentation. Multilingual. |
-| `regex_pattern` | Regex-based tokenization. |
-| `source_code` | camelCase / snake_case splitting. |
-| `literal` | No splitting. Exact match, sort, aggregation. |
-| `literal_normalized` | Literal + lowercase + token filters. |
-| `whitespace` | Whitespace splitting + lowercase. |
-| `chinese_compatible` | CJK-aware word segmentation. |
-| `jieba` | Chinese segmentation via Jieba. |
-| `lindera` | Japanese/Korean/Chinese via Lindera. |
+ParadeDB BM25 indexes require a `key_field` — a unique column that identifies each document. It is required, must be a string, and is typically (but not always) the table's primary key.
 
 ## Capabilities
 
-The extension declares:
-
-- `paradedb/bm25`: Indicates support for BM25 full-text search indexes
-
-## Not Yet Implemented
+- `paradedb/bm25` — indicates support for BM25 full-text search indexes
 
-The following are planned for follow-up work:
+## Not yet implemented
 
-- **Query plane**: `@@@` operator support in the sql-orm query builder
-- **Query plane**: `pdb.*` query builder functions (match, term, phrase, fuzzy, etc.)
-- **Migration plane**: `CREATE INDEX ... USING bm25` DDL generation from contract diffs
-- **Runtime**: Scoring, aggregation, and highlight functions
-- **Database dependencies**: `CREATE EXTENSION pg_search` via migration planner
+- Per-column / per-expression tokenizer configuration (deferred to expression-index support)
+- `@@@` operator and `pdb.*` query builder functions
+- `CREATE EXTENSION pg_search` via migration planner
+- Scoring, aggregation, and highlight functions
 
 ## References
 
 - [ParadeDB documentation](https://docs.paradedb.com/)
 - [ParadeDB CREATE INDEX](https://docs.paradedb.com/documentation/indexing/create-index)
-- [ParadeDB Tokenizers](https://docs.paradedb.com/documentation/tokenizers/overview)
-- [pg_search source](https://github.com/paradedb/paradedb/tree/main/pg_search)
+- [ADR 210 — Index-type registry](../../../docs/architecture%20docs/adrs/ADR%20210%20-%20Index-type%20registry.md)
 - [Prisma Next Architecture Overview](../../../docs/Architecture%20Overview.md)

package/dist/control.d.mts

@@ -1,3 +1,6 @@
+import * as _$_prisma_next_sql_contract_index_types0 from "@prisma-next/sql-contract/index-types";
+import { SqlControlExtensionDescriptor } from "@prisma-next/family-sql/control";
+
 //#region src/core/descriptor-meta.d.ts
 declare const paradedbPackMeta: {
   readonly kind: "extension";
@@ -10,7 +13,24 @@ declare const paradedbPackMeta: {
       readonly 'paradedb/bm25': true;
     };
   };
+  readonly indexTypes: _$_prisma_next_sql_contract_index_types0.IndexTypeBuilder<Record<never, never> & Record<"bm25", {
+    readonly options: {
+      key_field: string;
+    };
+  }>>;
+  readonly types: {
+    readonly queryOperationTypes: {
+      readonly import: {
+        readonly package: "@prisma-next/extension-paradedb/operation-types";
+        readonly named: "QueryOperationTypes";
+        readonly alias: "ParadeDbQueryOperationTypes";
+      };
+    };
+  };
 };
 //#endregion
-export { paradedbPackMeta };
+//#region src/exports/control.d.ts
+declare const paradedbExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'>;
+//#endregion
+export { paradedbExtensionDescriptor as default, paradedbExtensionDescriptor, paradedbPackMeta };
 //# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":[],"mappings":";cAEa;EAAA,SAAA,IAAA,EAAA,WAWH"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/descriptor-meta.ts","../src/exports/control.ts"],"mappings":";;;;cAgMa,gBAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cCtJP,2BAAA,EAA6B,6BAAA"}

package/dist/control.mjs

@@ -1,3 +1,38 @@
-import { t as paradedbPackMeta } from "./descriptor-meta-BTFnIGJ6.mjs";
+import { n as paradedbQueryOperations, t as paradedbPackMeta } from "./descriptor-meta-CmokJ02r.mjs";
+//#region src/exports/control.ts
+const paradedbDatabaseDependencies = { init: [{
+	id: "postgres.extension.pg_search",
+	label: "Enable pg_search extension",
+	install: [{
+		id: "extension.pg_search",
+		label: "Enable extension \"pg_search\"",
+		summary: "Ensures the pg_search extension is available for ParadeDB BM25 operations",
+		operationClass: "additive",
+		target: { id: "postgres" },
+		precheck: [{
+			description: "verify extension \"pg_search\" is not already enabled",
+			sql: "SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_search')"
+		}],
+		execute: [{
+			description: "create extension \"pg_search\"",
+			sql: "CREATE EXTENSION IF NOT EXISTS pg_search"
+		}],
+		postcheck: [{
+			description: "confirm extension \"pg_search\" is enabled",
+			sql: "SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_search')"
+		}]
+	}]
+}] };
+const paradedbExtensionDescriptor = {
+	...paradedbPackMeta,
+	queryOperations: () => paradedbQueryOperations(),
+	databaseDependencies: paradedbDatabaseDependencies,
+	create: () => ({
+		familyId: "sql",
+		targetId: "postgres"
+	})
+};
+//#endregion
+export { paradedbExtensionDescriptor as default, paradedbExtensionDescriptor, paradedbPackMeta };
 
-export { paradedbPackMeta };
+//# sourceMappingURL=control.mjs.map

package/dist/control.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.mjs","names":[],"sources":["../src/exports/control.ts"],"sourcesContent":["import type {\n  ComponentDatabaseDependencies,\n  SqlControlExtensionDescriptor,\n} from '@prisma-next/family-sql/control';\nimport { paradedbPackMeta, paradedbQueryOperations } from '../core/descriptor-meta';\n\nconst paradedbDatabaseDependencies: ComponentDatabaseDependencies<unknown> = {\n  init: [\n    {\n      id: 'postgres.extension.pg_search',\n      label: 'Enable pg_search extension',\n      install: [\n        {\n          id: 'extension.pg_search',\n          label: 'Enable extension \"pg_search\"',\n          summary: 'Ensures the pg_search extension is available for ParadeDB BM25 operations',\n          operationClass: 'additive',\n          target: { id: 'postgres' },\n          precheck: [\n            {\n              description: 'verify extension \"pg_search\" is not already enabled',\n              sql: \"SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_search')\",\n            },\n          ],\n          execute: [\n            {\n              description: 'create extension \"pg_search\"',\n              sql: 'CREATE EXTENSION IF NOT EXISTS pg_search',\n            },\n          ],\n          postcheck: [\n            {\n              description: 'confirm extension \"pg_search\" is enabled',\n              sql: \"SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_search')\",\n            },\n          ],\n        },\n      ],\n    },\n  ],\n};\n\nconst paradedbExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'> = {\n  ...paradedbPackMeta,\n  queryOperations: () => paradedbQueryOperations(),\n  databaseDependencies: paradedbDatabaseDependencies,\n  create: () => ({\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n  }),\n};\n\nexport { paradedbExtensionDescriptor, paradedbPackMeta };\nexport default paradedbExtensionDescriptor;\n"],"mappings":";;AAMA,MAAM,+BAAuE,EAC3E,MAAM,CACJ;CACE,IAAI;CACJ,OAAO;CACP,SAAS,CACP;EACE,IAAI;EACJ,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,QAAQ,EAAE,IAAI,YAAY;EAC1B,UAAU,CACR;GACE,aAAa;GACb,KAAK;GACN,CACF;EACD,SAAS,CACP;GACE,aAAa;GACb,KAAK;GACN,CACF;EACD,WAAW,CACT;GACE,aAAa;GACb,KAAK;GACN,CACF;EACF,CACF;CACF,CACF,EACF;AAED,MAAM,8BAAyE;CAC7E,GAAG;CACH,uBAAuB,yBAAyB;CAChD,sBAAsB;CACtB,eAAe;EACb,UAAU;EACV,UAAU;EACX;CACF"}

package/dist/descriptor-meta-CmokJ02r.mjs

@@ -0,0 +1,260 @@
+import { t as paradedbIndexTypes } from "./index-types-BWFfNqUb.mjs";
+import { LiteralExpr, OperationExpr } from "@prisma-next/sql-relational-core/ast";
+import { buildOperation, toExpr } from "@prisma-next/sql-relational-core/expression";
+//#region src/core/constants.ts
+/**
+* Extension ID for ParadeDB pg_search.
+*/
+const PARADEDB_EXTENSION_ID = "paradedb";
+//#endregion
+//#region src/core/proximity-chain.ts
+const TEXT$1 = "pg/text@1";
+var ParadeDbProximityChain = class ParadeDbProximityChain {
+	returnType = {
+		codecId: TEXT$1,
+		nullable: false
+	};
+	start;
+	steps;
+	constructor(start, steps = []) {
+		this.start = start;
+		this.steps = steps;
+	}
+	within(distance, term, options) {
+		if (!Number.isInteger(distance) || distance < 0) throw new Error(`paradeDbProximity.within: distance must be a non-negative integer; got ${String(distance)}`);
+		return new ParadeDbProximityChain(this.start, [...this.steps, {
+			distance,
+			term,
+			ordered: options?.ordered === true
+		}]);
+	}
+	buildAst() {
+		if (this.steps.length === 0) throw new Error("paradeDbProximity: chain must have at least one .within(distance, term) step");
+		const args = [toExpr(this.start, TEXT$1)];
+		let template = "({{self}}";
+		this.steps.forEach((step, i) => {
+			const op = step.ordered ? "##>" : "##";
+			args.push(LiteralExpr.of(step.distance));
+			args.push(toExpr(step.term, TEXT$1));
+			template += ` ${op} {{arg${2 * i}}} ${op} {{arg${2 * i + 1}}}`;
+		});
+		template += ")";
+		const [self, ...rest] = args;
+		if (!self) throw new Error("paradeDbProximity: invariant violation — empty args");
+		return new OperationExpr({
+			method: "paradeDbProximity",
+			self,
+			args: rest.length > 0 ? rest : void 0,
+			returns: this.returnType,
+			lowering: {
+				targetFamily: "sql",
+				strategy: "function",
+				template
+			}
+		});
+	}
+};
+//#endregion
+//#region src/core/descriptor-meta.ts
+const TEXT = "pg/text@1";
+const BOOL = "pg/bool@1";
+const FLOAT4 = "pg/float4@1";
+const INT4 = "pg/int4@1";
+function paradedbQueryOperations() {
+	return {
+		paradeDbMatch: {
+			self: { codecId: TEXT },
+			impl: (self, query) => buildOperation({
+				method: "paradeDbMatch",
+				args: [toExpr(self, TEXT), toExpr(query, TEXT)],
+				returns: {
+					codecId: BOOL,
+					nullable: false
+				},
+				lowering: {
+					targetFamily: "sql",
+					strategy: "function",
+					template: "{{self}} @@@ {{arg0}}"
+				}
+			})
+		},
+		paradeDbMatchAny: {
+			self: { codecId: TEXT },
+			impl: (self, query) => buildOperation({
+				method: "paradeDbMatchAny",
+				args: [toExpr(self, TEXT), toExpr(query, TEXT)],
+				returns: {
+					codecId: BOOL,
+					nullable: false
+				},
+				lowering: {
+					targetFamily: "sql",
+					strategy: "function",
+					template: "{{self}} ||| {{arg0}}"
+				}
+			})
+		},
+		paradeDbMatchAll: {
+			self: { codecId: TEXT },
+			impl: (self, query) => buildOperation({
+				method: "paradeDbMatchAll",
+				args: [toExpr(self, TEXT), toExpr(query, TEXT)],
+				returns: {
+					codecId: BOOL,
+					nullable: false
+				},
+				lowering: {
+					targetFamily: "sql",
+					strategy: "function",
+					template: "{{self}} &&& {{arg0}}"
+				}
+			})
+		},
+		paradeDbTerm: {
+			self: { codecId: TEXT },
+			impl: (self, query) => buildOperation({
+				method: "paradeDbTerm",
+				args: [toExpr(self, TEXT), toExpr(query, TEXT)],
+				returns: {
+					codecId: BOOL,
+					nullable: false
+				},
+				lowering: {
+					targetFamily: "sql",
+					strategy: "function",
+					template: "{{self}} === {{arg0}}"
+				}
+			})
+		},
+		paradeDbPhrase: {
+			self: { codecId: TEXT },
+			impl: (self, query) => buildOperation({
+				method: "paradeDbPhrase",
+				args: [toExpr(self, TEXT), toExpr(query, TEXT)],
+				returns: {
+					codecId: BOOL,
+					nullable: false
+				},
+				lowering: {
+					targetFamily: "sql",
+					strategy: "function",
+					template: "{{self}} ### {{arg0}}"
+				}
+			})
+		},
+		paradeDbScore: {
+			self: { codecId: INT4 },
+			impl: (self) => buildOperation({
+				method: "paradeDbScore",
+				args: [toExpr(self, INT4)],
+				returns: {
+					codecId: FLOAT4,
+					nullable: false
+				},
+				lowering: {
+					targetFamily: "sql",
+					strategy: "function",
+					template: "pdb.score({{self}})"
+				}
+			})
+		},
+		paradeDbFuzzy: {
+			self: { codecId: TEXT },
+			impl: (self, distance) => {
+				if (!Number.isInteger(distance) || distance < 0 || distance > 2) throw new Error(`paradeDbFuzzy: distance must be an integer in [0, 2]; got ${String(distance)}`);
+				return buildOperation({
+					method: "paradeDbFuzzy",
+					args: [toExpr(self, TEXT), LiteralExpr.of(distance)],
+					returns: {
+						codecId: TEXT,
+						nullable: false
+					},
+					lowering: {
+						targetFamily: "sql",
+						strategy: "function",
+						template: "{{self}}::pdb.fuzzy({{arg0}})"
+					}
+				});
+			}
+		},
+		paradeDbBoost: {
+			self: { codecId: TEXT },
+			impl: (self, weight) => {
+				if (!Number.isInteger(weight) || weight < -2048 || weight > 2048) throw new Error(`paradeDbBoost: boost must be an integer in [-2048, 2048]; got ${String(weight)}`);
+				return buildOperation({
+					method: "paradeDbBoost",
+					args: [toExpr(self, TEXT), LiteralExpr.of(weight)],
+					returns: {
+						codecId: TEXT,
+						nullable: false
+					},
+					lowering: {
+						targetFamily: "sql",
+						strategy: "function",
+						template: "{{self}}::pdb.boost({{arg0}})"
+					}
+				});
+			}
+		},
+		paradeDbConst: {
+			self: { codecId: TEXT },
+			impl: (self, value) => {
+				if (!Number.isInteger(value)) throw new Error(`paradeDbConst: value must be an integer; got ${String(value)}`);
+				return buildOperation({
+					method: "paradeDbConst",
+					args: [toExpr(self, TEXT), LiteralExpr.of(value)],
+					returns: {
+						codecId: TEXT,
+						nullable: false
+					},
+					lowering: {
+						targetFamily: "sql",
+						strategy: "function",
+						template: "{{self}}::pdb.const({{arg0}})"
+					}
+				});
+			}
+		},
+		paradeDbSlop: {
+			self: { codecId: TEXT },
+			impl: (self, slop) => {
+				if (!Number.isInteger(slop) || slop < 0) throw new Error(`paradeDbSlop: slop must be a non-negative integer; got ${String(slop)}`);
+				return buildOperation({
+					method: "paradeDbSlop",
+					args: [toExpr(self, TEXT), LiteralExpr.of(slop)],
+					returns: {
+						codecId: TEXT,
+						nullable: false
+					},
+					lowering: {
+						targetFamily: "sql",
+						strategy: "function",
+						template: "{{self}}::pdb.slop({{arg0}})"
+					}
+				});
+			}
+		},
+		paradeDbProximity: {
+			self: { codecId: TEXT },
+			impl: (start) => new ParadeDbProximityChain(start)
+		}
+	};
+}
+const paradedbPackMeta = {
+	kind: "extension",
+	id: PARADEDB_EXTENSION_ID,
+	familyId: "sql",
+	targetId: "postgres",
+	version: "0.0.1",
+	capabilities: { postgres: { "paradedb/bm25": true } },
+	indexTypes: paradedbIndexTypes,
+	types: { queryOperationTypes: { import: {
+		package: "@prisma-next/extension-paradedb/operation-types",
+		named: "QueryOperationTypes",
+		alias: "ParadeDbQueryOperationTypes"
+	} } }
+};
+//#endregion
+export { paradedbQueryOperations as n, paradedbPackMeta as t };
+
+//# sourceMappingURL=descriptor-meta-CmokJ02r.mjs.map

package/dist/descriptor-meta-CmokJ02r.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-CmokJ02r.mjs","names":["TEXT"],"sources":["../src/core/constants.ts","../src/core/proximity-chain.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["/**\n * Extension ID for ParadeDB pg_search.\n */\nexport const PARADEDB_EXTENSION_ID = 'paradedb' as const;\n","import {\n  type AnyExpression,\n  LiteralExpr,\n  OperationExpr,\n} from '@prisma-next/sql-relational-core/ast';\nimport { type Expression, toExpr } from '@prisma-next/sql-relational-core/expression';\n\nconst TEXT = 'pg/text@1' as const;\n\nexport type ProximityTerm = unknown;\n\nexport interface ProximityWithinOptions {\n  readonly ordered?: boolean;\n}\n\ninterface ProximityStep {\n  readonly distance: number;\n  readonly term: ProximityTerm;\n  readonly ordered: boolean;\n}\n\n// https://docs.paradedb.com/documentation/full-text/proximity\nexport class ParadeDbProximityChain\n  implements Expression<{ codecId: 'pg/text@1'; nullable: false }>\n{\n  readonly returnType = { codecId: TEXT, nullable: false } as const;\n\n  private readonly start: ProximityTerm;\n  private readonly steps: readonly ProximityStep[];\n\n  constructor(start: ProximityTerm, steps: readonly ProximityStep[] = []) {\n    this.start = start;\n    this.steps = steps;\n  }\n\n  within(\n    distance: number,\n    term: ProximityTerm,\n    options?: ProximityWithinOptions,\n  ): ParadeDbProximityChain {\n    if (!Number.isInteger(distance) || distance < 0) {\n      throw new Error(\n        `paradeDbProximity.within: distance must be a non-negative integer; got ${String(distance)}`,\n      );\n    }\n    return new ParadeDbProximityChain(this.start, [\n      ...this.steps,\n      { distance, term, ordered: options?.ordered === true },\n    ]);\n  }\n\n  buildAst(): AnyExpression {\n    if (this.steps.length === 0) {\n      throw new Error(\n        'paradeDbProximity: chain must have at least one .within(distance, term) step',\n      );\n    }\n    const args: AnyExpression[] = [toExpr(this.start, TEXT)];\n    let template = '({{self}}';\n    this.steps.forEach((step, i) => {\n      const op = step.ordered ? '##>' : '##';\n      args.push(LiteralExpr.of(step.distance));\n      args.push(toExpr(step.term, TEXT));\n      template += ` ${op} {{arg${2 * i}}} ${op} {{arg${2 * i + 1}}}`;\n    });\n    template += ')';\n    const [self, ...rest] = args;\n    if (!self) {\n      throw new Error('paradeDbProximity: invariant violation — empty args');\n    }\n    return new OperationExpr({\n      method: 'paradeDbProximity',\n      self,\n      args: rest.length > 0 ? rest : undefined,\n      returns: this.returnType,\n      lowering: {\n        targetFamily: 'sql',\n        strategy: 'function',\n        template,\n      },\n    });\n  }\n}\n","import { LiteralExpr } from '@prisma-next/sql-relational-core/ast';\nimport { buildOperation, toExpr } from '@prisma-next/sql-relational-core/expression';\nimport { paradedbIndexTypes } from '../types/index-types';\nimport type { QueryOperationTypes } from '../types/operation-types';\nimport { PARADEDB_EXTENSION_ID } from './constants';\nimport { ParadeDbProximityChain } from './proximity-chain';\n\ntype CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;\n\nconst TEXT = 'pg/text@1' as const;\nconst BOOL = 'pg/bool@1' as const;\nconst FLOAT4 = 'pg/float4@1' as const;\nconst INT4 = 'pg/int4@1' as const;\n\nexport function paradedbQueryOperations<CT extends CodecTypesBase>(): QueryOperationTypes<CT> {\n  return {\n    // `@@@` accepts both text and structured query types on its RHS.\n    // https://docs.paradedb.com/documentation/full-text/match\n    paradeDbMatch: {\n      self: { codecId: TEXT },\n      impl: (self, query) =>\n        buildOperation({\n          method: 'paradeDbMatch',\n          args: [toExpr(self, TEXT), toExpr(query, TEXT)],\n          returns: { codecId: BOOL, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}} @@@ {{arg0}}',\n          },\n        }),\n    },\n    paradeDbMatchAny: {\n      self: { codecId: TEXT },\n      impl: (self, query) =>\n        buildOperation({\n          method: 'paradeDbMatchAny',\n          args: [toExpr(self, TEXT), toExpr(query, TEXT)],\n          returns: { codecId: BOOL, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}} ||| {{arg0}}',\n          },\n        }),\n    },\n    paradeDbMatchAll: {\n      self: { codecId: TEXT },\n      impl: (self, query) =>\n        buildOperation({\n          method: 'paradeDbMatchAll',\n          args: [toExpr(self, TEXT), toExpr(query, TEXT)],\n          returns: { codecId: BOOL, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}} &&& {{arg0}}',\n          },\n        }),\n    },\n    // https://docs.paradedb.com/documentation/full-text/term\n    paradeDbTerm: {\n      self: { codecId: TEXT },\n      impl: (self, query) =>\n        buildOperation({\n          method: 'paradeDbTerm',\n          args: [toExpr(self, TEXT), toExpr(query, TEXT)],\n          returns: { codecId: BOOL, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}} === {{arg0}}',\n          },\n        }),\n    },\n    // https://docs.paradedb.com/documentation/full-text/phrase\n    paradeDbPhrase: {\n      self: { codecId: TEXT },\n      impl: (self, query) =>\n        buildOperation({\n          method: 'paradeDbPhrase',\n          args: [toExpr(self, TEXT), toExpr(query, TEXT)],\n          returns: { codecId: BOOL, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}} ### {{arg0}}',\n          },\n        }),\n    },\n    // https://docs.paradedb.com/documentation/sorting/score\n    paradeDbScore: {\n      self: { codecId: INT4 },\n      impl: (self) =>\n        buildOperation({\n          method: 'paradeDbScore',\n          args: [toExpr(self, INT4)],\n          returns: { codecId: FLOAT4, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: 'pdb.score({{self}})',\n          },\n        }),\n    },\n    // PG rejects parameterized typmods, so the cast argument lowers to a literal.\n    // https://docs.paradedb.com/documentation/full-text/fuzzy\n    paradeDbFuzzy: {\n      self: { codecId: TEXT },\n      impl: (self, distance) => {\n        if (!Number.isInteger(distance) || distance < 0 || distance > 2) {\n          throw new Error(\n            `paradeDbFuzzy: distance must be an integer in [0, 2]; got ${String(distance)}`,\n          );\n        }\n        return buildOperation({\n          method: 'paradeDbFuzzy',\n          args: [toExpr(self, TEXT), LiteralExpr.of(distance)],\n          returns: { codecId: TEXT, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}}::pdb.fuzzy({{arg0}})',\n          },\n        });\n      },\n    },\n    // https://docs.paradedb.com/documentation/sorting/boost\n    paradeDbBoost: {\n      self: { codecId: TEXT },\n      impl: (self, weight) => {\n        if (!Number.isInteger(weight) || weight < -2048 || weight > 2048) {\n          throw new Error(\n            `paradeDbBoost: boost must be an integer in [-2048, 2048]; got ${String(weight)}`,\n          );\n        }\n        return buildOperation({\n          method: 'paradeDbBoost',\n          args: [toExpr(self, TEXT), LiteralExpr.of(weight)],\n          returns: { codecId: TEXT, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}}::pdb.boost({{arg0}})',\n          },\n        });\n      },\n    },\n    paradeDbConst: {\n      self: { codecId: TEXT },\n      impl: (self, value) => {\n        if (!Number.isInteger(value)) {\n          throw new Error(`paradeDbConst: value must be an integer; got ${String(value)}`);\n        }\n        return buildOperation({\n          method: 'paradeDbConst',\n          args: [toExpr(self, TEXT), LiteralExpr.of(value)],\n          returns: { codecId: TEXT, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}}::pdb.const({{arg0}})',\n          },\n        });\n      },\n    },\n    paradeDbSlop: {\n      self: { codecId: TEXT },\n      impl: (self, slop) => {\n        if (!Number.isInteger(slop) || slop < 0) {\n          throw new Error(`paradeDbSlop: slop must be a non-negative integer; got ${String(slop)}`);\n        }\n        return buildOperation({\n          method: 'paradeDbSlop',\n          args: [toExpr(self, TEXT), LiteralExpr.of(slop)],\n          returns: { codecId: TEXT, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}}::pdb.slop({{arg0}})',\n          },\n        });\n      },\n    },\n    // https://docs.paradedb.com/documentation/full-text/proximity\n    paradeDbProximity: {\n      self: { codecId: TEXT },\n      impl: (start) => new ParadeDbProximityChain(start),\n    },\n  };\n}\n\nexport const paradedbPackMeta = {\n  kind: 'extension',\n  id: PARADEDB_EXTENSION_ID,\n  familyId: 'sql',\n  targetId: 'postgres',\n  version: '0.0.1',\n  capabilities: {\n    postgres: {\n      'paradedb/bm25': true,\n    },\n  },\n  indexTypes: paradedbIndexTypes,\n  types: {\n    queryOperationTypes: {\n      import: {\n        package: '@prisma-next/extension-paradedb/operation-types',\n        named: 'QueryOperationTypes',\n        alias: 'ParadeDbQueryOperationTypes',\n      },\n    },\n  },\n} as const;\n"],"mappings":"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"}

package/dist/index-types-BWFfNqUb.mjs

@@ -0,0 +1,11 @@
+import { defineIndexTypes } from "@prisma-next/sql-contract/index-types";
+import { type } from "arktype";
+//#region src/types/index-types.ts
+const paradedbIndexTypes = defineIndexTypes().add("bm25", { options: type({
+	"+": "reject",
+	key_field: "string"
+}) });
+//#endregion
+export { paradedbIndexTypes as t };
+
+//# sourceMappingURL=index-types-BWFfNqUb.mjs.map

package/dist/index-types-BWFfNqUb.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-types-BWFfNqUb.mjs","names":[],"sources":["../src/types/index-types.ts"],"sourcesContent":["import { defineIndexTypes } from '@prisma-next/sql-contract/index-types';\nimport { type } from 'arktype';\n\nexport const paradedbIndexTypes = defineIndexTypes().add('bm25', {\n  options: type({\n    '+': 'reject',\n    key_field: 'string',\n  }),\n});\n\nexport type IndexTypes = typeof paradedbIndexTypes.IndexTypes;\nexport type Bm25IndexOptions = IndexTypes['bm25']['options'];\n"],"mappings":";;;AAGA,MAAa,qBAAqB,kBAAkB,CAAC,IAAI,QAAQ,EAC/D,SAAS,KAAK;CACZ,KAAK;CACL,WAAW;CACZ,CAAC,EACH,CAAC"}