payment-kit 1.25.8 → 1.26.0

package/api/src/routes/meters.ts

@@ -137,6 +137,34 @@ router.post('/', auth, async (req, res) => {
   }
 });
 
+// Public endpoint: only returns safe fields, no auth required
+const PUBLIC_METER_FIELDS = ['id', 'name', 'event_name', 'status', 'unit', 'description', 'currency_id'] as const;
+
+router.get('/public/:id', async (req, res) => {
+  try {
+    const meter = await Meter.findOne({
+      where: {
+        [Op.or]: [{ id: req.params.id }, { event_name: req.params.id }],
+      },
+      include: [{ model: PaymentCurrency, as: 'paymentCurrency' }],
+    });
+
+    if (!meter) {
+      return res.status(404).json({ error: 'Meter not found' });
+    }
+
+    return res.json({
+      ...pick(meter.toJSON(), PUBLIC_METER_FIELDS),
+      paymentCurrency: (meter as any).paymentCurrency
+        ? pick((meter as any).paymentCurrency.toJSON(), ['id', 'name', 'symbol', 'decimal', 'logo', 'type'])
+        : null,
+    });
+  } catch (err) {
+    logger.error('get public meter failed', { error: err?.message, meterId: req.params.id });
+    return res.status(400).json({ error: err?.message });
+  }
+});
+
 router.get('/:id', auth, async (req, res) => {
   try {
     const meter = await Meter.findOne({

package/api/src/routes/payment-stats.ts

@@ -11,6 +11,7 @@ import { ethWallet, wallet } from '../libs/auth';
 import dayjs from '../libs/dayjs';
 import { authenticate } from '../libs/security';
 import {
+  CreditGrant,
   EVMChainType,
   Invoice,
   InvoiceItem,
@@ -20,6 +21,7 @@ import {
   PaymentStat,
   Payout,
   Refund,
+  RevenueSnapshot,
   Subscription,
 } from '../store/models';
 import { EVM_CHAIN_TYPES } from '../libs/constants';
@@ -121,7 +123,9 @@ async function getCurrencyLinks(livemode: boolean) {
 
 type RevenueStats = {
   totalRevenue: string;
+  refundAmount: string;
   promotionCost: string;
+  creditGrantCost: string;
   vendorCost: string;
   taxedRevenue: string;
   netRevenue: string;
@@ -129,7 +133,9 @@ type RevenueStats = {
 
 const ZERO_REVENUE_STATS: RevenueStats = {
   totalRevenue: '0',
+  refundAmount: '0',
   promotionCost: '0',
+  creditGrantCost: '0',
   vendorCost: '0',
   taxedRevenue: '0',
   netRevenue: '0',
@@ -202,6 +208,62 @@ async function getTaxedInvoiceIds(
 
 async function getRevenueStats(livemode: boolean, currencyId?: string, start?: number, end?: number) {
   const currencyFilter = currencyId ? [currencyId] : undefined;
+  const byCurrency: Record<string, RevenueStats> = {};
+
+  // Step 1: Query snapshots within the date range
+  const snapshotWhere: WhereOptions = { livemode };
+  if (currencyId) {
+    snapshotWhere.currency_id = currencyId;
+  }
+  if (start || end) {
+    snapshotWhere.timestamp = {};
+    if (start) {
+      (snapshotWhere.timestamp as any)[Op.gte] = start;
+    }
+    if (end) {
+      (snapshotWhere.timestamp as any)[Op.lt] = end;
+    }
+  }
+
+  const snapshots = await RevenueSnapshot.findAll({ where: snapshotWhere });
+
+  // Track the latest snapshot end timestamp to avoid double counting
+  // Each snapshot's timestamp is month start, so the data covers [timestamp, timestamp + 1 month)
+  let latestSnapshotEnd = 0;
+
+  for (const snapshot of snapshots) {
+    const id = snapshot.currency_id;
+    if (!byCurrency[id]) {
+      byCurrency[id] = { ...ZERO_REVENUE_STATS };
+    }
+    const entry = byCurrency[id]!;
+    entry.totalRevenue = new BN(entry.totalRevenue).add(new BN(snapshot.total_revenue || '0')).toString();
+    entry.refundAmount = new BN(entry.refundAmount).add(new BN(snapshot.refund_amount || '0')).toString();
+    entry.promotionCost = new BN(entry.promotionCost).add(new BN(snapshot.promotion_cost || '0')).toString();
+    entry.creditGrantCost = new BN(entry.creditGrantCost).add(new BN(snapshot.credit_grant_cost || '0')).toString();
+    entry.vendorCost = new BN(entry.vendorCost).add(new BN(snapshot.vendor_cost || '0')).toString();
+    entry.taxedRevenue = new BN(entry.taxedRevenue).add(new BN(snapshot.taxed_revenue || '0')).toString();
+    entry.netRevenue = new BN(entry.netRevenue).add(new BN(snapshot.net_revenue || '0')).toString();
+
+    // Calculate the end of this snapshot's coverage (start of next month)
+    const snapshotEndTimestamp = dayjs.unix(snapshot.timestamp).add(1, 'month').startOf('month').unix();
+    if (snapshotEndTimestamp > latestSnapshotEnd) {
+      latestSnapshotEnd = snapshotEndTimestamp;
+    }
+  }
+
+  // Step 2: Query live data only for time AFTER the latest snapshot
+  // This prevents double counting data that's already in snapshots
+  const liveDataStart = latestSnapshotEnd > 0 ? Math.max(latestSnapshotEnd, start || 0) : start;
+  const liveDataEnd = end;
+
+  // Skip live data query if the requested range is entirely covered by snapshots
+  if (liveDataStart && liveDataEnd && liveDataStart >= liveDataEnd) {
+    if (Object.keys(byCurrency).length === 0 && currencyId) {
+      byCurrency[currencyId] = { ...ZERO_REVENUE_STATS };
+    }
+    return byCurrency;
+  }
 
   const invoiceWhere: WhereOptions = {
     livemode,
@@ -214,13 +276,13 @@ async function getRevenueStats(livemode: boolean, currencyId?: string, start?: n
     invoiceWhere.currency_id = invoiceCurrencyFilter;
   }
 
-  if (start || end) {
+  if (liveDataStart || liveDataEnd) {
     invoiceWhere.created_at = {};
-    if (start) {
-      invoiceWhere.created_at[Op.gte] = new Date(start * 1000);
+    if (liveDataStart) {
+      invoiceWhere.created_at[Op.gte] = new Date(liveDataStart * 1000);
     }
-    if (end) {
-      invoiceWhere.created_at[Op.lt] = new Date(end * 1000);
+    if (liveDataEnd) {
+      invoiceWhere.created_at[Op.lt] = new Date(liveDataEnd * 1000);
     }
   }
 
@@ -229,7 +291,7 @@ async function getRevenueStats(livemode: boolean, currencyId?: string, start?: n
       where: invoiceWhere,
       attributes: ['id', 'total', 'total_discount_amounts', 'currency_id'],
     }),
-    getTaxedInvoiceIds(livemode, currencyFilter, start, end),
+    getTaxedInvoiceIds(livemode, currencyFilter, liveDataStart, liveDataEnd),
   ]);
 
   const totalRevenueByCurrency: Record<string, string> = {};
@@ -255,6 +317,7 @@ async function getRevenueStats(livemode: boolean, currencyId?: string, start?: n
     }
   });
 
+  // Query payouts for live data period
   const payoutWhere: WhereOptions = {
     livemode,
     status: { [Op.in]: ['paid', 'deferred'] },
@@ -266,13 +329,13 @@ async function getRevenueStats(livemode: boolean, currencyId?: string, start?: n
     payoutWhere.currency_id = payoutCurrencyFilter;
   }
 
-  if (start || end) {
+  if (liveDataStart || liveDataEnd) {
     payoutWhere.created_at = {};
-    if (start) {
-      payoutWhere.created_at[Op.gte] = new Date(start * 1000);
+    if (liveDataStart) {
+      payoutWhere.created_at[Op.gte] = new Date(liveDataStart * 1000);
     }
-    if (end) {
-      payoutWhere.created_at[Op.lt] = new Date(end * 1000);
+    if (liveDataEnd) {
+      payoutWhere.created_at[Op.lt] = new Date(liveDataEnd * 1000);
     }
   }
 
@@ -286,32 +349,116 @@ async function getRevenueStats(livemode: boolean, currencyId?: string, start?: n
     addToMap(vendorCostByCurrency, payout.currency_id, payout.amount || '0');
   });
 
+  // Query refunds for live data period
+  const refundWhere: WhereOptions = {
+    livemode,
+    status: 'succeeded',
+  };
+  const refundCurrencyFilter = buildCurrencyFilter(currencyFilter);
+  if (refundCurrencyFilter) {
+    refundWhere.currency_id = refundCurrencyFilter;
+  }
+  if (liveDataStart || liveDataEnd) {
+    refundWhere.created_at = {};
+    if (liveDataStart) {
+      refundWhere.created_at[Op.gte] = new Date(liveDataStart * 1000);
+    }
+    if (liveDataEnd) {
+      refundWhere.created_at[Op.lt] = new Date(liveDataEnd * 1000);
+    }
+  }
+
+  const refunds = await Refund.findAll({
+    where: refundWhere,
+    attributes: ['amount', 'currency_id'],
+  });
+
+  const refundAmountByCurrency: Record<string, string> = {};
+  refunds.forEach((refund) => {
+    addToMap(refundAmountByCurrency, refund.currency_id, refund.amount || '0');
+  });
+
+  // Query credit grants for live data period
+  // Include granted (active), depleted, and expired - all have consumed portions
+  // Exclude: pending (not yet active), voided (revoked, not a cost)
+  // Cost = amount - remaining_amount (the actually consumed portion)
+  const creditGrantWhere: WhereOptions = {
+    livemode,
+    status: { [Op.in]: ['granted', 'depleted', 'expired'] },
+  };
+  const creditGrantCurrencyFilter = buildCurrencyFilter(currencyFilter);
+  if (creditGrantCurrencyFilter) {
+    creditGrantWhere.currency_id = creditGrantCurrencyFilter;
+  }
+  if (liveDataStart || liveDataEnd) {
+    creditGrantWhere.created_at = {};
+    if (liveDataStart) {
+      creditGrantWhere.created_at[Op.gte] = new Date(liveDataStart * 1000);
+    }
+    if (liveDataEnd) {
+      creditGrantWhere.created_at[Op.lt] = new Date(liveDataEnd * 1000);
+    }
+  }
+
+  const creditGrants = await CreditGrant.findAll({
+    where: creditGrantWhere,
+    attributes: ['amount', 'remaining_amount', 'currency_id'],
+  });
+
+  const creditGrantCostByCurrency: Record<string, string> = {};
+  creditGrants.forEach((grant) => {
+    // Cost = consumed amount = total amount - remaining amount
+    const consumed = new BN(grant.amount || '0').sub(new BN(grant.remaining_amount || '0'));
+    addToMap(creditGrantCostByCurrency, grant.currency_id, consumed.toString());
+  });
+
+  // Merge live data with snapshot data
   const currencySet = new Set<string>(currencyFilter || []);
-  [totalRevenueByCurrency, promotionCostByCurrency, taxedRevenueByCurrency, vendorCostByCurrency].forEach((map) => {
+  [
+    totalRevenueByCurrency,
+    promotionCostByCurrency,
+    taxedRevenueByCurrency,
+    vendorCostByCurrency,
+    refundAmountByCurrency,
+    creditGrantCostByCurrency,
+  ].forEach((map) => {
     Object.keys(map).forEach((id) => currencySet.add(id));
   });
+  Object.keys(byCurrency).forEach((id) => currencySet.add(id));
 
   const currencyList = Array.from(currencySet);
-  const byCurrency: Record<string, RevenueStats> = {};
 
   currencyList.forEach((id) => {
-    const totalRevenue = totalRevenueByCurrency[id] || '0';
-    const promotionCost = promotionCostByCurrency[id] || '0';
-    const taxedRevenue = taxedRevenueByCurrency[id] || '0';
-    const vendorCost = vendorCostByCurrency[id] || '0';
+    const snapshotData = byCurrency[id] || ZERO_REVENUE_STATS;
+    const liveTotal = totalRevenueByCurrency[id] || '0';
+    const liveRefund = refundAmountByCurrency[id] || '0';
+    const livePromotion = promotionCostByCurrency[id] || '0';
+    const liveCreditGrant = creditGrantCostByCurrency[id] || '0';
+    const liveTaxed = taxedRevenueByCurrency[id] || '0';
+    const liveVendor = vendorCostByCurrency[id] || '0';
+
+    const totalRevenue = new BN(snapshotData.totalRevenue).add(new BN(liveTotal)).toString();
+    const refundAmount = new BN(snapshotData.refundAmount).add(new BN(liveRefund)).toString();
+    const promotionCost = new BN(snapshotData.promotionCost).add(new BN(livePromotion)).toString();
+    const creditGrantCost = new BN(snapshotData.creditGrantCost).add(new BN(liveCreditGrant)).toString();
+    const taxedRevenue = new BN(snapshotData.taxedRevenue).add(new BN(liveTaxed)).toString();
+    const vendorCost = new BN(snapshotData.vendorCost).add(new BN(liveVendor)).toString();
+    // Net Revenue = Total Revenue - Refunds
+    const netRevenue = new BN(totalRevenue).sub(new BN(refundAmount)).toString();
 
     const includeEntry =
-      hasNonZeroValue([totalRevenue, promotionCost, taxedRevenue, vendorCost]) || Boolean(currencyFilter);
+      hasNonZeroValue([totalRevenue, refundAmount, promotionCost, creditGrantCost, taxedRevenue, vendorCost]) ||
+      Boolean(currencyFilter);
 
     if (!includeEntry) {
       return;
     }
 
-    const netRevenue = new BN(totalRevenue).sub(new BN(vendorCost)).toString();
-
     byCurrency[id] = {
       totalRevenue,
+      refundAmount,
       promotionCost,
+      creditGrantCost,
       vendorCost,
       taxedRevenue,
       netRevenue,

package/api/src/store/migrations/20260203-archive.ts

@@ -0,0 +1,12 @@
+import type { Migration } from '../migrate';
+import models from '../models';
+
+export const up: Migration = async ({ context }) => {
+  await context.createTable('archive_metadata', models.ArchiveMetadata.GENESIS_ATTRIBUTES);
+  await context.createTable('archive_locks', models.ArchiveLock.GENESIS_ATTRIBUTES);
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.dropTable('archive_metadata');
+  await context.dropTable('archive_locks');
+};

package/api/src/store/migrations/20260204-revenue-snapshot.ts

@@ -0,0 +1,19 @@
+import type { Migration } from '../migrate';
+import { createIndexIfNotExists } from '../migrate';
+import models from '../models';
+
+export const up: Migration = async ({ context }) => {
+  await context.createTable('revenue_snapshots', models.RevenueSnapshot.GENESIS_ATTRIBUTES);
+  await createIndexIfNotExists(
+    context,
+    'revenue_snapshots',
+    ['timestamp', 'currency_id', 'livemode', 'period_type'],
+    'idx_revenue_snapshots_unique',
+    { unique: true }
+  );
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeIndex('revenue_snapshots', 'idx_revenue_snapshots_unique');
+  await context.dropTable('revenue_snapshots');
+};

package/api/src/store/models/archive-lock.ts

@@ -0,0 +1,55 @@
+/* eslint-disable @typescript-eslint/lines-between-class-members */
+import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model } from 'sequelize';
+
+export class ArchiveLock extends Model<InferAttributes<ArchiveLock>, InferCreationAttributes<ArchiveLock>> {
+  declare id: CreationOptional<string>;
+  declare locked_by?: string | null;
+  declare locked_at?: number | null;
+  declare expires_at?: number | null;
+  declare created_at: CreationOptional<Date>;
+  declare updated_at: CreationOptional<Date>;
+
+  public static readonly GENESIS_ATTRIBUTES = {
+    id: {
+      type: DataTypes.STRING(40),
+      primaryKey: true,
+      allowNull: false,
+    },
+    locked_by: {
+      type: DataTypes.STRING(64),
+      allowNull: true,
+    },
+    locked_at: {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+    },
+    expires_at: {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+    },
+    created_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+    updated_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+  };
+
+  public static initialize(sequelize: any) {
+    this.init(ArchiveLock.GENESIS_ATTRIBUTES, {
+      sequelize,
+      modelName: 'ArchiveLock',
+      tableName: 'archive_locks',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+    });
+  }
+
+  public static associate() {}
+}
+
+export type TArchiveLock = InferAttributes<ArchiveLock>;

package/api/src/store/models/archive-metadata.ts

@@ -0,0 +1,132 @@
+/* eslint-disable @typescript-eslint/lines-between-class-members */
+import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model } from 'sequelize';
+
+export class ArchiveMetadata extends Model<InferAttributes<ArchiveMetadata>, InferCreationAttributes<ArchiveMetadata>> {
+  declare id: CreationOptional<string>;
+  declare archive_file: string;
+  declare created_at: CreationOptional<Date>;
+  declare updated_at: CreationOptional<Date>;
+
+  declare date_range_start: number;
+  declare date_range_end: number;
+
+  declare tables: Record<
+    string,
+    {
+      archived_count: number;
+      deleted_count: number;
+      failed_count: number;
+      failed_ids?: string[];
+    }
+  >;
+  declare total_records: number;
+
+  declare checksum?: string;
+  declare file_size?: number;
+
+  declare duration_ms?: number;
+  declare triggered_by: 'cron' | 'manual';
+  declare triggered_by_user_id?: string;
+  declare status: 'completed' | 'failed' | 'in_progress';
+  declare error?: string;
+
+  declare query_count: number;
+  declare query_actor_ids?: string[];
+  declare last_queried_at?: number;
+
+  public static readonly GENESIS_ATTRIBUTES = {
+    id: {
+      type: DataTypes.STRING(40),
+      primaryKey: true,
+      allowNull: false,
+    },
+    archive_file: {
+      type: DataTypes.STRING(128),
+      allowNull: false,
+    },
+    date_range_start: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+    },
+    date_range_end: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+    },
+    tables: {
+      type: DataTypes.JSON,
+      allowNull: false,
+      defaultValue: {},
+    },
+    total_records: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      defaultValue: 0,
+    },
+    checksum: {
+      type: DataTypes.STRING(128),
+      allowNull: true,
+    },
+    file_size: {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+    },
+    duration_ms: {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+    },
+    triggered_by: {
+      type: DataTypes.ENUM('cron', 'manual'),
+      allowNull: false,
+    },
+    triggered_by_user_id: {
+      type: DataTypes.STRING(64),
+      allowNull: true,
+    },
+    status: {
+      type: DataTypes.ENUM('completed', 'failed', 'in_progress'),
+      allowNull: false,
+    },
+    error: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+    },
+    query_count: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      defaultValue: 0,
+    },
+    query_actor_ids: {
+      type: DataTypes.JSON,
+      allowNull: true,
+      defaultValue: [],
+    },
+    last_queried_at: {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+    },
+    created_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+    updated_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+  };
+
+  public static initialize(sequelize: any) {
+    this.init(ArchiveMetadata.GENESIS_ATTRIBUTES, {
+      sequelize,
+      modelName: 'ArchiveMetadata',
+      tableName: 'archive_metadata',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+    });
+  }
+
+  public static associate() {}
+}
+
+export type TArchiveMetadata = InferAttributes<ArchiveMetadata>;

package/api/src/store/models/index.ts

@@ -36,6 +36,9 @@ import { ProductVendor } from './product-vendor';
 import { TaxRate } from './tax-rate';
 import { ExchangeRateProvider } from './exchange-rate-provider';
 import { PriceQuote } from './price-quote';
+import { ArchiveMetadata } from './archive-metadata';
+import { ArchiveLock } from './archive-lock';
+import { RevenueSnapshot } from './revenue-snapshot';
 
 const models = {
   CheckoutSession,
@@ -75,6 +78,9 @@ const models = {
   TaxRate,
   ExchangeRateProvider,
   PriceQuote,
+  ArchiveMetadata,
+  ArchiveLock,
+  RevenueSnapshot,
 };
 
 export function initialize(sequelize: any) {
@@ -128,6 +134,9 @@ export * from './product-vendor';
 export * from './tax-rate';
 export * from './exchange-rate-provider';
 export * from './price-quote';
+export * from './archive-metadata';
+export * from './archive-lock';
+export * from './revenue-snapshot';
 
 export type TPriceExpanded = TPrice & {
   object: 'price';

package/api/src/store/models/revenue-snapshot.ts

@@ -0,0 +1,110 @@
+/* eslint-disable @typescript-eslint/lines-between-class-members */
+import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model } from 'sequelize';
+
+import { createIdGenerator } from '../../libs/util';
+
+const nextId = createIdGenerator('rs', 24);
+
+export class RevenueSnapshot extends Model<InferAttributes<RevenueSnapshot>, InferCreationAttributes<RevenueSnapshot>> {
+  declare id: CreationOptional<string>;
+  declare livemode: boolean;
+  declare currency_id: string;
+
+  declare timestamp: number;
+  declare period_type: 'monthly' | 'quarterly';
+
+  declare total_revenue: string;
+  declare refund_amount: string;
+  declare promotion_cost: string;
+  declare credit_grant_cost: string;
+  declare vendor_cost: string;
+  declare taxed_revenue: string;
+  declare net_revenue: string;
+
+  declare archive_metadata_id: CreationOptional<string>;
+
+  declare created_at: CreationOptional<Date>;
+  declare updated_at: CreationOptional<Date>;
+
+  public static readonly GENESIS_ATTRIBUTES = {
+    id: {
+      type: DataTypes.STRING(30),
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: nextId,
+    },
+    livemode: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+    },
+    currency_id: {
+      type: DataTypes.STRING(16),
+      allowNull: false,
+    },
+    timestamp: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+    },
+    period_type: {
+      type: DataTypes.ENUM('monthly', 'quarterly'),
+      allowNull: false,
+      defaultValue: 'monthly',
+    },
+    total_revenue: {
+      type: DataTypes.STRING(64),
+      defaultValue: '0',
+    },
+    refund_amount: {
+      type: DataTypes.STRING(64),
+      defaultValue: '0',
+    },
+    promotion_cost: {
+      type: DataTypes.STRING(64),
+      defaultValue: '0',
+    },
+    credit_grant_cost: {
+      type: DataTypes.STRING(64),
+      defaultValue: '0',
+    },
+    vendor_cost: {
+      type: DataTypes.STRING(64),
+      defaultValue: '0',
+    },
+    taxed_revenue: {
+      type: DataTypes.STRING(64),
+      defaultValue: '0',
+    },
+    net_revenue: {
+      type: DataTypes.STRING(64),
+      defaultValue: '0',
+    },
+    archive_metadata_id: {
+      type: DataTypes.STRING(40),
+      allowNull: true,
+    },
+    created_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+    updated_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+  };
+
+  public static initialize(sequelize: any) {
+    this.init(RevenueSnapshot.GENESIS_ATTRIBUTES, {
+      sequelize,
+      modelName: 'RevenueSnapshot',
+      tableName: 'revenue_snapshots',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+    });
+  }
+
+  public static associate() {}
+}
+
+export type TRevenueSnapshot = InferAttributes<RevenueSnapshot>;