convex-ents 0.9.5 → 0.10.0

package/dist/actions.d.ts

@@ -0,0 +1,6 @@
+import 'convex/server';
+import 'convex/values';
+export { a7 as ActionReadFuncRef, a8 as ActionWriteFuncRef, a6 as EntActionCtx, ab as EntsTableAction, aj as PromiseEdgeAction, al as PromiseEdgeActionOrNull, ak as PromiseEdgeActionOrThrow, ap as PromiseEdgeEntsAction, an as PromiseEdgeEntsActionOrNull, ao as PromiseEdgeOrderedEntsAction, am as PromiseEdgeOrderedEntsActionOrNull, af as PromiseEntAction, ae as PromiseEntActionOrNull, ad as PromiseEntIdAction, ai as PromiseEntsAction, ah as PromiseEntsActionOrNull, ag as PromiseEntsActionOrNulls, aq as PromiseOrderedQueryAction, au as PromiseOrderedQueryActionOrNull, at as PromisePaginationResultAction, as as PromisePaginationResultActionOrNull, ar as PromiseQueryAction, av as PromiseQueryActionOrNull, ac as PromiseTableAction, aw as PromiseTableActionImpl, ay as SerializedSearchFilter, a9 as entsActionReadFactory, aa as entsActionWriteFactory, ax as serializeExpression } from './index-olos0Rx-.js';
+import './schema.js';
+import './shared.js';
+import './deletion.js';

package/dist/actions.js

@@ -0,0 +1,662 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/actions.ts
+var actions_exports = {};
+__export(actions_exports, {
+  PromiseTableActionImpl: () => PromiseTableActionImpl,
+  entsActionReadFactory: () => entsActionReadFactory,
+  entsActionWriteFactory: () => entsActionWriteFactory,
+  serializeExpression: () => serializeExpression
+});
+module.exports = __toCommonJS(actions_exports);
+var import_server = 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_server.makeFunctionReference)("functions:read");
+  return await ctx.runQuery(readRef, { read });
+}
+async function runWrite(ctx, write) {
+  const writeRef = ctx?.actionRead ?? (0, import_server.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;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PromiseTableActionImpl,
+  entsActionReadFactory,
+  entsActionWriteFactory,
+  serializeExpression
+});
+//# sourceMappingURL=actions.js.map