convex-ents 0.19.0 → 0.20.0

package/dist/shared.d.ts

@@ -14,7 +14,7 @@ type IndexFieldTypesForEq<EntsDataModel extends GenericEntsDataModel, Table exte
 type PopIfSeveral<T extends any[]> = T extends [infer Only] ? [Only] : T extends [...infer Rest, infer _Last] ? Rest : never;
 declare function getEdgeDefinitions<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>>(entDefinitions: EntsDataModel, table: Table): Record<keyof EntsDataModel[Table]["edges"], EdgeConfig>;
 type UniqueIndexFieldName<T extends string[]> = T extends [infer Only] ? Only : T extends [infer Single, "_creationTime"] ? Single : never;
-declare function systemAwareGet<DataModel extends GenericDataModel, Table extends TableNamesInDataModel<DataModel>>(db: GenericDatabaseReader<DataModel>, table: Table, id: GenericId<Table>): Promise<DocumentByName<SystemDataModel, (Table & "_storage") | (Table & "_scheduled_functions")> | null> | Promise<DocumentByName<DataModel, Table> | null>;
+declare function systemAwareGet<DataModel extends GenericDataModel, Table extends TableNamesInDataModel<DataModel>>(db: GenericDatabaseReader<DataModel>, table: Table, id: GenericId<Table>): Promise<DocumentByName<SystemDataModel, (Table & "_scheduled_functions") | (Table & "_storage")> | null> | Promise<DocumentByName<DataModel, Table> | null>;
 declare function systemAwareQuery<DataModel extends GenericDataModel, Table extends TableNamesInDataModel<DataModel>>(db: GenericDatabaseReader<DataModel>, table: Table): QueryInitializer<NamedTableInfo<DataModel, Table>>;
 declare function isSystemTable(table: string): table is SystemTableNames;
 

package/dist/writer.d.ts

@@ -44,6 +44,28 @@ interface PromiseOrderedQueryOrNull<EntsDataModel extends GenericEntsDataModel,
     unique(): PromiseEntOrNull<EntsDataModel, Table>;
     docs(): Promise<DocumentByName<EntsDataModel, Table>[] | null>;
 }
+interface PromiseOrderedIdsQueryOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<GenericId<Table>[] | null> {
+    /**
+     * Map over the relevant IDs.
+     */
+    map<TOutput>(callbackFn: (value: GenericId<Table>, index: number, array: GenericId<Table>[]) => TOutput | Promise<TOutput>): PromiseArrayOrNull<TOutput>;
+    /**
+     * Paginate the relevant IDs.
+     */
+    paginate(paginationOpts: PaginationOptions): PromiseIdsPaginationResultOrNull<EntsDataModel, Table>;
+    /**
+     * Take the first `n` relevant IDs.
+     */
+    take(n: number): PromiseIdsOrNull<EntsDataModel, Table>;
+    /**
+     * Returns the first relevant ID, or `null` if there are no relevant IDs.
+     */
+    first(): Promise<GenericId<Table> | null>;
+    /**
+     * Returns the only relevant ID, or `null` if there are none or throws if there is more than one.
+     */
+    unique(): Promise<GenericId<Table> | null>;
+}
 interface PromiseOrderedQueryWriterOrNull<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): PromiseArrayOrNull<TOutput>;
@@ -129,6 +151,15 @@ interface PromiseOrderedQuery<EntsDataModel extends GenericEntsDataModel, Table
     unique(): PromiseEntOrNull<EntsDataModel, Table>;
     uniqueX(): PromiseEnt<EntsDataModel, Table>;
 }
