@rpcbase/db 0.121.0 → 0.123.0

package/dist/billingStorage.d.ts

@@ -0,0 +1,7 @@
+import { BillingStorage } from '@rpcbase/billing';
+import { LoadModelCtx } from './modelsApi';
+export declare const createTenantBillingStorage: (params: {
+    ctx: LoadModelCtx;
+    tenantId: string;
+}) => BillingStorage;
+//# sourceMappingURL=billingStorage.d.ts.map

package/dist/billingStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"billingStorage.d.ts","sourceRoot":"","sources":["../src/billingStorage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EAKf,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AA8D/C,eAAO,MAAM,0BAA0B,GAAI,QAAQ;IACjD,GAAG,EAAE,YAAY,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB,KAAG,cAsEH,CAAA"}

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export * from './search';
 export * from './zod';
 export * from './modelTypes';
 export * from './createModels';
+export * from './billingStorage';
 export * from './modelsApi';
 export * from './tenantFilesystemDb';
 export * from './transactions';

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -3,6 +3,7 @@ import { b, a, c, g, d, e, f } from "./can-B4pD_pnR.js";
 import mongoose, { Schema as Schema$1, Types } from "mongoose";
 import { default as default2 } from "mongoose";
 import { z } from "zod";
+import { SUBSCRIPTION_STATUSES, SUBSCRIPTION_INTERVAL_UNITS, SUBSCRIPTION_TYPES, SUBSCRIPTION_SCOPES, SUBSCRIPTION_EVENT_TYPES, SUBSCRIPTION_CHANGE_DIRECTIONS } from "@rpcbase/billing";
 import { timingSafeEqual, createHmac } from "node:crypto";
 import { w as withLocalizedStringFallback } from "./index-DrIoUXc2.js";
 import { E, a as a2, L, b as b2, e as e2, m, r, z as z2, c as c2, d as d2, f as f2 } from "./index-DrIoUXc2.js";
@@ -166,16 +167,22 @@ const RBTenantSchema = new Schema$1({
     type: String
   }
 });
-const ZRBTenantSubscriptionStatus = z.enum(["trialing", "active", "past_due", "paused", "canceled", "expired"]);
-const ZRBTenantSubscriptionIntervalUnit = z.enum(["month", "year"]);
+const ZRBTenantSubscriptionStatus = z.enum(SUBSCRIPTION_STATUSES);
+const ZRBTenantSubscriptionIntervalUnit = z.enum(SUBSCRIPTION_INTERVAL_UNITS);
+const ZRBTenantSubscriptionType = z.enum(SUBSCRIPTION_TYPES);
+const ZRBTenantSubscriptionScope = z.enum(SUBSCRIPTION_SCOPES);
+const ZRBTenantSubscriptionEventType = z.enum(SUBSCRIPTION_EVENT_TYPES);
 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(),
