backend-manager 5.0.123 → 5.0.124

package/CLAUDE.md

@@ -646,44 +646,43 @@ npx bm firestore:delete users/test123 --emulator
 
 ### Overview
 
-Usage is tracked per-metric (e.g., `requests`, `marketing-subscribe`) with two counters:
-- `period`: Current month's count, reset on the 1st of each month
+Usage is tracked per-metric (e.g., `requests`, `sponsorships`) with four fields:
+- `monthly`: Current month's count, reset on the 1st of each month by cron
+- `daily`: Current day's count, reset every day by cron
 - `total`: All-time count, never resets
+- `last`: Object with `id`, `timestamp`, `timestampUNIX` of the last usage event
 
-### Product Rate Limit Modes
+### Limits & Daily Caps
 
-Products can set a `rateLimit` field to control how limits are enforced:
+Limits are always specified as **monthly** values in product config (e.g., `limits.requests = 100` means 100/month).
 
-| Value | Behavior | Default |
-|-------|----------|---------|
-| `'monthly'` | Full monthly limit available at any time | Yes |
-| `'daily'` | Proportional daily cap: `ceil(limit * dayOfMonth / daysInMonth)` | No |
+By default, limits are enforced with **daily caps** to prevent users from burning their entire monthly quota in a single day. Two checks are applied:
 
-Example config (not in the template — add per-product as needed):
+1. **Flat daily cap**: `ceil(monthlyLimit / daysInMonth)` — max uses per day
+   - e.g., 100/month in a 31-day month = `ceil(100/31)` = 4/day
+2. **Proportional monthly cap**: `ceil(monthlyLimit * dayOfMonth / daysInMonth)` — running total
+   - Prevents accumulating too much too fast even within daily limits
+   - e.g., Day 15 of a 30-day month with 100/month limit = max 50 used so far
+
+Products can opt out of daily caps by setting `rateLimit: 'monthly'` (default is `'daily'`):
 ```json
 {
   "id": "basic",
   "limits": { "requests": 100 },
-  "rateLimit": "daily"
+  "rateLimit": "monthly"
 }
 ```
 
-With `rateLimit: 'daily'` and 100 requests/month in a 30-day month:
-- Day 1: max 4 requests used so far
-- Day 15: max 50 requests used so far
-- Day 30: max 100 requests (full allocation)
-
-Unused days roll forward — a user who doesn't use the product for 2 weeks can use a burst later.
-
 ### Reset Schedule
 
 | Target | Frequency | What happens |
 |--------|-----------|-------------|
 | Local storage | Daily | Cleared entirely |
 | `usage` collection (unauthenticated) | Daily | Deleted entirely |
-| User doc `usage.*.period` (authenticated) | Monthly (1st) | Reset to 0 |
+| User doc `usage.*.daily` (authenticated) | Daily | Reset to 0 |
+| User doc `usage.*.monthly` (authenticated) | Monthly (1st) | Reset to 0 |
 
-The daily cron runs at midnight UTC (`0 0 * * *`). Authenticated user period resets only execute on the 1st of the month.
+The daily cron (`reset-usage.js`) runs at midnight UTC. It collects all users with non-zero counters across all metrics, then performs a single write per user to reset daily (and monthly on the 1st).
 
 ## Subscription System
 

package/README.md

@@ -473,7 +473,7 @@ const userProps = Manager.User(existingData, { defaults: true }).properties;
   affiliate: { code, referrals, referrer },
   activity: { lastActivity, created, geolocation, client },
   api: { clientId, privateKey },
-  usage: { requests: { period, total, last } },
+  usage: { requests: { monthly, daily, total, last } },
   personal: { birthday, gender, location, name, company, telephone },
   oauth2: {}
 }
@@ -519,13 +519,13 @@ const usage = await Manager.Usage().init(assistant, {
 });
 
 // Check and validate limits
