@rpcbase/db 0.28.0 → 0.30.0

package/README.md

@@ -2,7 +2,7 @@
 
 ### `LocalizedString` / `zI18nString()`
 
-`zI18nString()` (alias de `zLocalizedString()`) décrit une string localisée sous forme d’objet, avec des clés en *language codes* (BCP47) :
+`zI18nString()` (alias of `zLocalizedString()`) describes a localized string as an object, keyed by *language codes* (BCP47):
 
 ```ts
 import { z } from "zod"
@@ -15,11 +15,11 @@ const ZPost = z.object({
 const schema = zodSchema(ZPost)
 ```
 
-**Côté Mongoose (important)**
+**Mongoose-side (important)**
 
-- Le champ est stocké comme un objet et typé `SchemaTypes.Mixed` (pas un `Map`).
-- À la lecture, le getter Mongoose renvoie un objet “proxy” avec fallback automatique : `fr-FR` retombe sur `fr` si `fr-FR` n’existe pas.
+- The field is stored as an object and typed as `SchemaTypes.Mixed` (not a `Map`).
+- On read, the Mongoose getter returns a “proxy” object with automatic fallback: `fr-FR` falls back to `fr` if `fr-FR` doesn’t exist.
   - `doc.title["fr-FR"]` → fallback
-  - `doc.title.get("fr-FR")` → fallback (helper de lecture)
-  - `doc.title.getExact("fr-FR")` → exact (sans fallback)
-- À l’écriture, comme c’est du `Mixed`, évite les mutations profondes silencieuses : préfère remplacer l’objet (`doc.title = { ...doc.title, fr: "Salut" }`) ou appelle `doc.markModified("title")`.
+  - `doc.title.get("fr-FR")` → fallback (read helper)
+  - `doc.title.getExact("fr-FR")` → exact (no fallback)
+- On write, because it’s `Mixed`, avoid silent deep mutations: prefer replacing the object (`doc.title = { ...doc.title, fr: "Salut" }`) or call `doc.markModified("title")`.

package/dist/acl/mongooseAclPlugin.d.ts

@@ -0,0 +1,36 @@
+import { default as mongoose } from '../../../vite/node_modules/mongoose';
+import { AclAction, AppAbility } from './types';
+type StoredAcl = {
+    ability: AppAbility;
+    action?: AclAction;
+};
+type PipelineStageLike = Record<string, unknown>;
+declare const mongooseAclPluginBrand: unique symbol;
+declare module '../../../vite/node_modules/mongoose' {
+    interface QueryOptions<DocType = unknown> {
+        rbAcl?: StoredAcl;
+        [mongooseAclPluginBrand]?: DocType;
+    }
+    interface AggregateOptions {
+        rbAcl?: StoredAcl;
+    }
+    interface Query<ResultType, DocType, THelpers = {}, RawDocType = unknown, QueryOp = "find", TDocOverrides = Record<string, never>> {
+        [mongooseAclPluginBrand]?: [ResultType, DocType, THelpers, RawDocType, QueryOp, TDocOverrides];
+        acl: (ability: AppAbility, action?: AclAction) => this;
+    }
+    interface Aggregate<ResultType> {
+        [mongooseAclPluginBrand]?: ResultType;
+        acl: (ability: AppAbility, action?: AclAction) => this;
+    }
+    interface Model<TRawDocType, TQueryHelpers, TInstanceMethods, TVirtuals, THydratedDocumentType, TSchema, TLeanResultType> {
+        [mongooseAclPluginBrand]?: [TRawDocType, TQueryHelpers, TInstanceMethods, TVirtuals, THydratedDocumentType, TSchema, TLeanResultType];
+        acl: (ability: AppAbility) => this;
+    }
+}
+export declare const mongooseAclPlugin: (schema: mongoose.Schema) => void;
+export declare const _private: {
+    injectAggregateMatch: (pipeline: PipelineStageLike[], match: Record<string, unknown>) => void;
+    mergeMongoQuery: (left: unknown, right: Record<string, unknown>) => Record<string, unknown>;
+};
+export {};
+//# sourceMappingURL=mongooseAclPlugin.d.ts.map

