@davidtkramer/convex-relations 0.4.0 → 0.4.2

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { GenericDataModel, TableNamesInDataModel, DocumentByName, GenericTableInfo, FilterBuilder, ExpressionOrValue, NamedTableInfo, IndexNames, IndexRangeBuilder, NamedIndex, IndexRange, GenericDatabaseReader } from 'convex/server';
+import { GenericDataModel, TableNamesInDataModel, DocumentByName, IndexNames, NamedTableInfo, IndexRangeBuilder, NamedIndex, IndexRange, GenericTableInfo, FilterBuilder, ExpressionOrValue, GenericDatabaseReader, SchemaDefinition } from 'convex/server';
 import { GenericId } from 'convex/values';
 
 type Simplify<T> = {
@@ -139,6 +139,8 @@ type TableNamespace<DataModel extends GenericDataModel, Table extends AppTable<D
     find<const Id extends GenericId<Table>>(id: Id): FindQueryBuilder<AppDoc<DataModel, Table>>;
     findOrNull<const Id extends GenericId<Table>>(id: Id): FindOrNullQueryBuilder<AppDoc<DataModel, Table>>;
     in<const Id extends GenericId<Table>>(ids: Id[]): TableBatchQueryFacade<DataModel, Table>;
+    withIndex<const IndexName extends UserIndex<DataModel, Table>>(index: IndexName, selector: IndexSelector<DataModel, Table, IndexName>): TableQueryFacade<DataModel, Table>;
+    withIndex<const IndexName extends UserIndex<DataModel, Table>>(index: IndexName): TableRangeQueryFacade<DataModel, Table>;
     through: {
         <const SourceTable extends AppTable<DataModel>, SourceItem, const TargetField extends ThroughSourceField<DataModel, Table, SourceItem>>(sourceQuery: ThroughCollectionSource<DataModel, SourceTable, SourceItem>, targetField: TargetField): ThroughQueryFacade<DataModel, Table, SourceItem>;
         <SourceItem, const TargetField extends ThroughSourceField<DataModel, Table, SourceItem>>(sourceQuery: AnyManySourceNode<SourceItem>, targetField: TargetField): ManyThroughQueryBuilder<AppDoc<DataModel, Table>, SourceItem>;
@@ -165,17 +167,19 @@ type QuerySourcePlan = {
     table: string;
     index?: string;
     selector?: unknown;
+    indexFields?: readonly string[];
 } | {
     kind: 'batch';
     table: string;
     index: string;
     values: unknown[];
+    indexFields?: readonly string[];
 };
 type QueryPlan = {
     source: QuerySourcePlan;
     modifiers: QueryModifier[];
     expanders: AnyWithBuilder<any, any>[];
 };
-declare function createQueryFacade<DataModel extends GenericDataModel>(db: GenericDatabaseReader<DataModel>): QueryFacade<DataModel>;
+declare function createQueryFacade<DataModel extends GenericDataModel>(db: GenericDatabaseReader<DataModel>, schema: SchemaDefinition<any, boolean>): QueryFacade<DataModel>;
 
 export { type AppDoc, type AppTable, type QueryFacade, type RootIndexValueArg, type StrictRootIndexValueArg, type UserIndex, createQueryFacade };

package/dist/index.js

@@ -67,16 +67,15 @@ function withExpander(plan, expander) {
     expanders: [...plan.expanders, expander]
   };
 }
-function normalizeIndexValues(index, value) {
+function normalizeIndexValues(index, value, indexFields) {
   if (Array.isArray(value)) {
-    const fieldNames = inferFieldNamesFromIndex(index);
-    return Object.fromEntries(fieldNames.map((field, index2) => [field, value[index2]]));
+    return Object.fromEntries(indexFields.map((field, index2) => [field, value[index2]]));
   }
   if (isPlainObject(value)) {
     return value;
   }
   return {
-    [inferFieldNameFromIndex(index)]: value
+    [index === "by_id" ? "_id" : indexFields[0]]: value
   };
 }
 function isPlainObject(value) {
@@ -89,19 +88,16 @@ function applyIndexValues(query, values) {
   }
   return current;
 }
-function inferFieldNameFromIndex(index) {
-  return inferFieldNamesFromIndex(index)[0];
-}
-function inferFieldNamesFromIndex(index) {
+function requireIndexFields(index, indexFields) {
   if (index === "by_id") {
     return ["_id"];
   }
-  if (index.startsWith("by") && index.length > 2) {
-    return index.slice(2).split("And").map((part) => `${part[0].toLowerCase()}${part.slice(1)}`);
+  if (indexFields === void 0) {
+    throw new Error(`Missing schema metadata for index ${index}`);
   }
-  throw new Error(`Cannot infer field name from index ${index}`);
+  return indexFields;
 }
-function createIndexedQuery(db, table, index, selector) {
+function createIndexedQuery(db, table, index, selector, indexFields = []) {
   const baseQuery = db.query(table);
   if (index === void 0) {
     return baseQuery;
@@ -115,9 +111,10 @@ function createIndexedQuery(db, table, index, selector) {
   if (index === "by_id") {
     return baseQuery.withIndex(index, (q) => q.eq("_id", selector));
   }
+  const fields = requireIndexFields(index, indexFields);
   return baseQuery.withIndex(
     index,
-    (q) => applyIndexValues(q, normalizeIndexValues(index, selector))
+    (q) => applyIndexValues(q, normalizeIndexValues(index, selector, fields))
   );
 }
 function sourceDescription(plan) {
@@ -154,7 +151,13 @@ async function* iterateDecoratedSourceItems(db, plan) {
   const runtime = createPlanRuntime(db, plan);
   const source = plan.source;
   const query = buildQuery(
-    () => createIndexedQuery(db, source.table, source.index, source.selector),
+    () => createIndexedQuery(
+      db,
+      source.table,
+      source.index,
+      source.selector,
+      source.indexFields
+    ),
     plan.modifiers
   );
   for await (const rawItem of query) {
@@ -191,18 +194,28 @@ function createPlanRuntime(db, plan) {
       return {
         many: async () => (await Promise.all(
           source.values.map(
-            async (value) => await queryUniqueByIndex(db, source.table, source.index, value)
+            async (value) => await queryManyByIndex(
+              db,
+              source.table,
+              source.index,
+              value,
+              source.indexFields
+            )
           )
-        )).filter(
-          (doc) => doc !== null
-        ),
+        )).flat(),
         mapOne: async (rawItem) => rawItem,
         mapMany: async (rawItems) => rawItems,
         missingMessages: {}
       };
     case "query": {
       const runQuery = () => buildQuery(
-        () => createIndexedQuery(db, source.table, source.index, source.selector),
+        () => createIndexedQuery(
+          db,
+          source.table,
+          source.index,
+          source.selector,
+          source.indexFields
+        ),
         plan.modifiers
       );
       return {
@@ -593,20 +606,22 @@ function createIdPlan(table, id) {
     id
   });
 }
-function createQueryPlan(table, index, selector) {
+function createQueryPlan(table, index, selector, indexFields) {
   return createPlan({
     kind: "query",
     table,
     index,
-    selector
+    selector,
+    indexFields
   });
 }
-function createBatchPlan(table, index, values) {
+function createBatchPlan(table, index, values, indexFields) {
   return createPlan({
     kind: "batch",
     table,
     index,
-    values
+    values,
+    indexFields
   });
 }
 function isCollectionSource(value) {
@@ -627,7 +642,7 @@ function normalizeIndexSelectorArgs(args) {
   }
   return args;
 }
-function createTableNamespace(db, table) {
+function createTableNamespace(db, table, resolveIndexFields) {
   const rootFacade = createCollectionFacade(db, createQueryPlan(table));
   const target = {
     ...rootFacade,
@@ -640,6 +655,12 @@ function createTableNamespace(db, table) {
     in(ids) {
       return createBatchFacade(db, createBatchPlan(table, "by_id", ids));
     },
+    withIndex(index, selector) {
+      return createCollectionFacade(
+        db,
+        createQueryPlan(table, index, selector, resolveIndexFields(table, index))
+      );
+    },
     through(sourceQuery, targetField) {
       if (isCollectionSource(sourceQuery)) {
         return createThroughCollectionFacade(db, {
@@ -685,18 +706,49 @@ function createTableNamespace(db, table) {
         createQueryPlan(
           table,
           prop,
-          normalizeIndexSelectorArgs(args)
+          normalizeIndexSelectorArgs(args),
+          resolveIndexFields(table, prop)
         )
       ));
       indexMethod.in = (values) => createBatchFacade(
         db,
-        createBatchPlan(table, prop, values)
+        createBatchPlan(
+          table,
+          prop,
+          values,
+          resolveIndexFields(table, prop)
+        )
       );
       return indexMethod;
     }
   });
 }
-function createQueryFacade(db) {
+function createIndexFieldResolver(schema) {
+  const cache = /* @__PURE__ */ new Map();
+  return (table, index) => {
+    if (index === "by_id") {
+      return ["_id"];
+    }
+    const cacheKey = `${table}:${index}`;
+    const cached = cache.get(cacheKey);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const tableDefinition = schema.tables[table];
+    const indexes = tableDefinition?.[" indexes"]();
+    const match = indexes?.find(
+      (candidate) => candidate.indexDescriptor === index
+    );
+    if (match !== void 0 && Array.isArray(match.fields)) {
+      const fields = [...match.fields];
+      cache.set(cacheKey, fields);
+      return fields;
+    }
+    throw new Error(`Missing schema metadata for index ${table}.${index}`);
+  };
+}
+function createQueryFacade(db, schema) {
+  const resolveIndexFields = createIndexFieldResolver(schema);
   return new Proxy(
     {},
     {
@@ -704,19 +756,25 @@ function createQueryFacade(db) {
         if (typeof prop !== "string" || RESERVED_PROMISE_KEYS.has(prop)) {
           return void 0;
         }
-        return createTableNamespace(db, prop);
+        return createTableNamespace(
+          db,
+          prop,
+          resolveIndexFields
+        );
       }
     }
   );
 }
-async function queryUniqueByIndex(db, table, index, value) {
+async function queryManyByIndex(db, table, index, value, indexFields) {
   if (index === "by_id") {
-    return await db.query(table).withIndex("by_id", (q) => q.eq("_id", value)).unique();
+    const doc = await db.query(table).withIndex("by_id", (q) => q.eq("_id", value)).unique();
+    return doc ? [doc] : [];
   }
+  const fields = requireIndexFields(index, indexFields);
   return await db.query(table).withIndex(
     index,
-    (q) => applyIndexValues(q, normalizeIndexValues(index, value))
-  ).unique();
+    (q) => applyIndexValues(q, normalizeIndexValues(index, value, fields))
+  ).collect();
 }
 export {
   createQueryFacade

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davidtkramer/convex-relations",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Typed query facade helpers for Convex backends",
   "type": "module",
   "license": "MIT",