@rpcbase/db 0.122.0 → 0.123.0

package/dist/billingStorage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"billingStorage.d.ts","sourceRoot":"","sources":["../src/billingStorage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EAIf,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAkE/C,eAAO,MAAM,0BAA0B,GAAI,QAAQ;IACjD,GAAG,EAAE,YAAY,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB,KAAG,cAwEH,CAAA"}
+{"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.js

@@ -3,7 +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 } from "@rpcbase/billing";
+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";
@@ -173,16 +173,15 @@ 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: ZRBTenantSubscriptionEventType,
+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(),
-  subscriptionType: ZRBTenantSubscriptionType.optional(),
+  subscriptionType: ZRBTenantSubscriptionType,
   parentSubscriptionId: z.string().optional(),
-  scope: ZRBTenantSubscriptionScope.optional(),
+  scope: ZRBTenantSubscriptionScope,
   scopeId: z.string().optional(),
   fromPlanKey: z.string().optional(),
   toPlanKey: z.string().optional(),
@@ -198,7 +197,7 @@ const ZRBTenantSubscriptionEvent = z.object({
   toPriceId: z.string().optional(),
   billingAnchor: z.date().optional(),
   supersedesEventId: z.string().optional(),
-  idempotencyKey: z.string().optional(),
+  idempotencyKey: z.string().trim().min(1),
   direction: ZRBTenantSubscriptionChangeDirection.optional(),
   actorUserId: z.string().optional(),
   source: ZRBTenantSubscriptionEventSource.optional(),
@@ -208,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,
@@ -235,54 +293,72 @@ const RBTenantSubscriptionEventSchema = new Schema$1({
   },
   subscriptionType: {
     type: String,
+    required: true,
     enum: ZRBTenantSubscriptionType.options
   },
   parentSubscriptionId: {
-    type: String
+    type: String,
+    required() {
+      return this.subscriptionType === "addon";
+    }
   },
   scope: {
     type: String,
+    required: true,
     enum: ZRBTenantSubscriptionScope.options
   },
   scopeId: {
-    type: String
+    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: {
@@ -292,13 +368,15 @@ const RBTenantSubscriptionEventSchema = new Schema$1({
     type: String
   },
   billingAnchor: {
-    type: Date
+    type: Date,
+    required: requiredForEventTypes("created")
   },
   supersedesEventId: {
     type: String
   },
   idempotencyKey: {
-    type: String
+    type: String,
+    required: true
   },
   direction: {
     type: String,
@@ -338,14 +416,20 @@ RBTenantSubscriptionEventSchema.index({
   providerEventId: 1
 }, {
   unique: true,
-  sparse: true
+  partialFilterExpression: {
+    provider: {
+      $type: "string"
+    },
+    providerEventId: {
+      $type: "string"
+    }
+  }
 });
 RBTenantSubscriptionEventSchema.index({
   tenantId: 1,
   idempotencyKey: 1
 }, {
-  unique: true,
-  sparse: true
+  unique: true
 });
 const ZRBTenantSubscriptionProjection = z.object({
   tenantId: z.string(),
@@ -2243,26 +2327,16 @@ const getTransactionSession = (transaction) => {
 };
 const toSubscriptionEvent = (document) => {
   const parsed = ZRBTenantSubscriptionEvent.parse(document);
+  if (!document._id) throw new Error("Persisted subscription event is missing its id");
   return {
     ...parsed,
-    id: document._id ? String(document._id) : void 0
+    id: String(document._id)
   };
 };
-const getExistingEventQuery = (event, tenantId) => {
-  if (event.idempotencyKey) {
-    return {
-      tenantId,
-      idempotencyKey: event.idempotencyKey
-    };
-  }
-  if (event.provider && event.providerEventId) {
-    return {
-      provider: event.provider,
-      providerEventId: event.providerEventId
-    };
-  }
-  return null;
-};
+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,
@@ -2308,16 +2382,14 @@ const createTenantBillingStorage = (params) => {
       session
     })),
     createEvent: async (event, transaction) => {
-      const existingQuery = getExistingEventQuery(event, params.tenantId);
-      if (existingQuery) {
-        const existing = await findExistingEvent(existingQuery, transaction);
-        if (existing) return existing;
+      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,
-        tenantId: params.tenantId
-      });
+      const eventDocument = ZRBTenantSubscriptionEvent.parse(event);
       const session = getTransactionSession(transaction);
       try {
         const documents = await EventModel.create([eventDocument], session ? {
@@ -2327,10 +2399,10 @@ const createTenantBillingStorage = (params) => {
         if (!document) throw new Error("Subscription event was not persisted");
         return toSubscriptionEvent(document);
       } catch (error) {
-        if (!existingQuery || !isDuplicateKeyError(error)) throw error;
-        const existing = await findExistingEvent(existingQuery, transaction);
-        if (!existing) throw error;
-        return existing;
+        if (!isDuplicateKeyError(error)) throw error;
+        const duplicate = await findExistingEvent(existingQuery, transaction);
+        if (!duplicate) throw error;
+        return duplicate;
       }
     },
     listEvents: async (tenantId, subscriptionId, transaction) => {