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

package/src/core/descriptor-meta.ts

@@ -1,4 +1,194 @@
+import { LiteralExpr } from '@prisma-next/sql-relational-core/ast';
+import { buildOperation, toExpr } from '@prisma-next/sql-relational-core/expression';
+import { paradedbIndexTypes } from '../types/index-types';
+import type { QueryOperationTypes } from '../types/operation-types';
 import { PARADEDB_EXTENSION_ID } from './constants';
+import { ParadeDbProximityChain } from './proximity-chain';
+
+type CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;
+
+const TEXT = 'pg/text@1' as const;
+const BOOL = 'pg/bool@1' as const;
+const FLOAT4 = 'pg/float4@1' as const;
+const INT4 = 'pg/int4@1' as const;
+
+export function paradedbQueryOperations<CT extends CodecTypesBase>(): QueryOperationTypes<CT> {
+  return {
+    // `@@@` accepts both text and structured query types on its RHS.
+    // https://docs.paradedb.com/documentation/full-text/match
+    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}}',
+          },
+        }),
+    },
+    // https://docs.paradedb.com/documentation/full-text/term
+    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}}',
+          },
+        }),
+    },
+    // https://docs.paradedb.com/documentation/full-text/phrase
+    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}}',
+          },
+        }),
+    },
+    // https://docs.paradedb.com/documentation/sorting/score
+    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}})',
+          },
+        }),
+    },
+    // PG rejects parameterized typmods, so the cast argument lowers to a literal.
+    // https://docs.paradedb.com/documentation/full-text/fuzzy
+    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}})',
+          },
+        });
+      },
+    },
+    // https://docs.paradedb.com/documentation/sorting/boost
+    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}})',
+          },
+        });
+      },
+    },
+    // https://docs.paradedb.com/documentation/full-text/proximity
+    paradeDbProximity: {
+      self: { codecId: TEXT },
+      impl: (start) => new ParadeDbProximityChain(start),
+    },
+  };
+}
 
 export const paradedbPackMeta = {
   kind: 'extension',
@@ -11,4 +201,14 @@ export const paradedbPackMeta = {
       'paradedb/bm25': true,
     },
   },
+  indexTypes: paradedbIndexTypes,
+  types: {
+    queryOperationTypes: {
+      import: {
+        package: '@prisma-next/extension-paradedb/operation-types',
+        named: 'QueryOperationTypes',
+        alias: 'ParadeDbQueryOperationTypes',
+      },
+    },
+  },
 } as const;

package/src/core/proximity-chain.ts

