convex-ents 0.10.0 → 0.11.0

package/dist/deletion.d.ts

@@ -13,7 +13,7 @@ type Origin = {
     table: string;
     deletionTime: number;
 };
-declare const vApproach: convex_values.VUnion<"paginate" | "cascade", [convex_values.VLiteral<"cascade", "required">, convex_values.VLiteral<"paginate", "required">], "required", never>;
+declare const vApproach: convex_values.VUnion<"cascade" | "paginate", [convex_values.VLiteral<"cascade", "required">, convex_values.VLiteral<"paginate", "required">], "required", never>;
 type Approach = Infer<typeof vApproach>;
 declare function scheduledDeleteFactory<EntsDataModel extends GenericEntsDataModel>(entDefinitions: EntsDataModel, options?: {
     scheduledDelete: ScheduledDeleteFuncRef;

package/dist/functions.d.ts

@@ -1,6 +1,6 @@
 import 'convex/values';
 import 'convex/server';
-export { a1 as DocRetriever, I as Ent, a0 as EntMutationCtx, $ as EntQueryCtx, G as EntsTable, H as EntsTableWriter, J as GenericEnt, Z as GenericEntWriter, C as PromiseArray, B as PromiseArrayOrNull, K as PromiseEdge, w as PromiseEdgeEnts, s as PromiseEdgeEntsOrNull, y as PromiseEdgeEntsWriter, u as PromiseEdgeEntsWriterOrNull, L as PromiseEdgeOrThrow, v as PromiseEdgeOrderedEnts, r as PromiseEdgeOrderedEntsOrNull, x as PromiseEdgeOrderedEntsWriter, t as PromiseEdgeOrderedEntsWriterOrNull, 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, m as PromisePaginationResult, l as PromisePaginationResultOrNull, U as PromisePaginationResultWriter, T as PromisePaginationResultWriterOrNull, k as PromiseQuery, e as PromiseQueryOrNull, R as PromiseQueryWriter, f as PromiseQueryWriterOrNull, h as PromiseTable, g as PromiseTableBase, V as PromiseTableWriter, a2 as addEntRules, D as entWrapper, F as entsTableFactory, a5 as getDeletionConfig, a3 as getReadRule, a4 as getWriteRule } from './index-olos0Rx-.js';
 import './deletion.js';
 import './schema.js';
 import './shared.js';
+export { a1 as DocRetriever, I as Ent, a0 as EntMutationCtx, $ as EntQueryCtx, G as EntsTable, H as EntsTableWriter, J as GenericEnt, Z as GenericEntWriter, C as PromiseArray, B as PromiseArrayOrNull, K as PromiseEdge, w as PromiseEdgeEnts, s as PromiseEdgeEntsOrNull, y as PromiseEdgeEntsWriter, u as PromiseEdgeEntsWriterOrNull, L as PromiseEdgeOrThrow, v as PromiseEdgeOrderedEnts, r as PromiseEdgeOrderedEntsOrNull, x as PromiseEdgeOrderedEntsWriter, t as PromiseEdgeOrderedEntsWriterOrNull, 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, m as PromisePaginationResult, l as PromisePaginationResultOrNull, U as PromisePaginationResultWriter, T as PromisePaginationResultWriterOrNull, k as PromiseQuery, e as PromiseQueryOrNull, R as PromiseQueryWriter, f as PromiseQueryWriterOrNull, h as PromiseTable, g as PromiseTableBase, V as PromiseTableWriter, a2 as addEntRules, D as entWrapper, F as entsTableFactory, a5 as getDeletionConfig, a3 as getReadRule, a4 as getWriteRule } from './index-kwzjMMHy.js';

package/dist/functions.js

@@ -29,471 +29,8 @@ __export(functions_exports, {
 });
 module.exports = __toCommonJS(functions_exports);
 
-// src/actions.ts
-var import_server = require("convex/server");
-
-// src/shared.ts
-function getEdgeDefinitions(entDefinitions, table) {
-  return entDefinitions[table].edges;
-}
-
-// src/actions.ts
-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 serializeFilterPredicate(predicate) {
-  return serializeExpression(predicate(filterBuilderImpl));
-}
-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();
-}
-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/schema.ts
-var import_server2 = require("convex/server");
+var import_server = require("convex/server");
 var import_values = require("convex/values");
 function edgeCompoundIndexName(edgeDefinition) {
   return edgeCompoundIndexNameRaw(edgeDefinition.field, edgeDefinition.ref);
@@ -502,8 +39,13 @@ function edgeCompoundIndexNameRaw(idA, idB) {
   return `${idA}_${idB}`;
 }
 
+// src/shared.ts
+function getEdgeDefinitions(entDefinitions, table) {
+  return entDefinitions[table].edges;
+}
+
 // 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;
@@ -560,7 +102,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, {
@@ -1646,36 +1188,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;