+interface PromiseOrderedIdsQuery<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<GenericId<Table>[]> {
+    map<TOutput>(callbackFn: (value: GenericId<Table>, index: number, array: GenericId<Table>[]) => Promise<TOutput> | TOutput): PromiseArray<TOutput>;
+    paginate(paginationOpts: PaginationOptions): PromiseIdsPaginationResult<EntsDataModel, Table>;
+    take(n: number): PromiseIds<EntsDataModel, Table>;
+    first(): Promise<GenericId<Table> | null>;
+    firstX(): Promise<GenericId<Table>>;
+    unique(): Promise<GenericId<Table> | null>;
+    uniqueX(): Promise<GenericId<Table>>;
+}
 interface PromiseQuery<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseOrderedQuery<EntsDataModel, Table> {
     order(order: "asc" | "desc"): PromiseOrderedQuery<EntsDataModel, Table>;
 }
@@ -140,6 +171,12 @@ interface PromisePaginationResult<EntsDataModel extends GenericEntsDataModel, Ta
     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 PromiseIdsPaginationResultOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<PaginationResult<GenericId<Table>> | null> {
+    map<TOutput>(callbackFn: (value: GenericId<Table>, index: number, array: GenericId<Table>[]) => Promise<TOutput> | TOutput): Promise<PaginationResult<TOutput> | null>;
+}
+interface PromiseIdsPaginationResult<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<PaginationResult<GenericId<Table>>> {
+    map<TOutput>(callbackFn: (value: GenericId<Table>, index: number, array: GenericId<Table>[]) => 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): PromiseArrayOrNull<TOutput>;
     docs(): Promise<DocumentByName<EntsDataModel, Table>[] | null>;
@@ -154,6 +191,12 @@ interface PromiseEnts<EntsDataModel extends GenericEntsDataModel, Table extends
 }
 interface PromiseEntsOrNulls<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<(Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel> | null)[]> {
 }