@@ -0,0 +1,83 @@
+import {
+  type AnyExpression,
+  LiteralExpr,
+  OperationExpr,
+} from '@prisma-next/sql-relational-core/ast';
+import { type Expression, toExpr } from '@prisma-next/sql-relational-core/expression';
+
+const TEXT = 'pg/text@1' as const;
+
+export type ProximityTerm = unknown;
+
+export interface ProximityWithinOptions {
+  readonly ordered?: boolean;
+}
+
+interface ProximityStep {
+  readonly distance: number;
+  readonly term: ProximityTerm;
+  readonly ordered: boolean;
+}
+
+// https://docs.paradedb.com/documentation/full-text/proximity
+export class ParadeDbProximityChain
+  implements Expression<{ codecId: 'pg/text@1'; nullable: false }>
+{
+  readonly returnType = { codecId: TEXT, nullable: false } as const;
+
+  private readonly start: ProximityTerm;
+  private readonly steps: readonly ProximityStep[];
+
+  constructor(start: ProximityTerm, steps: readonly ProximityStep[] = []) {
+    this.start = start;
+    this.steps = steps;
+  }
+
+  within(
+    distance: number,
+    term: ProximityTerm,
+    options?: ProximityWithinOptions,
+  ): ParadeDbProximityChain {
+    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(): AnyExpression {
+    if (this.steps.length === 0) {
+      throw new Error(
+        'paradeDbProximity: chain must have at least one .within(distance, term) step',
+      );
+    }
+    const args: AnyExpression[] = [toExpr(this.start, TEXT)];
+    let template = '({{self}}';
+    this.steps.forEach((step, i) => {
+      const op = step.ordered ? '##>' : '##';
+      args.push(LiteralExpr.of(step.distance));
+      args.push(toExpr(step.term, TEXT));
+      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 : undefined,
+      returns: this.returnType,
+      lowering: {
+        targetFamily: 'sql',
+        strategy: 'function',
+        template,
+      },
+    });
+  }
+}

package/src/exports/control.ts

@@ -1,3 +1,54 @@
-import { paradedbPackMeta } from '../core/descriptor-meta';
+import type {
+  ComponentDatabaseDependencies,
+  SqlControlExtensionDescriptor,
+} from '@prisma-next/family-sql/control';
+import { paradedbPackMeta, paradedbQueryOperations } from '../core/descriptor-meta';
 
-export { paradedbPackMeta };
+const paradedbDatabaseDependencies: ComponentDatabaseDependencies<unknown> = {
+  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: SqlControlExtensionDescriptor<'postgres'> = {
+  ...paradedbPackMeta,
+  queryOperations: () => paradedbQueryOperations(),
+  databaseDependencies: paradedbDatabaseDependencies,
+  create: () => ({
+    familyId: 'sql' as const,
+    targetId: 'postgres' as const,
+  }),
+};
+
+export { paradedbExtensionDescriptor, paradedbPackMeta };
+export default paradedbExtensionDescriptor;

package/src/exports/index-types.ts

@@ -1,12 +1,2 @@
-export type { TokenizerId } from '../core/constants';
-export type {
-  Bm25ColumnFieldConfig,
-  Bm25ExpressionFieldConfig,
-  Bm25ExpressionFieldOptions,
-  Bm25FieldConfig,
-  Bm25IndexConfig,
-  Bm25IndexOptions,
-  Bm25JsonFieldOptions,
-  Bm25TextFieldOptions,
-} from '../types/index-types';
-export { bm25, bm25Index } from '../types/index-types';
+export type { Bm25IndexOptions, IndexTypes } from '../types/index-types';
+export { paradedbIndexTypes } from '../types/index-types';

package/src/exports/operation-types.ts

@@ -0,0 +1 @@
+export type { QueryOperationTypes } from '../types/operation-types';

package/src/exports/runtime.ts

@@ -0,0 +1,20 @@
+import type { SqlRuntimeExtensionDescriptor } from '@prisma-next/sql-runtime';
+import { paradedbPackMeta, paradedbQueryOperations } from '../core/descriptor-meta';
+
+const paradedbRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {
+  kind: 'extension' as const,
+  id: paradedbPackMeta.id,
+  version: paradedbPackMeta.version,
+  familyId: 'sql' as const,
+  targetId: 'postgres' as const,
+  codecs: () => [],
+  queryOperations: () => paradedbQueryOperations(),
+  create() {
+    return {
+      familyId: 'sql' as const,
+      targetId: 'postgres' as const,
+    };
+  },
+};
+
+export default paradedbRuntimeDescriptor;

package/src/types/index-types.ts

@@ -1,179 +1,12 @@
-import type { IndexDef } from '@prisma-next/contract-authoring';
-import type { TokenizerId } from '../core/constants';
-
-/**
- * BM25 field config for a table column.
- */
-export type Bm25ColumnFieldConfig = {
-  readonly column: string;
-  readonly expression?: never;
-  readonly tokenizer?: string;
-  readonly tokenizerParams?: Record<string, unknown>;
-  readonly alias?: string;
-};
-
-/**
- * BM25 field config for a SQL expression.
- */
-export type Bm25ExpressionFieldConfig = {
-  readonly expression: string;
-  readonly column?: never;
-  readonly alias: string;
-  readonly tokenizer?: string;
-  readonly tokenizerParams?: Record<string, unknown>;
-};
-
-/**
- * BM25 field config union.
- */
-export type Bm25FieldConfig = Bm25ColumnFieldConfig | Bm25ExpressionFieldConfig;
-
-/**
- * BM25 index configuration payload stored in `IndexDef.config`.
- */
-export type Bm25IndexConfig = {
-  readonly keyField: string;
-  readonly fields: readonly Bm25FieldConfig[];
-};
-
-/**
- * Options for a BM25 text field (text, varchar columns).
- */
-export type Bm25TextFieldOptions = {
-  readonly tokenizer?: TokenizerId | (string & {});
-  readonly stemmer?: string;
-  readonly alias?: string;
-  readonly remove_emojis?: boolean;
-};
-
-/**
- * Options for a BM25 JSON field (json, jsonb columns).
- */
-export type Bm25JsonFieldOptions = {
-  readonly tokenizer?: TokenizerId | (string & {});
-  readonly alias?: string;
-  /** Ngram-specific params when tokenizer is 'ngram'. */
-  readonly min?: number;
-  readonly max?: number;
-};
-
-/**
- * Options for a BM25 expression-based field.
- */
-export type Bm25ExpressionFieldOptions = {
-  readonly alias: string;
-  readonly tokenizer?: TokenizerId | (string & {});
-  readonly min?: number;
-  readonly max?: number;
-  readonly stemmer?: string;
-  readonly pattern?: string;
-};
-
-type TokenizerConfig = {
-  readonly tokenizer?: string;
-  readonly tokenizerParams?: Record<string, unknown>;
-};
-
-/**
- * Options for constructing a BM25 index definition.
- */
-export type Bm25IndexOptions = {
-  readonly keyField: string;
-  readonly fields: readonly Bm25FieldConfig[];
-  readonly name?: string;
-};
-
-/**
- * Typed BM25 field builders.
- * These produce `Bm25FieldConfig` objects for use in `bm25Index()`.
- */
-export const bm25 = {
-  /** Text field with optional tokenizer config. */
-  text(column: string, opts?: Bm25TextFieldOptions): Bm25FieldConfig {
-    return {
-      column,
-      ...buildTokenizerConfig(opts?.tokenizer, {
-        stemmer: opts?.stemmer,
-        remove_emojis: opts?.remove_emojis,
-      }),
-      ...(opts?.alias !== undefined && { alias: opts.alias }),
-    };
-  },
-
-  /** Numeric field (filterable, sortable in BM25). */
-  numeric(column: string): Bm25FieldConfig {
-    return { column };
-  },
-
-  /** Boolean field. */
-  boolean(column: string): Bm25FieldConfig {
-    return { column };
-  },
-
-  /** JSON/JSONB field with optional tokenizer config. */
-  json(column: string, opts?: Bm25JsonFieldOptions): Bm25FieldConfig {
-    return {
-      column,
-      ...buildTokenizerConfig(opts?.tokenizer, { min: opts?.min, max: opts?.max }),
-      ...(opts?.alias !== undefined && { alias: opts.alias }),
-    };
-  },
-
-  /** Datetime (timestamp/date) field. */
-  datetime(column: string): Bm25FieldConfig {
-    return { column };
-  },
-
-  /** Range field. */
-  range(column: string): Bm25FieldConfig {
-    return { column };
-  },
-
-  /** Raw SQL expression field. `alias` is required. */
-  expression(sql: string, opts: Bm25ExpressionFieldOptions): Bm25FieldConfig {
-    return {
-      expression: sql,
-      alias: opts.alias,
-      ...buildTokenizerConfig(opts.tokenizer, {
-        min: opts.min,
-        max: opts.max,
-        stemmer: opts.stemmer,
-        pattern: opts.pattern,
-      }),
-    };
-  },
-} as const;
-
-/**
- * Creates a generic index definition with a ParadeDB BM25 payload.
- *
- * `columns` only includes real table columns so core index validation remains
- * target-agnostic. Expression fields stay in extension-owned `config.fields`.
- */
-export function bm25Index(opts: Bm25IndexOptions): IndexDef {
-  return {
-    columns: opts.fields.flatMap((field) => ('column' in field ? [field.column] : [])),
-    ...(opts.name !== undefined && { name: opts.name }),
-    using: 'bm25',
-    config: {
-      keyField: opts.keyField,
-      fields: opts.fields,
-    } satisfies Bm25IndexConfig,
-  };
-}
-
-/**
- * Builds `{ tokenizer, tokenizerParams? }` from a tokenizer ID and a bag of params.
- * Filters out undefined values and omits `tokenizerParams` when empty.
- */
-function buildTokenizerConfig(
-  tokenizer: string | undefined,
-  params: Record<string, unknown>,
-): TokenizerConfig {
-  if (!tokenizer) return {};
-  const filtered = Object.fromEntries(Object.entries(params).filter(([, v]) => v !== undefined));
-  return {
-    tokenizer,
-    ...(Object.keys(filtered).length > 0 && { tokenizerParams: filtered }),
-  };
-}
+import { defineIndexTypes } from '@prisma-next/sql-contract/index-types';
+import { type } from 'arktype';
+
+export const paradedbIndexTypes = defineIndexTypes().add('bm25', {
+  options: type({
+    '+': 'reject',
+    key_field: 'string',
+  }),
+});
+
+export type IndexTypes = typeof paradedbIndexTypes.IndexTypes;
+export type Bm25IndexOptions = IndexTypes['bm25']['options'];

package/src/types/operation-types.ts

@@ -0,0 +1,84 @@
+import type { SqlQueryOperationTypes } from '@prisma-next/sql-contract/types';
+import type { CodecExpression, Expression } from '@prisma-next/sql-relational-core/expression';
+import type { ParadeDbProximityChain } from '../core/proximity-chain';
+
+type CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;
+
+export type QueryOperationTypes<CT extends CodecTypesBase> = SqlQueryOperationTypes<
+  CT,
+  {
+    readonly paradeDbMatch: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        query: CodecExpression<'pg/text@1', boolean, CT>,
+      ) => Expression<{ codecId: 'pg/bool@1'; nullable: false }>;
+    };
+    readonly paradeDbMatchAny: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        query: CodecExpression<'pg/text@1', boolean, CT>,
+      ) => Expression<{ codecId: 'pg/bool@1'; nullable: false }>;
+    };
+    readonly paradeDbMatchAll: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        query: CodecExpression<'pg/text@1', boolean, CT>,
+      ) => Expression<{ codecId: 'pg/bool@1'; nullable: false }>;
+    };
+    readonly paradeDbTerm: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        query: CodecExpression<'pg/text@1', boolean, CT>,
+      ) => Expression<{ codecId: 'pg/bool@1'; nullable: false }>;
+    };
+    readonly paradeDbPhrase: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        query: CodecExpression<'pg/text@1', boolean, CT>,
+      ) => Expression<{ codecId: 'pg/bool@1'; nullable: false }>;
+    };
+    readonly paradeDbScore: {
+      readonly self: { readonly codecId: 'pg/int4@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/int4@1', boolean, CT>,
+      ) => Expression<{ codecId: 'pg/float4@1'; nullable: false }>;
+    };
+    readonly paradeDbFuzzy: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        distance: number,
+      ) => Expression<{ codecId: 'pg/text@1'; nullable: false }>;
+    };
+    readonly paradeDbBoost: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        weight: number,
+      ) => Expression<{ codecId: 'pg/text@1'; nullable: false }>;
+    };
+    readonly paradeDbConst: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        value: number,
+      ) => Expression<{ codecId: 'pg/text@1'; nullable: false }>;
+    };
+    readonly paradeDbSlop: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        slop: number,
+      ) => Expression<{ codecId: 'pg/text@1'; nullable: false }>;
+    };
+    readonly paradeDbProximity: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (start: CodecExpression<'pg/text@1', boolean, CT>) => ParadeDbProximityChain;
+    };
+  }
+>;

