@onesub/server 0.20.0 → 0.21.0

package/dist/__tests__/purchase-product-lookup.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Product-scoped purchase lookup — `PurchaseStore.getPurchasesForProduct`.
+ *
+ * Non-consumable validation used to read a user's entire purchase history and
+ * filter it in process, so an account with a long consumable history paid for
+ * every one of those rows on each lifetime-product purchase. The optional
+ * store method pushes the filter into an index instead.
+ *
+ * Covered here:
+ *   - the store contract, including the most-recent-first ordering all three
+ *     built-in stores must agree on
+ *   - that the route actually uses the index-backed method when a store has one
+ *     (responses are identical either way, so only a call count shows it)
+ *   - that a store without the method still works, since it is optional
+ */
+export {};
+//# sourceMappingURL=purchase-product-lookup.test.d.ts.map

package/dist/__tests__/purchase-product-lookup.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"purchase-product-lookup.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/purchase-product-lookup.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}

package/dist/index.cjs

@@ -91,11 +91,17 @@ var InMemoryPurchaseStore = class {
     }
     this.byTransactionId.set(purchase.transactionId, purchase);
     const list = this.byUserId.get(purchase.userId) ?? [];
-    list.push(purchase);
+    const at = Date.parse(purchase.purchasedAt);
+    const idx = list.findIndex((p) => Date.parse(p.purchasedAt) < at);
+    if (idx === -1) list.push(purchase);
+    else list.splice(idx, 0, purchase);
     this.byUserId.set(purchase.userId, list);
   }
   async getPurchasesByUserId(userId) {
-    return this.byUserId.get(userId) ?? [];
+    return [...this.byUserId.get(userId) ?? []];
+  }
+  async getPurchasesForProduct(userId, productId) {
+    return (this.byUserId.get(userId) ?? []).filter((p) => p.productId === productId);
   }
   async getPurchaseByTransactionId(txId) {
     return this.byTransactionId.get(txId) ?? null;
@@ -1981,6 +1987,13 @@ var purchaseStatusQuerySchema = zod.z.object({
   userId: zod.z.string().min(1).max(256),
   productId: zod.z.string().min(1).max(256).optional()
 });
+async function purchasesForProduct(purchaseStore, userId, productId) {
+  if (purchaseStore.getPurchasesForProduct) {
+    return purchaseStore.getPurchasesForProduct(userId, productId);
+  }
+  const all = await purchaseStore.getPurchasesByUserId(userId);
+  return all.filter((p) => p.productId === productId);
+}
 function createPurchaseRouter(config, purchaseStore) {
   const router = express.Router();
   const registry = getAppRegistry(config);
@@ -2002,9 +2015,7 @@ function createPurchaseRouter(config, purchaseStore) {
     });
     try {
       if (type === shared.PURCHASE_TYPE.NON_CONSUMABLE) {
-        const owned = (await purchaseStore.getPurchasesByUserId(userId)).find(
-          (p) => p.productId === productId
-        );
+        const owned = (await purchasesForProduct(purchaseStore, userId, productId))[0];
         if (owned) {
           const response2 = {
             valid: true,
@@ -2134,10 +2145,7 @@ function createPurchaseRouter(config, purchaseStore) {
     }
     const { userId, productId } = query;
     try {
-      let purchases = await purchaseStore.getPurchasesByUserId(userId);
-      if (productId !== void 0) {
-        purchases = purchases.filter((p) => p.productId === productId);
-      }
+      const purchases = productId !== void 0 ? await purchasesForProduct(purchaseStore, userId, productId) : await purchaseStore.getPurchasesByUserId(userId);
       const response = { purchases };
       res.status(200).json(response);
     } catch (err2) {
@@ -3113,6 +3121,26 @@ var PostgresPurchaseStore = class {
     );
     return result.rows.map(rowToPurchaseInfo);
   }
+  /**
+   * Purchases for one user + product, most-recent-first.
+   *
+   * Same shape and ordering as `getPurchasesByUserId`, with `product_id` pushed
+   * into the WHERE clause instead of filtered in process. Non-consumables also
+   * have a partial unique index on `(user_id, product_id)`, so the ownership
+   * check this backs is a single index lookup rather than a full read of the
+   * user's purchase history.
+   */
+  async getPurchasesForProduct(userId, productId) {
+    const pool = await this.getPool();
+    const result = await pool.query(
+      `SELECT *
+         FROM onesub_purchases
+        WHERE user_id = $1 AND product_id = $2
+        ORDER BY purchased_at DESC`,
+      [userId, productId]
+    );
+    return result.rows.map(rowToPurchaseInfo);
+  }
   async getPurchaseByTransactionId(txId) {
     const pool = await this.getPool();
     const result = await pool.query(
@@ -3323,6 +3351,23 @@ var RedisPurchaseStore = class {
     const raws = await this.redis.mget(...ids.map((id) => PUR_TX_PREFIX + id));
     return raws.filter((r) => r != null).map((r) => JSON.parse(r));
   }
+  /**
+   * Purchases for one user + product, most-recent-first.
+   *
+   * Served from the `user_product` set that `savePurchase` already maintains for
+   * `hasPurchased`, so this reads only the rows for this product rather than the
+   * user's whole purchase history.
+   *
+   * That set is unordered — unlike the per-user sorted set — so the
+   * most-recent-first contract is restored by an explicit sort here. The row
+   * count is per-product, so this is small.
+   */
+  async getPurchasesForProduct(userId, productId) {
+    const ids = await this.redis.smembers(PUR_USER_PRODUCT_PREFIX + userId + ":" + productId);
+    if (ids.length === 0) return [];
+    const raws = await this.redis.mget(...ids.map((id) => PUR_TX_PREFIX + id));
+    return raws.filter((r) => r != null).map((r) => JSON.parse(r)).sort((a, b) => Date.parse(b.purchasedAt) - Date.parse(a.purchasedAt));
+  }
   async getPurchaseByTransactionId(txId) {
     const raw = await this.redis.get(PUR_TX_PREFIX + txId);
     return raw ? JSON.parse(raw) : null;