+interface PromiseIdsOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<GenericId<Table>[] | null> {
+    map<TOutput>(callbackFn: (value: GenericId<Table>, index: number, array: GenericId<Table>[]) => Promise<TOutput> | TOutput): PromiseArrayOrNull<TOutput>;
+}
+interface PromiseIds<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<GenericId<Table>[]> {
+    map<TOutput>(callbackFn: (value: GenericId<Table>, index: number, array: GenericId<Table>[]) => Promise<TOutput> | TOutput): PromiseArrayOrNull<TOutput>;
+}
 interface PromiseEdgeOrderedEntsOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseEntsOrNull<EntsDataModel, Table> {
     /**
      * Paginate the ents on the other end of the edge.
@@ -190,6 +233,13 @@ interface PromiseEdgeEntsOrNull<EntsDataModel extends GenericEntsDataModel, Tabl
     order(order: "asc" | "desc", indexName?: IndexNames<NamedTableInfo<EntsDataModel, Table>>): PromiseEdgeOrderedEntsOrNull<EntsDataModel, Table>;
 }
 interface PromiseEdgeOrderedEntsWriterOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseEntsWriterOrNull<EntsDataModel, Table> {
+    /**
+     * Returns the IDs of the ents on the other end of the edge.
+     * Returns null if chained to a null result.
+     *
+     * Note that read rules are not applied to filter the returned IDs.
+     */
+    ids(): PromiseOrderedIdsQueryOrNull<EntsDataModel, Table>;
     /**
      * Paginate the ents on the other end of the edge.
      * Results are ordered by edge's `_creationTime`.
@@ -225,6 +275,12 @@ interface PromiseEdgeEntsWriterOrNull<EntsDataModel extends GenericEntsDataModel
     order(order: "asc" | "desc", indexName?: IndexNames<NamedTableInfo<EntsDataModel, Table>>): PromiseEdgeOrderedEntsWriterOrNull<EntsDataModel, Table>;
 }
 interface PromiseEdgeOrderedEnts<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseEnts<EntsDataModel, Table> {
+    /**
+     * Returns the IDs of the ents on the other end of the edge.
+     *
+     * Note that read rules are not applied to filter the returned IDs.
+     */
+    ids(): PromiseOrderedIdsQuery<EntsDataModel, Table>;
     /**
      * Paginate the ents on the other end of the edge.
      * Results are ordered by edge's `_creationTime`.
@@ -264,6 +320,12 @@ interface PromiseEdgeEnts<EntsDataModel extends GenericEntsDataModel, Table exte
      * @param id The ID of the ent on the other end of the edge
      */
     has(id: GenericId<Table>): Promise<boolean>;
+    /**
+     * Returns the IDs of the ents on the other end of the edge.
+     *
+     * Note that read rules are not applied to filter the returned IDs.
+     */
+    ids(): PromiseOrderedIdsQuery<EntsDataModel, Table>;
     /**
      * Query the ents on the other end of the edge
      * ordered by edge's `_creationTime`.
@@ -271,6 +333,12 @@ interface PromiseEdgeEnts<EntsDataModel extends GenericEntsDataModel, Table exte
     order(order: "asc" | "desc", indexName?: IndexNames<NamedTableInfo<EntsDataModel, Table>>): PromiseEdgeOrderedEnts<EntsDataModel, Table>;
 }
 interface PromiseEdgeOrderedEntsWriter<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseEntsWriter<EntsDataModel, Table> {
+    /**
+     * Returns the IDs of the ents on the other end of the edge.
+     *
+     * Note that read rules are not applied to filter the returned IDs.
+     */
+    ids(): PromiseOrderedIdsQuery<EntsDataModel, Table>;
     /**
      * Paginate the ents on the other end of the edge.
      * Results are ordered by edge's `_creationTime`.
@@ -345,7 +413,14 @@ type EntsTable<EntsDataModel extends GenericEntsDataModel> = EntsTableReader<Ent
     system: EntsTableReader<EntsSystemDataModel>;
 };
 type EntsTableWriter<EntsDataModel extends GenericEntsDataModel> = {
+    /**
+     * Read from and write to the given `table` using the index with the given `indexName`.
+     * Without the `indexRange` argument, the use of the index only affects the order of the results.
+     */
     <Table extends TableNamesInDataModel<EntsDataModel>, IndexName extends IndexNames<NamedTableInfo<EntsDataModel, Table>>>(table: Table, indexName: IndexName, indexRange?: (q: IndexRangeBuilder<DocumentByName<EntsDataModel, Table>, NamedIndex<NamedTableInfo<EntsDataModel, Table>, IndexName>>) => IndexRange): PromiseQueryWriter<EntsDataModel, Table>;
+    /**
+     * Read from and write to the given `table`.
+     */
     <Table extends TableNamesInDataModel<EntsDataModel>>(table: Table): PromiseTableWriter<Table, EntsDataModel>;
     system: EntsTableReader<EntsSystemDataModel>;
 };
@@ -363,12 +438,34 @@ type PromiseEdgeWriter<EntsDataModel extends GenericEntsDataModel, Table extends
 type PromiseEdgeWriterOrThrow<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>, Edge extends keyof EntsDataModel[Table]["edges"], Config extends GenericEdgeConfig = EntsDataModel[Table]["edges"][Edge], ToTable extends TableNamesInDataModel<EntsDataModel> = EntsDataModel[Table]["edges"][Edge]["to"]> = PromiseEdgeResult<Config, PromiseEdgeEntsWriter<EntsDataModel, ToTable>, PromiseQueryWriter<EntsDataModel, ToTable>, PromiseEntWriter<EntsDataModel, ToTable>, PromiseEntWriter<EntsDataModel, ToTable>>;
 type PromiseEdgeWriterOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>, Edge extends keyof EntsDataModel[Table]["edges"], Config extends GenericEdgeConfig = EntsDataModel[Table]["edges"][Edge], ToTable extends TableNamesInDataModel<EntsDataModel> = EntsDataModel[Table]["edges"][Edge]["to"]> = PromiseEdgeResult<Config, PromiseEdgeEntsWriterOrNull<EntsDataModel, ToTable>, PromiseQueryWriterOrNull<EntsDataModel, ToTable>, PromiseEntWriterOrNull<EntsDataModel, ToTable>, PromiseEntWriterOrNull<EntsDataModel, ToTable>>;
 interface PromiseOrderedQueryWriter<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]>, PromiseOrderedQueryBase<EntsDataModel, Table> {
+    /**
+     * Paginate the relevant ents.
+     */
     paginate(paginationOpts: PaginationOptions): PromisePaginationResultWriter<EntsDataModel, Table>;
+    /**
+     * Map over the relevant ents.
+     */
     map<TOutput>(callbackFn: (value: EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>, index: number, array: EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]) => Promise<TOutput> | TOutput): PromiseArray<TOutput>;
