@drawbridge/drawbridge-utils 0.0.71 → 0.0.73

package/dist/billing.cjs

@@ -387,6 +387,63 @@ var action = {
       await incrementUsageTotals({ controller, usageId, $inc: { "totals.actions": amount }, session });
     }
   },
+  // Batch variant of record() for a caller writing many ledger rows inside ONE
+  // transaction. A session forbids concurrent ops, so the alternative is a serial
+  // await-loop costing N round-trips; this does a single bulkWrite of idempotent
+  // { usage, key } upserts (ordered:false), then bumps usage.totals.actions by the
+  // summed units of ONLY the genuinely-inserted rows (upsertedIds) — mirroring
+  // record()'s per-row `inserted` gate. Rows are deduped by key within the batch
+  // so two upserts can't target the same { usage, key }. Pass `session` to join
+  // the caller's transaction (the intended path).
+  bulk: async ({ controller, organization, usageId, rows = [], session }) => {
+    if (!controller || !organization || !usageId || !Array.isArray(rows) || rows.length === 0) return;
+    const seen = /* @__PURE__ */ new Set();
+    const valid = [];
+    for (const row of rows) {
+      const { type, units = 1, key, meta = {}, traceId } = row || {};
+      const amount2 = Number(units);
+      if (!type || !key || !Number.isFinite(amount2) || amount2 === 0) continue;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      valid.push({ type, amount: amount2, key, meta, traceId });
+    }
+    if (valid.length === 0) return;
+    const result = await controller.bulk({
+      collection: "action",
+      pipeline: valid.map(({ type, amount: amount2, key, meta, traceId }) => ({
+        updateOne: {
+          filter: { key, usage: usageId },
+          update: {
+            $setOnInsert: {
+              organization,
+              usage: usageId,
+              type,
+              units: amount2,
+              key,
+              meta,
+              ...traceId && { traceId }
+            }
+          },
+          upsert: true
+        }
+      })),
+      options: {
+        bypassDocumentValidation: true,
+        ordered: false,
+        ...session && { session }
+      }
+    });
+    const amount = Object.keys((result == null ? void 0 : result.upsertedIds) || {}).reduce(
+      (sum, index) => {
+        var _a;
+        return sum + (((_a = valid[Number(index)]) == null ? void 0 : _a.amount) || 0);
+      },
+      0
+    );
+    if (amount > 0) {
+      await incrementUsageTotals({ controller, usageId, $inc: { "totals.actions": amount }, session });
+    }
+  },
   // Authoritative per-period total to bill — sum(units) over the period's ledger
   // rows. The Stripe meter emit (in the Stripe/sync layer) reports this number.
   sum: async ({ controller, usageId }) => {

package/dist/billing.d.cts

@@ -1,5 +1,5 @@
 import { credit, debit } from './transactions.cjs';
-import { isDuplicateKey, incrementUsageTotals } from './usage.cjs';
+import { incrementUsageTotals, isDuplicateKey } from './usage.cjs';
 import { createLogger } from '@drawbridge/drawbridge-telemetry';
 
 // Billing — the single source of truth for what Drawbridge charges, and the
@@ -9,7 +9,7 @@ import { createLogger } from '@drawbridge/drawbridge-telemetry';
 //   billing.ai      { price, cost, bill }   AI requests   → credit rail (debit)
 //   billing.scrape  { fee, bill }           scrape fees   → credit rail (debit)
 //   billing.grant   { bonus, admin }        promo credits → credit rail (credit)
-//   billing.action  { record, sum }         usage actions → Stripe meter rail
+//   billing.action  { record, bulk, sum }   usage actions → Stripe meter rail
 //
 // Sits on top of transactions.js (the generic credit/debit money rail) and
 // usage.js (the action-ledger + usage-totals primitives). Shopify order fees are
@@ -399,6 +399,76 @@ const action = {
 
 	},
 
+	// Batch variant of record() for a caller writing many ledger rows inside ONE
+	// transaction. A session forbids concurrent ops, so the alternative is a serial
+	// await-loop costing N round-trips; this does a single bulkWrite of idempotent
+	// { usage, key } upserts (ordered:false), then bumps usage.totals.actions by the
+	// summed units of ONLY the genuinely-inserted rows (upsertedIds) — mirroring
+	// record()'s per-row `inserted` gate. Rows are deduped by key within the batch
+	// so two upserts can't target the same { usage, key }. Pass `session` to join
+	// the caller's transaction (the intended path).
+	bulk : async ({ controller, organization, usageId, rows = [], session }) => {
+
+		if( ! controller || ! organization || ! usageId || ! Array.isArray( rows ) || rows.length === 0 ) return;
+
+		const seen = new Set();
+		const valid = [];
+
+		for( const row of rows ){
+
+			const { type, units = 1, key, meta = {}, traceId } = row || {};
+			const amount = Number( units );
+
+			if( ! type || ! key || ! Number.isFinite( amount ) || amount === 0 ) continue;
+			if( seen.has( key ) ) continue;
+
+			seen.add( key );
+			valid.push({ type, amount, key, meta, traceId });
+
+		}
+
+		if( valid.length === 0 ) return;
+
+		const result = await controller.bulk({
+			collection : 'action',
+			pipeline : valid.map( ({ type, amount, key, meta, traceId }) => ({
+				updateOne : {
+					filter : { key, usage : usageId },
+					update : {
+						$setOnInsert : {
+							organization,
+							usage : usageId,
+							type,
+							units : amount,
+							key,
+							meta,
+							...( traceId && { traceId })
+						}
+					},
+					upsert : true
+				}
+			})),
+			options : {
+				bypassDocumentValidation : true,
+				ordered : false,
+				...( session && { session })
+			}
+		});
+
+		// upsertedIds = { <opIndex>: _id } for newly-inserted rows; sum their units.
+		const amount = Object.keys( result?.upsertedIds || {} ).reduce(
+			( sum, index ) => sum + ( valid[ Number( index ) ]?.amount || 0 ),
+			0
+		);
+
+		if( amount > 0 ){
+
+			await incrementUsageTotals({ controller, usageId, $inc : { 'totals.actions' : amount }, session });
+
+		}
+
+	},
+
 	// Authoritative per-period total to bill — sum(units) over the period's ledger
 	// rows. The Stripe meter emit (in the Stripe/sync layer) reports this number.
 	sum : async ({ controller, usageId }) => {

package/dist/billing.d.ts

@@ -1,5 +1,5 @@
 import { credit, debit } from './transactions.js';
-import { isDuplicateKey, incrementUsageTotals } from './usage.js';
+import { incrementUsageTotals, isDuplicateKey } from './usage.js';
 import { createLogger } from '@drawbridge/drawbridge-telemetry';
 
 // Billing — the single source of truth for what Drawbridge charges, and the
@@ -9,7 +9,7 @@ import { createLogger } from '@drawbridge/drawbridge-telemetry';
 //   billing.ai      { price, cost, bill }   AI requests   → credit rail (debit)
 //   billing.scrape  { fee, bill }           scrape fees   → credit rail (debit)
 //   billing.grant   { bonus, admin }        promo credits → credit rail (credit)
-//   billing.action  { record, sum }         usage actions → Stripe meter rail
+//   billing.action  { record, bulk, sum }   usage actions → Stripe meter rail
 //
 // Sits on top of transactions.js (the generic credit/debit money rail) and
 // usage.js (the action-ledger + usage-totals primitives). Shopify order fees are
@@ -399,6 +399,76 @@ const action = {
 
 	},
 
+	// Batch variant of record() for a caller writing many ledger rows inside ONE
+	// transaction. A session forbids concurrent ops, so the alternative is a serial
+	// await-loop costing N round-trips; this does a single bulkWrite of idempotent
+	// { usage, key } upserts (ordered:false), then bumps usage.totals.actions by the
+	// summed units of ONLY the genuinely-inserted rows (upsertedIds) — mirroring
+	// record()'s per-row `inserted` gate. Rows are deduped by key within the batch
+	// so two upserts can't target the same { usage, key }. Pass `session` to join
+	// the caller's transaction (the intended path).
+	bulk : async ({ controller, organization, usageId, rows = [], session }) => {
+
+		if( ! controller || ! organization || ! usageId || ! Array.isArray( rows ) || rows.length === 0 ) return;
+
+		const seen = new Set();
+		const valid = [];
+
+		for( const row of rows ){
+
+			const { type, units = 1, key, meta = {}, traceId } = row || {};
+			const amount = Number( units );
+
+			if( ! type || ! key || ! Number.isFinite( amount ) || amount === 0 ) continue;
+			if( seen.has( key ) ) continue;
+
+			seen.add( key );
+			valid.push({ type, amount, key, meta, traceId });
+
+		}
+
+		if( valid.length === 0 ) return;
+
+		const result = await controller.bulk({
+			collection : 'action',
+			pipeline : valid.map( ({ type, amount, key, meta, traceId }) => ({
+				updateOne : {
+					filter : { key, usage : usageId },
+					update : {
+						$setOnInsert : {
+							organization,
+							usage : usageId,
+							type,
+							units : amount,
+							key,
+							meta,
+							...( traceId && { traceId })
+						}
+					},
+					upsert : true
+				}
+			})),
+			options : {
+				bypassDocumentValidation : true,
+				ordered : false,
+				...( session && { session })
+			}
+		});
+
+		// upsertedIds = { <opIndex>: _id } for newly-inserted rows; sum their units.
+		const amount = Object.keys( result?.upsertedIds || {} ).reduce(
+			( sum, index ) => sum + ( valid[ Number( index ) ]?.amount || 0 ),
+			0
+		);
+
+		if( amount > 0 ){
+
+			await incrementUsageTotals({ controller, usageId, $inc : { 'totals.actions' : amount }, session });
+
+		}
+
+	},
+
 	// Authoritative per-period total to bill — sum(units) over the period's ledger
 	// rows. The Stripe meter emit (in the Stripe/sync layer) reports this number.
 	sum : async ({ controller, usageId }) => {

package/dist/billing.js

@@ -358,6 +358,63 @@ var action = {
       await incrementUsageTotals({ controller, usageId, $inc: { "totals.actions": amount }, session });
     }
   },
+  // Batch variant of record() for a caller writing many ledger rows inside ONE
+  // transaction. A session forbids concurrent ops, so the alternative is a serial
+  // await-loop costing N round-trips; this does a single bulkWrite of idempotent
+  // { usage, key } upserts (ordered:false), then bumps usage.totals.actions by the
+  // summed units of ONLY the genuinely-inserted rows (upsertedIds) — mirroring
+  // record()'s per-row `inserted` gate. Rows are deduped by key within the batch
+  // so two upserts can't target the same { usage, key }. Pass `session` to join
+  // the caller's transaction (the intended path).
+  bulk: async ({ controller, organization, usageId, rows = [], session }) => {
+    if (!controller || !organization || !usageId || !Array.isArray(rows) || rows.length === 0) return;
+    const seen = /* @__PURE__ */ new Set();
+    const valid = [];
+    for (const row of rows) {
+      const { type, units = 1, key, meta = {}, traceId } = row || {};
+      const amount2 = Number(units);
+      if (!type || !key || !Number.isFinite(amount2) || amount2 === 0) continue;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      valid.push({ type, amount: amount2, key, meta, traceId });
+    }
+    if (valid.length === 0) return;
+    const result = await controller.bulk({
+      collection: "action",
+      pipeline: valid.map(({ type, amount: amount2, key, meta, traceId }) => ({
+        updateOne: {
+          filter: { key, usage: usageId },
+          update: {
+            $setOnInsert: {
+              organization,
+              usage: usageId,
+              type,
+              units: amount2,
+              key,
+              meta,
+              ...traceId && { traceId }
+            }
+          },
+          upsert: true
+        }
+      })),
+      options: {
+        bypassDocumentValidation: true,
+        ordered: false,
+        ...session && { session }
+      }
+    });
+    const amount = Object.keys((result == null ? void 0 : result.upsertedIds) || {}).reduce(
+      (sum, index) => {
+        var _a;
+        return sum + (((_a = valid[Number(index)]) == null ? void 0 : _a.amount) || 0);
+      },
+      0
+    );
+    if (amount > 0) {
+      await incrementUsageTotals({ controller, usageId, $inc: { "totals.actions": amount }, session });
+    }
+  },
   // Authoritative per-period total to bill — sum(units) over the period's ledger
   // rows. The Stripe meter emit (in the Stripe/sync layer) reports this number.
   sum: async ({ controller, usageId }) => {

package/dist/sanitize.cjs

@@ -31,6 +31,7 @@ var sanitize_exports = {};
 __export(sanitize_exports, {
   sanitizeDomain: () => sanitizeDomain,
   sanitizeEmail: () => sanitizeEmail,
+  sanitizeHttps: () => sanitizeHttps,
   sanitizeQueries: () => sanitizeQueries,
   sanitizeString: () => sanitizeString,
   sanitizeUrl: () => sanitizeUrl
@@ -82,6 +83,10 @@ var sanitizeDomain = (value, pattern) => {
   }
   return cleaned;
 };
+var sanitizeHttps = (val) => {
+  const value = val == null ? void 0 : val.replace(/^(https?:\/\/)+/i, "");
+  return value ? "https://" + value : "";
+};
 var sanitizeUrl = (url) => {
   var _a, _b;
   return (_b = (_a = url == null ? void 0 : url.replace(/^http:\/\//, "https://")) == null ? void 0 : _a.replace(/^https:\/\/www\./, "https://")) == null ? void 0 : _b.replace(/\/$/, "");
@@ -127,6 +132,7 @@ var sanitizeQueries = (req, res, next) => {
 0 && (module.exports = {
   sanitizeDomain,
   sanitizeEmail,
+  sanitizeHttps,
   sanitizeQueries,
   sanitizeString,
   sanitizeUrl

package/dist/sanitize.d.cts

@@ -89,6 +89,18 @@ const sanitizeDomain = ( value, pattern ) => {
 
 };
 
+// Coerce a value to a canonical https prefix: strips ALL leading http(s)://
+// occurrences (case-insensitive — a doubled prefix from re-submitted input
+// self-heals) then prepends https://. Keystroke-safe, so the same helper
+// backs app-web's InputUrl and server routes that accept submitted urls.
+const sanitizeHttps = ( val ) => {
+
+	const value = val?.replace( /^(https?:\/\/)+/i, '' );
+
+	return value ? 'https://' + value : '';
+
+};
+
 const sanitizeUrl = ( url ) => url
 	?.replace( /^http:\/\//, 'https://' )
 	?.replace( /^https:\/\/www\./, 'https://' )
@@ -171,4 +183,4 @@ const sanitizeQueries = ( req, res, next ) => {
 
 };
 
-export { sanitizeDomain, sanitizeEmail, sanitizeQueries, sanitizeString, sanitizeUrl };
+export { sanitizeDomain, sanitizeEmail, sanitizeHttps, sanitizeQueries, sanitizeString, sanitizeUrl };

package/dist/sanitize.d.ts

@@ -89,6 +89,18 @@ const sanitizeDomain = ( value, pattern ) => {
 
 };
 
+// Coerce a value to a canonical https prefix: strips ALL leading http(s)://
+// occurrences (case-insensitive — a doubled prefix from re-submitted input
+// self-heals) then prepends https://. Keystroke-safe, so the same helper
+// backs app-web's InputUrl and server routes that accept submitted urls.
+const sanitizeHttps = ( val ) => {
+
+	const value = val?.replace( /^(https?:\/\/)+/i, '' );
+
+	return value ? 'https://' + value : '';
+
+};
+
 const sanitizeUrl = ( url ) => url
 	?.replace( /^http:\/\//, 'https://' )
 	?.replace( /^https:\/\/www\./, 'https://' )
@@ -171,4 +183,4 @@ const sanitizeQueries = ( req, res, next ) => {
 
 };
 
-export { sanitizeDomain, sanitizeEmail, sanitizeQueries, sanitizeString, sanitizeUrl };
+export { sanitizeDomain, sanitizeEmail, sanitizeHttps, sanitizeQueries, sanitizeString, sanitizeUrl };

package/dist/sanitize.js

@@ -45,6 +45,10 @@ var sanitizeDomain = (value, pattern) => {
   }
   return cleaned;
 };
+var sanitizeHttps = (val) => {
+  const value = val == null ? void 0 : val.replace(/^(https?:\/\/)+/i, "");
+  return value ? "https://" + value : "";
+};
 var sanitizeUrl = (url) => {
   var _a, _b;
   return (_b = (_a = url == null ? void 0 : url.replace(/^http:\/\//, "https://")) == null ? void 0 : _a.replace(/^https:\/\/www\./, "https://")) == null ? void 0 : _b.replace(/\/$/, "");
@@ -89,6 +93,7 @@ var sanitizeQueries = (req, res, next) => {
 export {
   sanitizeDomain,
   sanitizeEmail,
+  sanitizeHttps,
   sanitizeQueries,
   sanitizeString,
   sanitizeUrl

package/package.json

@@ -158,5 +158,5 @@
     "build": "tsup && npm publish"
   },
   "types": "dist/index.d.ts",
-  "version": "0.0.71"
+  "version": "0.0.73"
 }