convex-ents 0.18.1 → 0.20.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { EntDefinition, defineEnt, defineEntFromTable, defineEntSchema, defineEntsFromTables, getEntDefinitions } from './schema.js';
-export { G as GenericEnt, U as GenericEntWriter, t as PromiseEdgeEnts, p as PromiseEdgeEntsOrNull, v as PromiseEdgeEntsWriter, I as PromiseEdgeWriter, K as PromiseEdgeWriterOrNull, J as PromiseEdgeWriterOrThrow, x as PromiseEnt, V as PromiseEntId, w as PromiseEntOrNull, T as PromiseEntWriter, S as PromiseEntWriterOrNull, m as PromiseEnts, k as PromiseEntsOrNull, n as PromiseEntsOrNulls, N as PromiseEntsWriter, l as PromiseEntsWriterOrNull, g as PromiseOrderedQuery, f as PromiseOrderedQueryBase, P as PromiseOrderedQueryOrNull, L as PromiseOrderedQueryWriter, a as PromiseOrderedQueryWriterOrNull, h as PromiseQuery, b as PromiseQueryOrNull, M as PromiseQueryWriter, c as PromiseQueryWriterOrNull, e as PromiseTable, d as PromiseTableBase, R as PromiseTableWriter, Z as addEntRules, B as entsTableFactory } from './writer.js';
+export { L as GenericEnt, _ as GenericEntWriter, z as PromiseEdgeEnts, v as PromiseEdgeEntsOrNull, B as PromiseEdgeEntsWriter, O as PromiseEdgeWriter, R as PromiseEdgeWriterOrNull, Q as PromiseEdgeWriterOrThrow, D as PromiseEnt, $ as PromiseEntId, C as PromiseEntOrNull, Z as PromiseEntWriter, Y as PromiseEntWriterOrNull, q as PromiseEnts, o as PromiseEntsOrNull, r as PromiseEntsOrNulls, U as PromiseEntsWriter, p as PromiseEntsWriterOrNull, h as PromiseOrderedQuery, g as PromiseOrderedQueryBase, P as PromiseOrderedQueryOrNull, S as PromiseOrderedQueryWriter, b as PromiseOrderedQueryWriterOrNull, j as PromiseQuery, c as PromiseQueryOrNull, T as PromiseQueryWriter, d as PromiseQueryWriterOrNull, f as PromiseTable, e as PromiseTableBase, X as PromiseTableWriter, a3 as addEntRules, H as entsTableFactory } from './writer.js';
 export { scheduledDeleteFactory } from './deletion.js';
 import 'convex/server';
 import 'convex/values';

package/dist/index.js

