convex-ents 0.1.0 → 0.2.0

package/dist/functions.d.ts

@@ -1,13 +1,13 @@
 import { GenericEntsDataModel } from './schema.js';
 import * as convex_values from 'convex/values';
 import { GenericId } from 'convex/values';
-import { TableNamesInDataModel, DocumentByName, FilterBuilder, NamedTableInfo, ExpressionOrValue, PaginationOptions, PaginationResult, IndexNames, FieldTypeFromFieldPath, SearchIndexNames, SearchFilterBuilder, NamedSearchIndex, SearchFilter, GenericDatabaseReader, GenericDatabaseWriter, IndexRangeBuilder, NamedIndex, IndexRange, WithoutSystemFields, WithOptionalSystemFields, GenericDocument } from 'convex/server';
+import { TableNamesInDataModel, DocumentByName, FilterBuilder, NamedTableInfo, ExpressionOrValue, PaginationOptions, IndexNames, FieldTypeFromFieldPath, SearchIndexNames, SearchFilterBuilder, NamedSearchIndex, SearchFilter, PaginationResult, GenericDatabaseReader, GenericDatabaseWriter, IndexRangeBuilder, NamedIndex, IndexRange, WithoutSystemFields, WithOptionalSystemFields, GenericDocument } from 'convex/server';
 import { WithEdges, WithEdgePatches } from './writer.js';
 
 interface PromiseOrderedQueryOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[] | null> {
     filter(predicate: (q: FilterBuilder<NamedTableInfo<EntsDataModel, Table>>) => ExpressionOrValue<boolean>): this;
     map<TOutput>(callbackFn: (value: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>, index: number, array: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]) => Promise<TOutput> | TOutput): Promise<TOutput[] | null>;
-    paginate(paginationOpts: PaginationOptions): Promise<PaginationResult<DocumentByName<EntsDataModel, Table>> | null>;
+    paginate(paginationOpts: PaginationOptions): PromisePaginationResultOrNull<EntsDataModel, Table>;
     take(n: number): PromiseEntsOrNull<EntsDataModel, Table>;
     first(): PromiseEntOrNull<EntsDataModel, Table>;
     unique(): PromiseEntOrNull<EntsDataModel, Table>;
@@ -66,7 +66,7 @@ interface PromiseTable<EntsDataModel extends GenericEntsDataModel, Table extends
 }
 interface PromiseOrderedQueryBase<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> {
     filter(predicate: (q: FilterBuilder<NamedTableInfo<EntsDataModel, Table>>) => ExpressionOrValue<boolean>): this;
-    paginate(paginationOpts: PaginationOptions): Promise<PaginationResult<DocumentByName<EntsDataModel, Table>>>;
+    paginate(paginationOpts: PaginationOptions): PromisePaginationResult<EntsDataModel, Table>;
     first(): PromiseEntOrNull<EntsDataModel, Table>;
     unique(): PromiseEntOrNull<EntsDataModel, Table>;
     docs(): Promise<DocumentByName<EntsDataModel, Table>[]>;
@@ -80,6 +80,14 @@ interface PromiseOrderedQuery<EntsDataModel extends GenericEntsDataModel, Table
 interface PromiseQuery<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseOrderedQuery<EntsDataModel, Table> {
     order(order: "asc" | "desc", indexName?: IndexNames<NamedTableInfo<EntsDataModel, Table>>): PromiseOrderedQuery<EntsDataModel, Table>;
 }
+interface PromisePaginationResultOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<PaginationResult<Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>> | null> {
+    docs(): Promise<PaginationResult<DocumentByName<EntsDataModel, Table>> | null>;
+    map<TOutput>(callbackFn: (value: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>, index: number, array: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]) => Promise<TOutput> | TOutput): Promise<PaginationResult<TOutput> | null>;
+}
+interface PromisePaginationResult<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<PaginationResult<Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>>> {
+    docs(): Promise<PaginationResult<DocumentByName<EntsDataModel, Table>>>;
+    map<TOutput>(callbackFn: (value: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>, index: number, array: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]) => Promise<TOutput> | TOutput): Promise<PaginationResult<TOutput>>;
+}
 interface PromiseEntsOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[] | null> {
     map<TOutput>(callbackFn: (value: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>, index: number, array: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]) => Promise<TOutput> | TOutput): Promise<TOutput[] | null>;
     docs(): Promise<DocumentByName<EntsDataModel, Table>[] | null>;