-const currentUsage = usage.getUsage('requests');  // Get current period usage
-const limit = usage.getLimit('requests');         // Get plan limit
-await usage.validate('requests');                 // Throws if over limit
+const currentUsage = usage.getUsage('requests');  // Get current monthly usage
+const limit = usage.getLimit('requests');         // Get plan limit (monthly)
+await usage.validate('requests');                 // Throws if over daily or monthly limit
 
-// Increment usage
+// Increment usage (increments monthly, daily, and total counters)
 usage.increment('requests', 1);
-usage.set('requests', 0);  // Reset to specific value
+usage.set('requests', 0);  // Reset monthly to specific value
 
 // Save to Firestore
 await usage.update();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "5.0.123",
+  "version": "5.0.124",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {

package/src/manager/cron/daily/reset-usage.js

@@ -4,7 +4,8 @@
  * Runs daily at midnight UTC and handles different reset schedules:
  * - Local storage: cleared every day
  * - Unauthenticated usage collection: deleted every day
- * - Authenticated user period counters: reset on the 1st (or 2nd as grace window) of each month
+ * - Authenticated user daily counters: reset every day
+ * - Authenticated user monthly counters: reset on the 1st of each month
  */
 module.exports = async ({ Manager, assistant, context, libraries }) => {
   const storage = Manager.storage({ name: 'usage', temporary: true, clear: false, log: false });
@@ -12,24 +13,18 @@ module.exports = async ({ Manager, assistant, context, libraries }) => {
   assistant.log('Starting...');
 
   // Clear local storage (daily)
-  await clearLocal(assistant, storage);
+  clearLocal(assistant, storage);
 
   // Clear unauthenticated usage collection (daily)
   await clearUnauthenticatedUsage(assistant, libraries);
 
-  // Reset authenticated user periods (monthly - 1st or 2nd of month)
-  await resetAuthenticatedUsage(Manager, assistant, libraries);
+  // Reset authenticated user counters (daily + monthly on 1st)
+  await resetAuthenticated(Manager, assistant);
 };
 
-async function clearLocal(assistant, storage) {
-  assistant.log('[local]: Starting...');
-
-  assistant.log('[local]: storage(apps)', storage.get('apps', {}).value());
-  assistant.log('[local]: storage(users)', storage.get('users', {}).value());
-
-  // Clear storage
+function clearLocal(assistant, storage) {
+  assistant.log('[local]: Clearing...');
   storage.setState({}).write();
-
   assistant.log('[local]: Completed!');
 }
 
@@ -40,96 +35,107 @@ async function clearUnauthenticatedUsage(assistant, libraries) {
 
   await admin.firestore().recursiveDelete(admin.firestore().collection('usage'))
   .then(() => {
-    assistant.log('[unauthenticated]: Deleted usage collection');
+    assistant.log('[unauthenticated]: Completed!');
   })
   .catch((e) => {
     assistant.errorify(`Error deleting usage collection: ${e}`, { code: 500, log: true });
   });
 }
 
-async function resetAuthenticatedUsage(Manager, assistant, libraries) {
-  const { admin } = libraries;
-  const dayOfMonth = new Date().getDate();
-
-  // Only reset on the 1st of the month
-  if (dayOfMonth !== 1) {
-    assistant.log('[authenticated]: Skipping period reset (not the 1st of the month)');
-    return;
-  }
-
-  assistant.log('[authenticated]: Monthly reset starting...');
-
-  // Gather all unique metric names from ALL products
+async function resetAuthenticated(Manager, assistant) {
+  const isFirstOfMonth = new Date().getDate() === 1;
   const products = Manager.config.payment?.products || [];
-  const metrics = {};
 
+  // Gather all metric names from all products
+  const metricSet = { requests: true };
   for (const product of products) {
-    const limits = product.limits || {};
-
-    for (const key of Object.keys(limits)) {
-      metrics[key] = true;
+    for (const key of Object.keys(product.limits || {})) {
+      metricSet[key] = true;
     }
   }
+  const metricNames = Object.keys(metricSet);
 
-  // Ensure requests is always included
-  metrics.requests = true;
+  assistant.log(`[authenticated]: Resetting ${isFirstOfMonth ? 'daily + monthly' : 'daily'} for metrics`, metricNames);
 
-  const metricNames = Object.keys(metrics);
+  // Collect all user IDs that need resetting (deduplicated across metrics)
+  // Each entry maps uid -> { ref, usage } so we only write once per user
+  const usersToReset = {};
 
-  assistant.log('[authenticated]: Resetting metrics', metricNames);
-
-  // Reset each metric for users who have usage > 0
   for (const metric of metricNames) {
-    assistant.log(`[authenticated]: Resetting ${metric} for all users`);
-
-    await Manager.Utilities().iterateCollection((batch, index) => {
-      return new Promise(async (resolve, reject) => {
+    // Query users with daily > 0 for this metric
+    await Manager.Utilities().iterateCollection((batch) => {
+      return new Promise(async (resolve) => {
         for (const doc of batch.docs) {
-          const data = doc.data();
-
-          // Normalize the metric
-          data.usage = data.usage || {};
-          data.usage[metric] = data.usage[metric] || {};
-          data.usage[metric].period = data.usage[metric].period || 0;
-          data.usage[metric].total = data.usage[metric].total || 0;
-          data.usage[metric].last = data.usage[metric].last || {};
-
-          // Skip if already 0
-          if (data.usage[metric].period <= 0) {
-            continue;
+          if (!usersToReset[doc.id]) {
+            usersToReset[doc.id] = { ref: doc.ref, usage: doc.data().usage || {} };
           }
-
-          // Reset the metric
-          const original = data.usage[metric].period;
-          data.usage[metric].period = 0;
-
-          // Update the doc
-          await doc.ref.update({ usage: data.usage })
-          .then(r => {
-            assistant.log(`[authenticated]: Reset ${metric} for ${doc.id} (${original} -> 0)`);
-          })
-          .catch(e => {
-            assistant.errorify(`Error resetting ${metric} for ${doc.id}: ${e}`, { code: 500, log: true });
-          });
         }
-
         return resolve();
       });
     }, {
       collection: 'users',
       where: [
-        { field: `usage.${metric}.period`, operator: '>', value: 0 },
+        { field: `usage.${metric}.daily`, operator: '>', value: 0 },
       ],
       batchSize: 5000,
-      log: true,
+      log: false,
     })
-    .then((r) => {
-      assistant.log(`[authenticated]: Reset ${metric} for all users complete!`);
+    .catch(e => {
+      assistant.errorify(`Error querying ${metric}.daily: ${e}`, { code: 500, log: true });
+    });
+
+    // On the 1st, also query users with monthly > 0
+    if (isFirstOfMonth) {
+      await Manager.Utilities().iterateCollection((batch) => {
+        return new Promise(async (resolve) => {
+          for (const doc of batch.docs) {
+            if (!usersToReset[doc.id]) {
+              usersToReset[doc.id] = { ref: doc.ref, usage: doc.data().usage || {} };
+            }
+          }
+          return resolve();
+        });
+      }, {
+        collection: 'users',
+        where: [
+          { field: `usage.${metric}.monthly`, operator: '>', value: 0 },
+        ],
+        batchSize: 5000,
+        log: false,
+      })
+      .catch(e => {
+        assistant.errorify(`Error querying ${metric}.monthly: ${e}`, { code: 500, log: true });
+      });
+    }
+  }
+
+  const userIds = Object.keys(usersToReset);
+  assistant.log(`[authenticated]: Found ${userIds.length} users to reset`);
+
+  // Single write per user: reset daily (always) + monthly (on 1st) for all metrics
+  for (const uid of userIds) {
+    const { ref, usage } = usersToReset[uid];
+
+    for (const metric of metricNames) {
+      if (!usage[metric]) {
+        continue;
+      }
+
+      usage[metric].daily = 0;
+
+      if (isFirstOfMonth) {
+        usage[metric].monthly = 0;
+      }
+    }
+
+    await ref.update({ usage })
+    .then(() => {
+      assistant.log(`[authenticated]: Reset ${uid}`);
     })
     .catch(e => {
-      assistant.errorify(`Error resetting ${metric} for all users: ${e}`, { code: 500, log: true });
+      assistant.errorify(`Error resetting ${uid}: ${e}`, { code: 500, log: true });
     });
   }
 
-  assistant.log('[authenticated]: Monthly reset completed!');
+  assistant.log(`[authenticated]: Completed!`);
 }

package/src/manager/helpers/usage.js

@@ -114,18 +114,18 @@ Usage.prototype.validate = function (name, options) {
     options._forceReject = typeof options._forceReject === 'undefined' ? false : options._forceReject;
 
     // Check for required options
-    const period = self.getUsage(name);
+    const monthly = self.getUsage(name);
     const allowed = self.getLimit(name);
 
     // Log (independent of options.log because this is important)
     if (options.log) {
-      assistant.log(`Usage.validate(): Checking ${period}/${allowed} for ${name} (${self.key})...`);
+      assistant.log(`Usage.validate(): Checking ${monthly}/${allowed} for ${name} (${self.key})...`);
     }
 
     // Reject function
     function _reject() {
       reject(
-        assistant.errorify(`You have exceeded your ${name} usage limit of ${period}/${allowed}.`, {code: 429})
+        assistant.errorify(`You have exceeded your ${name} usage limit of ${monthly}/${allowed}.`, {code: 429})
       );
     }
 
@@ -142,22 +142,38 @@ Usage.prototype.validate = function (name, options) {
       return resolve(true);
     }
 
-    // Check proportional daily allowance (for products with rateLimit: 'daily')
+    // Check daily caps (for products with rateLimit: 'daily', which is the default)
     const dailyAllowance = self.getDailyAllowance(name);
     if (dailyAllowance !== null) {
+      // Flat daily cap: ceil(monthlyLimit / daysInMonth)
+      const now = new Date();
+      const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
+      const flatDailyCap = Math.ceil(allowed / daysInMonth);
+
+      // Get today's usage from the daily counter
+      const daily = _.get(self.user, `usage.${name}.daily`, 0);
+
       if (options.log) {
-        assistant.log(`Usage.validate(): Daily allowance check: ${period}/${dailyAllowance} (monthly: ${allowed}) for ${name} (${self.key})`);
+        assistant.log(`Usage.validate(): Daily cap check: ${daily}/${flatDailyCap} today, ${monthly}/${dailyAllowance} proportional (monthly: ${allowed}) for ${name} (${self.key})`);
       }
 
-      if (period >= dailyAllowance) {
+      // Check flat daily cap (can't exceed ceil(limit/daysInMonth) in a single day)
+      if (daily >= flatDailyCap) {
         return reject(
-          assistant.errorify(`You have reached your daily usage limit for ${name} (${period}/${dailyAllowance}). Your monthly limit is ${allowed}.`, {code: 429})
+          assistant.errorify(`You have reached your daily usage limit for ${name} (${daily}/${flatDailyCap}). Your monthly limit is ${allowed}.`, {code: 429})
+        );
+      }
+
+      // Check proportional monthly cap (can't accumulate too fast)
+      if (monthly >= dailyAllowance) {
+        return reject(
+          assistant.errorify(`You have reached your usage limit for ${name} (${monthly}/${dailyAllowance}). Your monthly limit is ${allowed}.`, {code: 429})
         );
       }
     }
 
     // If they are under the monthly limit, resolve
-    if (period < allowed) {
+    if (monthly < allowed) {
       self.log(`Usage.validate(): Valid for ${name}`);
 
       return resolve(true);
@@ -200,8 +216,8 @@ Usage.prototype.increment = function (name, value, options) {
   options = options || {};
   options.id = options.id || null;
 
-  // Update total and period
-  ['total', 'period', 'last'].forEach((key) => {
+  // Update total, monthly, daily, and last
+  ['total', 'monthly', 'daily', 'last'].forEach((key) => {
     const resolved = `usage.${name}.${key}`;
     const existing = _.get(self.user, resolved, 0);
 
@@ -237,8 +253,8 @@ Usage.prototype.set = function (name, value) {
   // Set value
   value = typeof value === 'undefined' ? 0 : value;
 
-  // Update total and period
-  const resolved = `usage.${name}.period`;
+  // Update monthly
+  const resolved = `usage.${name}.monthly`;
 
   // Set the value
   _.set(self.user, resolved, value);
@@ -256,7 +272,7 @@ Usage.prototype.getUsage = function (name) {
 
   // Get usage
   if (name) {
-    return _.get(self.user, `usage.${name}.period`, 0);
+    return _.get(self.user, `usage.${name}.monthly`, 0);
   } else {
     return self.user.usage;
   }
@@ -290,20 +306,27 @@ Usage.prototype.getLimit = function (name) {
 };
 
 /**
- * Get the proportional daily allowance for a metric
- * Based on how far into the month we are: ceil(monthlyLimit * dayOfMonth / daysInMonth)
+ * Get the daily allowance cap for a metric
+ * Prevents users from burning their entire monthly quota in a single day
+ *
+ * Uses two checks:
+ * 1. Flat daily cap: ceil(monthlyLimit / daysInMonth) — max uses per day
+ *    e.g. 100/month in March (31 days) = ceil(100/31) = 4/day
+ *    e.g. 10/month in March (31 days) = ceil(10/31) = 1/day
+ * 2. Proportional monthly cap: ceil(monthlyLimit * dayOfMonth / daysInMonth) — running total
+ *    Ensures users can't accumulate too much too fast even within daily limits
  *
- * Returns null if the product uses monthly rate limiting (no daily cap)
- * Products can set rateLimit: 'daily' | 'monthly' (default: 'monthly')
+ * Returns null if the product opts out with rateLimit: 'monthly'
+ * Products can set rateLimit: 'daily' (default) | 'monthly'
  */
 Usage.prototype.getDailyAllowance = function (name) {
   const self = this;
 
   // Get the product config
   const product = self.getProduct();
-  const rateLimit = product.rateLimit || 'monthly';
+  const rateLimit = product.rateLimit || 'daily';
 
-  // If monthly rate limiting, no daily cap
+  // If explicitly set to monthly, no daily cap
   if (rateLimit !== 'daily') {
     return null;
   }
@@ -314,11 +337,12 @@ Usage.prototype.getDailyAllowance = function (name) {
     return null;
   }
 
-  // Calculate proportional allowance based on day of month
+  // Calculate caps
   const now = new Date();
   const dayOfMonth = now.getDate();
   const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
 
+  // Proportional monthly cap — how much should be used by this day at most
   // ceil ensures at least 1 usage per day even with very low limits
   return Math.ceil(monthlyLimit * (dayOfMonth / daysInMonth));
 };

package/src/manager/helpers/user.js

@@ -97,7 +97,8 @@ const SCHEMA = {
   usage: {
     $passthrough: true,
     $template: {
-      period: { type: 'number', default: 0 },
+      monthly: { type: 'number', default: 0 },
+      daily: { type: 'number', default: 0 },
       total: { type: 'number', default: 0 },
       last: {
         id: { type: 'string', default: null, nullable: true },

package/src/manager/routes/test/usage/post.js

@@ -8,8 +8,9 @@ module.exports = async ({ assistant, user, settings }) => {
   const amount = settings.amount;
 
   // Get usage before increment
-  const beforePeriod = usage.getUsage('requests');
+  const beforeMonthly = usage.getUsage('requests');
   const beforeTotal = user.usage?.requests?.total || 0;
+  const beforeDaily = user.usage?.requests?.daily || 0;
 
   // Increment usage
   usage.increment('requests', amount);
@@ -18,15 +19,16 @@ module.exports = async ({ assistant, user, settings }) => {
   await usage.update();
 
   // Get usage after increment
-  const afterPeriod = usage.getUsage('requests');
+  const afterMonthly = usage.getUsage('requests');
   const afterTotal = user.usage?.requests?.total || 0;
+  const afterDaily = user.usage?.requests?.daily || 0;
 
   // Log
   assistant.log(`test/usage: Incremented requests by ${amount}`, {
     authenticated: user.authenticated,
     key: usage.key,
-    before: { period: beforePeriod, total: beforeTotal },
-    after: { period: afterPeriod, total: afterTotal },
+    before: { monthly: beforeMonthly, daily: beforeDaily, total: beforeTotal },
+    after: { monthly: afterMonthly, daily: afterDaily, total: afterTotal },
   });
 
   return assistant.respond({
@@ -35,11 +37,13 @@ module.exports = async ({ assistant, user, settings }) => {
     authenticated: user.authenticated,
     key: usage.key,
     before: {
-      period: beforePeriod,
+      monthly: beforeMonthly,
+      daily: beforeDaily,
       total: beforeTotal,
     },
     after: {
-      period: afterPeriod,
+      monthly: afterMonthly,
+      daily: afterDaily,
       total: afterTotal,
     },
     user: {

package/test/_legacy/usage.js

@@ -54,7 +54,7 @@ describe(`${package.name}`, () => {
         return assert.deepStrictEqual({
           requests: {
             total: 0,
-            period: 0,
+            monthly: 0,
             last: {
               id: '',
               timestamp: '1970-01-01T00:00:00.000Z',
@@ -72,7 +72,7 @@ describe(`${package.name}`, () => {
         return assert.deepStrictEqual({
           requests: {
             total: 1,
-            period: 1,
+            monthly: 1,
             last: {
               id: 'increment',
               timestamp: '2024-01-01T01:00:00.000Z',
@@ -90,7 +90,7 @@ describe(`${package.name}`, () => {
         return assert.deepStrictEqual({
           requests: {
             total: -1,
-            period: -1,
+            monthly: -1,
             last: {
               id: 'decrement',
               timestamp: '2024-01-01T01:00:00.000Z',
@@ -132,7 +132,7 @@ describe(`${package.name}`, () => {
         return assert.deepStrictEqual({
           requests: {
             total: 1,
-            period: 1,
+            monthly: 1,
             last: {
               id: 'update',
               timestamp: '2024-01-01T01:00:00.000Z',
@@ -154,7 +154,7 @@ describe(`${package.name}`, () => {
         return assert.deepStrictEqual({
           signups: {
             total: 1,
-            period: 1,
+            monthly: 1,
             last: {
               id: 'singups',
               timestamp: '2024-01-01T01:00:00.000Z',

package/test/routes/test/usage.js

@@ -19,7 +19,8 @@ module.exports = {
         state.initialUsage = userDoc?.usage || {};
 
         // Store initial values for requests metric (may not exist yet)
-        state.initialPeriod = state.initialUsage?.requests?.period || 0;
+        state.initialMonthly = state.initialUsage?.requests?.monthly || 0;
+        state.initialDaily = state.initialUsage?.requests?.daily || 0;
         state.initialTotal = state.initialUsage?.requests?.total || 0;
 
         assert.ok(true, 'Initial usage state captured');
@@ -42,12 +43,21 @@ module.exports = {
         assert.equal(response.data.metric, 'requests', 'Metric should be requests');
         assert.equal(response.data.amount, 1, 'Default amount should be 1');
 
-        // Verify increment happened
+        // Verify monthly incremented
         assert.equal(
-          response.data.after.period,
-          response.data.before.period + 1,
-          'Period should be incremented by 1'
+          response.data.after.monthly,
+          response.data.before.monthly + 1,
+          'Monthly should be incremented by 1'
         );
+
+        // Verify daily incremented
+        assert.equal(
+          response.data.after.daily,
+          response.data.before.daily + 1,
+          'Daily should be incremented by 1'
+        );
+
+        // Verify total incremented
         assert.equal(
           response.data.after.total,
           response.data.before.total + 1,
@@ -69,15 +79,25 @@ module.exports = {
         assert.ok(userDoc?.usage?.requests, 'User should have requests usage');
 
         assert.equal(
-          userDoc.usage.requests.period,
-          state.afterFirstIncrement.period,
-          'Persisted period should match API response'
+          userDoc.usage.requests.monthly,
+          state.afterFirstIncrement.monthly,
+          'Persisted monthly should match API response'
+        );
+        assert.equal(
+          userDoc.usage.requests.daily,
+          state.afterFirstIncrement.daily,
+          'Persisted daily should match API response'
         );
         assert.equal(
           userDoc.usage.requests.total,
           state.afterFirstIncrement.total,
           'Persisted total should match API response'
         );
+
+        // Verify last timestamp exists
+        assert.ok(userDoc.usage.requests.last, 'Should have last object');
+        assert.ok(userDoc.usage.requests.last.timestamp, 'Should have last.timestamp');
+        assert.ok(userDoc.usage.requests.last.timestampUNIX, 'Should have last.timestampUNIX');
       },
     },
 
@@ -92,11 +112,16 @@ module.exports = {
         assert.isSuccess(response, 'Custom amount increment should succeed');
         assert.equal(response.data.amount, 5, 'Amount should be 5');
 
-        // Verify increment happened with custom amount
+        // Verify all counters incremented by 5
+        assert.equal(
+          response.data.after.monthly,
+          response.data.before.monthly + 5,
+          'Monthly should be incremented by 5'
+        );
         assert.equal(
-          response.data.after.period,
-          response.data.before.period + 5,
-          'Period should be incremented by 5'
+          response.data.after.daily,
+          response.data.before.daily + 5,
+          'Daily should be incremented by 5'
         );
         assert.equal(
           response.data.after.total,
@@ -117,9 +142,14 @@ module.exports = {
         assert.ok(userDoc?.usage?.requests, 'User should have requests usage');
 
         assert.equal(
-          userDoc.usage.requests.period,
-          state.afterCustomAmount.period,
-          'Requests period should be persisted'
+          userDoc.usage.requests.monthly,
+          state.afterCustomAmount.monthly,
+          'Requests monthly should be persisted'
+        );
+        assert.equal(
+          userDoc.usage.requests.daily,
+          state.afterCustomAmount.daily,
+          'Requests daily should be persisted'
         );
         assert.equal(
           userDoc.usage.requests.total,
@@ -151,13 +181,19 @@ module.exports = {
         assert.isSuccess(response3, 'Third increment should succeed');
 
         // Verify accumulation: should be initial + 1 (test 2) + 5 (test 4) + 1 + 1 + 3 = initial + 11
-        const expectedPeriod = state.initialPeriod + 11;
+        const expectedMonthly = state.initialMonthly + 11;
+        const expectedDaily = state.initialDaily + 11;
         const expectedTotal = state.initialTotal + 11;
 
         assert.equal(
-          response3.data.after.period,
-          expectedPeriod,
-          `Period should accumulate to ${expectedPeriod}`
+          response3.data.after.monthly,
+          expectedMonthly,
+          `Monthly should accumulate to ${expectedMonthly}`
+        );
+        assert.equal(
+          response3.data.after.daily,
+          expectedDaily,
+          `Daily should accumulate to ${expectedDaily}`
         );
         assert.equal(
           response3.data.after.total,
@@ -180,9 +216,11 @@ module.exports = {
         assert.equal(response.data.authenticated, false, 'Should report as unauthenticated');
         assert.equal(response.data.key, state.unauthKey, 'Key should be unknown');
 
-        // Verify increment happened (relative check — prior tests may have incremented too)
-        state.unauthPeriod = response.data.after.period;
-        assert.equal(response.data.after.period, response.data.before.period + 1, 'Period should increment by 1');
+        // Verify all counters incremented
+        assert.equal(response.data.after.monthly, response.data.before.monthly + 1, 'Monthly should increment by 1');
+        assert.equal(response.data.after.daily, response.data.before.daily + 1, 'Daily should increment by 1');
+
+        state.unauthMonthly = response.data.after.monthly;
       },
     },
 
@@ -194,22 +232,66 @@ module.exports = {
 
         assert.ok(usageDoc, 'Usage doc should exist in usage collection');
         assert.ok(usageDoc?.requests, 'Usage doc should have the requests metric');
-        assert.equal(usageDoc.requests.period, state.unauthPeriod, 'Persisted period should match');
+        assert.equal(usageDoc.requests.monthly, state.unauthMonthly, 'Persisted monthly should match');
       },
     },
 
-    // Test 9: Cleanup - trigger daily cron via PubSub to delete usage collection
+    // Test 9: Cron resets daily counters for authenticated users
     {
-      name: 'cleanup-reset-usage',
-      async run({ assert, firestore, state, waitFor, pubsub }) {
-        // Verify unauthenticated usage doc exists before cron
-        const beforeUsageDoc = await firestore.get(`usage/${state.unauthKey}`);
-        assert.ok(beforeUsageDoc, 'Usage doc should exist before cron');
+      name: 'cron-resets-daily-counters',
+      async run({ assert, firestore, state, accounts, waitFor, pubsub }) {
+        // Verify daily counter is > 0 before cron
+        const beforeDoc = await firestore.get(`users/${accounts.basic.uid}`);
+        assert.ok(beforeDoc?.usage?.requests?.daily > 0, 'Daily counter should be > 0 before cron');
+
+        // Store monthly and total before cron (should NOT be reset by daily cron)
+        state.monthlyBeforeCron = beforeDoc.usage.requests.monthly;
+        state.totalBeforeCron = beforeDoc.usage.requests.total;
 
         // Trigger cron via PubSub
         await pubsub.trigger('bm_cronDaily');
 
-        // Wait for cron to delete the usage collection doc (max 10 seconds)
+        // Wait for cron to reset daily counter
+        try {
+          await waitFor(
+            async () => {
+              const doc = await firestore.get(`users/${accounts.basic.uid}`);
+              return doc?.usage?.requests?.daily === 0;
+            },
+            10000,
+            500
+          );
+          assert.ok(true, 'Daily counter was reset to 0 by cron');
+        } catch (error) {
+          assert.fail('Daily counter should be reset to 0 within 10s');
+        }
+      },
+    },
+
+    // Test 10: Cron preserves monthly and total counters (non-1st of month)
+    {
+      name: 'cron-preserves-monthly-and-total',
+      async run({ assert, firestore, state, accounts }) {
+        const afterDoc = await firestore.get(`users/${accounts.basic.uid}`);
+
+        assert.equal(
+          afterDoc.usage.requests.monthly,
+          state.monthlyBeforeCron,
+          'Monthly counter should be preserved after daily cron'
+        );
+        assert.equal(
+          afterDoc.usage.requests.total,
+          state.totalBeforeCron,
+          'Total counter should be preserved after daily cron'
+        );
+      },
+    },
+
+    // Test 11: Cron deletes unauthenticated usage collection
+    {
+      name: 'cron-deletes-unauthenticated-usage',
+      async run({ assert, firestore, state, waitFor }) {
+        // The cron was already triggered in test 9, so the usage collection should be deleted
         try {
           await waitFor(
             async () => {
@@ -225,5 +307,27 @@ module.exports = {
         }
       },
     },
+
+    // Test 12: Daily counter accumulates after cron reset
+    {
+      name: 'daily-counter-accumulates-after-reset',
+      async run({ http, assert }) {
+        // After cron reset daily to 0, new increments should start from 0
+        const response = await http.as('basic').post('test/usage', {
+          amount: 3,
+        });
+
+        assert.isSuccess(response, 'Increment after cron reset should succeed');
+        assert.equal(response.data.before.daily, 0, 'Daily should be 0 after cron reset');
+        assert.equal(response.data.after.daily, 3, 'Daily should be 3 after increment');
+
+        // Monthly should have continued accumulating (not reset)
+        assert.equal(
+          response.data.after.monthly,
+          response.data.before.monthly + 3,
+          'Monthly should continue accumulating'
+        );
+      },
+    },
   ],
 };