@rpcbase/db 0.23.0 → 0.25.0

package/dist/index.js

@@ -9,8 +9,8 @@ const ZRBUser = z.object({
   name: z.string().optional(),
   phone: z.string().optional(),
   tenants: z.array(z.string()),
-  email_verification_code: z.string().length(6).optional(),
-  email_verification_expires_at: z.date().optional()
+  emailVerificationCode: z.string().length(6).optional(),
+  emailVerificationExpiresAt: z.date().optional()
 });
 const RBUserSchema = new Schema({
   email: { type: String, unique: true, sparse: true },
@@ -18,19 +18,155 @@ const RBUserSchema = new Schema({
   password: { type: String, required: true },
   name: String,
   tenants: { type: [String], index: true, required: true },
-  email_verification_code: { type: String, required: false },
-  email_verification_expires_at: { type: Date, required: false }
+  emailVerificationCode: { type: String, required: false },
+  emailVerificationExpiresAt: { type: Date, required: false }
 }, { collection: "users" });
 const ZRBTenant = z.object({
-  tenant_id: z.string(),
-  parent_tenant_id: z.string().optional(),
+  tenantId: z.string(),
+  parentTenantId: z.string().optional(),
   name: z.string().optional()
 });
 const RBTenantSchema = new Schema({
-  tenant_id: { type: String, required: true, unique: true, index: true },
-  parent_tenant_id: { type: String },
+  tenantId: { type: String, required: true, unique: true, index: true },
+  parentTenantId: { type: String },
   name: { type: String }
 }, { collection: "tenants" });
+const ZRBTenantSubscriptionStatus = z.enum([
+  "trialing",
+  "active",
+  "past_due",
+  "paused",
+  "canceled",
+  "expired"
+]);
+const ZRBTenantSubscriptionIntervalUnit = z.enum(["day", "month", "year"]);
+const ZRBTenantSubscriptionType = z.enum(["primary", "addon"]);
+const ZRBTenantSubscriptionScope = z.enum(["tenant", "shop", "custom"]);
+const ZRBTenantSubscription = z.object({
+  tenantId: z.string(),
+  subscriptionId: z.string(),
+  type: ZRBTenantSubscriptionType.optional(),
+  parentSubscriptionId: z.string().optional(),
+  scope: ZRBTenantSubscriptionScope.optional(),
+  scopeId: z.string().optional(),
+  planKey: z.string(),
+  status: ZRBTenantSubscriptionStatus,
+  intervalUnit: ZRBTenantSubscriptionIntervalUnit,
+  intervalCount: z.number().int().min(1).optional(),
+  modules: z.array(z.string()).optional(),
+  currentPeriodStart: z.date().optional(),
+  currentPeriodEnd: z.date().optional(),
+  trialEndsAt: z.date().optional(),
+  cancelAt: z.date().optional(),
+  cancelAtPeriodEnd: z.boolean().optional(),
+  canceledAt: z.date().optional(),
+  provider: z.string().optional(),
+  providerCustomerId: z.string().optional(),
+  providerSubscriptionId: z.string().optional(),
+  latestEventId: z.string().optional(),
+  latestEventAt: z.date().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+const RBTenantSubscriptionSchema = new Schema(
+  {
+    tenantId: { type: String, required: true, index: true },
+    subscriptionId: { type: String, required: true },
+    type: { type: String, required: true, enum: ZRBTenantSubscriptionType.options, default: "primary" },
+    parentSubscriptionId: { type: String },
+    scope: { type: String, enum: ZRBTenantSubscriptionScope.options, default: "tenant" },
+    scopeId: { type: String },
+    planKey: { type: String, required: true },
+    status: { type: String, required: true, enum: ZRBTenantSubscriptionStatus.options },
+    intervalUnit: { type: String, required: true, enum: ZRBTenantSubscriptionIntervalUnit.options },
+    intervalCount: { type: Number, min: 1, default: 1 },
+    modules: { type: [String], default: [] },
+    currentPeriodStart: { type: Date },
+    currentPeriodEnd: { type: Date },
+    trialEndsAt: { type: Date },
+    cancelAt: { type: Date },
+    cancelAtPeriodEnd: { type: Boolean, default: false },
+    canceledAt: { type: Date },
+    provider: { type: String },
+    providerCustomerId: { type: String },
+    providerSubscriptionId: { type: String },
+    latestEventId: { type: String },
+    latestEventAt: { type: Date },
+    metadata: { type: Schema.Types.Mixed }
+  },
+  {
+    collection: "tenantSubscriptions"
+  }
+);
+RBTenantSubscriptionSchema.index({ tenantId: 1, subscriptionId: 1 }, { unique: true });
+RBTenantSubscriptionSchema.index({ tenantId: 1, scope: 1, scopeId: 1 });
+const ZRBTenantSubscriptionEventSource = z.enum([
+  "admin",
+  "system",
+  "webhook",
+  "user"
+]);
+const ZRBTenantSubscriptionChangeDirection = z.enum([
+  "upgrade",
+  "downgrade",
+  "lateral"
+]);
+const ZRBTenantSubscriptionEvent = z.object({
+  tenantId: z.string(),
+  subscriptionId: z.string(),
+  type: z.string(),
+  occurredAt: z.date(),
+  effectiveAt: z.date().optional(),
+  fromPlanKey: z.string().optional(),
+  toPlanKey: z.string().optional(),
+  fromStatus: ZRBTenantSubscriptionStatus.optional(),
+  toStatus: ZRBTenantSubscriptionStatus.optional(),
+  fromModules: z.array(z.string()).optional(),
+  toModules: z.array(z.string()).optional(),
+  fromIntervalUnit: ZRBTenantSubscriptionIntervalUnit.optional(),
+  toIntervalUnit: ZRBTenantSubscriptionIntervalUnit.optional(),
+  fromIntervalCount: z.number().int().min(1).optional(),
+  toIntervalCount: z.number().int().min(1).optional(),
+  direction: ZRBTenantSubscriptionChangeDirection.optional(),
+  actorUserId: z.string().optional(),
+  source: ZRBTenantSubscriptionEventSource.optional(),
+  reason: z.string().optional(),
+  provider: z.string().optional(),
+  providerEventId: z.string().optional(),
+  providerPayload: z.unknown().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+const RBTenantSubscriptionEventSchema = new Schema(
+  {
+    tenantId: { type: String, required: true, index: true },
+    subscriptionId: { type: String, required: true, index: true },
+    type: { type: String, required: true },
+    occurredAt: { type: Date, required: true, default: Date.now },
+    effectiveAt: { type: Date },
+    fromPlanKey: { type: String },
+    toPlanKey: { type: String },
+    fromStatus: { type: String, enum: ZRBTenantSubscriptionStatus.options },
+    toStatus: { type: String, enum: ZRBTenantSubscriptionStatus.options },
+    fromModules: { type: [String], default: void 0 },
+    toModules: { type: [String], default: void 0 },
+    fromIntervalUnit: { type: String, enum: ZRBTenantSubscriptionIntervalUnit.options },
+    toIntervalUnit: { type: String, enum: ZRBTenantSubscriptionIntervalUnit.options },
+    fromIntervalCount: { type: Number, min: 1 },
+    toIntervalCount: { type: Number, min: 1 },
+    direction: { type: String, enum: ZRBTenantSubscriptionChangeDirection.options },
+    actorUserId: { type: String },
+    source: { type: String, enum: ZRBTenantSubscriptionEventSource.options },
+    reason: { type: String },
+    provider: { type: String },
+    providerEventId: { type: String },
+    providerPayload: { type: Schema.Types.Mixed },
+    metadata: { type: Schema.Types.Mixed }
+  },
+  {
+    collection: "tenantSubscriptionEvents"
+  }
+);
+RBTenantSubscriptionEventSchema.index({ tenantId: 1, subscriptionId: 1, occurredAt: 1 });
+RBTenantSubscriptionEventSchema.index({ provider: 1, providerEventId: 1 }, { unique: true, sparse: true });
 const ZRBRtsCounter = z.object({
   _id: z.string(),
   seq: z.number().int().min(0)
@@ -139,6 +275,8 @@ const frameworkSchemas = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   RBRtsChangeSchema,
   RBRtsCounterSchema,
   RBTenantSchema,
+  RBTenantSubscriptionEventSchema,
+  RBTenantSubscriptionSchema,
   RBUploadChunkSchema,
   RBUploadSessionSchema,
   RBUserSchema,
@@ -146,6 +284,14 @@ const frameworkSchemas = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   ZRBRtsChangeOp,
   ZRBRtsCounter,
   ZRBTenant,
+  ZRBTenantSubscription,
+  ZRBTenantSubscriptionChangeDirection,
+  ZRBTenantSubscriptionEvent,
+  ZRBTenantSubscriptionEventSource,
+  ZRBTenantSubscriptionIntervalUnit,
+  ZRBTenantSubscriptionScope,
+  ZRBTenantSubscriptionStatus,
+  ZRBTenantSubscriptionType,
   ZRBUploadChunk,
   ZRBUploadSession,
   ZRBUploadSessionStatus,
@@ -1119,7 +1265,7 @@ const loadModelFromDb = async (modelName, dbName) => {
 };
 const loadModel = async (modelName, ctx) => {
   assertTenantModelName(modelName);
-  const tenantId = ctx.req.session?.user?.current_tenant_id;
+  const tenantId = ctx.req.session?.user?.currentTenantId;
   assert(typeof tenantId === "string" && tenantId.trim(), "Tenant ID is missing from session");
   const dbName = `${APP_NAME}-${tenantId.trim()}-db`;
   return loadModelFromDb(modelName, dbName);
@@ -1150,7 +1296,7 @@ const normalizeTenantId = (tenantId) => {
 const getTenantFilesystemDbName = (tenantId) => `${getAppName()}-${normalizeTenantId(tenantId)}-filesystem-db`;
 const getTenantFilesystemDb = async (tenantId) => ensureMongooseConnection(getTenantFilesystemDbName(tenantId));
 const getTenantFilesystemDbFromCtx = async (ctx) => {
-  const tenantId = ctx.req.session?.user?.current_tenant_id;
+  const tenantId = ctx.req.session?.user?.currentTenantId;
   assert(typeof tenantId === "string" && tenantId.trim(), "Tenant ID is missing from session");
   return getTenantFilesystemDb(tenantId);
 };
@@ -1159,6 +1305,8 @@ export {
   RBRtsChangeSchema,
   RBRtsCounterSchema,
   RBTenantSchema,
+  RBTenantSubscriptionEventSchema,
+  RBTenantSubscriptionSchema,
   RBUploadChunkSchema,
   RBUploadSessionSchema,
   RBUserSchema,
@@ -1166,6 +1314,14 @@ export {
   ZRBRtsChangeOp,
   ZRBRtsCounter,
   ZRBTenant,
+  ZRBTenantSubscription,
+  ZRBTenantSubscriptionChangeDirection,
+  ZRBTenantSubscriptionEvent,
+  ZRBTenantSubscriptionEventSource,
+  ZRBTenantSubscriptionIntervalUnit,
+  ZRBTenantSubscriptionScope,
+  ZRBTenantSubscriptionStatus,
+  ZRBTenantSubscriptionType,
   ZRBUploadChunk,
   ZRBUploadSession,
   ZRBUploadSessionStatus,

package/dist/loadModel.d.ts

@@ -3,7 +3,7 @@ type LoadModelCtx = {
     req: {
         session?: {
             user?: {
-                current_tenant_id?: string;
+                currentTenantId?: string;
             };
         } | null;
     };

package/dist/loadModel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loadModel.d.ts","sourceRoot":"","sources":["../src/loadModel.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAA;AAMpC,KAAK,YAAY,GAAG;IAClB,GAAG,EAAE;QACH,OAAO,CAAC,EAAE;YACR,IAAI,CAAC,EAAE;gBACL,iBAAiB,CAAC,EAAE,MAAM,CAAC;aAC5B,CAAA;SACF,GAAG,IAAI,CAAC;KACV,CAAC;CACH,CAAC;AAuCF,eAAO,MAAM,SAAS,GAAU,WAAW,MAAM,EAAE,KAAK,YAAY,4DAOnE,CAAA;AAED,eAAO,MAAM,WAAW,GAAU,WAAW,MAAM,EAAE,MAAM,YAAY,4DAItE,CAAA;AAED,YAAY,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"loadModel.d.ts","sourceRoot":"","sources":["../src/loadModel.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAA;AAMpC,KAAK,YAAY,GAAG;IAClB,GAAG,EAAE;QACH,OAAO,CAAC,EAAE;YACR,IAAI,CAAC,EAAE;gBACL,eAAe,CAAC,EAAE,MAAM,CAAC;aAC1B,CAAA;SACF,GAAG,IAAI,CAAC;KACV,CAAC;CACH,CAAC;AAuCF,eAAO,MAAM,SAAS,GAAU,WAAW,MAAM,EAAE,KAAK,YAAY,4DAOnE,CAAA;AAED,eAAO,MAAM,WAAW,GAAU,WAAW,MAAM,EAAE,MAAM,YAAY,4DAItE,CAAA;AAED,YAAY,EAAE,YAAY,EAAE,CAAA"}

package/dist/models/RBTenantSubscription.d.ts

@@ -0,0 +1,70 @@
+import { Schema } from '../../../vite/node_modules/mongoose';
+import { z } from '../../../vite/node_modules/zod';
+export declare const ZRBTenantSubscriptionStatus: z.ZodEnum<{
+    trialing: "trialing";
+    active: "active";
+    past_due: "past_due";
+    paused: "paused";
+    canceled: "canceled";
+    expired: "expired";
+}>;
+export declare const ZRBTenantSubscriptionIntervalUnit: z.ZodEnum<{
+    day: "day";
+    month: "month";
+    year: "year";
+}>;
+export declare const ZRBTenantSubscriptionType: z.ZodEnum<{
+    primary: "primary";
+    addon: "addon";
+}>;
+export declare const ZRBTenantSubscriptionScope: z.ZodEnum<{
+    custom: "custom";
+    tenant: "tenant";
+    shop: "shop";
+}>;
+export declare const ZRBTenantSubscription: z.ZodObject<{
+    tenantId: z.ZodString;
+    subscriptionId: z.ZodString;
+    type: z.ZodOptional<z.ZodEnum<{
+        primary: "primary";
+        addon: "addon";
+    }>>;
+    parentSubscriptionId: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        custom: "custom";
+        tenant: "tenant";
+        shop: "shop";
+    }>>;
+    scopeId: z.ZodOptional<z.ZodString>;
+    planKey: z.ZodString;
+    status: z.ZodEnum<{
+        trialing: "trialing";
+        active: "active";
+        past_due: "past_due";
+        paused: "paused";
+        canceled: "canceled";
+        expired: "expired";
+    }>;
+    intervalUnit: z.ZodEnum<{
+        day: "day";
+        month: "month";
+        year: "year";
+    }>;
+    intervalCount: z.ZodOptional<z.ZodNumber>;
+    modules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    currentPeriodStart: z.ZodOptional<z.ZodDate>;
+    currentPeriodEnd: z.ZodOptional<z.ZodDate>;
+    trialEndsAt: z.ZodOptional<z.ZodDate>;
+    cancelAt: z.ZodOptional<z.ZodDate>;
+    cancelAtPeriodEnd: z.ZodOptional<z.ZodBoolean>;
+    canceledAt: z.ZodOptional<z.ZodDate>;
+    provider: z.ZodOptional<z.ZodString>;
+    providerCustomerId: z.ZodOptional<z.ZodString>;
+    providerSubscriptionId: z.ZodOptional<z.ZodString>;
+    latestEventId: z.ZodOptional<z.ZodString>;
+    latestEventAt: z.ZodOptional<z.ZodDate>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type IRBTenantSubscription = z.infer<typeof ZRBTenantSubscription>;
+export declare const RBTenantSubscriptionSchema: Schema;
+//# sourceMappingURL=RBTenantSubscription.d.ts.map

package/dist/models/RBTenantSubscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RBTenantSubscription.d.ts","sourceRoot":"","sources":["../../src/models/RBTenantSubscription.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,2BAA2B;;;;;;;EAOtC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;EAAmC,CAAA;AAEjF,eAAO,MAAM,yBAAyB;;;EAA+B,CAAA;AAErE,eAAO,MAAM,0BAA0B;;;;EAAuC,CAAA;AAE9E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwBhC,CAAA;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEzE,eAAO,MAAM,0BAA0B,EAAE,MA6BxC,CAAA"}

package/dist/models/RBTenantSubscriptionEvent.d.ts

@@ -0,0 +1,72 @@
+import { Schema } from '../../../vite/node_modules/mongoose';
+import { z } from '../../../vite/node_modules/zod';
+export declare const ZRBTenantSubscriptionEventSource: z.ZodEnum<{
+    admin: "admin";
+    system: "system";
+    webhook: "webhook";
+    user: "user";
+}>;
+export declare const ZRBTenantSubscriptionChangeDirection: z.ZodEnum<{
+    upgrade: "upgrade";
+    downgrade: "downgrade";
+    lateral: "lateral";
+}>;
+export declare const ZRBTenantSubscriptionEvent: z.ZodObject<{
+    tenantId: z.ZodString;
+    subscriptionId: z.ZodString;
+    type: z.ZodString;
+    occurredAt: z.ZodDate;
+    effectiveAt: z.ZodOptional<z.ZodDate>;
+    fromPlanKey: z.ZodOptional<z.ZodString>;
+    toPlanKey: z.ZodOptional<z.ZodString>;
+    fromStatus: z.ZodOptional<z.ZodEnum<{
+        trialing: "trialing";
+        active: "active";
+        past_due: "past_due";
+        paused: "paused";
+        canceled: "canceled";
+        expired: "expired";
+    }>>;
+    toStatus: z.ZodOptional<z.ZodEnum<{
+        trialing: "trialing";
+        active: "active";
+        past_due: "past_due";
+        paused: "paused";
+        canceled: "canceled";
+        expired: "expired";
+    }>>;
+    fromModules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    toModules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fromIntervalUnit: z.ZodOptional<z.ZodEnum<{
+        day: "day";
+        month: "month";
+        year: "year";
+    }>>;
+    toIntervalUnit: z.ZodOptional<z.ZodEnum<{
+        day: "day";
+        month: "month";
+        year: "year";
+    }>>;
+    fromIntervalCount: z.ZodOptional<z.ZodNumber>;
+    toIntervalCount: z.ZodOptional<z.ZodNumber>;
+    direction: z.ZodOptional<z.ZodEnum<{
+        upgrade: "upgrade";
+        downgrade: "downgrade";
+        lateral: "lateral";
+    }>>;
+    actorUserId: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodEnum<{
+        admin: "admin";
+        system: "system";
+        webhook: "webhook";
+        user: "user";
+    }>>;
+    reason: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    providerEventId: z.ZodOptional<z.ZodString>;
+    providerPayload: z.ZodOptional<z.ZodUnknown>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type IRBTenantSubscriptionEvent = z.infer<typeof ZRBTenantSubscriptionEvent>;
+export declare const RBTenantSubscriptionEventSchema: Schema;
+//# sourceMappingURL=RBTenantSubscriptionEvent.d.ts.map

package/dist/models/RBTenantSubscriptionEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RBTenantSubscriptionEvent.d.ts","sourceRoot":"","sources":["../../src/models/RBTenantSubscriptionEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,gCAAgC;;;;;EAK3C,CAAA;AAEF,eAAO,MAAM,oCAAoC;;;;EAI/C,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwBrC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEnF,eAAO,MAAM,+BAA+B,EAAE,MA6B7C,CAAA"}

package/dist/models/Tenant.d.ts

@@ -1,8 +1,8 @@
 import { Schema } from '../../../vite/node_modules/mongoose';
 import { z } from '../../../vite/node_modules/zod';
 export declare const ZRBTenant: z.ZodObject<{
-    tenant_id: z.ZodString;
-    parent_tenant_id: z.ZodOptional<z.ZodString>;
+    tenantId: z.ZodString;
+    parentTenantId: z.ZodOptional<z.ZodString>;
     name: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type IRBTenant = z.infer<typeof ZRBTenant>;

package/dist/models/User.d.ts

@@ -6,8 +6,8 @@ export declare const ZRBUser: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     phone: z.ZodOptional<z.ZodString>;
     tenants: z.ZodArray<z.ZodString>;
-    email_verification_code: z.ZodOptional<z.ZodString>;
-    email_verification_expires_at: z.ZodOptional<z.ZodDate>;
+    emailVerificationCode: z.ZodOptional<z.ZodString>;
+    emailVerificationExpiresAt: z.ZodOptional<z.ZodDate>;
 }, z.core.$strip>;
 export type IRBUser = z.infer<typeof ZRBUser>;
 export declare const RBUserSchema: Schema;

package/dist/models/index.d.ts

@@ -1,5 +1,7 @@
 export * from './User';
 export * from './Tenant';
+export * from './RBTenantSubscription';
+export * from './RBTenantSubscriptionEvent';
 export * from './RBRtsCounter';
 export * from './RBRtsChange';
 export * from './RBUploadSession';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,UAAU,CAAA;AACxB,cAAc,wBAAwB,CAAA;AACtC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA"}

package/package.json

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