convex-ents 0.10.0 → 0.11.0

package/dist/index.js

@@ -25,8 +25,6 @@ __export(src_exports, {
   defineEntFromTable: () => defineEntFromTable,
   defineEntSchema: () => defineEntSchema,
   defineEntsFromTables: () => defineEntsFromTables,
-  entsActionReadFactory: () => entsActionReadFactory,
-  entsActionWriteFactory: () => entsActionWriteFactory,
   entsTableFactory: () => entsTableFactory,
   getEntDefinitions: () => getEntDefinitions,
   scheduledDeleteFactory: () => scheduledDeleteFactory
@@ -406,636 +404,13 @@ function getEntDefinitions(schema) {
   );
 }
 
-// src/actions.ts
-var import_server2 = require("convex/server");
-
 // src/shared.ts
 function getEdgeDefinitions(entDefinitions, table) {
   return entDefinitions[table].edges;
 }
 
-// src/actions.ts
-async function entsActionReadFactory(ctx, args_) {
-  const { read } = args_;
-  let result;
-  for (const call of read) {
-    result = addMethodCall(ctx, call, result);
-  }
-  return await result;
-}
-async function entsActionWriteFactory(ctx, args_) {
-  const { write } = args_;
-  let result;
-  for (const call of write) {
-    result = addMethodCall(ctx, call, result);
-  }
-  return await result;
-}
-function addMethodCall(ctx, call, result) {
-  if ("table" in call) {
-    const [table, indexName, indexRange] = call.table;
-    return ctx.table(table, indexName, deserializeIndexRange(indexRange));
-  } else if ("search" in call) {
-    const [indexName, filters] = call.search;
-    return result.search(indexName, deserializeSearchFilter(filters));
-  } else if ("normalizeId" in call) {
-    return result.normalizeId(call.normalizeId);
-  } else if ("normalizeIdX" in call) {
-    return result.normalizeIdX(call.normalizeIdX);
-  } else if ("get" in call) {
-    return result.get(...call.get);
-  } else if ("getX" in call) {
-    return result.getX(...call.getX);
-  } else if ("getMany" in call) {
-    return result.getMany(...call.getMany);
-  } else if ("getManyX" in call) {
-    return result.getManyX(...call.getManyX);
-  } else if ("filter" in call) {
-    return result.filter(deserializeFilterPredicate(call.filter));
-  } else if ("order" in call) {
-    return result.order(...call.order);
-  } else if ("take" in call) {
-    return result.take(call.take);
-  } else if ("paginate" in call) {
-    return result.paginate(call.paginate);
-  } else if ("first" in call) {
-    return result.first();
-  } else if ("firstX" in call) {
-    return result.firstX();
-  } else if ("unique" in call) {
-    return result.unique();
-  } else if ("uniqueX" in call) {
-    return result.uniqueX();
-  } else if ("edge" in call) {
-    return result.edge(call.edge);
-  } else if ("edgeX" in call) {
-    return result.edge(call.edgeX);
-  } else if ("has" in call) {
-    return result.has(call.has);
-  } else if ("insert" in call) {
-    return result.insert(call.insert);
-  } else if ("insertMany" in call) {
-    return result.insertMany(call.insertMany);
-  } else if ("patch" in call) {
-    return result.patch(call.patch);
-  } else if ("replace" in call) {
-    return result.replace(call.replace);
-  } else if ("delete" in call) {
-    return result.delete();
-  } else {
-    call;
-  }
-}
-var PromiseQueryActionOrNullImpl = class _PromiseQueryActionOrNullImpl extends Promise {
-  constructor(ctx, entDefinitions, table, read) {
-    super(() => {
-    });
-    this.ctx = ctx;
-    this.entDefinitions = entDefinitions;
-    this.table = table;
-    this.read = read;
-  }
-  filter(predicate) {
-    return new _PromiseQueryActionOrNullImpl(
-      this.ctx,
-      this.entDefinitions,
-      this.table,
-      this.read.concat({ filter: serializeFilterPredicate(predicate) })
-    );
-  }
-  order(order, indexName) {
-    return new _PromiseQueryActionOrNullImpl(
-      this.ctx,
-      this.entDefinitions,
-      this.table,
-      this.read.concat({
-        order: [
-          order,
-          ...indexName === void 0 ? [] : [indexName]
-        ]
-      })
-    );
-  }
-  paginate(paginationOpts) {
-    return new PromisePaginationResultActionOrNullImpl(
-      this.ctx,
-      this.entDefinitions,
-      this.table,
-      this.read.concat({ paginate: paginationOpts })
-    );
-  }
-  async take(n) {
-    return await runRead(this.ctx, this.read.concat({ take: n }));
-  }
-  first() {
-    return new PromiseEntActionImpl(
-      this.ctx,
-      this.entDefinitions,
-      this.table,
-      this.read.concat({ first: true })
-    );
-  }
-  firstX() {
-    return new PromiseEntActionImpl(
-      this.ctx,
-      this.entDefinitions,
-      this.table,
-      this.read.concat({ firstX: true })
-    );
-  }
-  unique() {
-    return new PromiseEntActionImpl(
-      this.ctx,
-      this.entDefinitions,
-      this.table,
-      this.read.concat({ unique: true })
-    );
-  }
-  uniqueX() {
-    return new PromiseEntActionImpl(
-      this.ctx,
-      this.entDefinitions,
-      this.table,
-      this.read.concat({ uniqueX: true })
-    );
-  }
-  then(onfulfilled, onrejected) {
-    const docs = runRead(this.ctx, this.read);
-    return docs.then(onfulfilled, onrejected);
-  }
-};
-var PromiseEdgeActionOrNullImpl = class extends PromiseQueryActionOrNullImpl {
-  async has(targetId) {
-    return runRead(this.ctx, this.read.concat({ has: targetId }));
-  }
-};
-var PromiseTableActionImpl = class extends PromiseQueryActionOrNullImpl {
-  constructor(ctx, entDefinitions, table) {
-    super(ctx, entDefinitions, table, [{ table: [table] }]);
-  }
-  get(...args) {
-    return new PromiseEntActionImpl(
-      this.ctx,
-      this.entDefinitions,
-      this.table,
-      this.read.concat({ get: args })
-    );
-  }
-  getX(...args) {
-    return new PromiseEntActionImpl(
-      this.ctx,
-      this.entDefinitions,
-      this.table,
-      this.read.concat({ getX: args })
-    );
-  }
-  async getMany(...args) {
-    return await runRead(this.ctx, this.read.concat({ getMany: args }));
-  }
-  async getManyX(...args) {
-    return await runRead(this.ctx, this.read.concat({ getManyX: args }));
-  }
-  async normalizeId(id) {
-    return await runRead(this.ctx, this.read.concat({ normalizeId: id }));
-  }
-  async normalizeIdX(id) {
-    return await runRead(this.ctx, this.read.concat({ normalizeIdX: id }));
-  }
-  withIndex(indexName, indexRange) {
-    return new PromiseQueryActionOrNullImpl(
-      this.ctx,
-      this.entDefinitions,
-      this.table,
-      [
-        {
-          table: [
-            this.table,
-            indexName,
-            serializeIndexRange(indexRange)
-          ]
-        }
-      ]
-    );
-  }
-  search(indexName, searchFilter) {
-    return new PromiseQueryActionOrNullImpl(
-      this.ctx,
-      this.entDefinitions,
-      this.table,
-      this.read.concat({
-        search: [indexName, serializeSearchFilter(searchFilter)]
-      })
-    );
-  }
-  insert(value) {
-    return new PromiseEntIdActionImpl(
-      this.ctx,
-      this.entDefinitions,
-      this.table,
-      this.read.concat({ insert: value })
-    );
-  }
-  // TODO: fluent API
-  async insertMany(values) {
-    return await runWrite(
-      this.ctx,
-      this.read.concat({ insertMany: values })
-    );
-  }
-};
-var PromisePaginationResultActionOrNullImpl = class extends Promise {
-  constructor(ctx, entDefinitions, table, read) {
-    super(() => {
-    });
-    this.ctx = ctx;
-    this.entDefinitions = entDefinitions;
-    this.table = table;
-    this.read = read;
-  }
-  then(onfulfilled, onrejected) {
-    return runRead(this.ctx, this.read).then(onfulfilled, onrejected);
-  }
-};
-var PromiseEntActionImpl = class _PromiseEntActionImpl extends Promise {
-  constructor(ctx, entDefinitions, table, read) {
-    super(() => {
-    });
-    this.ctx = ctx;
-    this.entDefinitions = entDefinitions;
-    this.table = table;
-    this.read = read;
-  }
-  then(onfulfilled, onrejected) {
-    return runRead(this.ctx, this.read).then(onfulfilled, onrejected);
-  }
-  edge(edge) {
-    return this.edgeImpl(edge);
-  }
-  edgeX(edge) {
-    return this.edgeImpl(edge, true);
-  }
-  edgeImpl(edge, throwIfNull = false) {
-    const edgeDefinition = getEdgeDefinitions(this.entDefinitions, this.table)[edge];
-    const read = throwIfNull ? { edgeX: edge } : { edge };
-    if (edgeDefinition.cardinality === "multiple") {
-      if (edgeDefinition.type === "ref") {
-        return new PromiseEdgeActionOrNullImpl(
-          this.ctx,
-          this.entDefinitions,
-          edgeDefinition.to,
-          this.read.concat(read)
-        );
-      }
-      return new PromiseQueryActionOrNullImpl(
-        this.ctx,
-        this.entDefinitions,
-        edgeDefinition.to,
-        this.read.concat(read)
-      );
-    }
-    return new _PromiseEntActionImpl(
-      this.ctx,
-      this.entDefinitions,
-      edgeDefinition.to,
-      this.read.concat(read)
-    );
-  }
-  patch(value) {
-    return new PromiseEntIdActionImpl(
-      this.ctx,
-      this.entDefinitions,
-      this.table,
-      this.read.concat({ patch: value })
-    );
-  }
-  replace(value) {
-    return new PromiseEntIdActionImpl(
-      this.ctx,
-      this.entDefinitions,
-      this.table,
-      this.read.concat({ replace: value })
-    );
-  }
-  async delete() {
-    return await runWrite(
-      this.ctx,
-      this.read.concat({ delete: true })
-    );
-  }
-};
-var PromiseEntIdActionImpl = class extends Promise {
-  constructor(ctx, entDefinitions, table, write) {
-    super(() => {
-    });
-    this.ctx = ctx;
-    this.entDefinitions = entDefinitions;
-    this.table = table;
-    this.write = write;
-  }
-  async get() {
-    return await runWrite(this.ctx, this.write.concat({ get: [] }));
-  }
-  then(onfulfilled, onrejected) {
-    return runWrite(this.ctx, this.write).then(onfulfilled, onrejected);
-  }
-};
-async function runRead(ctx, read) {
-  const readRef = ctx?.actionRead ?? (0, import_server2.makeFunctionReference)("functions:read");
-  return await ctx.runQuery(readRef, { read });
-}
-async function runWrite(ctx, write) {
-  const writeRef = ctx?.actionRead ?? (0, import_server2.makeFunctionReference)("functions:write");
-  return await ctx.runMutation(writeRef, { write });
-}
-var IndexRangeBuilderImpl = class _IndexRangeBuilderImpl {
-  constructor(rangeExpressions) {
-    this.rangeExpressions = rangeExpressions;
-  }
-  static new() {
-    return new _IndexRangeBuilderImpl([]);
-  }
-  eq(fieldName, value) {
-    return new _IndexRangeBuilderImpl(
-      this.rangeExpressions.concat({
-        type: "Eq",
-        fieldPath: fieldName,
-        value: value === void 0 ? "$undefined" : value
-      })
-    );
-  }
-  gt(fieldName, value) {
-    return new _IndexRangeBuilderImpl(
-      this.rangeExpressions.concat({
-        type: "Gt",
-        fieldPath: fieldName,
-        value
-      })
-    );
-  }
-  gte(fieldName, value) {
-    return new _IndexRangeBuilderImpl(
-      this.rangeExpressions.concat({
-        type: "Gte",
-        fieldPath: fieldName,
-        value
-      })
-    );
-  }
-  lt(fieldName, value) {
-    return new _IndexRangeBuilderImpl(
-      this.rangeExpressions.concat({
-        type: "Lt",
-        fieldPath: fieldName,
-        value
-      })
-    );
-  }
-  lte(fieldName, value) {
-    return new _IndexRangeBuilderImpl(
-      this.rangeExpressions.concat({
-        type: "Lte",
-        fieldPath: fieldName,
-        value
-      })
-    );
-  }
-};
-function serializeIndexRange(indexRange) {
-  if (indexRange === void 0) {
-    return void 0;
-  }
-  return (indexRange?.(
-    IndexRangeBuilderImpl.new()
-  )).rangeExpressions;
-}
-function deserializeIndexRange(rangeExpressions) {
-  if (rangeExpressions === void 0) {
-    return void 0;
-  }
-  return (q) => {
-    for (const range of rangeExpressions) {
-      switch (range.type) {
-        case "Eq":
-          q = q.eq(
-            range.fieldPath,
-            range.value === "$undefined" ? void 0 : range.value
-          );
-          break;
-        case "Gt":
-          q = q.gt(range.fieldPath, range.value);
-          break;
-        case "Gte":
-          q = q.gte(range.fieldPath, range.value);
-          break;
-        case "Lt":
-          q = q.lt(range.fieldPath, range.value);
-          break;
-        case "Lte":
-          q = q.lte(range.fieldPath, range.value);
-          break;
-      }
-    }
-    return q;
-  };
-}
-function serializeFilterPredicate(predicate) {
-  return serializeExpression(predicate(filterBuilderImpl));
-}
-function deserializeFilterPredicate(predicate) {
-  return (q) => deserializeFilterExpression(q, predicate);
-}
-var binaryOps = [
-  "eq",
-  "neq",
-  "lt",
-  "lte",
-  "gt",
-  "gte",
-  "add",
-  "sub",
-  "mul",
-  "div",
-  "mod",
-  "and",
-  "or"
-];
-function deserializeFilterExpression(q, expression) {
-  if ("field" in expression) {
-    const fieldPath = expression["field"];
-    return q.field(fieldPath);
-  }
-  if ("literal" in expression) {
-    const literal = expression["literal"];
-    return literal === "$undefined" ? void 0 : literal;
-  }
-  if ("neg" in expression) {
-    return q.neg(deserializeFilterExpression(q, expression["neg"]));
-  }
-  if ("not" in expression) {
-    return q.not(deserializeFilterExpression(q, expression["not"]));
-  }
-  for (const op of binaryOps) {
-    if (op in expression) {
-      const [l, r] = expression[op];
-      return q[op](
-        deserializeFilterExpression(q, l),
-        deserializeFilterExpression(q, r)
-      );
-    }
-  }
-  throw new Error(
-    "Expected a valid filter expression, got " + JSON.stringify(expression)
-  );
-}
-var filterBuilderImpl = {
-  //  Comparisons  /////////////////////////////////////////////////////////////
-  eq(l, r) {
-    return new FilterExpression({
-      eq: [serializeExpression(l), serializeExpression(r)]
-    });
-  },
-  neq(l, r) {
-    return new FilterExpression({
-      neq: [serializeExpression(l), serializeExpression(r)]
-    });
-  },
-  lt(l, r) {
-    return new FilterExpression({
-      lt: [serializeExpression(l), serializeExpression(r)]
-    });
-  },
-  lte(l, r) {
-    return new FilterExpression({
-      lte: [serializeExpression(l), serializeExpression(r)]
-    });
-  },
-  gt(l, r) {
-    return new FilterExpression({
-      gt: [serializeExpression(l), serializeExpression(r)]
-    });
-  },
-  gte(l, r) {
-    return new FilterExpression({
-      gte: [serializeExpression(l), serializeExpression(r)]
-    });
-  },
-  //  Arithmetic  //////////////////////////////////////////////////////////////
-  add(l, r) {
-    return new FilterExpression({
-      add: [serializeExpression(l), serializeExpression(r)]
-    });
-  },
-  sub(l, r) {
-    return new FilterExpression({
-      sub: [serializeExpression(l), serializeExpression(r)]
-    });
-  },
-  mul(l, r) {
-    return new FilterExpression({
-      mul: [serializeExpression(l), serializeExpression(r)]
-    });
-  },
-  div(l, r) {
-    return new FilterExpression({
-      div: [serializeExpression(l), serializeExpression(r)]
-    });
-  },
-  mod(l, r) {
-    return new FilterExpression({
-      mod: [serializeExpression(l), serializeExpression(r)]
-    });
-  },
-  neg(x) {
-    return new FilterExpression({ neg: serializeExpression(x) });
-  },
-  //  Logic  ///////////////////////////////////////////////////////////////////
-  and(...exprs) {
-    return new FilterExpression({ and: exprs.map(serializeExpression) });
-  },
-  or(...exprs) {
-    return new FilterExpression({ or: exprs.map(serializeExpression) });
-  },
-  not(x) {
-    return new FilterExpression({ not: serializeExpression(x) });
-  },
-  //  Other  ///////////////////////////////////////////////////////////////////
-  field(fieldPath) {
-    return new FilterExpression({ field: fieldPath });
-  }
-};
-function serializeExpression(expr) {
-  if (expr instanceof FilterExpression) {
-    return expr.serialize();
-  } else {
-    return {
-      literal: expr === void 0 ? "$undefined" : expr
-    };
-  }
-}
-var FilterExpression = class {
-  inner;
-  constructor(inner) {
-    this.inner = inner;
-  }
-  serialize() {
-    return this.inner;
-  }
-};
-function serializeSearchFilter(searchFilter) {
-  return searchFilter(
-    SearchFilterBuilderImpl.new()
-  ).export();
-}
-function deserializeSearchFilter(filters) {
-  return (q) => {
-    for (const filter of filters) {
-      switch (filter.type) {
-        case "Search":
-          q = q.search(filter.fieldPath, filter.value);
-          break;
-        case "Eq":
-          q = q.eq(
-            filter.fieldPath,
-            filter.value === "$undefined" ? void 0 : filter.value
-          );
-          break;
-      }
-    }
-    return q;
-  };
-}
-var SearchFilterBuilderImpl = class _SearchFilterBuilderImpl {
-  constructor(filters) {
-    this.filters = filters;
-  }
-  static new() {
-    return new _SearchFilterBuilderImpl([]);
-  }
-  search(fieldName, query) {
-    return new _SearchFilterBuilderImpl(
-      this.filters.concat({
-        type: "Search",
-        fieldPath: fieldName,
-        value: query
-      })
-    );
-  }
-  eq(fieldName, value) {
-    return new _SearchFilterBuilderImpl(
-      this.filters.concat({
-        type: "Eq",
-        fieldPath: fieldName,
-        value: value === void 0 ? "$undefiend" : value
-      })
-    );
-  }
-  export() {
-    return this.filters;
-  }
-};
-
 // src/writer.ts
-var import_server3 = require("convex/server");
+var import_server2 = require("convex/server");
 var WriterImplBase = class _WriterImplBase {
   constructor(ctx, entDefinitions, table) {
     this.ctx = ctx;
@@ -1092,7 +467,7 @@ var WriterImplBase = class _WriterImplBase {
     }
     await this.writeEdges(id, edges, isDeletingSoftly);
     if (deletionConfig !== void 0 && deletionConfig.type === "scheduled") {
-      const fnRef = this.ctx.scheduledDelete ?? (0, import_server3.makeFunctionReference)(
+      const fnRef = this.ctx.scheduledDelete ?? (0, import_server2.makeFunctionReference)(
         "functions:scheduledDelete"
       );
       await this.ctx.scheduler.runAfter(deletionConfig.delayMs ?? 0, fnRef, {
@@ -2178,36 +1553,21 @@ function entsTableFactory(ctx, entDefinitions, options) {
     if (typeof table2 !== "string") {
       throw new Error(`Expected table name, got \`${table2}\``);
     }
-    if ("vectorSearch" in ctx) {
-      if (indexName !== void 0) {
-        return new PromiseTableActionImpl(
-          enrichedCtx,
-          entDefinitions,
-          table2
-        ).withIndex(indexName, indexRange);
-      }
-      return new PromiseTableActionImpl(
+    if (indexName !== void 0) {
+      return new PromiseTableImpl(
+        enrichedCtx,
+        entDefinitions,
+        table2
+      ).withIndex(indexName, indexRange);
+    }
+    if (ctx.db.insert !== void 0) {
+      return new PromiseTableWriterImpl(
         enrichedCtx,
         entDefinitions,
         table2
       );
-    } else {
-      if (indexName !== void 0) {
-        return new PromiseTableImpl(
-          enrichedCtx,
-          entDefinitions,
-          table2
-        ).withIndex(indexName, indexRange);
-      }
-      if (ctx.db.insert !== void 0) {
-        return new PromiseTableWriterImpl(
-          enrichedCtx,
-          entDefinitions,
-          table2
-        );
-      }
-      return new PromiseTableImpl(enrichedCtx, entDefinitions, table2);
     }
+    return new PromiseTableImpl(enrichedCtx, entDefinitions, table2);
   };
   table.system = table;
   return table;
@@ -2514,14 +1874,14 @@ function isSystemTable(table) {
 }
 
 // src/deletion.ts
-var import_server4 = require("convex/server");
+var import_server3 = require("convex/server");
 var import_values2 = require("convex/values");
 var vApproach = import_values2.v.union(import_values2.v.literal("cascade"), import_values2.v.literal("paginate"));
 function scheduledDeleteFactory(entDefinitions, options) {
-  const selfRef = options?.scheduledDelete ?? (0, import_server4.makeFunctionReference)(
+  const selfRef = options?.scheduledDelete ?? (0, import_server3.makeFunctionReference)(
     "functions:scheduledDelete"
   );
-  return (0, import_server4.internalMutationGeneric)({
+  return (0, import_server3.internalMutationGeneric)({
     args: {
       origin: import_values2.v.object({
         id: import_values2.v.string(),
@@ -2762,8 +2122,6 @@ async function paginate(ctx, {
   defineEntFromTable,
   defineEntSchema,
   defineEntsFromTables,
-  entsActionReadFactory,
-  entsActionWriteFactory,
   entsTableFactory,
   getEntDefinitions,
   scheduledDeleteFactory