convex-ents 0.12.0 → 0.13.0-alpha.1

package/dist/{index-kwzjMMHy.d.ts → index-surAwtky.d.ts}

@@ -1,7 +1,7 @@
 import { GenericEntsDataModel, GenericEdgeConfig, Expand, 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 { TableNamesInDataModel, GenericDocument, DocumentByName, FilterBuilder, NamedTableInfo, ExpressionOrValue, PaginationOptions, IndexNames, FieldTypeFromFieldPath, SearchIndexNames, SearchFilterBuilder, NamedSearchIndex, SearchFilter, PaginationResult, IndexRangeBuilder, NamedIndex, IndexRange, WithoutSystemFields, WithOptionalSystemFields, GenericDataModel, GenericDatabaseReader, GenericDatabaseWriter, StorageWriter, Scheduler } from 'convex/server';
 import { ScheduledDeleteFuncRef } from './deletion.js';
 import { IndexFieldTypesForEq, EntsSystemDataModel, PromiseEdgeResult } from './shared.js';
 
@@ -11,7 +11,8 @@ declare class WriterImplBase<EntsDataModel extends GenericEntsDataModel, Table e
     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>;
+    deleteIdIn(id: GenericId<any>, table: string, cascadingSoft: boolean): Promise<void>;
+    deleteSystem(table: string, id: GenericId<any>): 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;
@@ -34,6 +35,7 @@ type EdgeChanges = Record<string, {
     remove?: GenericId<any>[];
     removeEdges?: GenericId<any>[];
 }>;
+declare function isSystemTable(table: string): boolean;
 
 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;
@@ -351,7 +353,7 @@ declare class EntInstance<EntsDataModel extends GenericEntsDataModel, Table exte
 }
 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"], Config extends GenericEdgeConfig = EntsDataModel[Table]["edges"][Edge], ToTable extends TableNamesInDataModel<EntsDataModel> = EntsDataModel[Table]["edges"][Edge]["to"]> = PromiseEdgeResult<Config, PromiseEdgeEnts<EntsDataModel, ToTable>, PromiseQuery<EntsDataModel, ToTable>, PromiseEntOrNull<EntsDataModel, ToTable>, PromiseEnt<EntsDataModel, ToTable>>;
+type PromiseEdge<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, PromiseEdgeEnts<EntsDataModel, ToTable>, PromiseQuery<EntsDataModel, ToTable>, ToTable extends "_storage" | "_scheduled_functions" ? PromiseEntOrNull<EntsSystemDataModel, ToTable> : PromiseEntOrNull<EntsDataModel, ToTable>, ToTable extends "_storage" ? PromiseEnt<EntsSystemDataModel, ToTable> : ToTable extends "_scheduled_functions" ? PromiseEntOrNull<EntsSystemDataModel, ToTable> : PromiseEnt<EntsDataModel, ToTable>>;
 type PromiseEdgeOrThrow<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, PromiseEdgeEnts<EntsDataModel, ToTable>, PromiseQuery<EntsDataModel, ToTable>, PromiseEnt<EntsDataModel, ToTable>, PromiseEnt<EntsDataModel, ToTable>>;
 type PromiseEdgeOrNull<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, PromiseEdgeEntsOrNull<EntsDataModel, ToTable>, PromiseQueryOrNull<EntsDataModel, ToTable>, PromiseEntOrNull<EntsDataModel, ToTable>, PromiseEntOrNull<EntsDataModel, ToTable>>;
 type PromiseEdgeWriter<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>, PromiseEntWriterOrNull<EntsDataModel, ToTable>, PromiseEntWriter<EntsDataModel, ToTable>>;
