convex-ents 0.2.0 → 0.3.0

package/dist/index--8O_7LM9.d.ts

@@ -0,0 +1,368 @@
+import { GenericEntsDataModel, GenericEdgeConfig, Expand, EdgeConfig, DeletionConfig } from './schema.js';
+import * as convex_values from 'convex/values';
+import { GenericId } from 'convex/values';
+import { TableNamesInDataModel, GenericDocument, DocumentByName, FilterBuilder, NamedTableInfo, ExpressionOrValue, PaginationOptions, IndexNames, FieldTypeFromFieldPath, SearchIndexNames, SearchFilterBuilder, NamedSearchIndex, SearchFilter, PaginationResult, IndexRangeBuilder, NamedIndex, IndexRange, WithoutSystemFields, WithOptionalSystemFields, GenericDataModel, GenericDatabaseReader, GenericDatabaseWriter, Scheduler } from 'convex/server';
+import { ScheduledDeleteFuncRef } from './deletion.js';
+
+declare class WriterImplBase<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> {
+    protected ctx: EntMutationCtx<EntsDataModel>;
+    protected entDefinitions: EntsDataModel;
+    protected table: Table;
+    constructor(ctx: EntMutationCtx<EntsDataModel>, entDefinitions: EntsDataModel, table: Table);
+    deleteId(id: GenericId<any>, behavior: "default" | "soft" | "hard"): Promise<GenericId<any>>;
+    deletedIdIn(id: GenericId<any>, table: string, cascadingSoft: boolean): Promise<void>;
+    writeEdges(docId: GenericId<any>, changes: EdgeChanges, deleteSoftly?: boolean): Promise<void>;
+    checkUniqueness(value: Partial<GenericDocument>, id?: GenericId<any>): Promise<void>;
+    fieldsOnly(value: Partial<WithEdgePatches<DocumentByName<EntsDataModel, Table>, EntsDataModel[Table]["edges"]>>): GenericDocument;
+    checkReadAndWriteRule(operation: "create" | "update" | "delete", id: GenericId<Table> | undefined, value: Partial<GenericDocument> | undefined): Promise<void>;
+}
+type WithEdgeInserts<Document extends GenericDocument, Edges extends Record<string, GenericEdgeConfig>> = Document & {
+    [key in keyof Edges as Edges[key]["cardinality"] extends "single" ? Edges[key]["type"] extends "field" ? never : key : key]?: Edges[key]["cardinality"] extends "single" ? GenericId<Edges[key]["to"]> : GenericId<Edges[key]["to"]>[];
+};
+type WithEdges<Document extends GenericDocument, Edges extends Record<string, GenericEdgeConfig>> = Document & {
+    [key in keyof Edges as Edges[key]["cardinality"] extends "multiple" ? Edges[key]["type"] extends "ref" ? key : never : never]?: GenericId<Edges[key]["to"]>[];
+};
+type WithEdgePatches<Document extends GenericDocument, Edges extends Record<string, GenericEdgeConfig>> = Document & {
+    [key in keyof Edges as Edges[key]["cardinality"] extends "multiple" ? Edges[key]["type"] extends "ref" ? key : never : never]?: {
+        add?: GenericId<Edges[key]["to"]>[];
+        remove?: GenericId<Edges[key]["to"]>[];
+    };
+};
+type EdgeChanges = Record<string, {
+    add?: GenericId<any>[];
+    remove?: GenericId<any>[];
+    removeEdges?: GenericId<any>[];
+}>;
+
+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): PromiseArrayOrNull<TOutput>;
+    paginate(paginationOpts: PaginationOptions): PromisePaginationResultOrNull<EntsDataModel, Table>;
+    take(n: number): PromiseEntsOrNull<EntsDataModel, Table>;
+    first(): PromiseEntOrNull<EntsDataModel, Table>;
+    unique(): PromiseEntOrNull<EntsDataModel, Table>;
+    docs(): Promise<DocumentByName<EntsDataModel, Table>[] | null>;
+}
+interface PromiseQueryOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseOrderedQueryOrNull<EntsDataModel, Table> {
+    order(order: "asc" | "desc", indexName?: IndexNames<NamedTableInfo<EntsDataModel, Table>>): PromiseOrderedQueryOrNull<EntsDataModel, Table>;
+}
+interface PromiseTableBase<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> {
+    getMany<Indexes extends EntsDataModel[Table]["indexes"], Index extends keyof Indexes>(indexName: Index, values: FieldTypeFromFieldPath<DocumentByName<EntsDataModel, Table>, Indexes[Index][0]>[]): PromiseEntsOrNulls<EntsDataModel, Table>;
+    getMany(ids: GenericId<Table>[]): PromiseEntsOrNulls<EntsDataModel, Table>;
+    getManyX<Indexes extends EntsDataModel[Table]["indexes"], Index extends keyof Indexes>(indexName: Index, values: FieldTypeFromFieldPath<DocumentByName<EntsDataModel, Table>, Indexes[Index][0]>[]): PromiseEnts<EntsDataModel, Table>;
+    getManyX(ids: GenericId<Table>[]): PromiseEnts<EntsDataModel, Table>;
+    /**
+     * Returns the string ID format for the ID in a given table, or null if the ID
+     * is from a different table or is not a valid ID.
+     *
+     * This does not guarantee that the ID exists (i.e. `table("foo").get(id)` may return `null`).
+     *
+     * @param tableName - The name of the table.
+     * @param id - The ID string.
+     */
+    normalizeId(id: string): GenericId<Table> | null;
+}
+interface PromiseTable<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseQuery<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]>): PromiseEntOrNull<EntsDataModel, Table>;
+    get(id: GenericId<Table>): PromiseEntOrNull<EntsDataModel, Table>;
+    /**
+     * Fetch a document from the DB using given index, throw if it doesn't exist.
+     */
+    getX<Indexes extends EntsDataModel[Table]["indexes"], Index extends keyof Indexes>(indexName: Index, value0: FieldTypeFromFieldPath<DocumentByName<EntsDataModel, Table>, Indexes[Index][0]>): PromiseEnt<EntsDataModel, Table>;
+    /**
+     * Fetch a document from the DB for a given ID, throw if it doesn't exist.
+     */
+    getX(id: GenericId<Table>): PromiseEnt<EntsDataModel, Table>;
+    /**
+     * Query by running a full text search against a search index.
+     *
+     * Search queries must always search for some text within the index's
+     * `searchField`. This query can optionally add equality filters for any
+     * `filterFields` specified in the index.
+     *
+     * Documents will be returned in relevance order based on how well they
+     * match the search text.
+     *
+     * To learn about full text search, see [Indexes](https://docs.convex.dev/text-search).
+     *
+     * @param indexName - The name of the search index to query.
+     * @param searchFilter - A search filter expression constructed with the
+     * supplied {@link SearchFilterBuilder}. This defines the full text search to run
+     * along with equality filtering to run within the search index.
+     * @returns - A query that searches for matching documents, returning them
+     * in relevancy order.
+     */
+    search<IndexName extends SearchIndexNames<NamedTableInfo<EntsDataModel, Table>>>(indexName: IndexName, searchFilter: (q: SearchFilterBuilder<DocumentByName<EntsDataModel, Table>, NamedSearchIndex<NamedTableInfo<EntsDataModel, Table>, IndexName>>) => SearchFilter): PromiseOrderedQuery<EntsDataModel, Table>;
+}
+interface PromiseOrderedQueryBase<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> {
+    filter(predicate: (q: FilterBuilder<NamedTableInfo<EntsDataModel, Table>>) => ExpressionOrValue<boolean>): this;
+    paginate(paginationOpts: PaginationOptions): PromisePaginationResult<EntsDataModel, Table>;
+    docs(): Promise<DocumentByName<EntsDataModel, Table>[]>;
+}
+interface PromiseOrderedQuery<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]>, PromiseOrderedQueryBase<EntsDataModel, Table> {
+    map<TOutput>(callbackFn: (value: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>, index: number, array: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]) => Promise<TOutput> | TOutput): PromiseArray<TOutput>;
+    take(n: number): PromiseEnts<EntsDataModel, Table>;
+    first(): PromiseEntOrNull<EntsDataModel, Table>;
+    firstX(): PromiseEnt<EntsDataModel, Table>;
+    unique(): PromiseEntOrNull<EntsDataModel, Table>;
+    uniqueX(): PromiseEnt<EntsDataModel, 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): PromiseArrayOrNull<TOutput>;
+    docs(): Promise<DocumentByName<EntsDataModel, Table>[] | null>;
+}
+interface PromiseEnts<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]> {
+    map<TOutput>(callbackFn: (value: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>, index: number, array: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]) => Promise<TOutput> | TOutput): PromiseArray<TOutput>;
+    docs(): Promise<DocumentByName<EntsDataModel, Table>[]>;
+}
+interface PromiseEntsOrNulls<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<(Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel> | null)[]> {
+}
+interface PromiseEdgeEntsOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseEntsOrNull<EntsDataModel, Table> {
+    /**
+     * Returns whether there is an ent with given ID on the other side
+     * the edge. Returns null if chained to a null result.
+     * @param id The ID of the ent on the other end of the edge
+     */
+    has(id: GenericId<Table>): Promise<boolean | null>;
+}
+interface PromiseEdgeEnts<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseEnts<EntsDataModel, Table> {
+    /**
+     * Returns whether there is an ent with given ID on the other side
+     * the edge.
+     * @param id The ID of the ent on the other end of the edge
+     */
+    has(id: GenericId<Table>): Promise<boolean>;
+}
+interface PromiseEntOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel> | null> {
+    edge<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdgeOrNull<EntsDataModel, Table, Edge>;
+    doc(): Promise<DocumentByName<EntsDataModel, Table> | null>;
+}
+interface PromiseEnt<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>> {
+    edge<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdge<EntsDataModel, Table, Edge>;
+    edgeX<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdgeOrThrow<EntsDataModel, Table, Edge>;
+    doc(): Promise<DocumentByName<EntsDataModel, Table>>;
+}
+interface PromiseArrayOrNull<T> extends Promise<T[] | null> {
+    filter<S extends T>(predicate: (value: T, index: number, array: T[] | null) => value is S): Promise<S[] | null>;
+    filter(predicate: (value: T, index: number, array: T[] | null) => unknown): Promise<T[] | null>;
+}
+interface PromiseArray<T> extends Promise<T[]> {
+    filter<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S): Promise<S[]>;
+    filter(predicate: (value: T, index: number, array: T[]) => unknown): Promise<T[]>;
+}
+declare function entWrapper<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>>(fields: DocumentByName<EntsDataModel, Table>, ctx: EntQueryCtx<EntsDataModel>, entDefinitions: EntsDataModel, table: Table): Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>;
+declare function entsTableFactory<Ctx extends EntQueryCtx<any>, EntsDataModel extends GenericEntsDataModel>(ctx: Ctx, entDefinitions: EntsDataModel, options?: {
+    scheduledDelete: ScheduledDeleteFuncRef;
+}): Ctx extends EntMutationCtx<any> ? EntsTableWriter<EntsDataModel> : EntsTable<EntsDataModel>;
+type EntsTable<EntsDataModel extends GenericEntsDataModel> = {
+    <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): PromiseQuery<EntsDataModel, Table>;
+    <Table extends TableNamesInDataModel<EntsDataModel>>(table: Table): PromiseTable<EntsDataModel, Table>;
+};
+type EntsTableWriter<EntsDataModel extends GenericEntsDataModel> = {
+    <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): PromiseTableWriter<Table, EntsDataModel>;
+    <Table extends TableNamesInDataModel<EntsDataModel>>(table: Table): PromiseTableWriter<Table, EntsDataModel>;
+};
+declare class EntInstance<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> {
+    edge<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdge<EntsDataModel, Table, Edge>;
+    edgeX<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdgeOrThrow<EntsDataModel, Table, Edge>;
+    doc(): DocumentByName<EntsDataModel, Table>;
+}
+type Ent<Table extends TableNamesInDataModel<EntsDataModel>, Doc extends DocumentByName<EntsDataModel, Table>, EntsDataModel extends GenericEntsDataModel> = Doc & EntInstance<EntsDataModel, Table>;
+type GenericEnt<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> = Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>;
+type PromiseEdge<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" ? PromiseEntOrNull<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]> : PromiseEnt<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]>;
+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): PromiseArray<TOutput>;
+    take(n: number): PromiseEntsWriter<EntsDataModel, Table>;
+    first(): PromiseEntWriterOrNull<EntsDataModel, Table>;
+    firstX(): PromiseEntWriter<EntsDataModel, Table>;
+    unique(): PromiseEntWriterOrNull<EntsDataModel, Table>;
+    uniqueX(): PromiseEntWriter<EntsDataModel, Table>;
+}
+interface PromiseQueryWriter<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseOrderedQueryWriter<EntsDataModel, Table> {
+    order(order: "asc" | "desc", indexName?: IndexNames<NamedTableInfo<EntsDataModel, Table>>): PromiseOrderedQueryWriter<EntsDataModel, Table>;
+}
+interface PromiseEntsWriter<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseEnts<EntsDataModel, Table> {
+    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>;
+    /**
+     * Fetch a document from the DB using given index, throw if it doesn't exist.
+     */
+    getX<Indexes extends EntsDataModel[Table]["indexes"], Index extends keyof Indexes>(indexName: Index, value0: FieldTypeFromFieldPath<DocumentByName<EntsDataModel, Table>, Indexes[Index][0]>): PromiseEnt<EntsDataModel, Table>;
+    /**
+     * Fetch a document from the DB for a given ID, throw if it doesn't exist.
+     */
+    getX(id: GenericId<Table>): PromiseEntWriter<EntsDataModel, Table>;
+    /**
+     * Query by running a full text search against a search index.
+     *
+     * Search queries must always search for some text within the index's
+     * `searchField`. This query can optionally add equality filters for any
+     * `filterFields` specified in the index.
+     *
+     * Documents will be returned in relevance order based on how well they
+     * match the search text.
+     *
+     * To learn about full text search, see [Indexes](https://docs.convex.dev/text-search).
+     *
+     * @param indexName - The name of the search index to query.
+     * @param searchFilter - A search filter expression constructed with the
+     * supplied {@link SearchFilterBuilder}. This defines the full text search to run
+     * along with equality filtering to run within the search index.
+     * @returns - A query that searches for matching documents, returning them
+     * in relevancy order.
+     */
+    search<IndexName extends SearchIndexNames<NamedTableInfo<EntsDataModel, Table>>>(indexName: IndexName, searchFilter: (q: SearchFilterBuilder<DocumentByName<EntsDataModel, Table>, NamedSearchIndex<NamedTableInfo<EntsDataModel, Table>, IndexName>>) => SearchFilter): PromiseOrderedQueryWriter<EntsDataModel, Table>;
+    /**
+     * Insert a new document into a table.
+     *
+     * @param table - The name of the table to insert a new document into.
+     * @param value - The {@link Value} to insert into the given table.
+     * @returns - {@link GenericId} of the new document.
+     */
+    insert(value: Expand<WithoutSystemFields<WithEdgeInserts<DocumentByName<EntsDataModel, Table>, EntsDataModel[Table]["edges"]>>>): PromiseEntId<EntsDataModel, Table>;
+    /**
+     * Insert new documents into a table.
+     *
+     * @param table - The name of the table to insert a new document into.
+     * @param value - The {@link Value} to insert into the given table.
+     * @returns - {@link GenericId} of the new document.
+     */
+    insertMany(values: Expand<WithoutSystemFields<WithEdgeInserts<DocumentByName<EntsDataModel, Table>, EntsDataModel[Table]["edges"]>>>[]): Promise<GenericId<Table>[]>;
+}
+interface PromiseEntWriterOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel> | null> {
+    edge<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdgeOrNull<EntsDataModel, Table, Edge>;
+    doc(): Promise<DocumentByName<EntsDataModel, Table> | null>;
+}
+interface PromiseEntWriter<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>> {
+    edge<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdge<EntsDataModel, Table, Edge>;
+    edgeX<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdgeOrThrow<EntsDataModel, Table, Edge>;
+    doc(): Promise<DocumentByName<EntsDataModel, Table>>;
+    /**
+     * Patch this existing document, shallow merging it with the given partial
+     * document.
+     *
+     * New fields are added. Existing fields are overwritten. Fields set to
+     * `undefined` are removed.
+     *
+     * @param value - The partial {@link GenericDocument} to merge into this document. If this new value
+     * specifies system fields like `_id`, they must match the document's existing field values.
+     */
+    patch(value: Partial<Expand<WithEdgePatches<DocumentByName<EntsDataModel, Table>, EntsDataModel[Table]["edges"]>>>): Promise<PromiseEntId<EntsDataModel, Table>>;
+    /**
+     * Replace the value of an existing document, overwriting its old value.
+     *
+     * @param value - The new {@link GenericDocument} for the document. This value can omit the system fields,
+     * and the database will preserve them in.
+     */
+    replace(value: Expand<WithOptionalSystemFields<WithEdges<DocumentByName<EntsDataModel, Table>, EntsDataModel[Table]["edges"]>>>): Promise<PromiseEntId<EntsDataModel, Table>>;
+    /**
+     * Delete this existing document.
+     *
+     * @param id - The {@link GenericId} of the document to remove.
+     */
+    delete(): Promise<GenericId<Table>>;
+}
+declare class EntWriterInstance<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends EntInstance<EntsDataModel, Table> {
+    /**
+     * Patch this existing document, shallow merging it with the given partial
+     * document.
+     *
+     * New fields are added. Existing fields are overwritten. Fields set to
+     * `undefined` are removed.
+     *
+     * @param value - The partial {@link GenericDocument} to merge into this document. If this new value
+     * specifies system fields like `_id`, they must match the document's existing field values.
+     */
+    patch(value: Partial<WithEdgePatches<DocumentByName<EntsDataModel, Table>, EntsDataModel[Table]["edges"]>>): PromiseEntId<EntsDataModel, Table>;
+    /**
+     * Replace the value of this existing document, overwriting its old value.
+     *
+     * @param value - The new {@link GenericDocument} for the document. This value can omit the system fields,
+     * and the database will preserve them in.
+     */
+    replace(value: WithOptionalSystemFields<WithEdges<DocumentByName<EntsDataModel, Table>, EntsDataModel[Table]["edges"]>>): PromiseEntId<EntsDataModel, Table>;
+    /**
+     * Delete this existing document.
+     *
+     * @param id - The {@link GenericId} of the document to remove.
+     */
+    delete(): Promise<GenericId<Table>>;
+}
+type EntWriter<Table extends TableNamesInDataModel<EntsDataModel>, Doc extends DocumentByName<EntsDataModel, Table>, EntsDataModel extends GenericEntsDataModel> = Doc & EntWriterInstance<EntsDataModel, Table>;
+type GenericEntWriter<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> = EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>;
+interface PromiseEntId<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<GenericId<Table>> {
+    get(): PromiseEntWriter<EntsDataModel, Table>;
+}
+interface EntQueryCtx<DataModel extends GenericDataModel> {
+    db: GenericDatabaseReader<DataModel>;
+}
+interface EntMutationCtx<DataModel extends GenericDataModel> extends EntQueryCtx<DataModel> {
+    db: GenericDatabaseWriter<DataModel>;
+    scheduler: Scheduler;
+}
+type DocRetriever<ID, Doc> = () => Promise<{
+    id: ID;
+    doc: () => Promise<Doc>;
+}>;
+declare function addEntRules<EntsDataModel extends GenericEntsDataModel>(entDefinitions: EntsDataModel, rules: {
+    [Table in keyof EntsDataModel]?: Table extends TableNamesInDataModel<EntsDataModel> ? {
+        read?: (ent: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>) => Promise<boolean>;
+        write?: (args: {
+            operation: "create";
+            ent: undefined;
+            value: WithoutSystemFields<DocumentByName<EntsDataModel, Table>>;
+        } | {
+            operation: "update";
+            ent: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>;
+            value: Partial<WithoutSystemFields<DocumentByName<EntsDataModel, Table>>>;
+        } | {
+            operation: "delete";
+            ent: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>;
+            value: undefined;
+        }) => Promise<boolean>;
+    } : never;
+}): EntsDataModel;
+declare function getReadRule(entDefinitions: GenericEntsDataModel, table: string): ((doc: GenericDocument) => Promise<boolean>) | undefined;
+declare function getWriteRule(entDefinitions: GenericEntsDataModel, table: string): ((args: {
+    operation: "create";
+    ent: undefined;
+    value: {
+        [x: string]: convex_values.Value;
+    };
+} | {
+    operation: "update";
+    ent: Ent<any, GenericDocument, any>;
+    value: Partial<{
+        [x: string]: convex_values.Value;
+    }>;
+} | {
+    operation: "delete";
+    ent: Ent<any, GenericDocument, any>;
+    value: undefined;
+}) => Promise<boolean>) | undefined;
+declare function getEdgeDefinitions<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>>(entDefinitions: EntsDataModel, table: Table): Record<keyof EntsDataModel[Table]["edges"], EdgeConfig>;
+declare function getDeletionConfig<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>>(entDefinitions: EntsDataModel, table: Table): DeletionConfig | undefined;
+
+export { type PromiseQueryWriter as A, type PromiseEntsWriter as B, type PromisePaginationResultWriter as C, type PromiseTableWriter as D, type EdgeChanges as E, type PromiseEntWriterOrNull as F, type GenericEnt as G, type PromiseEntWriter as H, type GenericEntWriter as I, type PromiseEntId as J, type EntQueryCtx as K, type EntMutationCtx as L, type DocRetriever as M, addEntRules as N, getReadRule as O, type PromiseOrderedQueryOrNull as P, getWriteRule as Q, getEdgeDefinitions as R, getDeletionConfig as S, WriterImplBase as W, type WithEdgeInserts as a, type WithEdges as b, type WithEdgePatches as c, type PromiseQueryOrNull as d, type PromiseTableBase as e, type PromiseTable as f, type PromiseOrderedQueryBase as g, type PromiseOrderedQuery as h, type PromiseQuery as i, type PromisePaginationResultOrNull as j, type PromisePaginationResult as k, type PromiseEntsOrNull as l, type PromiseEnts as m, type PromiseEntsOrNulls as n, type PromiseEdgeEntsOrNull as o, type PromiseEdgeEnts as p, type PromiseEntOrNull as q, type PromiseEnt as r, type PromiseArrayOrNull as s, type PromiseArray as t, entWrapper as u, entsTableFactory as v, type Ent as w, type PromiseEdge as x, type PromiseEdgeOrThrow as y, type PromiseOrderedQueryWriter as z };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { EntDefinition, defineEnt, defineEntSchema, getEntDefinitions } from './schema.js';
-export { GenericEnt, GenericEntWriter, PromiseEdgeEnts, PromiseEdgeEntsOrNull, PromiseEnt, PromiseEntId, PromiseEntOrNull, PromiseEntWriter, PromiseEntWriterOrNull, PromiseEnts, PromiseEntsOrNull, PromiseEntsOrNulls, PromiseEntsWriter, PromiseOrderedQuery, PromiseOrderedQueryBase, PromiseOrderedQueryOrNull, PromiseOrderedQueryWriter, PromiseQuery, PromiseQueryOrNull, PromiseQueryWriter, PromiseTable, PromiseTableBase, PromiseTableWriter, addEntRules, entsTableFactory } from './functions.js';
+export { G as GenericEnt, I as GenericEntWriter, p as PromiseEdgeEnts, o as PromiseEdgeEntsOrNull, r as PromiseEnt, J as PromiseEntId, q as PromiseEntOrNull, H as PromiseEntWriter, F as PromiseEntWriterOrNull, m as PromiseEnts, l as PromiseEntsOrNull, n as PromiseEntsOrNulls, B as PromiseEntsWriter, h as PromiseOrderedQuery, g as PromiseOrderedQueryBase, P as PromiseOrderedQueryOrNull, z as PromiseOrderedQueryWriter, i as PromiseQuery, d as PromiseQueryOrNull, A as PromiseQueryWriter, f as PromiseTable, e as PromiseTableBase, D as PromiseTableWriter, N as addEntRules, v as entsTableFactory } from './index--8O_7LM9.js';
+export { scheduledDeleteFactory } from './deletion.js';
 import 'convex/server';
 import 'convex/values';
-import './writer.js';