package/dist/acl/mongooseAclPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongooseAclPlugin.d.ts","sourceRoot":"","sources":["../../src/acl/mongooseAclPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAA;AAG/B,OAAO,KAAK,EAAE,SAAS,EAAkB,UAAU,EAAE,MAAM,SAAS,CAAA;AAGpE,KAAK,SAAS,GAAG;IACf,OAAO,EAAE,UAAU,CAAA;IACnB,MAAM,CAAC,EAAE,SAAS,CAAA;CACnB,CAAA;AAID,KAAK,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AA6HhD,OAAO,CAAC,MAAM,sBAAsB,EAAE,OAAO,MAAM,CAAA;AAEnD,OAAO,QAAQ,UAAU,CAAC;IACxB,UAAU,YAAY,CAAC,OAAO,GAAG,OAAO;QACtC,KAAK,CAAC,EAAE,SAAS,CAAC;QAClB,CAAC,sBAAsB,CAAC,CAAC,EAAE,OAAO,CAAC;KACpC;IAED,UAAU,gBAAgB;QACxB,KAAK,CAAC,EAAE,SAAS,CAAC;KACnB;IAED,UAAU,KAAK,CACb,UAAU,EACV,OAAO,EACP,QAAQ,GAAG,EAAE,EACb,UAAU,GAAG,OAAO,EACpB,OAAO,GAAG,MAAM,EAChB,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;QAErC,CAAC,sBAAsB,CAAC,CAAC,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC;QAC/F,GAAG,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,SAAS,KAAK,IAAI,CAAC;KACxD;IAED,UAAU,SAAS,CAAC,UAAU;QAC5B,CAAC,sBAAsB,CAAC,CAAC,EAAE,UAAU,CAAC;QACtC,GAAG,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,SAAS,KAAK,IAAI,CAAC;KACxD;IAED,UAAU,KAAK,CACb,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,SAAS,EACT,qBAAqB,EACrB,OAAO,EACP,eAAe;QAEf,CAAC,sBAAsB,CAAC,CAAC,EAAE,CAAC,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,SAAS,EAAE,qBAAqB,EAAE,OAAO,EAAE,eAAe,CAAC,CAAC;QACtI,GAAG,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,IAAI,CAAC;KACpC;CACF;AAED,eAAO,MAAM,iBAAiB,GAAI,QAAQ,QAAQ,CAAC,MAAM,KAAG,IAsE3D,CAAA;AAED,eAAO,MAAM,QAAQ;qCAjMmB,iBAAiB,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,IAAI;4BA3CnE,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CA+O/F,CAAA"}

package/dist/index.d.ts

@@ -4,4 +4,5 @@ export * from './createModels';
 export * from './loadModel';
 export * from './tenantFilesystemDb';
 export * from './acl';
+export * from './pagination';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,aAAa,CAAA;AAC3B,cAAc,sBAAsB,CAAA;AACpC,cAAc,OAAO,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,aAAa,CAAA;AAC3B,cAAc,sBAAsB,CAAA;AACpC,cAAc,OAAO,CAAA;AACrB,cAAc,cAAc,CAAA"}

package/dist/index.js

@@ -5,6 +5,7 @@ import { z as z2 } from "zod";
 import assert from "assert";
 import { accessibleBy, accessibleRecordsPlugin } from "@casl/mongoose";
 import { AbilityBuilder, createMongoAbility, subject } from "@casl/ability";