@@ -135,6 +143,7 @@ type PromiseEdge<EntsDataModel extends GenericEntsDataModel, Table extends Table
 type PromiseEdgeOrThrow<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>, Edge extends keyof EntsDataModel[Table]["edges"]> = EntsDataModel[Table]["edges"][Edge]["cardinality"] extends "multiple" ? EntsDataModel[Table]["edges"][Edge]["type"] extends "ref" ? PromiseEdgeEnts<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]> : PromiseQuery<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]> : EntsDataModel[Table]["edges"][Edge]["type"] extends "ref" ? PromiseEnt<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]> : PromiseEnt<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]>;
 type PromiseEdgeOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>, Edge extends keyof EntsDataModel[Table]["edges"]> = EntsDataModel[Table]["edges"][Edge]["cardinality"] extends "multiple" ? EntsDataModel[Table]["edges"][Edge]["type"] extends "ref" ? PromiseEdgeEntsOrNull<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]> : PromiseQueryOrNull<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]> : PromiseEntOrNull<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]>;
 interface PromiseOrderedQueryWriter<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]>, PromiseOrderedQueryBase<EntsDataModel, Table> {
+    paginate(paginationOpts: PaginationOptions): PromisePaginationResultWriter<EntsDataModel, Table>;
     map<TOutput>(callbackFn: (value: EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>, index: number, array: EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]) => Promise<TOutput> | TOutput): Promise<TOutput[]>;
     take(n: number): PromiseEntsWriter<EntsDataModel, Table>;
     firstX(): PromiseEntWriter<EntsDataModel, Table>;
@@ -147,6 +156,10 @@ interface PromiseEntsWriter<EntsDataModel extends GenericEntsDataModel, Table ex
     firstX(): PromiseEntWriter<EntsDataModel, Table>;
     uniqueX(): PromiseEntWriter<EntsDataModel, Table>;
 }
+interface PromisePaginationResultWriter<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<PaginationResult<EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>>> {
+    docs(): Promise<PaginationResult<DocumentByName<EntsDataModel, Table>>>;
+    map<TOutput>(callbackFn: (value: EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>, index: number, array: EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]) => Promise<TOutput> | TOutput): Promise<PaginationResult<TOutput>>;
+}
 interface PromiseTableWriter<Table extends TableNamesInDataModel<EntsDataModel>, EntsDataModel extends GenericEntsDataModel> extends PromiseQueryWriter<EntsDataModel, Table>, PromiseTableBase<EntsDataModel, Table> {
     get<Indexes extends EntsDataModel[Table]["indexes"], Index extends keyof Indexes>(indexName: Index, value0: FieldTypeFromFieldPath<DocumentByName<EntsDataModel, Table>, Indexes[Index][0]>): PromiseEntWriterOrNull<EntsDataModel, Table>;
     get(id: GenericId<Table>): PromiseEntWriterOrNull<EntsDataModel, Table>;
@@ -300,4 +313,4 @@ declare function getWriteRule(entDefinitions: GenericEntsDataModel, table: strin
     value: undefined;
 }) => Promise<boolean>) | undefined;
 
-export { type DocRetriever, type Ent, type GenericEnt, type GenericEntWriter, type PromiseEdge, type PromiseEdgeEnts, type PromiseEdgeEntsOrNull, type PromiseEdgeOrThrow, type PromiseEnt, type PromiseEntId, type PromiseEntOrNull, type PromiseEntWriter, type PromiseEntWriterOrNull, type PromiseEnts, type PromiseEntsOrNull, type PromiseEntsOrNulls, type PromiseEntsWriter, type PromiseOrderedQuery, type PromiseOrderedQueryBase, type PromiseOrderedQueryOrNull, type PromiseOrderedQueryWriter, type PromiseQuery, type PromiseQueryOrNull, type PromiseQueryWriter, type PromiseTable, type PromiseTableBase, type PromiseTableWriter, addEntRules, entWrapper, entsTableFactory, getReadRule, getWriteRule };
+export { type DocRetriever, type Ent, type GenericEnt, type GenericEntWriter, type PromiseEdge, type PromiseEdgeEnts, type PromiseEdgeEntsOrNull, type PromiseEdgeOrThrow, type PromiseEnt, type PromiseEntId, type PromiseEntOrNull, type PromiseEntWriter, type PromiseEntWriterOrNull, type PromiseEnts, type PromiseEntsOrNull, type PromiseEntsOrNulls, type PromiseEntsWriter, type PromiseOrderedQuery, type PromiseOrderedQueryBase, type PromiseOrderedQueryOrNull, type PromiseOrderedQueryWriter, type PromisePaginationResult, type PromisePaginationResultOrNull, type PromisePaginationResultWriter, type PromiseQuery, type PromiseQueryOrNull, type PromiseQueryWriter, type PromiseTable, type PromiseTableBase, type PromiseTableWriter, addEntRules, entWrapper, entsTableFactory, getReadRule, getWriteRule };