@@ -499,6 +501,7 @@ interface EntQueryCtx<DataModel extends GenericDataModel> {
 }
 interface EntMutationCtx<DataModel extends GenericDataModel> extends EntQueryCtx<DataModel> {
     db: GenericDatabaseWriter<DataModel>;
+    storage: StorageWriter;
     scheduler: Scheduler;
 }
 type DocRetriever<ID, Doc> = () => Promise<{
@@ -543,4 +546,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 { type EntQueryCtx as $, type PromiseEnt as A, type PromiseArrayOrNull as B, type PromiseArray as C, entWrapper as D, type EdgeChanges as E, entsTableFactory as F, type EntsTable as G, type EntsTableWriter as H, type Ent as I, type GenericEnt as J, type PromiseEdge as K, type PromiseEdgeOrThrow as L, type PromiseEdgeWriter as M, type PromiseEdgeWriterOrThrow as N, type PromiseEdgeWriterOrNull as O, type PromiseOrderedQueryOrNull as P, type PromiseOrderedQueryWriter as Q, type PromiseQueryWriter as R, type PromiseEntsWriter as S, type PromisePaginationResultWriterOrNull as T, type PromisePaginationResultWriter as U, type PromiseTableWriter as V, WriterImplBase as W, type PromiseEntWriterOrNull as X, type PromiseEntWriter as Y, type GenericEntWriter as Z, type PromiseEntId as _, type WithEdgeInserts as a, type EntMutationCtx as a0, type DocRetriever as a1, addEntRules as a2, getReadRule as a3, getWriteRule as a4, getDeletionConfig as a5, type WithEdges as b, type WithEdgePatches as c, type PromiseOrderedQueryWriterOrNull as d, type PromiseQueryOrNull as e, type PromiseQueryWriterOrNull as f, type PromiseTableBase as g, type PromiseTable as h, type PromiseOrderedQueryBase as i, type PromiseOrderedQuery as j, type PromiseQuery as k, type PromisePaginationResultOrNull as l, type PromisePaginationResult as m, type PromiseEntsOrNull as n, type PromiseEntsWriterOrNull as o, type PromiseEnts as p, type PromiseEntsOrNulls as q, type PromiseEdgeOrderedEntsOrNull as r, type PromiseEdgeEntsOrNull as s, type PromiseEdgeOrderedEntsWriterOrNull as t, type PromiseEdgeEntsWriterOrNull as u, type PromiseEdgeOrderedEnts as v, type PromiseEdgeEnts as w, type PromiseEdgeOrderedEntsWriter as x, type PromiseEdgeEntsWriter as y, type PromiseEntOrNull as z };
+export { type PromiseEntId as $, type PromiseEntOrNull as A, type PromiseEnt as B, type PromiseArrayOrNull as C, type PromiseArray as D, type EdgeChanges as E, entWrapper as F, entsTableFactory as G, type EntsTable as H, type EntsTableWriter as I, type Ent as J, type GenericEnt as K, type PromiseEdge as L, type PromiseEdgeOrThrow as M, type PromiseEdgeWriter as N, type PromiseEdgeWriterOrThrow as O, type PromiseOrderedQueryOrNull as P, type PromiseEdgeWriterOrNull as Q, type PromiseOrderedQueryWriter as R, type PromiseQueryWriter as S, type PromiseEntsWriter as T, type PromisePaginationResultWriterOrNull as U, type PromisePaginationResultWriter as V, WriterImplBase as W, type PromiseTableWriter as X, type PromiseEntWriterOrNull as Y, type PromiseEntWriter as Z, type GenericEntWriter as _, type WithEdgeInserts 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 WithEdges as b, type WithEdgePatches as c, type PromiseOrderedQueryWriterOrNull as d, type PromiseQueryOrNull as e, type PromiseQueryWriterOrNull as f, type PromiseTableBase as g, type PromiseTable as h, isSystemTable as i, type PromiseOrderedQueryBase as j, type PromiseOrderedQuery as k, type PromiseQuery as l, type PromisePaginationResultOrNull as m, type PromisePaginationResult as n, type PromiseEntsOrNull as o, type PromiseEntsWriterOrNull as p, type PromiseEnts as q, type PromiseEntsOrNulls as r, type PromiseEdgeOrderedEntsOrNull as s, type PromiseEdgeEntsOrNull as t, type PromiseEdgeOrderedEntsWriterOrNull as u, type PromiseEdgeEntsWriterOrNull as v, type PromiseEdgeOrderedEnts as w, type PromiseEdgeEnts as x, type PromiseEdgeOrderedEntsWriter as y, type PromiseEdgeEntsWriter as z };

package/dist/index.d.ts

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

package/dist/index.js

@@ -41,13 +41,31 @@ function defineEntSchema(schema, options) {
     for (const edge of edgeConfigsBeforeDefineSchema(table)) {
       if (
         // Skip inverse edges, we process their forward edges
-        edge.cardinality === "multiple" && edge.type === "ref" && edge.inverse !== void 0 || // symmetric is only set by defineEntSchema,
+        edge.cardinality === "multiple" && edge.type === "ref" && (edge.inverse !== void 0 || // symmetric is only set by defineEntSchema,
         // so we already processed the pair
-        edge.symmetric !== void 0
+        edge.symmetric !== void 0)
       ) {
         continue;
       }
       const otherTableName = edge.to;
+      if (otherTableName.startsWith("_")) {
+        if (edge.cardinality !== "single") {
+          throw new Error(
+            `Many:many edge "${edge.name}" in table "${tableName}" points to a system table "${otherTableName}", but only 1:1 edges can point to system tables`
+          );
+        }
+        if (edge.type !== "field") {
+          throw new Error(
+            `Edge "${edge.name}" in table "${tableName}" pointing to a system table "${otherTableName}" must store the edge by storing the system document ID. Remove the \`ref\` option.`
+          );
+        }
+        if (edge.deletion === "soft") {
+          throw new Error(
+            `Edge "${edge.name}" in table "${tableName}" pointing to a system table "${otherTableName}" cannot use soft deletion, because system documents cannot be soft deleted.`
+          );
+        }
+        continue;
+      }
       const otherTable = schema[otherTableName];
       if (otherTable === void 0) {
         throw new Error(
@@ -77,7 +95,7 @@ function defineEntSchema(schema, options) {
         }
         if (inverseEdge.cardinality === "single" && inverseEdge.type === "ref") {
           throw new Error(
-            `Both edge "${edge.name}" in table "${inverseEdge.to}" and edge "${inverseEdge.name}" in table "${edge.to}" are marked as optional, choose one to be required.`
+            `Both edge "${edge.name}" in table "${inverseEdge.to}" and edge "${inverseEdge.name}" in table "${edge.to}" are marked as references, choose one to store the edge by removing the \`ref\` option.`
           );
         }
         if (inverseEdge.cardinality !== "single" || inverseEdge.type !== "field") {
@@ -90,7 +108,7 @@ function defineEntSchema(schema, options) {
         }
         inverseEdge.unique = true;
       }
-      if (edge.cardinality === "single" && edge.type === "ref" || edge.cardinality === "multiple" && edge.type === "field") {
+      if (edge.cardinality === "single" || edge.cardinality === "multiple" && edge.type === "field") {
         if (edge.deletion !== void 0 && deletionConfigFromEntDefinition(otherTable) === void 0) {
           throw new Error(
             `Cannot specify soft deletion behavior for edge "${edge.name}" in table "${tableName}" because the target table "${otherTableName}" does not have a "soft" or "scheduled" deletion behavior configured.`
@@ -106,7 +124,7 @@ function defineEntSchema(schema, options) {
         if (inverseEdge?.cardinality === "single") {
           if (inverseEdge.type === "ref") {
             throw new Error(
-              `The edge "${inverseEdge.name}" in table "${otherTableName}" cannot be optional, as it must store the 1:many edge as a field. Check the its inverse edge "${edge.name}" in table "${tableName}".`
+              `The edge "${inverseEdge.name}" in table "${otherTableName}" specified \`ref\`, but it must store the 1:many edge as a field. Check the its inverse edge "${edge.name}" in table "${tableName}".`
             );
           }
           if (edge.type === "ref") {
@@ -146,17 +164,19 @@ function defineEntSchema(schema, options) {
             ]);
           }
           schema[edgeTableName] = edgeTable;
-          edge.type = "ref";
-          edge.table = edgeTableName;
-          edge.field = forwardId;
-          edge.ref = inverseId;
-          edge.symmetric = inverseEdge === void 0;
+          const edgeConfig = edge;
+          edgeConfig.type = "ref";
+          edgeConfig.table = edgeTableName;
+          edgeConfig.field = forwardId;
+          edgeConfig.ref = inverseId;
+          edgeConfig.symmetric = inverseEdge === void 0;
           if (inverseEdge !== void 0) {
             inverseEdge.type = "ref";
-            inverseEdge.table = edgeTableName;
-            inverseEdge.field = inverseId;
-            inverseEdge.ref = forwardId;
-            inverseEdge.symmetric = false;
+            const inverseEdgeConfig = inverseEdge;
+            inverseEdgeConfig.table = edgeTableName;
+            inverseEdgeConfig.field = inverseId;
+            inverseEdgeConfig.ref = forwardId;
+            inverseEdgeConfig.symmetric = false;
           }
         }
       }
@@ -305,7 +325,12 @@ var EntDefinitionImpl = class {
       throw new Error(`Duplicate edge "${edgeName}"`);
     }
     const to = options?.to ?? edgeName + "s";
-    if (options?.field !== void 0 || options?.optional !== true) {
+    if (options?.field !== void 0 && options?.ref !== void 0) {
+      throw new Error(
+        `Cannot specify both \`field\` and \`ref\` for the same edge, choose one to be the reference and the other to store the foreign key.`
+      );
+    }
+    if (options?.field !== void 0 || options?.ref === void 0) {
       const fieldName = options?.field ?? edgeName + "Id";
       this.documentSchema = {
         ...this.documentSchema,
@@ -317,7 +342,8 @@ var EntDefinitionImpl = class {
         cardinality: "single",
         type: "field",
         field: fieldName,
-        optional: options?.optional === true
+        optional: options?.optional === true,
+        deletion: options?.deletion
       };
       this.indexes.push({
         indexDescriptor: fieldName,
@@ -325,15 +351,14 @@ var EntDefinitionImpl = class {
       });
       return this;
     }
-    if (options.optional === true) {
-      this.edgeConfigs[edgeName] = {
-        name: edgeName,
-        to,
-        cardinality: "single",
-        type: "ref",
-        ref: options.ref ?? null
-      };
-    }
+    this.edgeConfigs[edgeName] = {
+      name: edgeName,
+      to,
+      cardinality: "single",
+      type: "ref",
+      ref: options.ref === true ? null : options.ref,
+      deletion: options.deletion
+    };
     return this;
   }
   edges(name, options) {
@@ -427,7 +452,7 @@ var WriterImplBase = class _WriterImplBase {
     const isDeletingSoftly = behavior !== "hard" && deletionConfig !== void 0 && (deletionConfig.type === "soft" || deletionConfig.type === "scheduled");
     if (behavior === "soft" && !isDeletingSoftly) {
       throw new Error(
-        `Cannot soft delete document with ID "${id}" in table "${this.table}" because it does not have an "allowSoft", "soft" or "scheduled" deletion behavior configured.`
+        `Cannot soft delete document with ID "${id}" in table "${this.table}" because it does not have a "soft" or "scheduled" deletion behavior configured.`
       );
     }
     const edges = {};
@@ -443,6 +468,16 @@ var WriterImplBase = class _WriterImplBase {
               ).collect()).map((doc) => doc._id);
               edges[key] = { remove };
             }
+          } else if (edgeDefinition.cardinality === "single") {
+            if (edgeDefinition.deletion !== void 0 && (!isDeletingSoftly || edgeDefinition.deletion === "soft")) {
+              const doc = await this.ctx.db.get(id);
+              if (doc !== null) {
+                const otherId = doc[edgeDefinition.field];
+                edges[key] = {
+                  remove: otherId !== void 0 ? [otherId] : []
+                };
+              }
+            }
           } else if (edgeDefinition.cardinality === "multiple") {
             if (!isDeletingSoftly) {
               const removeEdges = (await this.ctx.db.query(edgeDefinition.table).withIndex(
@@ -486,12 +521,26 @@ var WriterImplBase = class _WriterImplBase {
     }
     return id;
   }
-  async deletedIdIn(id, table, cascadingSoft) {
+  async deleteIdIn(id, table, cascadingSoft) {
     await new _WriterImplBase(this.ctx, this.entDefinitions, table).deleteId(
       id,
       cascadingSoft ? "soft" : "hard"
     );
   }
+  async deleteSystem(table, id) {
+    switch (table) {
+      case "_storage":
+        await this.ctx.storage.delete(id);
+        break;
+      case "_scheduled_functions":
+        await this.ctx.scheduler.cancel(id);
+        break;
+      default:
+        throw new Error(
+          `Cannot cascade deletion to unsupported system table "${table}".`
+        );
+    }
+  }
   async writeEdges(docId, changes, deleteSoftly) {
     await Promise.all(
       Object.values(getEdgeDefinitions(this.entDefinitions, this.table)).map(
@@ -504,7 +553,7 @@ var WriterImplBase = class _WriterImplBase {
             if (idOrIds.remove !== void 0 && idOrIds.remove.length > 0) {
               await Promise.all(
                 idOrIds.remove.map(
-                  (id) => this.deletedIdIn(
+                  (id) => this.deleteIdIn(
                     id,
                     edgeDefinition.to,
                     (deleteSoftly ?? false) && edgeDefinition.deletion === "soft"
@@ -521,6 +570,18 @@ var WriterImplBase = class _WriterImplBase {
                 )
               );
             }
+          } else if (edgeDefinition.cardinality === "single") {
+            if (idOrIds.remove !== void 0 && idOrIds.remove.length > 0) {
+              await Promise.all(
+                idOrIds.remove.map(
+                  isSystemTable(edgeDefinition.to) ? (id) => this.deleteSystem(edgeDefinition.to, id) : (id) => this.deleteIdIn(
+                    id,
+                    edgeDefinition.to,
+                    (deleteSoftly ?? false) && edgeDefinition.deletion === "soft"
+                  )
+                )
+              );
+            }
           } else if (edgeDefinition.cardinality === "multiple") {
             if ((idOrIds.removeEdges ?? []).length > 0) {
               await Promise.all(
@@ -605,7 +666,7 @@ var WriterImplBase = class _WriterImplBase {
         this.entDefinitions,
         this.table
       )[key];
-      if (edgeDefinition === void 0) {
+      if (edgeDefinition === void 0 || edgeDefinition.cardinality === "single" && edgeDefinition.type === "field" && edgeDefinition.field === key) {
         fields[key] = value[key];
       }
     });
@@ -664,6 +725,9 @@ var WriterImplBase = class _WriterImplBase {
     }
   }
 };
+function isSystemTable(table) {
+  return table.startsWith("_");
+}
 
 // src/functions.ts
 var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
@@ -1454,7 +1518,7 @@ var PromiseEntOrNullImpl = class extends Promise {
               );
             }
             const otherDoc = await this.ctx.db.get(otherId);
-            if (otherDoc === null) {
+            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}".`
               );
@@ -1723,7 +1787,7 @@ var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
               if (edgeDefinition.type === "ref") {
                 const oldDoc = await this.ctx.db.get(docId);
                 if (oldDoc[key] !== void 0 && oldDoc[key] !== idOrIds) {
-                  throw new Error("Cannot set 1:1 edge from optional end.");
+                  throw new Error("Cannot set 1:1 edge from ref end.");
                 }
               }
             } else {
@@ -1881,9 +1945,6 @@ function getWriteRule(entDefinitions, table) {
 function getDeletionConfig(entDefinitions, table) {
   return entDefinitions[table].deletionConfig;
 }
-function isSystemTable(table) {
-  return table.startsWith("_");
-}
 
 // src/deletion.ts
 var import_server3 = require("convex/server");
@@ -1933,11 +1994,11 @@ function scheduledDeleteFactory(entDefinitions, options) {
       if (doc.deletionTime !== origin.deletionTime) {
         if (inProgress) {
           console.error(
-            `[Ents] Already in-progress scheduled deletion for "${origin.id}" was cancelled!`
+            `[Ents] Already in-progress scheduled deletion for "${origin.id}" was canceled!`
           );
         } else {
           console.log(
-            `[Ents] Scheduled deletion for "${origin.id}" was cancelled`
+            `[Ents] Scheduled deletion for "${origin.id}" was canceled`
           );
         }
         return;