+import { timingSafeEqual, createHmac } from "node:crypto";
 const ZRBUser = z.object({
   email: z.string().email().optional(),
   password: z.string(),
@@ -1424,8 +1425,439 @@ const can = (ability, action, subjectType, object) => {
   }
   return ability.can(action, subjectType);
 };
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const mergeMongoQuery = (left, right) => {
+  const leftQuery = isRecord(left) ? left : {};
+  if (Object.keys(leftQuery).length === 0) return right;
+  if (Object.keys(right).length === 0) return leftQuery;
+  return { $and: [leftQuery, right] };
+};
+const getQueryOptions$1 = (query) => {
+  if (!query || typeof query !== "object") return void 0;
+  if (!("getOptions" in query) || typeof query.getOptions !== "function") return void 0;
+  return query.getOptions();
+};
+const getStoredAclFromQuery = (query) => {
+  const options = getQueryOptions$1(query);
+  const raw = options?.rbAcl;
+  if (!isRecord(raw)) return null;
+  if (!("ability" in raw)) return null;
+  return raw;
+};
+const getStoredAclFromAggregate = (aggregate) => {
+  if (!aggregate || typeof aggregate !== "object") return null;
+  const raw = aggregate.options;
+  if (!isRecord(raw)) return null;
+  const acl = raw.rbAcl;
+  if (!isRecord(acl)) return null;
+  if (!("ability" in acl)) return null;
+  return acl;
+};
+const addQueryAclFilter = (query, action) => {
+  const storedAcl = getStoredAclFromQuery(query);
+  if (!storedAcl) return;
+  const ability = storedAcl.ability;
+  const resolvedAction = storedAcl.action ?? action;
+  const modelName = query.model.modelName;
+  const accessQuery = accessibleBy(ability, resolvedAction).ofType(modelName);
+  query.and([accessQuery]);
+};
+const injectAggregateMatch = (pipeline, match) => {
+  if (pipeline.length === 0) {
+    pipeline.unshift({ $match: match });
+    return;
+  }
+  const first = pipeline[0];
+  if (!isRecord(first)) {
+    pipeline.unshift({ $match: match });
+    return;
+  }
+  if ("$geoNear" in first) {
+    const geoNear = first.$geoNear;
+    if (isRecord(geoNear)) {
+      geoNear.query = mergeMongoQuery(geoNear.query, match);
+      return;
+    }
+  }
+  if ("$search" in first || "$vectorSearch" in first || "$searchMeta" in first) {
+    pipeline.splice(1, 0, { $match: match });
+    return;
+  }
+  pipeline.unshift({ $match: match });
+};
+const addAggregateAclFilter = (aggregate, action) => {
+  const storedAcl = getStoredAclFromAggregate(aggregate);
+  if (!storedAcl) return;
+  const ability = storedAcl.ability;
+  const resolvedAction = storedAcl.action ?? action;
+  const modelName = aggregate.model().modelName;
+  const accessQuery = accessibleBy(ability, resolvedAction).ofType(modelName);
+  injectAggregateMatch(aggregate.pipeline(), accessQuery);
+};
+const patchAggregateAcl = () => {
+  const globalKey = /* @__PURE__ */ Symbol.for("@rpcbase/db/acl/mongooseAggregateAclPatched");
+  const globalState = globalThis;
+  if (globalState[globalKey]) return;
+  globalState[globalKey] = true;
+  const AggregatePrototype = mongoose.Aggregate.prototype;
+  if (typeof AggregatePrototype.acl === "function") return;
+  AggregatePrototype.acl = function(ability, action = "read") {
+    this.option({ rbAcl: { ability, action } });
+    return this;
+  };
+};
+const createModelAclProxy = (model, ability) => {
+  return new Proxy(model, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") return value;
+      return (...args) => {
+        const result = Reflect.apply(value, target, args);
+        if (result && typeof result === "object" && "acl" in result && typeof result.acl === "function") {
+          return result.acl(ability);
+        }
+        return result;
+      };
+    }
+  });
+};
+const mongooseAclPlugin = (schema) => {
+  patchAggregateAcl();
+  schema.query.acl = function(ability, action) {
+    this.setOptions({ rbAcl: { ability, action } });
+    return this;
+  };
+  schema.statics.acl = function(ability) {
+    return createModelAclProxy(this, ability);
+  };
+  schema.pre("aggregate", function() {
+    addAggregateAclFilter(this, "read");
+  });
+  schema.pre("countDocuments", function() {
+    addQueryAclFilter(this, "read");
+  });
+  schema.pre("deleteMany", function() {
+    addQueryAclFilter(this, "delete");
+  });
+  schema.pre("deleteOne", function() {
+    addQueryAclFilter(this, "delete");
+  });
+  schema.pre("distinct", function() {
+    addQueryAclFilter(this, "read");
+  });
+  schema.pre("find", function() {
+    addQueryAclFilter(this, "read");
+  });
+  schema.pre("findOne", function() {
+    addQueryAclFilter(this, "read");
+  });
+  schema.pre("findOneAndDelete", function() {
+    addQueryAclFilter(this, "delete");
+  });
+  schema.pre("findOneAndReplace", function() {
+    addQueryAclFilter(this, "update");
+  });
+  schema.pre("findOneAndUpdate", function() {
+    addQueryAclFilter(this, "update");
+  });
+  schema.pre("replaceOne", function() {
+    addQueryAclFilter(this, "update");
+  });
+  schema.pre("updateMany", function() {
+    addQueryAclFilter(this, "update");
+  });
+  schema.pre("updateOne", function() {
+    addQueryAclFilter(this, "update");
+  });
+};
+class PaginationValidationError extends Error {
+  code = "invalid_pagination";
+  statusCode = 400;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "PaginationValidationError";
+  }
+}
+const isPaginationValidationError = (error) => {
+  if (!error || typeof error !== "object") return false;
+  const anyError = error;
+  return anyError.name === "PaginationValidationError" && anyError.code === "invalid_pagination" && anyError.statusCode === 400;
+};
+const DISALLOWED_MONGO_FIELD_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+const PAGINATION_LIMIT_MAX = 128;
+const normalizePaginationSpec = (spec) => {
+  if (!spec || typeof spec !== "object") throw new PaginationValidationError("Invalid PaginationSpec");
+  const limit = normalizeLimit(spec.limit);
+  const direction = spec.direction ?? "next";
+  if (direction !== "next" && direction !== "prev") throw new PaginationValidationError("Invalid pagination direction");
+  if (!Array.isArray(spec.sort) || spec.sort.length === 0) throw new PaginationValidationError("Invalid pagination sort");
+  const sort = spec.sort.map(({ field, order }) => ({
+    field: assertSafeMongoFieldPath(field),
+    order: normalizeOrder(order)
+  }));
+  const seenFields = /* @__PURE__ */ new Set();
+  for (const { field } of sort) {
+    if (seenFields.has(field)) throw new PaginationValidationError(`Duplicate pagination sort field: ${field}`);
+    seenFields.add(field);
+  }
+  const primaryOrder = sort[0]?.order;
+  if (!seenFields.has("_id")) {
+    sort.push({ field: "_id", order: primaryOrder });
+  }
+  return {
+    ...spec,
+    limit,
+    direction,
+    sort
+  };
+};
+const normalizeLimit = (limit) => {
+  if (typeof limit !== "number" || !Number.isFinite(limit) || !Number.isInteger(limit) || limit <= 0) {
+    throw new PaginationValidationError("Invalid pagination limit");
+  }
+  if (limit > PAGINATION_LIMIT_MAX) {
+    throw new PaginationValidationError("Invalid pagination limit");
+  }
+  return limit;
+};
+const normalizeOrder = (order) => {
+  if (order !== "asc" && order !== "desc") throw new PaginationValidationError("Invalid pagination order");
+  return order;
+};
+const assertSafeMongoFieldPath = (field) => {
+  if (typeof field !== "string" || field.length === 0) throw new PaginationValidationError("Invalid pagination sort field");
+  if (field.startsWith("$")) throw new PaginationValidationError("Invalid pagination sort field");
+  const parts = field.split(".");
+  for (const part of parts) {
+    if (part.length === 0) throw new PaginationValidationError("Invalid pagination sort field");
+    if (DISALLOWED_MONGO_FIELD_SEGMENTS.has(part)) throw new PaginationValidationError("Invalid pagination sort field");
+    if (!/^[a-zA-Z0-9_]+$/.test(part)) throw new PaginationValidationError("Invalid pagination sort field");
+  }
+  return field;
+};
+const encodePaginationCursor = (spec, node, options) => {
+  const normalized = normalizePaginationSpec(spec);
+  const values = /* @__PURE__ */ Object.create(null);
+  for (const { field } of normalized.sort) {
+    const value = readFieldValue(node, field);
+    if (typeof value === "undefined") {
+      throw new Error(`Pagination cursor encode failed (missing field: ${field})`);
+    }
+    values[field] = encodeCursorValue(field, value);
+  }
+  const payload = { v: 1, values };
+  const payloadB64 = Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+  const sigB64 = signCursorPayloadB64(payloadB64, options.signingSecret);
+  return `${payloadB64}.${sigB64}`;
+};
+const decodePaginationCursor = (spec, cursor, options) => {
+  const normalized = normalizePaginationSpec(spec);
+  const [payloadB64, sigB64, ...rest] = cursor.split(".");
+  if (rest.length > 0) throw new PaginationValidationError("Invalid pagination cursor format");
+  if (!sigB64) throw new PaginationValidationError("Invalid pagination cursor format");
+  verifyCursorSignature(payloadB64, sigB64, options.signingSecret);
+  const payloadRaw = Buffer.from(payloadB64, "base64url").toString("utf8");
+  let payloadUnknown;
+  try {
+    payloadUnknown = JSON.parse(payloadRaw);
+  } catch {
+    throw new PaginationValidationError("Invalid pagination cursor payload");
+  }
+  if (!payloadUnknown || typeof payloadUnknown !== "object") throw new PaginationValidationError("Invalid pagination cursor payload");
+  const payload = payloadUnknown;
+  if (payload.v !== 1) throw new PaginationValidationError("Unsupported pagination cursor version");
+  if (!payload.values || typeof payload.values !== "object") throw new PaginationValidationError("Invalid pagination cursor payload");
+  const decoded = /* @__PURE__ */ Object.create(null);
+  for (const { field } of normalized.sort) {
+    if (!Object.prototype.hasOwnProperty.call(payload.values, field)) {
+      throw new PaginationValidationError(`Pagination cursor missing field: ${field}`);
+    }
+    const encodedValue = payload.values[field];
+    decoded[field] = decodeCursorValue(field, encodedValue);
+  }
+  return decoded;
+};
+const signCursorPayloadB64 = (payloadB64, secret) => {
+  return createHmac("sha256", secret).update(payloadB64, "utf8").digest("base64url");
+};
+const verifyCursorSignature = (payloadB64, sigB64, secret) => {
+  const expectedSigB64 = signCursorPayloadB64(payloadB64, secret);
+  const a = Buffer.from(sigB64, "utf8");
+  const b = Buffer.from(expectedSigB64, "utf8");
+  if (a.length !== b.length || !timingSafeEqual(a, b)) {
+    throw new PaginationValidationError("Invalid pagination cursor signature");
+  }
+};
+const encodeCursorValue = (field, value) => {
+  if (value === null) return null;
+  if (field === "_id") {
+    if (value instanceof Types.ObjectId) return { $oid: value.toHexString() };
+    throw new Error("Pagination cursor encode failed (_id must be an ObjectId)");
+  }
+  if (value instanceof Date) return { $date: value.toISOString() };
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+  if (value instanceof Types.ObjectId) return { $oid: value.toHexString() };
+  throw new Error(`Unsupported pagination cursor value type for field: ${field}`);
+};
+const decodeCursorValue = (field, value) => {
+  if (value === null) return null;
+  if (typeof value === "string") {
+    if (field === "_id") throw new PaginationValidationError(`Invalid pagination cursor ObjectId for field: ${field}`);
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (!value || typeof value !== "object") throw new PaginationValidationError(`Invalid pagination cursor value for field: ${field}`);
+  if ("$date" in value) {
+    if (typeof value.$date !== "string") throw new PaginationValidationError(`Invalid pagination cursor date for field: ${field}`);
+    const d = new Date(value.$date);
+    if (Number.isNaN(d.getTime())) throw new PaginationValidationError(`Invalid pagination cursor date for field: ${field}`);
+    return d;
+  }
+  if ("$oid" in value) {
+    if (typeof value.$oid !== "string" || !Types.ObjectId.isValid(value.$oid)) {
+      throw new PaginationValidationError(`Invalid pagination cursor ObjectId for field: ${field}`);
+    }
+    return new Types.ObjectId(value.$oid);
+  }
+  throw new PaginationValidationError(`Invalid pagination cursor value for field: ${field}`);
+};
+const readFieldValue = (node, field) => {
+  if (!node || typeof node !== "object") return void 0;
+  if ("get" in node && typeof node.get === "function") {
+    return node.get(field);
+  }
+  return field.split(".").reduce((acc, key) => {
+    if (!acc || typeof acc !== "object") return void 0;
+    return acc[key];
+  }, node);
+};
+const compileMongoPagination = (spec, options) => {
+  const normalized = normalizePaginationSpec(spec);
+  const mongoLimit = normalized.limit + 1;
+  const mongoSort = toMongoSort(normalized);
+  if (normalized.cursor == null) {
+    return {
+      spec: normalized,
+      mongoFilterDelta: {},
+      mongoSort,
+      mongoLimit
+    };
+  }
+  if (typeof normalized.cursor !== "string" || normalized.cursor.length === 0) {
+    throw new PaginationValidationError("Invalid pagination cursor");
+  }
+  const cursorValues = decodePaginationCursor(normalized, normalized.cursor, options.cursor);
+  const mongoFilterDelta = buildKeysetFilterDelta(normalized, cursorValues);
+  return {
+    spec: normalized,
+    mongoFilterDelta,
+    mongoSort,
+    mongoLimit
+  };
+};
+const toMongoSort = (spec) => {
+  const mongoSort = /* @__PURE__ */ Object.create(null);
+  for (const { field, order } of spec.sort) {
+    const forQueryOrder = spec.direction === "prev" ? invertOrder(order) : order;
+    mongoSort[field] = forQueryOrder === "asc" ? 1 : -1;
+  }
+  return mongoSort;
+};
+const buildKeysetFilterDelta = (spec, cursorValues) => {
+  const branches = [];
+  for (let i = 0; i < spec.sort.length; i++) {
+    const current = spec.sort[i];
+    if (!current) continue;
+    const and = [];
+    for (let j = 0; j < i; j++) {
+      const prev = spec.sort[j];
+      if (!prev) continue;
+      const eq = /* @__PURE__ */ Object.create(null);
+      eq[prev.field] = cursorValues[prev.field];
+      and.push(eq);
+    }
+    const op = getKeysetOp(current.order, spec.direction);
+    const cmpOp = /* @__PURE__ */ Object.create(null);
+    cmpOp[op] = cursorValues[current.field];
+    const cmp = /* @__PURE__ */ Object.create(null);
+    cmp[current.field] = cmpOp;
+    and.push(cmp);
+    branches.push(and.length === 1 ? and[0] : { $and: and });
+  }
+  return { $or: branches };
+};
+const getKeysetOp = (order, direction) => {
+  if (direction === "next") return order === "asc" ? "$gt" : "$lt";
+  return order === "asc" ? "$lt" : "$gt";
+};
+const invertOrder = (order) => {
+  return order === "asc" ? "desc" : "asc";
+};
+const materializeMongoPagination = (compiled, fetchedNodes, options) => {
+  const limit = compiled.spec.limit;
+  const hasMore = fetchedNodes.length > limit;
+  const trimmed = fetchedNodes.slice(0, limit);
+  const nodes = compiled.spec.direction === "prev" ? trimmed.reverse() : trimmed;
+  const hasPrevPage = compiled.spec.direction === "next" ? Boolean(compiled.spec.cursor) : hasMore;
+  const hasNextPage = compiled.spec.direction === "next" ? hasMore : Boolean(compiled.spec.cursor);
+  const pageInfo = {
+    hasNextPage,
+    hasPrevPage
+  };
+  if (nodes.length === 0) {
+    return { nodes, pageInfo };
+  }
+  if (hasPrevPage) {
+    pageInfo.prevCursor = encodePaginationCursor(compiled.spec, nodes[0], options.cursor);
+  }
+  if (hasNextPage) {
+    pageInfo.nextCursor = encodePaginationCursor(compiled.spec, nodes[nodes.length - 1], options.cursor);
+  }
+  return { nodes, pageInfo };
+};
+const MongoAdapter = {
+  applyPagination: (query, compiled) => {
+    query.where(compiled.mongoFilterDelta);
+    query.sort(compiled.mongoSort);
+    query.limit(compiled.mongoLimit);
+    return query;
+  }
+};
+const paginateMongoQuery = async (query, pagination, options) => {
+  const compiled = compileMongoPagination(pagination, { cursor: options.cursor });
+  MongoAdapter.applyPagination(query, compiled);
+  const fetchedNodes = await query.exec();
+  if (!Array.isArray(fetchedNodes)) {
+    throw new Error("paginateMongoQuery expects query.exec() to return an array");
+  }
+  return materializeMongoPagination(compiled, fetchedNodes, { cursor: options.cursor });
+};
+const getQueryOptions = (query) => {
+  if (!query || typeof query !== "object") return void 0;
+  if (!("getOptions" in query) || typeof query.getOptions !== "function") return void 0;
+  return query.getOptions();
+};
+const getPaginationFromOptions = (query) => {
+  const options = getQueryOptions(query);
+  return options?.pagination;
+};
+const getCursorFromOptions = (query) => {
+  const options = getQueryOptions(query);
+  return options?.paginationCursor;
+};
+const mongoPaginationPlugin = (schema, pluginOptions) => {
+  schema.query.paginate = async function(pagination, options) {
+    const spec = pagination ?? getPaginationFromOptions(this);
+    if (!spec) throw new Error("Missing pagination spec");
+    const cursor = options?.cursor ?? getCursorFromOptions(this) ?? pluginOptions?.cursor;
+    if (!cursor?.signingSecret) throw new Error("Missing pagination cursor signingSecret");
+    return await paginateMongoQuery(this, spec, { cursor });
+  };
+};
 const rtsChangeLogApplied = /* @__PURE__ */ new WeakSet();
 const accessibleRecordsApplied = /* @__PURE__ */ new WeakSet();
+const aclPluginApplied = /* @__PURE__ */ new WeakSet();
+const paginationPluginApplied = /* @__PURE__ */ new WeakSet();
 let cachedModels = null;
 const isRtsChangelogExcludedModelName = (name) => name.startsWith("RB");
 const assertSchema = (exportName, value) => {
@@ -1445,6 +1877,14 @@ const buildAppModels = (modules) => Object.entries(modules).filter(([key]) => ke
     schema.plugin(accessibleRecordsPlugin);
     accessibleRecordsApplied.add(schema);
   }
+  if (!aclPluginApplied.has(schema)) {
+    schema.plugin(mongooseAclPlugin);
+    aclPluginApplied.add(schema);
+  }
+  if (!paginationPluginApplied.has(schema)) {
+    schema.plugin(mongoPaginationPlugin);
+    paginationPluginApplied.add(schema);
+  }
   if (!isRtsChangelogExcludedModelName(name)) {
     if (!rtsChangeLogApplied.has(schema)) {
       schema.plugin(rtsChangeLogPlugin);
@@ -1463,6 +1903,14 @@ const buildFrameworkModels = () => Object.entries(frameworkSchemas).filter(([key
     schema.plugin(accessibleRecordsPlugin);
     accessibleRecordsApplied.add(schema);
   }
+  if (!aclPluginApplied.has(schema)) {
+    schema.plugin(mongooseAclPlugin);
+    aclPluginApplied.add(schema);
+  }
+  if (!paginationPluginApplied.has(schema)) {
+    schema.plugin(mongoPaginationPlugin);
+    paginationPluginApplied.add(schema);
+  }
   if (!isRtsChangelogExcludedModelName(name)) {
     if (!rtsChangeLogApplied.has(schema)) {
       schema.plugin(rtsChangeLogPlugin);
@@ -1562,6 +2010,7 @@ const getTenantFilesystemDbFromCtx = async (ctx) => {
 };
 export {
   LANGUAGE_CODE_REGEX,
+  PaginationValidationError,
   RBNotificationPolicy,
   RBNotificationSchema,
   RBNotificationSettingsPolicy,
@@ -1607,8 +2056,10 @@ export {
   getTenantFilesystemDbFromCtx,
   getTenantFilesystemDbName,
   getTenantRolesFromSessionUser,
+  isPaginationValidationError,
   loadModel,
   loadRbModel,
+  mongoPaginationPlugin,
   registerPoliciesFromModules,
   registerPolicy,
   resolveLocalizedString,

package/dist/pagination/compileMongoPagination.d.ts

@@ -0,0 +1,14 @@
+import { PaginationSpec } from '../../../api/src';
+import { PaginationCursorCodecOptions } from './cursor';
+import { NormalizedPaginationSpec } from './normalizeSpec';
+export type CompiledMongoPagination = {
+    spec: NormalizedPaginationSpec;
+    mongoFilterDelta: Record<string, unknown>;
+    mongoSort: Record<string, 1 | -1>;
+    mongoLimit: number;
+};
+export type CompileMongoPaginationOptions = {
+    cursor: PaginationCursorCodecOptions;
+};
+export declare const compileMongoPagination: (spec: PaginationSpec, options: CompileMongoPaginationOptions) => CompiledMongoPagination;
+//# sourceMappingURL=compileMongoPagination.d.ts.map

package/dist/pagination/compileMongoPagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileMongoPagination.d.ts","sourceRoot":"","sources":["../../src/pagination/compileMongoPagination.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,cAAc,EAAE,MAAM,cAAc,CAAA;AAEnE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,UAAU,CAAA;AAG5D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAA;AAI/D,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,EAAE,wBAAwB,CAAC;IAC/B,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAA;AAED,MAAM,MAAM,6BAA6B,GAAG;IAC1C,MAAM,EAAE,4BAA4B,CAAC;CACtC,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,MAAM,cAAc,EACpB,SAAS,6BAA6B,KACrC,uBA4BF,CAAA"}

package/dist/pagination/cursor.d.ts

@@ -0,0 +1,7 @@
+import { PaginationSpec } from '../../../api/src';
+export type PaginationCursorCodecOptions = {
+    signingSecret: string | Buffer;
+};
+export declare const encodePaginationCursor: (spec: PaginationSpec, node: unknown, options: PaginationCursorCodecOptions) => string;
+export declare const decodePaginationCursor: (spec: PaginationSpec, cursor: string, options: PaginationCursorCodecOptions) => Record<string, unknown>;
+//# sourceMappingURL=cursor.d.ts.map

package/dist/pagination/cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../src/pagination/cursor.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAmBlD,MAAM,MAAM,4BAA4B,GAAG;IACzC,aAAa,EAAE,MAAM,GAAG,MAAM,CAAC;CAChC,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,MAAM,cAAc,EACpB,MAAM,OAAO,EACb,SAAS,4BAA4B,KACpC,MAiBF,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,MAAM,cAAc,EACpB,QAAQ,MAAM,EACd,SAAS,4BAA4B,KACpC,MAAM,CAAC,MAAM,EAAE,OAAO,CAiCxB,CAAA"}

package/dist/pagination/errors.d.ts

@@ -0,0 +1,8 @@
+export type PaginationErrorCode = "invalid_pagination";
+export declare class PaginationValidationError extends Error {
+    readonly code: PaginationErrorCode;
+    readonly statusCode = 400;
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare const isPaginationValidationError: (error: unknown) => error is PaginationValidationError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/pagination/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/pagination/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG,oBAAoB,CAAA;AAEtD,qBAAa,yBAA0B,SAAQ,KAAK;IAClD,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAuB;IACzD,QAAQ,CAAC,UAAU,OAAM;gBAEb,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD;AAED,eAAO,MAAM,2BAA2B,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,yBAQrE,CAAA"}

package/dist/pagination/index.d.ts

@@ -0,0 +1,5 @@
+export type { PaginationCursorCodecOptions } from './cursor';
+export type { MongoPaginationPluginOptions } from './mongoPaginationPlugin';
+export { mongoPaginationPlugin } from './mongoPaginationPlugin';
+export { PaginationValidationError, isPaginationValidationError } from './errors';
+//# sourceMappingURL=index.d.ts.map

package/dist/pagination/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pagination/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,4BAA4B,EAAE,MAAM,UAAU,CAAA;AAC5D,YAAY,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAA;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA;AAC/D,OAAO,EAAE,yBAAyB,EAAE,2BAA2B,EAAE,MAAM,UAAU,CAAA"}

package/dist/pagination/indexHint.d.ts

@@ -0,0 +1,4 @@
+import { PaginationSpec } from '../../../api/src';
+export type MongoIndexHint = Record<string, 1 | -1>;
+export declare const getMongoPaginationIndexHint: (spec: PaginationSpec, baseFilter: Record<string, unknown>) => MongoIndexHint;
+//# sourceMappingURL=indexHint.d.ts.map

package/dist/pagination/indexHint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexHint.d.ts","sourceRoot":"","sources":["../../src/pagination/indexHint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAKlD,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;AAEnD,eAAO,MAAM,2BAA2B,GACtC,MAAM,cAAc,EACpB,YAAY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAClC,cAeF,CAAA"}

package/dist/pagination/materializePagination.d.ts

@@ -0,0 +1,8 @@
+import { PaginationResponse } from '../../../api/src';
+import { PaginationCursorCodecOptions } from './cursor';
+import { CompiledMongoPagination } from './compileMongoPagination';
+export type MaterializePaginationOptions = {
+    cursor: PaginationCursorCodecOptions;
+};
+export declare const materializeMongoPagination: <TNode>(compiled: CompiledMongoPagination, fetchedNodes: TNode[], options: MaterializePaginationOptions) => PaginationResponse<TNode>;
+//# sourceMappingURL=materializePagination.d.ts.map

package/dist/pagination/materializePagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"materializePagination.d.ts","sourceRoot":"","sources":["../../src/pagination/materializePagination.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAEtD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,UAAU,CAAA;AAE5D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAGvE,MAAM,MAAM,4BAA4B,GAAG;IACzC,MAAM,EAAE,4BAA4B,CAAC;CACtC,CAAA;AAED,eAAO,MAAM,0BAA0B,GAAI,KAAK,EAC9C,UAAU,uBAAuB,EACjC,cAAc,KAAK,EAAE,EACrB,SAAS,4BAA4B,KACpC,kBAAkB,CAAC,KAAK,CA4B1B,CAAA"}

package/dist/pagination/mongoAdapter.d.ts

@@ -0,0 +1,11 @@
+import { CompiledMongoPagination } from './compileMongoPagination';
+type MongoQueryLike = {
+    where: (delta: Record<string, unknown>) => unknown;
+    sort: (sort: Record<string, 1 | -1>) => unknown;
+    limit: (limit: number) => unknown;
+};
+export declare const MongoAdapter: {
+    applyPagination: <TQuery extends MongoQueryLike>(query: TQuery, compiled: CompiledMongoPagination) => TQuery;
+};
+export {};
+//# sourceMappingURL=mongoAdapter.d.ts.map

package/dist/pagination/mongoAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongoAdapter.d.ts","sourceRoot":"","sources":["../../src/pagination/mongoAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAGvE,KAAK,cAAc,GAAG;IACpB,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC;IACnD,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC;IAChD,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;CACnC,CAAA;AAED,eAAO,MAAM,YAAY;sBACL,MAAM,SAAS,cAAc,SAAS,MAAM,YAAY,uBAAuB,KAAG,MAAM;CAM3G,CAAA"}

package/dist/pagination/mongoPaginationPlugin.d.ts

@@ -0,0 +1,17 @@
+import { default as mongoose } from '../../../vite/node_modules/mongoose';
+import { PaginationResponse, PaginationSpec } from '../../../api/src';
+import { PaginationCursorCodecOptions } from './cursor';
+declare const mongoPaginationPluginBrand: unique symbol;
+export type MongoPaginationPluginOptions = {
+    cursor: PaginationCursorCodecOptions;
+};
+type QueryResultNode<TResult> = TResult extends Array<infer TNode> ? TNode : unknown;
+declare module '../../../vite/node_modules/mongoose' {
+    interface Query<ResultType, DocType, THelpers = {}, RawDocType = unknown, QueryOp = "find", TDocOverrides = Record<string, never>> {
+        [mongoPaginationPluginBrand]?: [DocType, THelpers, RawDocType, QueryOp, TDocOverrides];
+        paginate: (pagination?: PaginationSpec, options?: MongoPaginationPluginOptions) => Promise<PaginationResponse<QueryResultNode<ResultType>>>;
+    }
+}
+export declare const mongoPaginationPlugin: (schema: mongoose.Schema, pluginOptions?: MongoPaginationPluginOptions) => void;
+export {};
+//# sourceMappingURL=mongoPaginationPlugin.d.ts.map

package/dist/pagination/mongoPaginationPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongoPaginationPlugin.d.ts","sourceRoot":"","sources":["../../src/pagination/mongoPaginationPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAA;AAC/B,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAEtE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,UAAU,CAAA;AAI5D,OAAO,CAAC,MAAM,0BAA0B,EAAE,OAAO,MAAM,CAAA;AAqBvD,MAAM,MAAM,4BAA4B,GAAG;IACzC,MAAM,EAAE,4BAA4B,CAAC;CACtC,CAAA;AAED,KAAK,eAAe,CAAC,OAAO,IAAI,OAAO,SAAS,KAAK,CAAC,MAAM,KAAK,CAAC,GAAG,KAAK,GAAG,OAAO,CAAA;AAEpF,OAAO,QAAQ,UAAU,CAAC;IACxB,UAAU,KAAK,CACb,UAAU,EACV,OAAO,EACP,QAAQ,GAAG,EAAE,EACb,UAAU,GAAG,OAAO,EACpB,OAAO,GAAG,MAAM,EAChB,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;QAErC,CAAC,0BAA0B,CAAC,CAAC,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC;QACvF,QAAQ,EAAE,CACR,UAAU,CAAC,EAAE,cAAc,EAC3B,OAAO,CAAC,EAAE,4BAA4B,KACnC,OAAO,CAAC,kBAAkB,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;KAC/D;CACF;AAED,eAAO,MAAM,qBAAqB,GAAI,QAAQ,QAAQ,CAAC,MAAM,EAAE,gBAAgB,4BAA4B,KAAG,IAc7G,CAAA"}

package/dist/pagination/normalizeSpec.d.ts

@@ -0,0 +1,11 @@
+import { PaginationDirection, PaginationOrder, PaginationSpec } from '../../../api/src';
+export type NormalizedPaginationSpec = Omit<PaginationSpec, "direction" | "sort" | "limit"> & {
+    direction: PaginationDirection;
+    limit: number;
+    sort: Array<{
+        field: string;
+        order: PaginationOrder;
+    }>;
+};
+export declare const normalizePaginationSpec: (spec: PaginationSpec) => NormalizedPaginationSpec;
+//# sourceMappingURL=normalizeSpec.d.ts.map

package/dist/pagination/normalizeSpec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeSpec.d.ts","sourceRoot":"","sources":["../../src/pagination/normalizeSpec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAQxF,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,cAAc,EAAE,WAAW,GAAG,MAAM,GAAG,OAAO,CAAC,GAAG;IAC5F,SAAS,EAAE,mBAAmB,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,KAAK,CAAC;QACV,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,eAAe,CAAC;KACxB,CAAC,CAAC;CACJ,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAI,MAAM,cAAc,KAAG,wBAgC9D,CAAA"}

package/dist/pagination/paginateMongoQuery.d.ts

@@ -0,0 +1,14 @@
+import { PaginationResponse, PaginationSpec } from '../../../api/src';
+import { PaginationCursorCodecOptions } from './cursor';
+type MongoPaginateQueryLike<TNode> = {
+    where: (delta: Record<string, unknown>) => unknown;
+    sort: (sort: Record<string, 1 | -1>) => unknown;
+    limit: (limit: number) => unknown;
+    exec: () => Promise<TNode[]>;
+};
+export type PaginateMongoQueryOptions = {
+    cursor: PaginationCursorCodecOptions;
+};
+export declare const paginateMongoQuery: <TNode>(query: MongoPaginateQueryLike<TNode>, pagination: PaginationSpec, options: PaginateMongoQueryOptions) => Promise<PaginationResponse<TNode>>;
+export {};
+//# sourceMappingURL=paginateMongoQuery.d.ts.map

package/dist/pagination/paginateMongoQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginateMongoQuery.d.ts","sourceRoot":"","sources":["../../src/pagination/paginateMongoQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAEtE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,UAAU,CAAA;AAM5D,KAAK,sBAAsB,CAAC,KAAK,IAAI;IACnC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC;IACnD,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC;IAChD,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAClC,IAAI,EAAE,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;CAC9B,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,EAAE,4BAA4B,CAAC;CACtC,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAU,KAAK,EAC5C,OAAO,sBAAsB,CAAC,KAAK,CAAC,EACpC,YAAY,cAAc,EAC1B,SAAS,yBAAyB,KACjC,OAAO,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAWnC,CAAA"}

package/dist/registerModels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registerModels.d.ts","sourceRoot":"","sources":["../src/registerModels.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAA;AAa/B,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAwE3C,eAAO,MAAM,cAAc,GAAI,SAAS,YAAY,SAInD,CAAA;AAED,eAAO,MAAM,mBAAmB,sEAK/B,CAAA;AAED,YAAY,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"registerModels.d.ts","sourceRoot":"","sources":["../src/registerModels.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAA;AAiB/B,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAwF3C,eAAO,MAAM,cAAc,GAAI,SAAS,YAAY,SAInD,CAAA;AAED,eAAO,MAAM,mBAAmB,sEAK/B,CAAA;AAED,YAAY,EAAE,YAAY,EAAE,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/db",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "type": "module",
   "files": [
     "dist"