package/dist/functions.js

@@ -29,12 +29,62 @@ __export(functions_exports, {
 module.exports = __toCommonJS(functions_exports);
 
 // src/writer.ts
-var WriterImplBase = class {
+var WriterImplBase = class _WriterImplBase {
   constructor(db, entDefinitions, table) {
     this.db = db;
     this.entDefinitions = entDefinitions;
     this.table = table;
   }
+  async deleteId(id) {
+    await this.checkReadAndWriteRule("delete", id, void 0);
+    let memoized = void 0;
+    const oldDoc = async () => {
+      if (memoized !== void 0) {
+        return memoized;
+      }
+      return memoized = await this.db.get(id);
+    };
+    const edges = {};
+    await Promise.all(
+      Object.values(
+        this.entDefinitions[this.table].edges
+      ).map(async (edgeDefinition) => {
+        const key = edgeDefinition.name;
+        if (edgeDefinition.cardinality === "single") {
+          if (edgeDefinition.type === "ref") {
+            edges[key] = {
+              remove: (await oldDoc())[key]
+            };
+          }
+        } else {
+          if (edgeDefinition.type === "field") {
+            const existing = (await this.db.query(edgeDefinition.to).withIndex(
+              edgeDefinition.ref,
+              (q) => q.eq(edgeDefinition.ref, id)
+            ).collect()).map((doc) => doc._id);
+            edges[key] = { remove: existing };
+          } else {
+            const existing = (await this.db.query(edgeDefinition.table).withIndex(
+              edgeDefinition.field,
+              (q) => q.eq(edgeDefinition.field, id)
+            ).collect()).concat(
+              edgeDefinition.symmetric ? await this.db.query(edgeDefinition.table).withIndex(
+                edgeDefinition.ref,
+                (q) => q.eq(edgeDefinition.ref, id)
+              ).collect() : []
+            ).map((doc) => doc._id);
+            edges[key] = { removeEdges: existing };
+          }
+        }
+      })
+    );
+    await this.db.delete(id);
+    await this.writeEdges(id, edges);
+    return id;
+  }
+  async deletedIdIn(id, table) {
+    await new _WriterImplBase(this.db, this.entDefinitions, table).deleteId(id);
+  }
   async writeEdges(docId, changes) {
     await Promise.all(
       Object.values(
@@ -47,7 +97,10 @@ var WriterImplBase = class {
         if (edgeDefinition.cardinality === "single") {
           if (edgeDefinition.type === "ref") {
             if (idOrIds.remove !== void 0) {
-              await this.db.delete(idOrIds.remove);
+              await this.deletedIdIn(
+                idOrIds.remove,
+                edgeDefinition.to
+              );
             }
             if (idOrIds.add !== void 0) {
               await this.db.patch(
@@ -61,7 +114,7 @@ var WriterImplBase = class {
             if (idOrIds.remove !== void 0) {
               await Promise.all(
                 idOrIds.remove.map(
-                  (id) => this.db.delete(id)
+                  (id) => this.deletedIdIn(id, edgeDefinition.to)
                 )
               );
             }
@@ -276,13 +329,14 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
       }
     );
   }
-  // TODO: RLS for pagination
-  async paginate(paginationOpts) {
-    const query = await this.retrieve();
-    if (query === null) {
-      return null;
-    }
-    return await query.paginate(paginationOpts);
+  paginate(paginationOpts) {
+    return new PromisePaginationResultOrNullImpl(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      this.retrieve,
+      paginationOpts
+    );
   }
   take(n) {
     return new PromiseEntsOrNullImpl(
@@ -432,6 +486,54 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
     return docs;
   }
 };
+var PromisePaginationResultOrNullImpl = class extends Promise {
+  constructor(db, entDefinitions, table, retrieve, paginationOpts) {
+    super(() => {
+    });
+    this.db = db;
+    this.entDefinitions = entDefinitions;
+    this.table = table;
+    this.retrieve = retrieve;
+    this.paginationOpts = paginationOpts;
+  }
+  async map(callbackFn) {
+    const result = await this;
+    if (result === null) {
+      return null;
+    }
+    return {
+      ...result,
+      page: await Promise.all(result.page.map(callbackFn))
+    };
+  }
+  async docs() {
+    const query = await this.retrieve();
+    if (query === null) {
+      return null;
+    }
+    const result = await query.paginate(this.paginationOpts);
+    return {
+      ...result,
+      page: await filterByReadRule(
+        this.db,
+        this.entDefinitions,
+        this.table,
+        result.page,
+        false
+      )
+    };
+  }
+  then(onfulfilled, onrejected) {
+    return this.docs().then(
+      (result) => result === null ? null : {
+        ...result,
+        page: result.page.map(
+          (doc) => entWrapper(doc, this.db, this.entDefinitions, this.table)
+        )
+      }
+    ).then(onfulfilled, onrejected);
+  }
+};
 var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
   constructor(db, entDefinitions, table) {
     super(db, entDefinitions, table, async () => db.query(table));
@@ -1042,51 +1144,7 @@ var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
   async delete() {
     const { id: docId } = await this.retrieve();
     const id = docId;
-    await this.base.checkReadAndWriteRule("delete", id, void 0);
-    let memoized = void 0;
-    const oldDoc = async () => {
-      if (memoized !== void 0) {
-        return memoized;
-      }
-      return memoized = await this.db.get(id);
-    };
-    const edges = {};
-    await Promise.all(
-      Object.values(
-        this.entDefinitions[this.table].edges
-      ).map(async (edgeDefinition) => {
-        const key = edgeDefinition.name;
-        if (edgeDefinition.cardinality === "single") {
-          if (edgeDefinition.type === "ref") {
-            edges[key] = {
-              remove: (await oldDoc())[key]
-            };
-          }
-        } else {
-          if (edgeDefinition.type === "field") {
-            const existing = (await this.db.query(edgeDefinition.to).withIndex(
-              edgeDefinition.ref,
-              (q) => q.eq(edgeDefinition.ref, id)
-            ).collect()).map((doc) => doc._id);
-            edges[key] = { remove: existing };
-          } else {
-            const existing = (await this.db.query(edgeDefinition.table).withIndex(
-              edgeDefinition.field,
-              (q) => q.eq(edgeDefinition.field, id)
-            ).collect()).concat(
-              edgeDefinition.symmetric ? await this.db.query(edgeDefinition.table).withIndex(
-                edgeDefinition.ref,
-                (q) => q.eq(edgeDefinition.ref, id)
-              ).collect() : []
-            ).map((doc) => doc._id);
-            edges[key] = { removeEdges: existing };
-          }
-        }
-      })
-    );
-    await this.db.delete(id);
-    await this.base.writeEdges(id, edges);
-    return id;
+    return this.base.deleteId(id);
   }
 };
 var PromiseEntIdImpl = class extends Promise {
@@ -1132,23 +1190,23 @@ async function filterByReadRule(db, entDefinitions, table, docs, throwIfNull) {
     return null;
   }
   const readPolicy = getReadRule(entDefinitions, table);
-  if (readPolicy !== void 0) {
-    const decisions = await Promise.all(
-      docs.map(async (doc) => {
-        const decision = await readPolicy(
-          entWrapper(doc, db, entDefinitions, table)
-        );
-        if (throwIfNull && !decision) {
-          throw new Error(
-            `Document cannot be read with id \`${doc._id}\` in table "${table}"`
-          );
-        }
-        return decision;
-      })
-    );
-    return docs.filter((_, i) => decisions[i]);
+  if (readPolicy === void 0) {
+    return docs;
   }
-  return docs;
+  const decisions = await Promise.all(
+    docs.map(async (doc) => {
+      const decision = await readPolicy(
+        entWrapper(doc, db, entDefinitions, table)
+      );
+      if (throwIfNull && !decision) {
+        throw new Error(
+          `Document cannot be read with id \`${doc._id}\` in table "${table}"`
+        );
+      }
+      return decision;
+    })
+  );
+  return docs.filter((_, i) => decisions[i]);
 }
 function getReadRule(entDefinitions, table) {
   return entDefinitions.rules?.[table]?.read;