better-supabase 0.5.0 → 0.6.0

package/dist/blocks/usage/index.d.ts

@@ -0,0 +1,4 @@
+import { i as sqlTransport, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
+import { n as StripeSource, t as StripeClient } from "../../stripe-D04h-QBT.js";
+import { a as UsageBatchRecorded, c as UsageHistoryEntry, d as UsageOptions, f as UsagePeriod, g as reportUsageToStripe, h as createUsage, i as Usage, l as UsageHistoryOptions, m as UsageStatus, n as ReportUsageOptions, o as UsageBreakdownEntry, p as UsageRecorded, r as ReportUsageResult, s as UsageEntry, t as RecordUsageOptions, u as UsageMeterInfo } from "../../usage-CrvrL2vw.js";
+export { type BlockTransport, type RecordUsageOptions, type ReportUsageOptions, type ReportUsageResult, type StripeClient, type StripeSource, type Usage, type UsageBatchRecorded, type UsageBreakdownEntry, type UsageEntry, type UsageHistoryEntry, type UsageHistoryOptions, type UsageMeterInfo, type UsageOptions, type UsagePeriod, type UsageRecorded, type UsageStatus, createUsage, reportUsageToStripe, rpcTransport, sqlTransport };

package/dist/blocks/usage/index.js

@@ -0,0 +1,233 @@
+import { n as rpcTransport, r as sqlTransport } from "../../block-transport-BLr-ZgLc.js";
+import { O as textOf, d as isRecord, g as pageOf, h as optionalText, i as blockCall, k as toInstant, n as applyTemporal, o as eachLimit, x as recordsOf, y as recordOf } from "../../block-helpers-DWHxHsEQ.js";
+import { t as lazyStripe } from "../../stripe-BMj5LtsT.js";
+//#region src/blocks/usage/usage.ts
+const numberOf = (value) => typeof value === "number" ? value : Number(value);
+const optionalNumber = (value) => value === null || value === void 0 ? void 0 : numberOf(value);
+const PERIODS = /* @__PURE__ */ new Set([
+	"day",
+	"week",
+	"month",
+	"year",
+	"billing"
+]);
+const periodOf = (value) => {
+	const text = textOf(value);
+	return PERIODS.has(text) ? text : "month";
+};
+function recordedOf(value) {
+	const row = recordOf(value, "record_usage");
+	return {
+		recorded: row["recorded"] === true,
+		today: numberOf(row["today"]),
+		used: numberOf(row["used"])
+	};
+}
+const perMeter = (value) => isRecord(value) ? Object.fromEntries(Object.entries(value).map(([meter, used]) => [meter, numberOf(used)])) : {};
+function statusOf(value) {
+	const row = recordOf(value, "usage_status");
+	return {
+		meter: textOf(row["meter"]),
+		used: numberOf(row["used"]),
+		limit: optionalNumber(row["limit"]),
+		remaining: optionalNumber(row["remaining"]),
+		unlimited: row["unlimited"] === true,
+		period: periodOf(row["period"]),
+		startsAt: row["starts_at"] === void 0 || row["starts_at"] === null ? void 0 : toInstant(textOf(row["starts_at"])),
+		resetsAt: toInstant(textOf(row["resets_at"])),
+		...meterInfo(row)
+	};
+}
+function meterInfo(row) {
+	const unit = optionalText(row["unit"]);
+	const category = optionalText(row["category"]);
+	const label = optionalText(row["label"]);
+	return {
+		...unit === void 0 ? {} : { unit },
+		...category === void 0 ? {} : { category },
+		...label === void 0 ? {} : { label }
+	};
+}
+/** Usage metering and quotas over the `usage` module's functions. */
+function createUsage(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const args = (organizationId, meter, record = {}) => ({
+		tenant: organizationId,
+		meter,
+		quantity: record.quantity ?? 1,
+		idempotency_key: record.idempotencyKey,
+		source: record.source,
+		metadata: record.metadata,
+		actor: record.actor
+	});
+	const batch = (check) => (organizationId, entries, record = {}) => call("record_usage_batch", {
+		tenant: organizationId,
+		entries: JSON.stringify(entries.map((entry) => ({
+			meter: entry.meter,
+			quantity: entry.quantity ?? 1
+		}))),
+		idempotency_key: record.idempotencyKey,
+		check,
+		source: record.source,
+		metadata: record.metadata,
+		actor: record.actor
+	}, (value) => {
+		const row = recordOf(value, "record_usage_batch");
+		return {
+			recorded: row["recorded"] === true,
+			today: perMeter(row["today"]),
+			used: perMeter(row["used"])
+		};
+	});
+	const current = (organizationId, meter) => call("usage_status", {
+		tenant: organizationId,
+		meter
+	}, statusOf);
+	return {
+		record: (organizationId, meter, record) => call("record_usage", args(organizationId, meter, record), recordedOf),
+		consume: (organizationId, meter, record) => call("consume_quota", args(organizationId, meter, record), recordedOf),
+		recordMany: batch(false),
+		consumeMany: batch(true),
+		current,
+		overview: (organizationId) => call("usage_overview", { tenant: organizationId }, (value) => (Array.isArray(value) ? value : []).map(statusOf)),
+		remaining: (organizationId, meter) => current(organizationId, meter).map((status) => status.remaining),
+		history: (organizationId, list = {}) => call("usage_history", {
+			tenant: organizationId,
+			meter: list.meter,
+			max_rows: list.limit ?? 100,
+			before_id: pageOf(list).cursor
+		}, (value) => (Array.isArray(value) ? value.filter(isRecord) : []).map((row) => ({
+			id: numberOf(row["id"]),
+			meter: textOf(row["meter"]),
+			quantity: numberOf(row["quantity"]),
+			actor: optionalText(row["actor"]),
+			source: optionalText(row["source"]),
+			metadata: isRecord(row["metadata"]) ? row["metadata"] : {},
+			recordedAt: toInstant(textOf(row["recorded_at"]))
+		}))),
+		breakdown: (organizationId, meter) => call("usage_breakdown", {
+			tenant: organizationId,
+			meter
+		}, (value) => (Array.isArray(value) ? value.filter(isRecord) : []).map((row) => ({
+			actor: optionalText(row["actor"]),
+			source: optionalText(row["source"]),
+			quantity: numberOf(row["quantity"])
+		}))),
+		meters: () => call("usage_meters", {}, (value) => {
+			const row = isRecord(value) ? value : {};
+			return Object.fromEntries(Object.entries(row).map(([meter, info]) => [meter, meterInfo(isRecord(info) ? info : {})]));
+		})
+	};
+}
+/** Customer lookups, and meter events with their marks, in flight at once. */
+const REPORT_CONCURRENCY = 8;
+/**
+* Sends unreported usage to Stripe as meter events, one per counter and
+* delta. The event `identifier` is the tenant, meter, day and new total, so
+* a run that fails after sending and before marking resends the same event,
+* and Stripe drops the duplicate. Run it from a job or a cron route.
+*/
+async function reportUsageToStripe(options) {
+	const transport = options.transport;
+	const schema = options.schema ?? "better_supabase";
+	const stripe = await lazyStripe(options.stripe)();
+	const customers = /* @__PURE__ */ new Map();
+	const customerOf = options.customer ?? (async (organizationId) => optionalText(await transport.call("better_supabase", "tenant_stripe_customer", { tenant: organizationId })));
+	const limit = options.batch ?? 500;
+	const skipMeters = /* @__PURE__ */ new Set();
+	const skipTenants = /* @__PURE__ */ new Set();
+	/** Sends the meter event when there is a delta, then marks the total; `true` when it sent one. */
+	const send = async (pending) => {
+		const { organizationId, meter, day, value, delta, identifier } = pending;
+		if (delta > 0) await stripe.billing.meterEvents.create({
+			event_name: pending.eventName,
+			payload: {
+				stripe_customer_id: pending.customer,
+				value: String(delta)
+			},
+			identifier,
+			timestamp: Math.floor(Math.min(Date.now(), Date.parse(`${day}T23:59:59Z`)) / 1e3)
+		}, { idempotencyKey: identifier });
+		await transport.call(schema, "mark_usage_reported", {
+			tenant: organizationId,
+			meter,
+			day,
+			value
+		});
+		return delta > 0;
+	};
+	let reported = 0;
+	let skipped = 0;
+	let handled = 0;
+	for (;;) {
+		const rows = recordsOf(await transport.call(schema, "unreported_usage", {
+			max_rows: limit - handled,
+			skip_meters: [...skipMeters],
+			skip_tenants: [...skipTenants]
+		}), "unreported_usage");
+		let passedOver = false;
+		const eventNameOf = (meter) => options.eventName ? options.eventName(meter) : meter;
+		const lookups = /* @__PURE__ */ new Set();
+		for (const row of rows) {
+			const organizationId = textOf(row["organization_id"]);
+			if (!customers.has(organizationId) && !skipTenants.has(organizationId) && eventNameOf(textOf(row["meter"])) !== void 0) lookups.add(organizationId);
+		}
+		await eachLimit([...lookups], REPORT_CONCURRENCY, async (organizationId) => {
+			customers.set(organizationId, await customerOf(organizationId));
+		});
+		const sends = [];
+		for (const row of rows) {
+			const organizationId = textOf(row["organization_id"]);
+			const meter = textOf(row["meter"]);
+			if (skipMeters.has(meter) || skipTenants.has(organizationId)) {
+				skipped += 1;
+				continue;
+			}
+			const eventName = eventNameOf(meter);
+			if (eventName === void 0) {
+				skipMeters.add(meter);
+				skipped += 1;
+				passedOver = true;
+				continue;
+			}
+			const customer = customers.get(organizationId);
+			if (customer === void 0) {
+				skipTenants.add(organizationId);
+				skipped += 1;
+				passedOver = true;
+				continue;
+			}
+			handled += 1;
+			const day = textOf(row["day"]).slice(0, 10);
+			const value = numberOf(row["value"]);
+			const previous = numberOf(row["reported_value"]);
+			const included = optionalNumber(row["included"]);
+			const before = numberOf(row["window_before"] ?? 0);
+			const delta = options.overage === true && row["unlimited"] === true ? 0 : options.overage === true && included !== void 0 ? Math.max(0, before + value - included) - Math.max(0, before + previous - included) : value - previous;
+			const identifier = `${organizationId}:${meter}:${day}:${String(value)}`;
+			sends.push({
+				organizationId,
+				meter,
+				day,
+				value,
+				delta,
+				eventName,
+				customer,
+				identifier
+			});
+		}
+		const sent = [];
+		await eachLimit(sends, REPORT_CONCURRENCY, async (pending, index) => {
+			sent[index] = await send(pending);
+		});
+		reported += sent.filter(Boolean).length;
+		if (!passedOver || handled >= limit || rows.length === 0) break;
+	}
+	return {
+		reported,
+		skipped
+	};
+}
+//#endregion
+export { createUsage, reportUsageToStripe, rpcTransport, sqlTransport };

package/dist/blocks/waitlist/index.d.ts

@@ -0,0 +1,117 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-D7y2fT87.js";
+import { i as sqlTransport, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-CKtbFcRv.js";
+import { s as VerifyOptions } from "../../verify-DPuWngD4.js";
+//#region src/blocks/waitlist/waitlist.d.ts
+type WaitlistStatus = "waiting" | "approved" | "rejected" | "joined";
+interface WaitlistEntry {
+  readonly id: string;
+  readonly email: string;
+  readonly status: WaitlistStatus;
+  readonly position: number;
+  readonly referrer: string | undefined;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  readonly userId: string | undefined;
+  readonly decidedBy: string | undefined;
+  readonly decidedAt: Temporal.Instant | undefined;
+  readonly createdAt: Temporal.Instant;
+}
+/**
+ * What `join` tells the person. Without the service role it is always
+ * `waiting`, with the place a new address would get once the entry left the
+ * line, so it never reveals who was approved or signed up. The service role
+ * sees the real status, with rejected entries read as `waiting`.
+ */
+interface WaitlistPlace {
+  /** Their place among the waiting entries; `undefined` for the service role once the entry left the line. */
+  readonly position: number | undefined;
+  readonly status: Exclude<WaitlistStatus, "rejected">;
+}
+interface InviteCode {
+  readonly id: string;
+  /** The first four characters, to tell codes apart in a list. */
+  readonly prefix: string;
+  readonly maxUses: number | undefined;
+  readonly uses: number;
+  readonly expiresAt: Temporal.Instant | undefined;
+  readonly organizationId: string | undefined;
+  readonly role: string | undefined;
+  readonly createdBy: string | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly revokedAt: Temporal.Instant | undefined;
+}
+interface CreateInviteCodeInput {
+  /** Defaults to 1. `null` allows any number of uses. */
+  readonly maxUses?: number | null;
+  readonly expiresAt?: Temporal.Instant;
+  /** Adds whoever redeems the code to this organization. */
+  readonly organizationId?: string;
+  /** The role in `organizationId`; `sql.modules.waitlist.options.defaultRole` otherwise. */
+  readonly role?: string;
+  /** Your own code, such as `LAUNCH2026`; a random one otherwise. */
+  readonly code?: string;
+}
+interface Redemption {
+  readonly organizationId: string | undefined;
+  /** The role the code granted; `undefined` when the user was a member already. */
+  readonly role: string | undefined;
+}
+interface WaitlistOptions extends BlockTemporalOptions {
+  readonly transport: BlockTransport;
+  /** The module schema (`sql.modules.waitlist.schema`), default `better_supabase`. */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+}
+interface Waitlist {
+  /** Adds an address, or returns its place when it is already there. Works signed out; see `WaitlistPlace`. */
+  join(email: string, options?: {
+    readonly referrer?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+  }): AsyncResult<WaitlistPlace>;
+  /** Entries by position; needs `waitlist.manage` on the platform. */
+  entries(options?: {
+    readonly status?: WaitlistStatus | null;
+    readonly limit?: number;
+    readonly afterPosition?: number;
+  }): AsyncResult<readonly WaitlistEntry[]>;
+  /** Lets the address sign up and emits `waitlist.approved`. */
+  approve(entryId: string): AsyncResult<WaitlistEntry>;
+  reject(entryId: string): AsyncResult<WaitlistEntry>;
+  /** Creates a code; `code` is shown once, the database keeps its hash. */
+  createCode(input?: CreateInviteCodeInput): AsyncResult<{
+    readonly code: string;
+    readonly invite: InviteCode;
+  }>;
+  /** Platform codes, or one organization's. */
+  codes(organizationId?: string): AsyncResult<readonly InviteCode[]>;
+  revokeCode(codeId: string): AsyncResult<boolean>;
+  /** Uses a code for the signed-in user, e.g. one that joins an organization. */
+  redeem(code: string): AsyncResult<Redemption>;
+}
+/** A random code in groups of four, without characters that look alike. */
+export declare function generateInviteCode(): string;
+export declare function createWaitlist(options: WaitlistOptions): Waitlist;
+interface WaitlistHookOptions {
+  /** A service transport: `waitlist_admit` is granted to the service role. */
+  readonly transport: BlockTransport;
+  /** The hook secret, `v1,whsec_...`, or several while rotating. */
+  readonly secret: string | readonly string[];
+  /** The user metadata field the client puts the code in (`codeField`), default `invite_code`. */
+  readonly codeField?: string;
+  /** What Supabase Auth tells a rejected sign-up. */
+  readonly message?: string;
+  readonly schema?: string;
+  readonly verify?: VerifyOptions;
+}
+/**
+ * The before-user-created Auth hook: lets an address sign up when it is
+ * approved on the waitlist or the sign-up carries a valid invite code.
+ *
+ * ```ts
+ * export const POST = waitlistHook({ transport, secret: env.BEFORE_USER_CREATED_SECRET });
+ * ```
+ */
+export declare function waitlistHook(options: WaitlistHookOptions): (request: Request) => Promise<Response>;
+//#endregion
+export { type BlockTransport, type CreateInviteCodeInput, type InviteCode, type Redemption, type Waitlist, type WaitlistEntry, type WaitlistHookOptions, type WaitlistOptions, type WaitlistPlace, type WaitlistStatus, rpcTransport, sqlTransport };

package/dist/blocks/waitlist/index.js

@@ -0,0 +1,132 @@
+import { n as rpcTransport, r as sqlTransport } from "../../block-transport-BLr-ZgLc.js";
+import { O as textOf, d as isRecord, h as optionalText, i as blockCall, k as toInstant, m as optionalInstant, n as applyTemporal, u as instantArg, x as recordsOf, y as recordOf } from "../../block-helpers-DWHxHsEQ.js";
+import { r as hookError, t as authHook } from "../../verify-DL41hbvY.js";
+//#region src/blocks/waitlist/waitlist.ts
+const STATUSES = /* @__PURE__ */ new Set([
+	"waiting",
+	"approved",
+	"rejected",
+	"joined"
+]);
+function statusOf(value) {
+	const text = textOf(value);
+	if (!STATUSES.has(text)) throw new TypeError(`Unknown waitlist status ${text}`);
+	return text;
+}
+const optionalNumber = (value) => value === null || value === void 0 ? void 0 : Number(value);
+function entryOf(value) {
+	const row = recordOf(value, "waitlist_entries");
+	return {
+		id: textOf(row["id"]),
+		email: textOf(row["email"]),
+		status: statusOf(row["status"]),
+		position: Number(row["position"]),
+		referrer: optionalText(row["referrer"]),
+		metadata: isRecord(row["metadata"]) ? row["metadata"] : {},
+		userId: optionalText(row["user_id"]),
+		decidedBy: optionalText(row["decided_by"]),
+		decidedAt: optionalInstant(row["decided_at"]),
+		createdAt: toInstant(textOf(row["created_at"]))
+	};
+}
+function codeOf(value) {
+	const row = recordOf(value, "invite_codes");
+	return {
+		id: textOf(row["id"]),
+		prefix: textOf(row["prefix"]),
+		maxUses: optionalNumber(row["max_uses"]),
+		uses: Number(row["uses"]),
+		expiresAt: optionalInstant(row["expires_at"]),
+		organizationId: optionalText(row["organization_id"]),
+		role: optionalText(row["role"]),
+		createdBy: optionalText(row["created_by"]),
+		createdAt: toInstant(textOf(row["created_at"])),
+		revokedAt: optionalInstant(row["revoked_at"])
+	};
+}
+/** A random code in groups of four, without characters that look alike. */
+function generateInviteCode() {
+	const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+	const chars = [...crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16))].map((byte) => alphabet[byte % 32]);
+	return [
+		0,
+		4,
+		8,
+		12
+	].map((at) => chars.slice(at, at + 4).join("")).join("-");
+}
+function createWaitlist(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const decide = (entryId, approve) => call("decide_waitlist_entry", {
+		id: entryId,
+		approve
+	}, entryOf);
+	return {
+		join: (email, more = {}) => call("join_waitlist", {
+			email,
+			referrer: more.referrer ?? null,
+			metadata: more.metadata ?? {}
+		}, (value) => {
+			const row = recordOf(value, "join_waitlist");
+			const status = statusOf(row["status"]);
+			return {
+				position: optionalNumber(row["position"]),
+				status: status === "rejected" ? "waiting" : status
+			};
+		}),
+		entries: (query = {}) => call("list_waitlist", {
+			status: query.status === void 0 ? "waiting" : query.status,
+			page_size: query.limit ?? 50,
+			after_position: query.afterPosition ?? null
+		}, (value) => recordsOf(value, "list_waitlist").map(entryOf)),
+		approve: (entryId) => decide(entryId, true),
+		reject: (entryId) => decide(entryId, false),
+		createCode: (input = {}) => {
+			const code = input.code ?? generateInviteCode();
+			return call("create_invite_code", {
+				code,
+				max_uses: input.maxUses === void 0 ? 1 : input.maxUses,
+				expires_at: instantArg(input.expiresAt),
+				tenant: input.organizationId ?? null,
+				role: input.role ?? null
+			}, (value) => ({
+				code,
+				invite: codeOf(value)
+			}));
+		},
+		codes: (organizationId) => call("list_invite_codes", { tenant: organizationId ?? null }, (value) => recordsOf(value, "list_invite_codes").map(codeOf)),
+		revokeCode: (codeId) => call("revoke_invite_code", { id: codeId }, (value) => value === true),
+		redeem: (code) => call("redeem_invite_code", { code }, (value) => {
+			const row = recordOf(value, "redeem_invite_code");
+			return {
+				organizationId: optionalText(row["organizationId"]),
+				role: optionalText(row["role"])
+			};
+		})
+	};
+}
+/**
+* The before-user-created Auth hook: lets an address sign up when it is
+* approved on the waitlist or the sign-up carries a valid invite code.
+*
+* ```ts
+* export const POST = waitlistHook({ transport, secret: env.BEFORE_USER_CREATED_SECRET });
+* ```
+*/
+function waitlistHook(options) {
+	const call = blockCall(options.transport, options.schema);
+	const field = options.codeField ?? "invite_code";
+	const message = options.message ?? "Sign-ups are invite-only. Join the waitlist first.";
+	return authHook("before_user_created", options.secret, async ({ user }) => {
+		const code = user.user_metadata?.[field];
+		const result = await call("waitlist_admit", {
+			email: user.email ?? "",
+			code: typeof code === "string" && code !== "" ? code : null
+		}, (value) => recordOf(value, "waitlist_admit")["allowed"] === true);
+		if (!result.ok) throw new Error(result.error.message);
+		return result.data ? {} : hookError(403, message);
+	}, options.verify);
+}
+//#endregion
+export { createWaitlist, generateInviteCode, rpcTransport, sqlTransport, waitlistHook };