package/dist/descriptor-meta-BTFnIGJ6.mjs

@@ -1,20 +0,0 @@
-//#region src/core/constants.ts
-/**
-* Extension ID for ParadeDB pg_search.
-*/
-const PARADEDB_EXTENSION_ID = "paradedb";
-
-//#endregion
-//#region src/core/descriptor-meta.ts
-const paradedbPackMeta = {
-	kind: "extension",
-	id: PARADEDB_EXTENSION_ID,
-	familyId: "sql",
-	targetId: "postgres",
-	version: "0.0.1",
-	capabilities: { postgres: { "paradedb/bm25": true } }
-};
-
-//#endregion
-export { paradedbPackMeta as t };
-//# sourceMappingURL=descriptor-meta-BTFnIGJ6.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"descriptor-meta-BTFnIGJ6.mjs","names":[],"sources":["../src/core/constants.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["/**\n * Extension ID for ParadeDB pg_search.\n */\nexport const PARADEDB_EXTENSION_ID = 'paradedb' as const;\n\n/**\n * Built-in ParadeDB tokenizer IDs.\n * These correspond to the `pdb.*` casting syntax in `CREATE INDEX ... USING bm25`.\n */\nexport type TokenizerId =\n  | 'unicode_words'\n  | 'simple'\n  | 'ngram'\n  | 'icu'\n  | 'regex_pattern'\n  | 'source_code'\n  | 'literal'\n  | 'literal_normalized'\n  | 'whitespace'\n  | 'chinese_compatible'\n  | 'jieba'\n  | 'lindera';\n","import { PARADEDB_EXTENSION_ID } from './constants';\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} as const;\n"],"mappings":";;;;AAGA,MAAa,wBAAwB;;;;ACDrC,MAAa,mBAAmB;CAC9B,MAAM;CACN,IAAI;CACJ,UAAU;CACV,UAAU;CACV,SAAS;CACT,cAAc,EACZ,UAAU,EACR,iBAAiB,MAClB,EACF;CACF"}