@rpcbase/db 0.121.0 → 0.122.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,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"}

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 } 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,23 @@ 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(),
+  type: ZRBTenantSubscriptionEventType,
   occurredAt: z.date(),
-  effectiveAt: z.date().optional(),
+  effectiveAt: z.date(),
+  subscriptionType: ZRBTenantSubscriptionType.optional(),
+  parentSubscriptionId: z.string().optional(),
+  scope: ZRBTenantSubscriptionScope.optional(),
+  scopeId: z.string().optional(),
   fromPlanKey: z.string().optional(),
   toPlanKey: z.string().optional(),
   fromStatus: ZRBTenantSubscriptionStatus.optional(),
@@ -186,6 +194,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().optional(),
   direction: ZRBTenantSubscriptionChangeDirection.optional(),
   actorUserId: z.string().optional(),
   source: ZRBTenantSubscriptionEventSource.optional(),
@@ -208,7 +221,8 @@ const RBTenantSubscriptionEventSchema = new Schema$1({
   },
   type: {
     type: String,
-    required: true
+    required: true,
+    enum: ZRBTenantSubscriptionEventType.options
   },
   occurredAt: {
     type: Date,
@@ -216,7 +230,22 @@ const RBTenantSubscriptionEventSchema = new Schema$1({
     default: Date.now
   },
   effectiveAt: {
-    type: Date
+    type: Date,
+    required: true
+  },
+  subscriptionType: {
+    type: String,
+    enum: ZRBTenantSubscriptionType.options
+  },
+  parentSubscriptionId: {
+    type: String
+  },
+  scope: {
+    type: String,
+    enum: ZRBTenantSubscriptionScope.options
+  },
+  scopeId: {
+    type: String
   },
   fromPlanKey: {
     type: String
@@ -256,6 +285,21 @@ const RBTenantSubscriptionEventSchema = new Schema$1({
     type: Number,
     min: 1
   },
+  fromPriceId: {
+    type: String
+  },
+  toPriceId: {
+    type: String
+  },
+  billingAnchor: {
+    type: Date
+  },
+  supersedesEventId: {
+    type: String
+  },
+  idempotencyKey: {
+    type: String
+  },
   direction: {
     type: String,
     enum: ZRBTenantSubscriptionChangeDirection.options
@@ -286,6 +330,7 @@ const RBTenantSubscriptionEventSchema = new Schema$1({
 RBTenantSubscriptionEventSchema.index({
   tenantId: 1,
   subscriptionId: 1,
+  effectiveAt: 1,
   occurredAt: 1
 });
 RBTenantSubscriptionEventSchema.index({
@@ -295,6 +340,148 @@ RBTenantSubscriptionEventSchema.index({
   unique: true,
   sparse: true
 });
+RBTenantSubscriptionEventSchema.index({
+  tenantId: 1,
+  idempotencyKey: 1
+}, {
+  unique: true,
+  sparse: 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(),
   seq: z.number().int().min(0)
@@ -889,6 +1076,7 @@ const frameworkSchemas = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   RBRtsCounterSchema,
   RBTenantSchema,
   RBTenantSubscriptionEventSchema,
+  RBTenantSubscriptionProjectionSchema,
   RBUploadChunkSchema,
   RBUploadSessionPolicy,
   RBUploadSessionSchema,
@@ -907,8 +1095,12 @@ const frameworkSchemas = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   ZRBTenantSubscriptionChangeDirection,
   ZRBTenantSubscriptionEvent,
   ZRBTenantSubscriptionEventSource,
+  ZRBTenantSubscriptionEventType,
   ZRBTenantSubscriptionIntervalUnit,
+  ZRBTenantSubscriptionProjection,
+  ZRBTenantSubscriptionScope,
   ZRBTenantSubscriptionStatus,
+  ZRBTenantSubscriptionType,
   ZRBUploadChunk,
   ZRBUploadSession,
   ZRBUploadSessionStatus,
@@ -2045,6 +2237,135 @@ 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);
+  return {
+    ...parsed,
+    id: document._id ? String(document._id) : void 0
+  };
+};
+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 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) => {
+      const existingQuery = getExistingEventQuery(event, params.tenantId);
+      if (existingQuery) {
+        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 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 (!existingQuery || !isDuplicateKeyError(error)) throw error;
+        const existing = await findExistingEvent(existingQuery, transaction);
+        if (!existing) throw error;
+        return existing;
+      }
+    },
+    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 +2382,7 @@ export {
   RBRtsCounterSchema,
   RBTenantSchema,
   RBTenantSubscriptionEventSchema,
+  RBTenantSubscriptionProjectionSchema,
   RBUploadChunkSchema,
   RBUploadSessionPolicy,
   RBUploadSessionSchema,
@@ -2080,8 +2402,12 @@ export {
   ZRBTenantSubscriptionChangeDirection,
   ZRBTenantSubscriptionEvent,
   ZRBTenantSubscriptionEventSource,
+  ZRBTenantSubscriptionEventType,
   ZRBTenantSubscriptionIntervalUnit,
+  ZRBTenantSubscriptionProjection,
+  ZRBTenantSubscriptionScope,
   ZRBTenantSubscriptionStatus,
+  ZRBTenantSubscriptionType,
   ZRBUploadChunk,
   ZRBUploadSession,
   ZRBUploadSessionStatus,
@@ -2092,6 +2418,7 @@ export {
   buildSearchTextStage,
   c as can,
   createModels,
+  createTenantBillingStorage,
   ensureSearchIndex,
   extendMongooseSchema,
   e2 as extendZod,