+const ZRBTenantSubscriptionChangeDirection = z.enum(SUBSCRIPTION_CHANGE_DIRECTIONS);
+const subscriptionEventBaseSchema = z.object({
+  tenantId: z.string().trim().min(1),
+  subscriptionId: z.string().trim().min(1),
   occurredAt: z.date(),
-  effectiveAt: z.date().optional(),
+  effectiveAt: z.date(),
+  subscriptionType: ZRBTenantSubscriptionType,
+  parentSubscriptionId: z.string().optional(),
+  scope: ZRBTenantSubscriptionScope,
+  scopeId: z.string().optional(),
   fromPlanKey: z.string().optional(),
   toPlanKey: z.string().optional(),
   fromStatus: ZRBTenantSubscriptionStatus.optional(),
@@ -186,6 +193,11 @@ const ZRBTenantSubscriptionEvent = z.object({
   toIntervalUnit: ZRBTenantSubscriptionIntervalUnit.optional(),
   fromIntervalCount: z.number().int().min(1).optional(),
   toIntervalCount: z.number().int().min(1).optional(),
+  fromPriceId: z.string().optional(),
+  toPriceId: z.string().optional(),
+  billingAnchor: z.date().optional(),
+  supersedesEventId: z.string().optional(),
+  idempotencyKey: z.string().trim().min(1),
   direction: ZRBTenantSubscriptionChangeDirection.optional(),
   actorUserId: z.string().optional(),
   source: ZRBTenantSubscriptionEventSource.optional(),
@@ -195,6 +207,65 @@ const ZRBTenantSubscriptionEvent = z.object({
   providerPayload: z.unknown().optional(),
   metadata: z.record(z.string(), z.unknown()).optional()
 });
+const subscriptionCreatedEventSchema = subscriptionEventBaseSchema.extend({
+  type: z.literal("created"),
+  toPlanKey: z.string().trim().min(1),
+  toStatus: ZRBTenantSubscriptionStatus,
+  toModules: z.array(z.string()),
+  toIntervalUnit: ZRBTenantSubscriptionIntervalUnit,
+  toIntervalCount: z.number().int().min(1),
+  billingAnchor: z.date()
+});
+const subscriptionPlanChangedEventSchema = subscriptionEventBaseSchema.extend({
+  type: z.literal("plan_changed"),
+  fromPlanKey: z.string().trim().min(1),
+  toPlanKey: z.string().trim().min(1),
+  fromModules: z.array(z.string()),
+  toModules: z.array(z.string()),
+  fromIntervalUnit: ZRBTenantSubscriptionIntervalUnit,
+  toIntervalUnit: ZRBTenantSubscriptionIntervalUnit,
+  fromIntervalCount: z.number().int().min(1),
+  toIntervalCount: z.number().int().min(1)
+});
+const subscriptionStatusChangedEventSchema = subscriptionEventBaseSchema.extend({
+  type: z.literal("status_changed"),
+  fromStatus: ZRBTenantSubscriptionStatus,
+  toStatus: ZRBTenantSubscriptionStatus
+});
+const subscriptionResumedEventSchema = subscriptionEventBaseSchema.extend({
+  type: z.literal("resumed"),
+  fromStatus: ZRBTenantSubscriptionStatus,
+  toStatus: z.literal("active")
+});
+const subscriptionCanceledEventSchema = subscriptionEventBaseSchema.extend({
+  type: z.literal("canceled"),
+  fromStatus: ZRBTenantSubscriptionStatus,
+  toStatus: z.literal("canceled")
+});
+const subscriptionRenewedEventSchema = subscriptionEventBaseSchema.extend({
+  type: z.literal("renewed"),
+  fromStatus: ZRBTenantSubscriptionStatus,
+  toStatus: ZRBTenantSubscriptionStatus
+});
+const ZRBTenantSubscriptionEvent = z.discriminatedUnion("type", [subscriptionCreatedEventSchema, subscriptionPlanChangedEventSchema, subscriptionStatusChangedEventSchema, subscriptionResumedEventSchema, subscriptionCanceledEventSchema, subscriptionRenewedEventSchema]).superRefine((event, ctx) => {
+  if (event.subscriptionType === "addon" && !event.parentSubscriptionId?.trim()) {
+    ctx.addIssue({
+      code: "custom",
+      message: "parentSubscriptionId is required for add-on subscriptions",
+      path: ["parentSubscriptionId"]
+    });
+  }
+  if (event.scope !== "tenant" && !event.scopeId?.trim()) {
+    ctx.addIssue({
+      code: "custom",
+      message: "scopeId is required for non-tenant subscriptions",
+      path: ["scopeId"]
+    });
+  }
+});
+const requiredForEventTypes = (...types) => function requiredForEventType() {
+  return Boolean(this.type && types.includes(this.type));
+};
 const RBTenantSubscriptionEventSchema = new Schema$1({
   tenantId: {
     type: String,
@@ -208,7 +279,8 @@ const RBTenantSubscriptionEventSchema = new Schema$1({
   },
   type: {
     type: String,
-    required: true
+    required: true,
+    enum: ZRBTenantSubscriptionEventType.options
   },
   occurredAt: {
     type: Date,
@@ -216,46 +288,96 @@ const RBTenantSubscriptionEventSchema = new Schema$1({
     default: Date.now
   },
   effectiveAt: {
-    type: Date
+    type: Date,
+    required: true
+  },
+  subscriptionType: {
+    type: String,
+    required: true,
+    enum: ZRBTenantSubscriptionType.options
+  },
+  parentSubscriptionId: {
+    type: String,
+    required() {
+      return this.subscriptionType === "addon";
+    }
+  },
+  scope: {
+    type: String,
+    required: true,
+    enum: ZRBTenantSubscriptionScope.options
+  },
+  scopeId: {
+    type: String,
+    required() {
+      return Boolean(this.scope && this.scope !== "tenant");
+    }
   },
   fromPlanKey: {
-    type: String
+    type: String,
+    required: requiredForEventTypes("plan_changed")
   },
   toPlanKey: {
-    type: String
+    type: String,
+    required: requiredForEventTypes("created", "plan_changed")
   },
   fromStatus: {
     type: String,
+    required: requiredForEventTypes("status_changed", "resumed", "canceled", "renewed"),
     enum: ZRBTenantSubscriptionStatus.options
   },
   toStatus: {
     type: String,
+    required: requiredForEventTypes("created", "status_changed", "resumed", "canceled", "renewed"),
     enum: ZRBTenantSubscriptionStatus.options
   },
   fromModules: {
     type: [String],
+    required: requiredForEventTypes("plan_changed"),
     default: void 0
   },
   toModules: {
     type: [String],
+    required: requiredForEventTypes("created", "plan_changed"),
     default: void 0
   },
   fromIntervalUnit: {
     type: String,
+    required: requiredForEventTypes("plan_changed"),
     enum: ZRBTenantSubscriptionIntervalUnit.options
   },
   toIntervalUnit: {
     type: String,
+    required: requiredForEventTypes("created", "plan_changed"),
     enum: ZRBTenantSubscriptionIntervalUnit.options
   },
   fromIntervalCount: {
     type: Number,
+    required: requiredForEventTypes("plan_changed"),
     min: 1
   },
   toIntervalCount: {
     type: Number,
+    required: requiredForEventTypes("created", "plan_changed"),
     min: 1
   },
+  fromPriceId: {
+    type: String
+  },
+  toPriceId: {
+    type: String
+  },
+  billingAnchor: {
+    type: Date,
+    required: requiredForEventTypes("created")
+  },
+  supersedesEventId: {
+    type: String
+  },
+  idempotencyKey: {
+    type: String,
+    required: true
+  },
   direction: {
     type: String,
     enum: ZRBTenantSubscriptionChangeDirection.options
@@ -286,6 +408,7 @@ const RBTenantSubscriptionEventSchema = new Schema$1({
 RBTenantSubscriptionEventSchema.index({
   tenantId: 1,
   subscriptionId: 1,
+  effectiveAt: 1,
   occurredAt: 1
 });
 RBTenantSubscriptionEventSchema.index({
@@ -293,7 +416,155 @@ RBTenantSubscriptionEventSchema.index({
   providerEventId: 1
 }, {
   unique: true,
-  sparse: true
+  partialFilterExpression: {
+    provider: {
+      $type: "string"
+    },
+    providerEventId: {
+      $type: "string"
+    }
+  }
+});
+RBTenantSubscriptionEventSchema.index({
+  tenantId: 1,
+  idempotencyKey: 1
+}, {
+  unique: true
+});
+const ZRBTenantSubscriptionProjection = z.object({
+  tenantId: z.string(),
+  subscriptionId: z.string(),
+  type: ZRBTenantSubscriptionType,
+  parentSubscriptionId: z.string().optional(),
+  scope: ZRBTenantSubscriptionScope,
+  scopeId: z.string().optional(),
+  planKey: z.string(),
+  priceId: z.string().optional(),
+  status: ZRBTenantSubscriptionStatus,
+  intervalUnit: ZRBTenantSubscriptionIntervalUnit,
+  intervalCount: z.number().int().min(1),
+  modules: z.array(z.string()),
+  billingAnchor: z.date(),
+  currentPeriodStart: z.date(),
+  currentPeriodEnd: z.date(),
+  cancelAtPeriodEnd: z.boolean(),
+  cancelAt: z.date().optional(),
+  canceledAt: z.date().optional(),
+  scheduledPlanKey: z.string().optional(),
+  scheduledPlanEffectiveAt: z.date().optional(),
+  provider: z.string().optional(),
+  latestEventId: z.string(),
+  latestEventAt: z.date(),
+  projectedAt: z.date()
+});
+const RBTenantSubscriptionProjectionSchema = new Schema$1({
+  tenantId: {
+    type: String,
+    required: true,
+    index: true
+  },
+  subscriptionId: {
+    type: String,
+    required: true
+  },
+  type: {
+    type: String,
+    required: true,
+    enum: ZRBTenantSubscriptionType.options
+  },
+  parentSubscriptionId: {
+    type: String
+  },
+  scope: {
+    type: String,
+    required: true,
+    enum: ZRBTenantSubscriptionScope.options
+  },
+  scopeId: {
+    type: String
+  },
+  planKey: {
+    type: String,
+    required: true
+  },
+  priceId: {
+    type: String
+  },
+  status: {
+    type: String,
+    required: true,
+    enum: ZRBTenantSubscriptionStatus.options
+  },
+  intervalUnit: {
+    type: String,
+    required: true,
+    enum: ZRBTenantSubscriptionIntervalUnit.options
+  },
+  intervalCount: {
+    type: Number,
+    required: true,
+    min: 1
+  },
+  modules: {
+    type: [String],
+    required: true,
+    default: []
+  },
+  billingAnchor: {
+    type: Date,
+    required: true
+  },
+  currentPeriodStart: {
+    type: Date,
+    required: true
+  },
+  currentPeriodEnd: {
+    type: Date,
+    required: true
+  },
+  cancelAtPeriodEnd: {
+    type: Boolean,
+    required: true,
+    default: false
+  },
+  cancelAt: {
+    type: Date
+  },
+  canceledAt: {
+    type: Date
+  },
+  scheduledPlanKey: {
+    type: String
+  },
+  scheduledPlanEffectiveAt: {
+    type: Date
+  },
+  provider: {
+    type: String
+  },
+  latestEventId: {
+    type: String,
+    required: true
+  },
+  latestEventAt: {
+    type: Date,
+    required: true
+  },
+  projectedAt: {
+    type: Date,
+    required: true
+  }
+});
+RBTenantSubscriptionProjectionSchema.index({
+  tenantId: 1,
+  subscriptionId: 1
+}, {
+  unique: true
+});
+RBTenantSubscriptionProjectionSchema.index({
+  tenantId: 1,
+  scope: 1,
+  scopeId: 1
 });
 const ZRBRtsCounter = z.object({
   _id: z.string(),
@@ -889,6 +1160,7 @@ const frameworkSchemas = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   RBRtsCounterSchema,
   RBTenantSchema,
   RBTenantSubscriptionEventSchema,
+  RBTenantSubscriptionProjectionSchema,
   RBUploadChunkSchema,
   RBUploadSessionPolicy,
   RBUploadSessionSchema,
@@ -907,8 +1179,12 @@ const frameworkSchemas = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   ZRBTenantSubscriptionChangeDirection,
   ZRBTenantSubscriptionEvent,
   ZRBTenantSubscriptionEventSource,
+  ZRBTenantSubscriptionEventType,
   ZRBTenantSubscriptionIntervalUnit,
+  ZRBTenantSubscriptionProjection,
+  ZRBTenantSubscriptionScope,
   ZRBTenantSubscriptionStatus,
+  ZRBTenantSubscriptionType,
   ZRBUploadChunk,
   ZRBUploadSession,
   ZRBUploadSessionStatus,
@@ -2045,6 +2321,123 @@ async function withTransaction(scope, fn, options) {
     await session.endSession();
   }
 }
+const getTransactionSession = (transaction) => {
+  if (!transaction || typeof transaction !== "object" || !("session" in transaction)) return void 0;
+  return transaction.session;
+};
+const toSubscriptionEvent = (document) => {
+  const parsed = ZRBTenantSubscriptionEvent.parse(document);
+  if (!document._id) throw new Error("Persisted subscription event is missing its id");
+  return {
+    ...parsed,
+    id: String(document._id)
+  };
+};
+const getExistingEventQuery = (event, tenantId) => ({
+  tenantId,
+  idempotencyKey: event.idempotencyKey
+});
+const isDuplicateKeyError = (error) => Boolean(error && typeof error === "object" && "code" in error && error.code === 11e3);
+const toProjectionDocument = (projection) => ({
+  tenantId: projection.tenantId,
+  subscriptionId: projection.subscriptionId,
+  type: projection.type,
+  parentSubscriptionId: projection.parentSubscriptionId ?? void 0,
+  scope: projection.scope,
+  scopeId: projection.scopeId ?? void 0,
+  planKey: projection.planKey,
+  priceId: projection.priceId ?? void 0,
+  status: projection.status,
+  intervalUnit: projection.intervalUnit,
+  intervalCount: projection.intervalCount,
+  modules: projection.modules,
+  billingAnchor: projection.billingAnchor,
+  currentPeriodStart: projection.currentPeriodStart,
+  currentPeriodEnd: projection.currentPeriodEnd,
+  cancelAtPeriodEnd: projection.cancelAtPeriodEnd,
+  cancelAt: projection.cancelAt ?? void 0,
+  canceledAt: projection.canceledAt ?? void 0,
+  scheduledPlanKey: projection.scheduledPlan?.planKey,
+  scheduledPlanEffectiveAt: projection.scheduledPlan?.effectiveAt,
+  provider: projection.provider ?? void 0,
+  latestEventId: projection.latestEventId,
+  latestEventAt: projection.latestEventAt,
+  projectedAt: projection.projectedAt
+});
+const createTenantBillingStorage = (params) => {
+  const findExistingEvent = async (query, transaction) => {
+    const EventModel = await models.get("RBTenantSubscriptionEvent", params.ctx);
+    const request = EventModel.findOne(query);
+    const session = getTransactionSession(transaction);
+    if (session) request.session(session);
+    const document = await request.lean();
+    return document ? toSubscriptionEvent(document) : null;
+  };
+  return {
+    runInTransaction: (operation) => withTransaction({
+      ctx: params.ctx
+    }, ({
+      session
+    }) => operation({
+      session
+    })),
+    createEvent: async (event, transaction) => {
+      if (event.tenantId !== params.tenantId) {
+        throw new Error("Billing event tenantId does not match the storage tenant");
+      }
+      const existingQuery = getExistingEventQuery(event, params.tenantId);
+      const existing = await findExistingEvent(existingQuery, transaction);
+      if (existing) return existing;
+      const EventModel = await models.get("RBTenantSubscriptionEvent", params.ctx);
+      const eventDocument = ZRBTenantSubscriptionEvent.parse(event);
+      const session = getTransactionSession(transaction);
+      try {
+        const documents = await EventModel.create([eventDocument], session ? {
+          session
+        } : void 0);
+        const document = documents[0]?.toObject();
+        if (!document) throw new Error("Subscription event was not persisted");
+        return toSubscriptionEvent(document);
+      } catch (error) {
+        if (!isDuplicateKeyError(error)) throw error;
+        const duplicate = await findExistingEvent(existingQuery, transaction);
+        if (!duplicate) throw error;
+        return duplicate;
+      }
+    },
+    listEvents: async (tenantId, subscriptionId, transaction) => {
+      if (tenantId !== params.tenantId) throw new Error("Billing storage tenant mismatch");
+      const EventModel = await models.get("RBTenantSubscriptionEvent", params.ctx);
+      const request = EventModel.find({
+        tenantId,
+        subscriptionId
+      }).sort({
+        effectiveAt: 1,
+        occurredAt: 1,
+        _id: 1
+      });
+      const session = getTransactionSession(transaction);
+      if (session) request.session(session);
+      const documents = await request.lean();
+      return documents.map(toSubscriptionEvent);
+    },
+    upsertProjection: async (projection, transaction) => {
+      if (projection.tenantId !== params.tenantId) throw new Error("Billing projection tenant mismatch");
+      const ProjectionModel = await models.get("RBTenantSubscriptionProjection", params.ctx);
+      const session = getTransactionSession(transaction);
+      await ProjectionModel.replaceOne({
+        tenantId: params.tenantId,
+        subscriptionId: projection.subscriptionId
+      }, toProjectionDocument(projection), {
+        upsert: true,
+        runValidators: true,
+        ...session ? {
+          session
+        } : {}
+      });
+    }
+  };
+};
 export {
   E as E164_PHONE_OR_EMPTY_REGEX,
   a2 as E164_PHONE_REGEX,
@@ -2061,6 +2454,7 @@ export {
   RBRtsCounterSchema,
   RBTenantSchema,
   RBTenantSubscriptionEventSchema,
+  RBTenantSubscriptionProjectionSchema,
   RBUploadChunkSchema,
   RBUploadSessionPolicy,
   RBUploadSessionSchema,
@@ -2080,8 +2474,12 @@ export {
   ZRBTenantSubscriptionChangeDirection,
   ZRBTenantSubscriptionEvent,
   ZRBTenantSubscriptionEventSource,
+  ZRBTenantSubscriptionEventType,
   ZRBTenantSubscriptionIntervalUnit,
+  ZRBTenantSubscriptionProjection,
+  ZRBTenantSubscriptionScope,
   ZRBTenantSubscriptionStatus,
+  ZRBTenantSubscriptionType,
   ZRBUploadChunk,
   ZRBUploadSession,
   ZRBUploadSessionStatus,
@@ -2092,6 +2490,7 @@ export {
   buildSearchTextStage,
   c as can,
   createModels,
+  createTenantBillingStorage,
   ensureSearchIndex,
   extendMongooseSchema,
   e2 as extendZod,