@@ -463,6 +463,15 @@ function getEntDefinitions(schema) {
 function getEdgeDefinitions(entDefinitions, table) {
   return entDefinitions[table].edges;
 }
+function systemAwareGet(db, table, id) {
+  return isSystemTable(table) ? db.system.get(table, id) : db.get(table, id);
+}
+function systemAwareQuery(db, table) {
+  return isSystemTable(table) ? db.system.query(table) : db.query(table);
+}
+function isSystemTable(table) {
+  return table.startsWith("_");
+}
 
 // src/writer.ts
 var import_server2 = require("convex/server");
@@ -496,7 +505,7 @@ var WriterImplBase = class _WriterImplBase {
             }
           } else if (edgeDefinition.cardinality === "single") {
             if (edgeDefinition.deletion !== void 0 && (!isDeletingSoftly || edgeDefinition.deletion === "soft")) {
-              const doc = await this.ctx.db.get(id);
+              const doc = await this.ctx.db.get(this.table, id);
               if (doc !== null) {
                 const otherId = doc[edgeDefinition.field];
                 edges[key] = {
@@ -702,7 +711,7 @@ var WriterImplBase = class _WriterImplBase {
     if (id !== void 0) {
       const readPolicy = getReadRule(this.entDefinitions, this.table);
       if (readPolicy !== void 0) {
-        const doc = await this.ctx.db.get(id);
+        const doc = await this.ctx.db.get(this.table, id);
         if (doc === null) {
           throw new Error(
             `Cannot update document with ID "${id}" in table "${this.table} because it does not exist"`
@@ -721,7 +730,7 @@ var WriterImplBase = class _WriterImplBase {
       return;
     }
     const ent = id === void 0 ? void 0 : entWrapper(
-      await this.ctx.db.get(id),
+      await this.ctx.db.get(this.table, id),
       this.ctx,
       this.entDefinitions,
       this.table
@@ -751,9 +760,6 @@ var WriterImplBase = class _WriterImplBase {
     }
   }
 };
-function isSystemTable(table) {
-  return table.startsWith("_");
-}
 
 // src/functions.ts
 var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
@@ -780,7 +786,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
     );
   }
   map(callbackFn) {
-    return new PromiseArrayImpl(async () => {
+    return new PromiseArrayOrNullImpl(async () => {
       const array = await this;
       if (array === null) {
         return null;
@@ -941,6 +947,90 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
     );
   }
 };
+var PromiseIdsQueryOrNullImpl = class extends Promise {
+  constructor(retrieve, field) {
+    super(() => {
+    });
+    this.retrieve = retrieve;
+    this.field = field;
+  }
+  map(callbackFn) {
+    return new PromiseArrayOrNullImpl(async () => {
+      const array = await this;
+      if (array === null) {
+        return null;
+      }
+      return await Promise.all(array.map(callbackFn));
+    });
+  }
+  paginate(paginationOpts) {
+    return new PromiseIdsPaginationResultOrNullImpl(async () => {
+      const query = await this.retrieve();
+      if (query === null) {
+        return null;
+      }
+      const result = await query.paginate(paginationOpts);
+      return {
+        ...result,
+        page: result.page.map((id) => this._getId(id))
+      };
+    });
+  }
+  take(n) {
+    return new PromiseIdsOrNullImpl(async () => {
+      const query = await this.retrieve();
+      if (query === null) {
+        return null;
+      }
+      const result = await query.take(n);
+      return result.map((id) => this._getId(id));
+    });
+  }
+  async first() {
+    const query = await this.retrieve();
+    if (query === null) {
+      return null;
+    }
+    const doc = await query.first();
+    if (doc === null) {
+      return null;
+    }
+    return this._getId(doc);
+  }
+  async firstX() {
+    const id = await this.first();
+    if (id === null) {
+      throw new Error("Expected at least one ID, but got none");
+    }
+    return id;
+  }
+  async unique() {
+    const query = await this.retrieve();
+    if (query === null) {
+      return null;
+    }
+    const result = await query.unique();
+    if (result === null) {
+      return null;
+    }
+    return this._getId(result);
+  }
+  async uniqueX() {
+    const id = await this.unique();
+    if (id === null) {
+      throw new Error("Expected one unique ID, but got none");
+    }
+    return id;
+  }
+  then(onfulfilled, onrejected) {
+    return this.retrieve().then((query) => query === null ? null : query.collect()).then(
+      (docs) => docs === null ? null : docs.map((doc) => this._getId(doc))
+    ).then(onfulfilled, onrejected);
+  }
+  _getId(doc) {
+    return doc[this.field];
+  }
+};
 var PromisePaginationResultOrNullImpl = class extends Promise {
   constructor(ctx, entDefinitions, table, retrieve) {
     super(() => {
@@ -987,13 +1077,33 @@ var PromisePaginationResultOrNullImpl = class extends Promise {
     ).then(onfulfilled, onrejected);
   }
 };
+var PromiseIdsPaginationResultOrNullImpl = class extends Promise {
+  constructor(retrieve) {
+    super(() => {
+    });
+    this.retrieve = retrieve;
+  }
+  async map(callbackFn) {
+    const result = await this;
+    if (result === null) {
+      return null;
+    }
+    return {
+      ...result,
+      page: await Promise.all(result.page.map(callbackFn))
+    };
+  }
+  then(onfulfilled, onrejected) {
+    return this.retrieve().then(onfulfilled, onrejected);
+  }
+};
 var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
   constructor(ctx, entDefinitions, table) {
     super(
       ctx,
       entDefinitions,
       table,
-      async () => isSystemTable(table) ? ctx.db.system.query(table) : ctx.db.query(table)
+      async () => systemAwareQuery(ctx.db, table)
     );
   }
   get(...args) {
@@ -1021,7 +1131,7 @@ var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
         return {
           id,
           doc: async () => {
-            const doc = await (isSystemTable(this.table) ? this.ctx.db.system.get(id) : this.ctx.db.get(id));
+            const doc = await systemAwareGet(this.ctx.db, this.table, id);
             if (throwIfNull && doc === null) {
               throw new Error(
                 `Document not found with id \`${id}\` in table "${this.table}"`
@@ -1037,7 +1147,7 @@ var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
           this.table,
           indexName
         );
-        const doc = await this.ctx.db.query(this.table).withIndex(
+        const doc = await systemAwareQuery(this.ctx.db, this.table).withIndex(
           indexName,
           (q) => values.reduce((q2, value, i) => q2.eq(fieldNames[i], value), q)
         ).unique();
@@ -1070,7 +1180,7 @@ var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
         });
         return await Promise.all(
           ids.map(async (id) => {
-            const doc = await (isSystemTable(this.table) ? this.ctx.db.system.get(id) : this.ctx.db.get(id));
+            const doc = await systemAwareGet(this.ctx.db, this.table, id);
             if (throwIfNull && doc === null) {
               throw new Error(
                 `Document not found with id \`${id}\` in table "${this.table}"`
@@ -1081,12 +1191,23 @@ var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
         );
       } : async () => {
         const [indexName, values] = args;
+        const fieldNames = getIndexFields(
+          this.entDefinitions,
+          this.table,
+          indexName
+        );
+        if (fieldNames.length > 1) {
+          throw new Error(
+            `Index "${indexName}" has ${fieldNames.length} fields, but getMany() supports only single field indexes`
+          );
+        }
+        const fieldName = fieldNames[0];
         return await Promise.all(
           values.map(async (value) => {
-            const doc = await this.ctx.db.query(this.table).withIndex(indexName, (q) => q.eq(indexName, value)).unique();
+            const doc = await systemAwareQuery(this.ctx.db, this.table).withIndex(indexName, (q) => q.eq(fieldName, value)).unique();
             if (throwIfNull && doc === null) {
               throw new Error(
-                `Table "${this.table}" does not contain document with field "${indexName}" = \`${value}\``
+                `Table "${this.table}" does not contain document with field "${fieldName}" = \`${value}\``
               );
             }
             return doc;
@@ -1141,7 +1262,7 @@ var PromiseEntsOrNullImpl = class extends Promise {
     this.throwIfNull = throwIfNull;
   }
   map(callbackFn) {
-    return new PromiseArrayImpl(async () => {
+    return new PromiseArrayOrNullImpl(async () => {
       const array = await this;
       if (array === null) {
         return null;
@@ -1243,11 +1364,34 @@ var PromiseEntsOrNullImpl = class extends Promise {
     ).then(onfulfilled, onrejected);
   }
 };
+var PromiseIdsOrNullImpl = class extends Promise {
+  constructor(retrieve) {
+    super(() => {
+    });
+    this.retrieve = retrieve;
+  }
+  map(callbackFn) {
+    return new PromiseArrayOrNullImpl(async () => {
+      const array = await this;
+      if (array === null) {
+        return null;
+      }
+      return await Promise.all(array.map(callbackFn));
+    });
+  }
+  then(onfulfilled, onrejected) {
+    return this.retrieve().then(onfulfilled, onrejected);
+  }
+};
 var PromiseEdgeOrNullImpl = class _PromiseEdgeOrNullImpl extends PromiseEntsOrNullImpl {
   constructor(ctx, entDefinitions, table, edgeDefinition, retrieveSourceId, retrieveQuery, retrieveDoc = async (edgeDoc) => {
     const sourceId = edgeDoc[edgeDefinition.field];
     const targetId = edgeDoc[edgeDefinition.ref];
-    const doc = await this.ctx.db.get(targetId);
+    const doc = await systemAwareGet(
+      this.ctx.db,
+      edgeDefinition.to,
+      targetId
+    );
     if (doc === null) {
       throw new Error(
         `Dangling reference for edge "${edgeDefinition.name}" in table "${this.table}" for document with ID "${sourceId}": Could not find a document with ID "${targetId}" in table "${edgeDefinition.to}" (edge document ID is "${edgeDoc._id}").`
@@ -1274,6 +1418,12 @@ var PromiseEdgeOrNullImpl = class _PromiseEdgeOrNullImpl extends PromiseEntsOrNu
     this.retrieveQuery = retrieveQuery;
     this.retrieveDoc = retrieveDoc;
   }
+  ids() {
+    return new PromiseIdsQueryOrNullImpl(
+      () => this.retrieveQuery(),
+      this.edgeDefinition.ref
+    );
+  }
   async has(targetId) {
     const sourceId = await this.retrieveSourceId();
     if (sourceId === null) {
@@ -1543,7 +1693,11 @@ var PromiseEntOrNullImpl = class extends Promise {
                 `Unexpected null reference for edge "${edgeDefinition.name}" in table "${this.table}" on document with ID "${id}": Expected an ID for a document in table "${edgeDefinition.to}".`
               );
             }
-            const otherDoc = await this.ctx.db.get(otherId);
+            const otherDoc = await systemAwareGet(
+              this.ctx.db,
+              edgeDefinition.to,
+              otherId
+            );
             if (otherDoc === null && edgeDefinition.to !== "_scheduled_functions") {
               throw new Error(
                 `Dangling reference for edge "${edgeDefinition.name}" in table "${this.table}" on document with ID "${id}": Could not find a document with ID "${otherId}" in table "${edgeDefinition.to}".`
@@ -1557,7 +1711,7 @@ var PromiseEntOrNullImpl = class extends Promise {
     );
   }
 };
-var PromiseArrayImpl = class extends Promise {
+var PromiseArrayOrNullImpl = class extends Promise {
   constructor(retrieve) {
     super(() => {
     });
@@ -1816,7 +1970,7 @@ var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
             }
             if (edgeDefinition.cardinality === "single") {
               if (edgeDefinition.type === "ref") {
-                const oldDoc = await this.ctx.db.get(docId);
+                const oldDoc = await this.ctx.db.get(this.table, docId);
                 if (oldDoc[key] !== void 0 && oldDoc[key] !== idOrIds) {
                   throw new Error("Cannot set 1:1 edge from ref end.");
                 }
@@ -1878,7 +2032,10 @@ var PromiseEntIdImpl = class extends Promise {
       this.table,
       async () => {
         const id = await this.retrieve();
-        return { id, doc: async () => this.ctx.db.get(id) };
+        return {
+          id,
+          doc: async () => systemAwareGet(this.ctx.db, this.table, id)
+        };
       },
       true
     );
@@ -1963,6 +2120,12 @@ async function filterByReadRule(ctx, entDefinitions, table, docs, throwIfNull) {
   return docs.filter((_, i) => decisions[i]);
 }
 function getIndexFields(entDefinitions, table, index) {
+  if (index === "by_id") {
+    return ["_id"];
+  }
+  if (index === "by_creation_time") {
+    return ["_creationTime"];
+  }
   return entDefinitions[table].indexes[index];
 }
 function getReadRule(entDefinitions, table) {
@@ -2015,11 +2178,7 @@ function scheduledDeleteFactory(entDefinitions, options) {
       inProgress: import_values2.v.boolean()
     },
     handler: async (ctx, { origin, stack, inProgress }) => {
-      const originId = ctx.db.normalizeId(origin.table, origin.id);
-      if (originId === null) {
-        throw new Error(`Invalid ID "${origin.id}" for table ${origin.table}`);
-      }
-      const doc = await ctx.db.get(originId);
+      const doc = await ctx.db.get(origin.table, origin.id);
       if (doc.deletionTime !== origin.deletionTime) {
         if (inProgress) {
           console.error(
@@ -2037,7 +2196,7 @@ function scheduledDeleteFactory(entDefinitions, options) {
         newCounter(),
         inProgress ? stack : [
           {
-            id: originId,
+            id: origin.id,
             table: origin.table,
             edges: getEdgeArgs(entDefinitions, origin.table)
           }