+    /**
+     * Take the first `n` relevant ents.
+     */
     take(n: number): PromiseEntsWriter<EntsDataModel, Table>;
+    /**
+     * Returns the first relevant ent, or `null` if there are no ents.
+     */
     first(): PromiseEntWriterOrNull<EntsDataModel, Table>;
+    /**
+     * Returns the first relevant ent, or throws if there are no ents.
+     */
     firstX(): PromiseEntWriter<EntsDataModel, Table>;
+    /**
+     * Returns the only relevant ent, `null` if there are none,
+     * or throws if there are more than one.
+     */
     unique(): PromiseEntWriterOrNull<EntsDataModel, Table>;
+    /**
+     * Returns the only relevant ent, or throws if there are none or more than one.
+     */
     uniqueX(): PromiseEntWriter<EntsDataModel, Table>;
 }
 interface PromiseQueryWriter<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseOrderedQueryWriter<EntsDataModel, Table> {
@@ -444,6 +541,9 @@ interface PromiseEntWriterOrNull<EntsDataModel extends GenericEntsDataModel, Tab
     doc(): Promise<DocumentByName<EntsDataModel, Table> | null>;
 }
 interface PromiseEntWriter<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>> {
+    /**
+     * Traverse the given `edge`.
+     */
     edge<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdgeWriter<EntsDataModel, Table, Edge>;
     edgeX<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdgeWriterOrThrow<EntsDataModel, Table, Edge>;
     doc(): Promise<DocumentByName<EntsDataModel, Table>>;
@@ -550,4 +650,4 @@ declare function getWriteRule(entDefinitions: GenericEntsDataModel, table: strin
 }) => Promise<boolean>) | undefined;
 declare function getDeletionConfig<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>>(entDefinitions: EntsDataModel, table: Table): DeletionConfig | undefined;
 
