uql-orm 0.67.1 → 0.68.1

package/dist/type/queryWhere.d.ts

@@ -26,10 +26,10 @@ export type QueryTextSearchOptions<E> = {
  * entity's keys so each stays linked for rename. An object and nothing else, so a wrong value is
  * reported on its key: ids go through `{ id: 1 }` or the by-id methods.
  */
-export type QueryWhere<E, K extends keyof E = FieldKey<E> | RelationKey<E>> = QueryWhereRootOperator<E> & {
-    [P in K]?: P extends FieldKey<E> ? QueryWhereFieldValue<E[P]> : QueryWhere<RelationTarget<E[P]>> | QueryRelationSizeFilter;
+export type QueryWhere<E, Raw = QueryRaw, K extends keyof E = FieldKey<E> | RelationKey<E>> = QueryWhereRootOperator<E, Raw> & {
+    [P in K]?: P extends FieldKey<E> ? QueryWhereFieldValue<E[P], Raw> : QueryWhere<RelationTarget<E[P]>, Raw> | QueryRelationSizeFilter;
 } & ([JsonFieldPaths<E>] extends [never] ? unknown : {
-    [P in JsonFieldPaths<E>]?: QueryWhereFieldValue<JsonFieldPathValue<E, P>>;
+    [P in JsonFieldPaths<E>]?: QueryWhereFieldValue<JsonFieldPathValue<E, P>, Raw>;
 });
 /**
  * Filter a to-many relation by its row count.
@@ -39,24 +39,24 @@ export type QueryWhere<E, K extends keyof E = FieldKey<E> | RelationKey<E>> = Qu
 export type QueryRelationSizeFilter = {
     readonly $size: number | QuerySizeComparisonOps;
 };
-export type QueryWhereRootOperator<E> = {
+export type QueryWhereRootOperator<E, Raw = QueryRaw> = {
     /**
      * joins query clauses with a logical `AND`, returns records that match all the clauses.
      */
-    $and?: QueryWhereArray<E>;
+    $and?: QueryWhereArray<E, Raw>;
     /**
      * joins query clauses with a logical `OR`, returns records that match any of the clauses.
      */
-    $or?: QueryWhereArray<E>;
+    $or?: QueryWhereArray<E, Raw>;
     /**
      * joins query clauses with a logical `AND`, returns records that do not match all the clauses.
      * @see {@link QueryWhereFieldOperatorMap.$not} for per-field negation.
      */
-    $not?: QueryWhereArray<E>;
+    $not?: QueryWhereArray<E, Raw>;
     /**
      * joins query clauses with a logical `OR`, returns records that do not match any of the clauses.
      */
-    $nor?: QueryWhereArray<E>;
+    $nor?: QueryWhereArray<E, Raw>;
     /**
      * whether the specified fields match against a full-text search of the given string.
      */
@@ -64,11 +64,11 @@ export type QueryWhereRootOperator<E> = {
     /**
      * whether the record exists in the given sub-query.
      */
-    $exists?: QueryRaw;
+    $exists?: Raw;
     /**
      * whether the record does not exists in the given sub-query.
      */
-    $nexists?: QueryRaw;
+    $nexists?: Raw;
 };
 /**
  * Per-field negation operators. `Pick`'s constraint ties this back to
@@ -100,7 +100,7 @@ export type QuerySizeComparisonOps = {
 export type QueryVectorNear = QueryVectorQuery & {
     [K in QueryOrderedOp]?: NonNullable<QueryWhereFieldOperatorMap<number>[K]>;
 };
-export type QueryWhereFieldOperatorMap<T> = {
+export type QueryWhereFieldOperatorMap<T, Raw = QueryRaw> = {
     /**
      * whether a value is equal to the given value.
      */
@@ -113,7 +113,7 @@ export type QueryWhereFieldOperatorMap<T> = {
      * negates the given comparison for a single field.
      * @see {@link QueryWhereRootOperator.$not} for root-level clause negation.
      */
-    $not?: QueryWhereFieldValue<T>;
+    $not?: QueryWhereFieldValue<T, Raw>;
     /**
      * whether a value is less than the given value.
      */
@@ -202,7 +202,7 @@ export type QueryWhereFieldOperatorMap<T> = {
      * @example { addresses: { $elemMatch: { city: 'NYC', zip: '10001' } } }
      * @example { addresses: { $elemMatch: { city: { $like: 'New%' } } } }
      */
-    $elemMatch?: unknown extends T ? QueryWhereElemMatch<unknown> : NonNullable<T> extends readonly (infer U)[] ? QueryWhereElemMatch<U> : never;
+    $elemMatch?: unknown extends T ? QueryWhereElemMatch<unknown, Raw> : NonNullable<T> extends readonly (infer U)[] ? QueryWhereElemMatch<U, Raw> : never;
     /**
      * whether a vector is within a given distance of the query vector. `$sort` ranks by distance;
      * this filters by it, so "the closest ten" and "everything closer than 0.35" are separate asks.
@@ -216,10 +216,10 @@ export type QueryWhereFieldOperatorMap<T> = {
  * field comparison. An untyped element (`unknown`) accepts any keys but still requires the
  * object-of-conditions shape (a bare scalar is rejected).
  */
-export type QueryWhereElemMatch<U> = unknown extends U ? {
-    [key: string]: QueryWhereFieldValue<unknown> | undefined;
-} : NonNullable<U> extends Scalar ? QueryWhereFieldOperators<NonNullable<U>> : {
-    [K in keyof NonNullable<U>]?: QueryWhereFieldValue<NonNullable<U>[K]>;
+export type QueryWhereElemMatch<U, Raw = QueryRaw> = unknown extends U ? {
+    [key: string]: QueryWhereFieldValue<unknown, Raw> | undefined;
+} : NonNullable<U> extends Scalar ? QueryWhereFieldOperators<NonNullable<U>, Raw> : {
+    [K in keyof NonNullable<U>]?: QueryWhereFieldValue<NonNullable<U>[K], Raw>;
 };
 /**
  * Simple relational comparison operators. `Pick`'s constraint ties this back to
@@ -269,7 +269,7 @@ type QueryAllowedOp<T> = QueryCommonOp | ([NonNullable<T>] extends [QueryCompara
  * The operators a field of type `T` takes. `unknown`, and a column typed as every scalar at once (a
  * runtime-defined entity), take all of them, since nothing narrows what they hold.
  */
-export type QueryWhereFieldOperators<T> = unknown extends T ? QueryWhereFieldOperatorMap<T> : IsUntypedColumn<T> extends true ? QueryWhereFieldOperatorMap<T> : Pick<QueryWhereFieldOperatorMap<T>, QueryAllowedOp<T>>;
+export type QueryWhereFieldOperators<T, Raw = QueryRaw> = unknown extends T ? QueryWhereFieldOperatorMap<T, Raw> : IsUntypedColumn<T> extends true ? QueryWhereFieldOperatorMap<T, Raw> : Pick<QueryWhereFieldOperatorMap<T, Raw>, QueryAllowedOp<T>>;
 /**
  * Whether a column admits every scalar at once, which is what an entity keyed by an index signature
  * says about all of its columns. `Scalar` is the yardstick rather than a parameter: the question is
@@ -280,9 +280,9 @@ type IsUntypedColumn<T> = [Scalar] extends [NonNullable<T>] ? true : false;
  * A field's filter value: the value, `null` where it is optional, a list as an implicit `$in` (not on
  * an array field, where it would be ambiguous), or an operator map.
  */
-export type QueryWhereFieldValue<T> = T | (undefined extends T ? null : never) | (IsMany<T> extends true ? never : T[]) | QueryWhereFieldOperators<T> | QueryRaw;
+export type QueryWhereFieldValue<T, Raw = QueryRaw> = T | (undefined extends T ? null : never) | (IsMany<T> extends true ? never : T[]) | QueryWhereFieldOperators<T, Raw> | Raw;
 /**
  * query filter array - the value every {@link QueryGroupOp} takes.
  */
-export type QueryWhereArray<E> = (QueryWhere<E> | QueryRaw)[];
+export type QueryWhereArray<E, Raw = QueryRaw> = (QueryWhere<E, Raw> | Raw)[];
 export {};

package/dist/type/universalQuerier.d.ts

@@ -2,38 +2,38 @@ import type { EntityData, EntityId, FieldKey, RelationKey, UpdatePayload, Writte
 import type { QueryConflictPaths, QueryFilter, QueryFindResult, QueryOneProjected, QueryOptions, QueryPage, QueryProjected, QuerySearch, QueryUpsertOneResult, QueryUpsertManyResult } from './query.js';
 import type { QueryAggMap, QueryAggregate, QueryAggregateResult, QueryGroupMap } from './queryAggregate.js';
 import type { Type } from './utility.js';
-import type { QuerierCountedResult, QuerierResult, QuerierTransport } from './wire.js';
+import type { QuerierCountedResult, QuerierRaw, QuerierResult, QuerierTransport } from './wire.js';
 /**
  * The operations the server and the browser client declare alike, per transport `W`, options `O`,
  * and delete options `DO`, which on the client also carry the {@link QueryOptions} it cannot pass otherwise.
  */
 export interface SharedQuerier<W extends QuerierTransport, O, DO = O> {
     /** Find the record with the given primary key. */
-    findOneById<E extends object, const S extends FieldKey<E> = never, const V = true, const X extends FieldKey<E> = never, const P extends RelationKey<E> = never, const C extends RelationKey<E> = never>(entity: Type<E>, id: EntityId<E>, q?: QueryOneProjected<E, S, V, X, P, C>, opts?: O): QuerierResult<W, QueryFindResult<E, S, V, X, P, C> | undefined>;
+    findOneById<E extends object, const S extends FieldKey<E> = never, const V = true, const X extends FieldKey<E> = never, const P extends RelationKey<E> = never, const C extends RelationKey<E> = never>(entity: Type<E>, id: EntityId<E>, q?: QueryOneProjected<E, S, V, X, P, C, QuerierRaw<W>>, opts?: O): QuerierResult<W, QueryFindResult<E, S, V, X, P, C> | undefined>;
     /**
      * obtains the first record matching the given search parameters.
      * @param entity the target entity
      * @param q the criteria options
      * @return the record
      */
-    findOne<E extends object, const S extends FieldKey<E> = never, const V = true, const X extends FieldKey<E> = never, const P extends RelationKey<E> = never, const C extends RelationKey<E> = never>(entity: Type<E>, q: QueryOneProjected<E, S, V, X, P, C>, opts?: O): QuerierResult<W, QueryFindResult<E, S, V, X, P, C> | undefined>;
+    findOne<E extends object, const S extends FieldKey<E> = never, const V = true, const X extends FieldKey<E> = never, const P extends RelationKey<E> = never, const C extends RelationKey<E> = never>(entity: Type<E>, q: QueryOneProjected<E, S, V, X, P, C, QuerierRaw<W>>, opts?: O): QuerierResult<W, QueryFindResult<E, S, V, X, P, C> | undefined>;
     /**
      * obtains the records matching the given search parameters.
      * @param entity the target entity
      * @param q the criteria options
      * @return the records
      */
-    findMany<E extends object, const S extends FieldKey<E> = never, const V = true, const X extends FieldKey<E> = never, const P extends RelationKey<E> = never, const C extends RelationKey<E> = never>(entity: Type<E>, q: QueryProjected<E, S, V, X, P, C>, opts?: O): QuerierResult<W, QueryFindResult<E, S, V, X, P, C>[]>;
+    findMany<E extends object, const S extends FieldKey<E> = never, const V = true, const X extends FieldKey<E> = never, const P extends RelationKey<E> = never, const C extends RelationKey<E> = never>(entity: Type<E>, q: QueryProjected<E, S, V, X, P, C, QuerierRaw<W>>, opts?: O): QuerierResult<W, QueryFindResult<E, S, V, X, P, C>[]>;
     /** Find the records matching the query, and count every match past its page. */
-    findManyAndCount<E extends object, const S extends FieldKey<E> = never, const V = true, const X extends FieldKey<E> = never, const P extends RelationKey<E> = never, const C extends RelationKey<E> = never>(entity: Type<E>, q: QueryProjected<E, S, V, X, P, C>, opts?: O): QuerierCountedResult<W, QueryFindResult<E, S, V, X, P, C>>;
+    findManyAndCount<E extends object, const S extends FieldKey<E> = never, const V = true, const X extends FieldKey<E> = never, const P extends RelationKey<E> = never, const C extends RelationKey<E> = never>(entity: Type<E>, q: QueryProjected<E, S, V, X, P, C, QuerierRaw<W>>, opts?: O): QuerierCountedResult<W, QueryFindResult<E, S, V, X, P, C>>;
     /** Count the records matching the filter, or those a page of them takes. */
-    count<E extends object>(entity: Type<E>, q?: QueryPage<E>, opts?: O): QuerierResult<W, number>;
+    count<E extends object>(entity: Type<E>, q?: QueryPage<E, QuerierRaw<W>>, opts?: O): QuerierResult<W, number>;
     /** Whether any record matches: a count capped at one row, so the engine stops at the first match. */
-    exists<E extends object>(entity: Type<E>, q?: QueryFilter<E>, opts?: O): QuerierResult<W, boolean>;
+    exists<E extends object>(entity: Type<E>, q?: QueryFilter<E, QuerierRaw<W>>, opts?: O): QuerierResult<W, boolean>;
     /** Update the record with the given primary key; resolves to the number of affected rows. */
-    updateOneById<E extends object>(entity: Type<E>, id: EntityId<E>, payload: UpdatePayload<E>, opts?: O): QuerierResult<W, number>;
+    updateOneById<E extends object>(entity: Type<E>, id: EntityId<E>, payload: UpdatePayload<E, QuerierRaw<W>>, opts?: O): QuerierResult<W, number>;
     /** Update the records matching the query; resolves to the number of affected rows. */
-    updateMany<E extends object>(entity: Type<E>, q: QuerySearch<E>, payload: UpdatePayload<E>, opts?: O): QuerierResult<W, number>;
+    updateMany<E extends object>(entity: Type<E>, q: QuerySearch<E, QuerierRaw<W>>, payload: UpdatePayload<E, QuerierRaw<W>>, opts?: O): QuerierResult<W, number>;
     /**
      * delete or SoftDelete a record.
      * @param entity the entity to persist on
@@ -47,7 +47,7 @@ export interface SharedQuerier<W extends QuerierTransport, O, DO = O> {
      * @param q the criteria to look for the records
      * @return the number of affected records
      */
-    deleteMany<E extends object>(entity: Type<E>, q: QuerySearch<E>, opts?: DO): QuerierResult<W, number>;
+    deleteMany<E extends object>(entity: Type<E>, q: QuerySearch<E, QuerierRaw<W>>, opts?: DO): QuerierResult<W, number>;
 }
 /**
  * A `querier` allows to interact with the datasource to perform persistence operations on any entity.

package/dist/type/vector.d.ts

@@ -28,20 +28,18 @@ export interface QueryVectorSearch extends QueryVectorQuery {
  */
 export type WithDistance<E, K extends string = '_distance'> = E & Record<K, number>;
 /**
- * How a dialect spells a metric: an operator with the operator class an index names from it, or a
- * function, `metricArg` where it takes the metric by name. One map, so its keys say which metrics exist.
+ * How a dialect spells a metric: an operator, or a function taking the metric by name where `metricArg`
+ * says so, and `index`, how the dialect's vector index names it where it builds one. One map serves the
+ * query and the index alike, so its keys say which metrics exist.
  */
 export type VectorMetric = {
     readonly op: string;
-    readonly opsSuffix: string;
+    readonly index: string;
 } | {
     readonly fn: string;
     readonly metricArg?: string;
+    readonly index?: string;
 };
-/** The operator form, for the pgvector-family dialects whose index DDL also needs `opsSuffix`. */
-export type VectorOperatorMetric = Extract<VectorMetric, {
-    op: string;
-}>;
 /** The error every dialect throws for a metric it lacks. */
 export declare function unsupportedVectorMetric(dialectName: string, distance: VectorDistance, indexName?: string): TypeError;
 /**

package/dist/type/wire.d.ts

@@ -1,3 +1,4 @@
+import type { QueryRaw } from './queryRaw.js';
 /**
  * The envelope a wire response wraps its result in.
  */
@@ -16,6 +17,14 @@ export type RequestCountedSuccessResponse<E> = RequestSuccessResponse<E> & {
  * client one hands back the envelope its transport wrapped it in.
  */
 export type QuerierTransport = 'server' | 'client';
+/**
+ * The `raw` SQL a transport carries. A client's query and payload travel as JSON, which a `raw` fragment
+ * is not: it would arrive as `{}`, so the client's types refuse one rather than let it leave.
+ */
+export type QuerierRaw<W extends QuerierTransport> = {
+    server: QueryRaw;
+    client: never;
+}[W];
 /**
  * A querier method's result on a transport: `Promise<User[]>` on the server, the response envelope on
  * the client. A map indexed by the transport, which resolves away in hovers.

package/dist/util/dialect.util.d.ts

@@ -138,6 +138,8 @@ export declare function parseGroupMap<E>(group?: QueryGroupMap<E>, select?: Quer
  * indices. Shared by the SQL and MongoDB builders, whose `$where` and `$having` all face this.
  */
 export declare function isOperatorMap(value: unknown): value is Record<string, unknown>;
+/** A JSON object, matched by what it holds: a plain object with no operator key. */
+export declare function isJsonObject(value: unknown): value is Record<string, unknown>;
 /**
  * A page operand, checked before it reaches an engine. These arrive from page arithmetic and from
  * REST query strings (`parseQueryParams` yields `NaN` for a non-numeric one), and each engine's own

package/dist/util/dialect.util.js

@@ -3,7 +3,7 @@ import { soleIdOf } from '../entity/metadata/definition.js';
 import { QueryRaw, resolveAggregateOp, SOFT_DELETE_FILTER, } from '../type/index.js';
 import { VECTOR_INDEX_TYPES } from '../type/vector.js';
 import { isDatabaseWritten } from './field.util.js';
-import { entityName, getFieldKeys, getKeys, hasKeys, isScalarId, isRecord, isWhereMap, someKey, } from './object.util.js';
+import { entityName, getFieldKeys, getKeys, hasKeys, isOperatorObject, isScalarId, isRecord, isWhereMap, someKey, } from './object.util.js';
 /** The keys of `payload` a write persists as columns. */
 export function filterFieldKeys(meta, payload, callbackKey) {
     return getKeys(payload).filter((key) => {
@@ -226,7 +226,7 @@ const JSON_UPDATE_OPS = [
 ];
 /** Type guard: checks whether an update payload value is a JSON operator object. */
 export function isJsonUpdateOp(value) {
-    return value !== null && typeof value === 'object' && someKey(value, (key) => JSON_UPDATE_OPS.includes(key));
+    return isRecord(value) && someKey(value, (key) => JSON_UPDATE_OPS.includes(key));
 }
 /**
  * The `$where` naming rows by key: a bare value names the one key column (refused on a composite), a
@@ -386,6 +386,10 @@ export function isOperatorMap(value) {
         !(value instanceof Uint8Array) &&
         !(value instanceof QueryRaw));
 }
+/** A JSON object, matched by what it holds: a plain object with no operator key. */
+export function isJsonObject(value) {
+    return isOperatorMap(value) && !isOperatorObject(value);
+}
 /**
  * A page operand, checked before it reaches an engine. These arrive from page arithmetic and from
  * REST query strings (`parseQueryParams` yields `NaN` for a non-numeric one), and each engine's own

package/dist/util/object.util.d.ts

@@ -9,12 +9,10 @@ export declare function hasKeys<T>(obj: T): obj is NonNullable<T>;
  * without materializing a key array (unlike `Object.keys(obj).some(pred)`).
  */
 export declare function someKey<T extends object>(obj: T, pred: (key: keyof T & string) => boolean): boolean;
-/** Whether any enumerable value of `obj` satisfies `pred`, short-circuiting like {@link someKey}. */
-export declare function someValue(obj: object, pred: (value: unknown) => boolean): boolean;
+/** Whether `key` names an operator (`$eq`, `$push`...) rather than a field. */
+export declare function isOperatorKey(key: string): boolean;
 /** Whether `value` is a non-empty object with an operator key (`$eq`, `$push`...): the one test every dialect classifies with. */
 export declare function isOperatorObject(value: unknown): value is Record<string, unknown>;
-/** Whether every key of the non-empty object `value` is an operator (no plain field names mixed in). */
-export declare function isOperatorOnlyObject(value: unknown): value is Record<string, unknown>;
 /** Whether `value` is an object that is not an array, whose keys can be read. */
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
 export declare function getKeys<T extends object>(obj: T | null | undefined): (keyof T & string)[];

package/dist/util/object.util.js

@@ -32,18 +32,13 @@ export function someKey(obj, pred) {
     }
     return false;
 }
-/** Whether any enumerable value of `obj` satisfies `pred`, short-circuiting like {@link someKey}. */
-export function someValue(obj, pred) {
-    return someKey(obj, (key) => pred(obj[key]));
+/** Whether `key` names an operator (`$eq`, `$push`...) rather than a field. */
+export function isOperatorKey(key) {
+    return key.startsWith('$');
 }
-const isOperatorKey = (key) => key.startsWith('$');
 /** Whether `value` is a non-empty object with an operator key (`$eq`, `$push`...): the one test every dialect classifies with. */
 export function isOperatorObject(value) {
-    return hasKeys(value) && !Array.isArray(value) && someKey(value, isOperatorKey);
-}
-/** Whether every key of the non-empty object `value` is an operator (no plain field names mixed in). */
-export function isOperatorOnlyObject(value) {
-    return hasKeys(value) && !Array.isArray(value) && !someKey(value, (key) => !isOperatorKey(key));
+    return isRecord(value) && someKey(value, isOperatorKey);
 }
 /** Whether `value` is an object that is not an array, whose keys can be read. */
 export function isRecord(value) {

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "The JSON-native TypeScript ORM for Bun, Browsers, Edge, Deno, Node, Workers. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, SQL Server, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.67.1",
+  "version": "0.68.1",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -161,7 +161,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rogerpadilla/uql.git",
-    "directory": "packages/uql-orm"
+    "directory": "packages/orm"
   },
   "bugs": {
     "url": "https://github.com/rogerpadilla/uql/issues"

package/dist/dialect/jsonArrayElemMatchUtils.d.ts

@@ -1,2 +0,0 @@
-/** An `$elemMatch` as per-field conditions, a plain value as `$eq`, so both spellings emit the same SQL. */
-export declare function buildElemMatchConditions(match: Record<string, unknown>, onCondition: (field: string, op: string, value: unknown) => string): string[];

package/dist/dialect/jsonArrayElemMatchUtils.js

@@ -1,7 +0,0 @@
-import { isOperatorObject } from '../util/object.util.js';
-/** An `$elemMatch` as per-field conditions, a plain value as `$eq`, so both spellings emit the same SQL. */
-export function buildElemMatchConditions(match, onCondition) {
-    return Object.entries(match).flatMap(([field, value]) => isOperatorObject(value)
-        ? Object.entries(value).map(([op, opVal]) => onCondition(field, op, opVal))
-        : onCondition(field, '$eq', value));
-}

package/dist/dialect/pgVectorMetrics.d.ts

@@ -1,13 +0,0 @@
-import type { VectorDistance, VectorOperatorMetric } from '../type/index.js';
-/**
- * Each metric's pgvector distance operator and the operator-class suffix its index takes, in one list
- * so a dialect cannot have the operator but not the opclass. Its own module because the two ends live
- * apart: the operator on the dialect, the opclass in the migrator's index DDL.
- */
-export declare const PG_VECTOR_METRICS: ReadonlyMap<VectorDistance, VectorOperatorMetric>;
-/**
- * CockroachDB's three: `<+>` and `vector_l1_ops` answer "unimplemented: operator class ... is not
- * supported" (verified live on v26.2), tracked at https://github.com/cockroachdb/cockroach/issues/147839.
- * Re-check that issue before adding `l1`; it is omitted on purpose.
- */
-export declare const COCKROACH_VECTOR_METRICS: ReadonlyMap<VectorDistance, VectorOperatorMetric>;

package/dist/dialect/pgVectorMetrics.js

@@ -1,17 +0,0 @@
-/**
- * Each metric's pgvector distance operator and the operator-class suffix its index takes, in one list
- * so a dialect cannot have the operator but not the opclass. Its own module because the two ends live
- * apart: the operator on the dialect, the opclass in the migrator's index DDL.
- */
-export const PG_VECTOR_METRICS = new Map([
-    ['cosine', { op: '<=>', opsSuffix: 'cosine' }],
-    ['l2', { op: '<->', opsSuffix: 'l2' }],
-    ['inner', { op: '<#>', opsSuffix: 'ip' }],
-    ['l1', { op: '<+>', opsSuffix: 'l1' }],
-]);
-/**
- * CockroachDB's three: `<+>` and `vector_l1_ops` answer "unimplemented: operator class ... is not
- * supported" (verified live on v26.2), tracked at https://github.com/cockroachdb/cockroach/issues/147839.
- * Re-check that issue before adding `l1`; it is omitted on purpose.
- */
-export const COCKROACH_VECTOR_METRICS = new Map([...PG_VECTOR_METRICS].filter(([metric]) => metric !== 'l1'));

package/dist/maria/mariaVectorMetrics.d.ts

@@ -1,8 +0,0 @@
-import type { VectorDistance } from '../type/index.js';
-/**
- * MariaDB's own name for each metric it supports (`euclidean`, not `l2`), which its index clause and
- * its distance function are both spelled from - one list, so a metric can never be searchable and
- * unindexable or the reverse. Its own module because the two ends now live apart: the distance
- * function on the dialect, the `DISTANCE=` clause in the migrator's index DDL.
- */
-export declare const MARIA_VECTOR_METRICS: Map<VectorDistance, string>;

package/dist/maria/mariaVectorMetrics.js

@@ -1,10 +0,0 @@
-/**
- * MariaDB's own name for each metric it supports (`euclidean`, not `l2`), which its index clause and
- * its distance function are both spelled from - one list, so a metric can never be searchable and
- * unindexable or the reverse. Its own module because the two ends now live apart: the distance
- * function on the dialect, the `DISTANCE=` clause in the migrator's index DDL.
- */
-export const MARIA_VECTOR_METRICS = new Map([
-    ['cosine', 'cosine'],
-    ['l2', 'euclidean'],
-]);