better-supabase 0.5.0 → 0.6.0

package/dist/timing-CyTQPubY.js

@@ -0,0 +1,92 @@
+import { defineMiddleware } from "@supabase/middleware";
+//#region src/server/entries/timing.ts
+/** The header `withDbStats` sets: `calls;waves;ms`, what `expectDbBudget` reads. */
+const DB_CALLS_HEADER = "x-bs-db-calls";
+/** `calls;waves;ms`, the value of the stats header. */
+function formatDbStats(stats) {
+	return `${stats.calls};${stats.waves};${stats.ms}`;
+}
+/** Parses the stats header back into numbers, or `undefined` when it is malformed. */
+function parseDbStats(value) {
+	if (!value) return void 0;
+	const [calls, waves, ms] = value.split(";").map(Number);
+	if (calls === void 0 || waves === void 0 || ms === void 0 || [
+		calls,
+		waves,
+		ms
+	].some(Number.isNaN)) return void 0;
+	return {
+		calls,
+		waves,
+		ms
+	};
+}
+function withHeaders(response, edit) {
+	const headers = new Headers(response.headers);
+	edit(headers);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+const TOKEN = /[^!#$%&'*+\-.^_`|~0-9A-Za-z]/g;
+function metric(name, dur, description) {
+	const desc = description === void 0 ? "" : `;desc="${description.replaceAll(/["\\]/g, "")}"`;
+	return `${name.replaceAll(TOKEN, "_")};dur=${dur.toFixed(1)}${desc}`;
+}
+/**
+* Entry contributing `ctx.timing`, and adding `Server-Timing` to the
+* response: `bs;dur=<ms>` for everything after it, plus the metrics handlers
+* add with `ctx.timing.add()` or `measure()`. Put it first, so it times the
+* whole request. Browsers show it in the network panel.
+*/
+function withServerTiming(now = () => performance.now()) {
+	return defineMiddleware({
+		key: "timing",
+		run: () => async function* () {
+			const started = now();
+			const metrics = [];
+			const response = yield { timing: {
+				add: (name, dur, description) => {
+					metrics.push(metric(name, dur, description));
+				},
+				async measure(name, fn) {
+					const start = now();
+					try {
+						return await fn();
+					} finally {
+						metrics.push(metric(name, now() - start));
+					}
+				}
+			} };
+			const total = metric("bs", now() - started);
+			return withHeaders(response, (headers) => {
+				headers.append("server-timing", [total, ...metrics].join(", "));
+			});
+		}
+	})();
+}
+/**
+* Entry adding the request's database totals to the response, after the
+* handler ran: `x-bs-db-calls: calls;waves;ms`, which `expectDbBudget(response)`
+* reads, and a `bs-db` `Server-Timing` metric. Put it
+* after `withBetterSupabase`, which contributes `ctx.bs`.
+*/
+function withDbStats(options = {}) {
+	const header = options.header ?? "x-bs-db-calls";
+	return defineMiddleware({
+		key: "dbStats",
+		run: () => async function* (_request, ctx) {
+			const dbStats = () => ctx.bs.stats();
+			const response = yield { dbStats };
+			const stats = dbStats();
+			return withHeaders(response, (headers) => {
+				headers.set(header, formatDbStats(stats));
+				headers.append("server-timing", metric("bs-db", stats.ms, `${stats.calls} calls, ${stats.waves} waves`));
+			});
+		}
+	})();
+}
+//#endregion
+export { withServerTiming as i, parseDbStats as n, withDbStats as r, DB_CALLS_HEADER as t };

package/dist/ttl-Hr34gRu8.js

@@ -0,0 +1,12 @@
+//#region src/storage/ttl.ts
+const TTL = {
+	minute: 60,
+	hour: 3600,
+	day: 86400,
+	week: 604800
+};
+function ttlSeconds(ttl) {
+	return typeof ttl === "number" ? ttl : TTL[ttl ?? "hour"];
+}
+//#endregion
+export { ttlSeconds as n, TTL as t };

package/dist/{types-Dnf_wRDz.d.ts → types-6BdhkmZe.d.ts}

@@ -1,4 +1,38 @@
 /// <reference lib="esnext.temporal" />
+//#region src/storage/versioning.d.ts
+/** A bucket's object versioning state in Storage. */
+type VersioningStatus = "DISABLED" | "ENABLED" | "SUSPENDED";
+/** One rule of a bucket lifecycle policy. Storage only expires noncurrent versions today. */
+interface BucketLifecycleRule {
+  /** Storage generates one when you omit it. */
+  readonly id?: string;
+  /** Defaults to `Enabled`. `Disabled` keeps the rule stored but inactive. */
+  readonly status?: "Enabled" | "Disabled";
+  readonly noncurrentVersionExpiration: {
+    /** How old a noncurrent version must be before it expires, in days (at least 1). */
+    readonly noncurrentDays: number;
+    /** Keep this many of the newest noncurrent versions regardless of age (1 to 100). */
+    readonly newerNoncurrentVersions?: number;
+  };
+}
+/** A bucket lifecycle policy: 1 to 1000 rules, applied by `bucket.apply()`. */
+interface BucketLifecycle {
+  readonly rules: readonly [BucketLifecycleRule, ...BucketLifecycleRule[]];
+}
+/** One version of an object, newest first in `versions()`. */
+interface ObjectVersion {
+  readonly versionId: string;
+  /** The version the path serves now. */
+  readonly current: boolean;
+  /** A delete marker hides the object without removing its versions. */
+  readonly deleteMarker: boolean;
+  readonly size?: number;
+  readonly contentType?: string;
+  readonly createdAt: string | null;
+  /** When the version stopped being current. */
+  readonly archivedAt: string | null;
+}
+//#endregion
 //#region src/schema/types.d.ts
 type Casing = "snake" | "camel";
 /** Runtime metadata for one column. Keyed by the app (cased) column name. */
@@ -8,6 +42,10 @@ interface ColumnMeta {
   /** Postgres type name (`uuid`, `text`, `timestamptz`, `note_kind`). */
   readonly type: string;
   readonly nullable: boolean;
+  /**
+   * An insert may leave the column out: it has a default, a `before insert`
+   * trigger can fill it, or `tables.<t>.insertOptional` lists it.
+   */
   readonly hasDefault: boolean;
   readonly generated?: boolean;
   /** Identity column; `'always'` columns can't be written. */
@@ -83,16 +121,44 @@ interface TableMeta {
   readonly relations: Readonly<Record<string, RelationMeta>>;
   readonly flags: TableFlags;
 }
-interface FunctionMeta {
+interface FunctionMeta extends FunctionSignature {
   readonly name: string;
   readonly schema: string;
+  /**
+   * Every signature of an overloaded function, in signature order. The
+   * fields above describe the first one; `$rpc` picks the signature whose
+   * argument names match the call.
+   */
+  readonly overloads?: readonly FunctionSignature[];
+}
+interface FunctionSignature {
   readonly args: readonly {
     readonly name: string;
     readonly type: string;
+    /** The argument has a default; set in `overloads` only. */
+    readonly optional?: boolean;
   }[];
   readonly returns: string;
   readonly returnsSet: boolean;
   readonly volatility: "immutable" | "stable" | "volatile";
+  /**
+   * How `$rpc` decodes the returned rows, present when decoding changes
+   * them: the rows of a table (by app key), or a `returns table (...)` record.
+   */
+  readonly result?: FunctionResult;
+}
+type FunctionResult = {
+  readonly table: string;
+} | {
+  readonly columns: readonly ResultColumn[];
+};
+/** A column of a `returns table (...)` result. */
+interface ResultColumn {
+  /** Database name, the key PostgREST returns. */
+  readonly db: string;
+  /** App name, when the casing changes it. */
+  readonly name?: string;
+  readonly codec?: Codec;
 }
 interface SchemaMeta {
   readonly version: 1;
@@ -107,7 +173,7 @@ interface SchemaMeta {
   /** Claim names from `config.claims` that differ from the defaults. */
   readonly claims?: Partial<ClaimsMeta>;
 }
-/** The claim names the SQL kit, codegen and runtime defaults agree on. */
+/** The claim names the SQL modules, codegen and runtime defaults agree on. */
 interface ClaimsMeta {
   /** Top-level claim holding the active tenant id. Defaults to `tenant_id`. */
   readonly tenant: string;
@@ -115,19 +181,35 @@ interface ClaimsMeta {
   readonly scope: string;
   /** Claim holding plan features per tenant (`{ [tenantId]: string[] }`). Defaults to `features`. */
   readonly features: string;
+  /** Claim holding the caller's memberships (`{ scope, id, role }[]`). Defaults to `memberships`. */
+  readonly memberships: string;
 }
 interface RealtimeTableMeta {
   /** App column whose value scopes the broadcast topic. */
   readonly tenant?: string;
+  /** App column of the row's user (`realtime.users`): the topic is per user. */
+  readonly user?: string;
 }
+type BucketPolicyName = "tenant" | "owner" | "public" | "none";
 /**
- * Storage policies that call PermDock's generated SQL helpers:
- * `<schema>.permitted_<scope>_ids(key)` for a scope keyed by a path segment,
- * `<schema>.permdock_has(key)` for `scope: 'global'`. Only for permissions
- * whose grants have no row conditions beyond the scope.
+ * SQL templates a Storage or Realtime policy calls instead of the access
+ * contract, usually an authorization provider's (`authorization.functions`).
+ * `{permission}` is the key as a literal and `{scope}` the policy's scope.
+ */
+interface AccessPolicySql {
+  /** The ids of the `{scope}` instances where the caller holds `{permission}`, as a set. */
+  readonly idsWith: string;
+  /** Whether the caller holds `{permission}` platform-wide. */
+  readonly isPlatform: string;
+}
+/**
+ * A policy through the SQL modules' [access contract](/docs/blocks/access):
+ * `tenant_ids_with(permission)` for the tenant id in the path, or
+ * `is_platform(permission)`. Works with every access model. With `sql`, it
+ * calls those templates instead, for any scope they take.
  */
-interface PermdockBucketPolicy {
-  readonly permdock: {
+interface AccessBucketPolicy {
+  readonly access: {
     /** Downloads, signed URLs, renders and metadata reads. */
     readonly read: string;
     /** Listing; without it `read` covers listing too. */
@@ -136,60 +218,44 @@ interface PermdockBucketPolicy {
     readonly write: string;
     readonly delete?: string;
   };
-  /** A PermDock scope such as `organization`, or `global`. */
-  readonly scope: string;
-  /** 1-based path segment holding the scope id. Defaults to the `{orgId}` segment. */
+  /**
+   * `tenant` (default) checks the path's tenant segment; `platform` checks
+   * platform permissions. With `sql`, any scope name its templates take.
+   */
+  readonly scope?: string;
+  /** 1-based path segment holding the scope id. Defaults to the `{organizationId}` segment. */
   readonly segment?: number;
   /**
-   * Schema of the helpers `permdock rls generate` writes: PermDock's
-   * `rls.schema`. Defaults to `permdock`, PermDock's default.
+   * The templates to call, or `"provider"` for `authorization.functions`
+   * from the config, which `gen` copies in.
    */
-  readonly schema?: string;
+  readonly sql?: AccessPolicySql | "provider";
 }
-/** A PermDock topic policy: `select` (receive) and `insert` (send) on `realtime.messages`. */
-interface PermdockTopicPolicy {
+/** An access topic policy: `select` (receive) and `insert` (send) on `realtime.messages`. */
+interface AccessTopicPolicy {
   readonly receive: string;
   /** Lets clients send on the topic with this permission. */
   readonly send?: string;
-  /** A PermDock scope such as `organization`, or `global`. */
-  readonly scope: string;
-  /** 1-based `:`-separated topic segment holding the scope id. Defaults to the `{orgId}` segment. */
-  readonly segment?: number;
-  /** Schema of PermDock's helpers (`rls.schema`). Defaults to `permdock`. */
-  readonly schema?: string;
-}
-type BucketPolicyName = "tenant" | "owner" | "public" | "none";
-/**
- * A policy through the SQL kit's [access contract](/docs/kits/access):
- * `tenant_ids_with(permission)` for the tenant id in the path, or
- * `is_platform(permission)`. Works with every access model.
- */
-interface AccessBucketPolicy {
-  readonly access: {
-    /** Downloads, signed URLs, renders and metadata reads. */
-    readonly read: string;
-    /** Listing; without it `read` covers listing too. */
-    readonly list?: string;
-    /** Uploads, updates and moves; also deletes unless `delete` is set. */
-    readonly write: string;
-    readonly delete?: string;
-  };
-  /** `tenant` (default) checks the path's tenant segment; `platform` checks platform permissions. */
-  readonly scope?: "tenant" | "platform";
-  /** 1-based path segment holding the tenant id. Defaults to the `{orgId}` segment. */
+  /** As for {@link AccessBucketPolicy}. */
+  readonly scope?: string;
+  /** 1-based `:`-separated topic segment holding the scope id. Defaults to the `{organizationId}` segment. */
   readonly segment?: number;
+  /** As for {@link AccessBucketPolicy}. */
+  readonly sql?: AccessPolicySql | "provider";
 }
 interface BucketMeta {
   readonly id: string;
   readonly public: boolean;
-  readonly path: string;
-  readonly policy?: BucketPolicyName | PermdockBucketPolicy | AccessBucketPolicy;
+  readonly path: string | readonly [string, ...string[]];
+  readonly policy?: BucketPolicyName | AccessBucketPolicy;
   /** Claim paths for the tenant policy, when `config.claims.tenant` is not the default. */
   readonly tenant?: {
     readonly claim: readonly string[];
   };
   readonly fileSizeLimit?: string;
   readonly allowedMimeTypes?: readonly string[];
+  readonly versioning?: boolean;
+  readonly lifecycle?: BucketLifecycle;
 }
 interface RelationTypes {
   readonly table: string;
@@ -271,4 +337,4 @@ type IsUnion<T, U = T> = T extends unknown ? [U] extends [T] ? false : true : ne
 type PrimaryKeyValue<M extends AnyModels, T extends keyof M> = true extends IsUnion<PrimaryKeyColumn<M, T>> ? { readonly [K in PrimaryKeyColumn<M, T>]: Row<M, T>[K]; } : Row<M, T>[PrimaryKeyColumn<M, T>];
 type Simplify<T> = { [K in keyof T]: T[K]; } & {};
 //#endregion
-export { Schema as A, PrimaryKeyColumn as C, RelationTypes as D, RelationMeta as E, TableMeta as F, UniqueConstraint as I, UniqueKeyName as L, Simplify as M, TableFlags as N, Relations as O, TableKey as P, UniqueWhere as R, PermdockTopicPolicy as S, RealtimeTableMeta as T, Insert as _, BucketPolicyName as a, ModelsOf as b, ClaimsMeta as c, DatabaseOf as d, Flags as f, FunctionsOf as g, FunctionTypes as h, BucketMeta as i, SchemaMeta as j, Row as k, Codec as l, FunctionMeta as m, AnyFunctions as n, Casing as o, ForeignKeyConstraint as p, AnyModels as r, CheckConstraint as s, AccessBucketPolicy as t, ColumnMeta as u, ModelFlags as v, PrimaryKeyValue as w, PermdockBucketPolicy as x, ModelTypes as y, Update as z };
+export { Relations as A, UniqueKeyName as B, ModelTypes as C, RealtimeTableMeta as D, PrimaryKeyValue as E, Simplify as F, ObjectVersion as G, Update as H, TableFlags as I, VersioningStatus as K, TableKey as L, Row as M, Schema as N, RelationMeta as O, SchemaMeta as P, TableMeta as R, ModelFlags as S, PrimaryKeyColumn as T, BucketLifecycle as U, UniqueWhere as V, BucketLifecycleRule as W, FunctionResult as _, AnyModels as a, FunctionsOf as b, Casing as c, Codec as d, ColumnMeta as f, FunctionMeta as g, ForeignKeyConstraint as h, AnyFunctions as i, ResultColumn as j, RelationTypes as k, CheckConstraint as l, Flags as m, AccessPolicySql as n, BucketMeta as o, DatabaseOf as p, AccessTopicPolicy as r, BucketPolicyName as s, AccessBucketPolicy as t, ClaimsMeta as u, FunctionSignature as v, ModelsOf as w, Insert as x, FunctionTypes as y, UniqueConstraint as z };