-export { getWriteRule as $, entWrapper as A, entsTableFactory as B, type EntsTableWriter as C, type Ent as D, type EntsTable as E, type EdgeChanges, type PromiseEdge as F, type GenericEnt as G, type PromiseEdgeOrThrow as H, type PromiseEdgeWriter as I, type PromiseEdgeWriterOrThrow as J, type PromiseEdgeWriterOrNull as K, type PromiseOrderedQueryWriter as L, type PromiseQueryWriter as M, type PromiseEntsWriter as N, type PromisePaginationResultWriterOrNull as O, type PromiseOrderedQueryOrNull as P, type PromisePaginationResultWriter as Q, type PromiseTableWriter as R, type PromiseEntWriterOrNull as S, type PromiseEntWriter as T, type GenericEntWriter as U, type PromiseEntId as V, type EntQueryCtx as W, type WithEdgeInserts, type WithEdgePatches, type WithEdges, WriterImplBase, type EntMutationCtx as X, type DocRetriever as Y, addEntRules as Z, getReadRule as _, type PromiseOrderedQueryWriterOrNull as a, getDeletionConfig as a0, type PromiseQueryOrNull as b, type PromiseQueryWriterOrNull as c, type PromiseTableBase as d, type PromiseTable as e, type PromiseOrderedQueryBase as f, type PromiseOrderedQuery as g, type PromiseQuery as h, type PromisePaginationResultOrNull as i, type PromisePaginationResult as j, type PromiseEntsOrNull as k, type PromiseEntsWriterOrNull as l, type PromiseEnts as m, type PromiseEntsOrNulls as n, type PromiseEdgeOrderedEntsOrNull as o, type PromiseEdgeEntsOrNull as p, type PromiseEdgeOrderedEntsWriterOrNull as q, type PromiseEdgeEntsWriterOrNull as r, type PromiseEdgeOrderedEnts as s, type PromiseEdgeEnts as t, type PromiseEdgeOrderedEntsWriter as u, type PromiseEdgeEntsWriter as v, type PromiseEntOrNull as w, type PromiseEnt as x, type PromiseArrayOrNull as y, type PromiseArray as z };
+export { type PromiseEntId as $, type PromiseEdgeOrderedEntsWriter as A, type PromiseEdgeEntsWriter as B, type PromiseEntOrNull as C, type PromiseEnt as D, type PromiseArrayOrNull as E, type EdgeChanges, type PromiseArray as F, entWrapper as G, entsTableFactory as H, type EntsTable as I, type EntsTableWriter as J, type Ent as K, type GenericEnt as L, type PromiseEdge as M, type PromiseEdgeOrThrow as N, type PromiseEdgeWriter as O, type PromiseOrderedQueryOrNull as P, type PromiseEdgeWriterOrThrow as Q, type PromiseEdgeWriterOrNull as R, type PromiseOrderedQueryWriter as S, type PromiseQueryWriter as T, type PromiseEntsWriter as U, type PromisePaginationResultWriterOrNull as V, type PromisePaginationResultWriter as W, type WithEdgeInserts, type WithEdgePatches, type WithEdges, WriterImplBase, type PromiseTableWriter as X, type PromiseEntWriterOrNull as Y, type PromiseEntWriter as Z, type GenericEntWriter as _, type PromiseOrderedIdsQueryOrNull as a, type EntQueryCtx as a0, type EntMutationCtx as a1, type DocRetriever as a2, addEntRules as a3, getReadRule as a4, getWriteRule as a5, getDeletionConfig as a6, type PromiseOrderedQueryWriterOrNull as b, type PromiseQueryOrNull as c, type PromiseQueryWriterOrNull as d, type PromiseTableBase as e, type PromiseTable as f, type PromiseOrderedQueryBase as g, type PromiseOrderedQuery as h, type PromiseOrderedIdsQuery as i, type PromiseQuery as j, type PromisePaginationResultOrNull as k, type PromisePaginationResult as l, type PromiseIdsPaginationResultOrNull as m, type PromiseIdsPaginationResult as n, type PromiseEntsOrNull as o, type PromiseEntsWriterOrNull as p, type PromiseEnts as q, type PromiseEntsOrNulls as r, type PromiseIdsOrNull as s, type PromiseIds as t, type PromiseEdgeOrderedEntsOrNull as u, type PromiseEdgeEntsOrNull as v, type PromiseEdgeOrderedEntsWriterOrNull as w, type PromiseEdgeEntsWriterOrNull as x, type PromiseEdgeOrderedEnts as y, type PromiseEdgeEnts as z };

package/dist/writer.js

@@ -71,7 +71,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;
@@ -232,6 +232,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(() => {
@@ -278,6 +362,26 @@ 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 PromiseEntsOrNullImpl = class extends Promise {
   constructor(ctx, entDefinitions, table, retrieve, throwIfNull) {
     super(() => {
@@ -289,7 +393,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;
@@ -391,6 +495,25 @@ 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];
@@ -426,6 +549,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) {
@@ -713,7 +842,7 @@ var PromiseEntOrNullImpl = class extends Promise {
     );
   }
 };
-var PromiseArrayImpl = class extends Promise {
+var PromiseArrayOrNullImpl = class extends Promise {
   constructor(retrieve) {
     super(() => {
     });