better-supabase 0.12.0 → 0.13.0

package/dist/form-definition-BjeElHsB.js

@@ -0,0 +1,311 @@
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/forms/options.ts
+const formsSqlOptions = blockOptions({
+	subjects: option.unknown(),
+	handlers: option.unknown(),
+	publicLimit: option.unknown(),
+	extraColumns: option.unknown()
+});
+const signaturesSqlOptions = blockOptions({
+	subjects: option.unknown(),
+	extraColumns: option.unknown()
+});
+//#endregion
+//#region src/core/contracts/form-definition.ts
+const FORM_FIELD_TYPES = [
+	"text",
+	"textarea",
+	"email",
+	"url",
+	"number",
+	"integer",
+	"date",
+	"bool",
+	"consent",
+	"option",
+	"multi",
+	"json"
+];
+/** The dialect every generated schema declares (`SPEC_PINS.jsonSchema`). */
+const FORM_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+/** The longest answer a field takes when it sets no `maxLength`. */
+const FORM_MAX_LENGTH = {
+	text: 500,
+	textarea: 1e4,
+	email: 320,
+	url: 2e3
+};
+const KEY = {
+	type: "string",
+	pattern: "^[a-z][a-zA-Z0-9_]{0,62}$"
+};
+const CONDITION = {
+	type: "object",
+	required: ["field"],
+	minProperties: 2,
+	maxProperties: 2,
+	additionalProperties: false,
+	properties: {
+		field: KEY,
+		equals: {},
+		in: {
+			type: "array",
+			minItems: 1,
+			maxItems: 500
+		},
+		filled: { const: true }
+	}
+};
+const TEXT = (max) => ({
+	type: "string",
+	maxLength: max
+});
+/**
+* The shape of a definition. It uses only keywords whose meaning is the same in
+* drafts 7 and 2020-12, because pg_jsonschema validates by draft 7 rules.
+*/
+const FORM_DEFINITION_SCHEMA = {
+	$schema: FORM_SCHEMA_DIALECT,
+	type: "object",
+	required: ["steps"],
+	additionalProperties: false,
+	properties: { steps: {
+		type: "array",
+		minItems: 1,
+		maxItems: 50,
+		items: {
+			type: "object",
+			required: ["key", "fields"],
+			additionalProperties: false,
+			properties: {
+				key: KEY,
+				title: TEXT(200),
+				description: TEXT(2e3),
+				showIf: CONDITION,
+				fields: {
+					type: "array",
+					minItems: 1,
+					maxItems: 200,
+					items: {
+						type: "object",
+						required: ["key"],
+						additionalProperties: false,
+						properties: {
+							key: KEY,
+							label: {
+								type: "string",
+								minLength: 1,
+								maxLength: 200
+							},
+							type: { enum: [...FORM_FIELD_TYPES] },
+							required: { type: "boolean" },
+							help: TEXT(1e3),
+							placeholder: TEXT(200),
+							options: {
+								type: "array",
+								minItems: 1,
+								maxItems: 500,
+								items: {
+									type: "object",
+									required: ["value", "label"],
+									additionalProperties: false,
+									properties: {
+										value: {
+											type: "string",
+											minLength: 1,
+											maxLength: 200
+										},
+										label: {
+											type: "string",
+											minLength: 1,
+											maxLength: 200
+										}
+									}
+								}
+							},
+							min: { type: "number" },
+							max: { type: "number" },
+							minLength: {
+								type: "integer",
+								minimum: 0
+							},
+							maxLength: {
+								type: "integer",
+								minimum: 1
+							},
+							pattern: TEXT(500),
+							showIf: CONDITION,
+							customField: {
+								type: "string",
+								pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+							}
+						}
+					}
+				}
+			}
+		}
+	} }
+};
+const EMPTY_VALUES = [
+	null,
+	"",
+	[]
+];
+/** The schema a condition holds under, as an `if`. */
+function conditionSchema(condition) {
+	const { field } = condition;
+	const value = "equals" in condition ? { const: condition.equals } : "in" in condition ? { enum: [...condition.in] } : { not: { enum: [...EMPTY_VALUES] } };
+	return {
+		properties: { [field]: value },
+		required: [field]
+	};
+}
+const defined = (entries) => Object.fromEntries(Object.entries(entries).filter((entry) => entry[1] !== void 0));
+/** The schema of one field's answer. */
+function fieldSchema(field) {
+	const type = field.type;
+	if (type === void 0) throw new TypeError(`form field ${field.key} has no type: publish the version to resolve its customField`);
+	const values = (field.options ?? []).map((option) => option.value);
+	const annotations = defined({
+		title: field.label,
+		description: field.help
+	});
+	const maxLength = (fallback) => field.maxLength ?? fallback;
+	const floor = field.required === true ? 1 : void 0;
+	switch (type) {
+		case "text":
+		case "textarea": return {
+			type: "string",
+			maxLength: maxLength(FORM_MAX_LENGTH[type]),
+			...defined({
+				minLength: field.minLength ?? floor,
+				pattern: field.pattern
+			}),
+			...annotations
+		};
+		case "email": return {
+			type: "string",
+			format: "email",
+			maxLength: FORM_MAX_LENGTH.email,
+			...annotations
+		};
+		case "url": return {
+			type: "string",
+			format: "uri",
+			maxLength: FORM_MAX_LENGTH.url,
+			...annotations
+		};
+		case "number":
+		case "integer": return {
+			type,
+			...defined({
+				minimum: field.min,
+				maximum: field.max
+			}),
+			...annotations
+		};
+		case "date": return {
+			type: "string",
+			format: "date",
+			...annotations
+		};
+		case "bool": return {
+			type: "boolean",
+			...annotations
+		};
+		case "consent": return {
+			type: "boolean",
+			const: true,
+			...annotations
+		};
+		case "option": return {
+			type: "string",
+			enum: values,
+			...annotations
+		};
+		case "multi": return {
+			type: "array",
+			items: {
+				type: "string",
+				enum: values
+			},
+			uniqueItems: true,
+			...defined({
+				minItems: field.min ?? floor,
+				maxItems: field.max
+			}),
+			...annotations
+		};
+		case "json": return { ...annotations };
+		default: throw new TypeError(`unknown form field type ${String(type)}`);
+	}
+}
+/**
+* The JSON Schema 2020-12 a version's submissions validate against. A required
+* field with a `showIf` (its own or its step's) is required only while the
+* condition holds. Like `FORM_DEFINITION_SCHEMA`, it keeps to the keywords
+* drafts 7 and 2020-12 share.
+*/
+function formSchema(definition) {
+	const properties = {};
+	const required = [];
+	const conditional = [];
+	for (const step of definition.steps) for (const field of step.fields) {
+		properties[field.key] = fieldSchema(field);
+		if (field.required !== true) continue;
+		const conditions = [step.showIf, field.showIf].filter((condition) => condition !== void 0).map(conditionSchema);
+		if (conditions.length === 0) {
+			required.push(field.key);
+			continue;
+		}
+		conditional.push({
+			if: conditions.length === 1 ? conditions[0] : { allOf: conditions },
+			then: { required: [field.key] }
+		});
+	}
+	return {
+		$schema: FORM_SCHEMA_DIALECT,
+		type: "object",
+		properties,
+		additionalProperties: false,
+		...required.length > 0 ? { required } : {},
+		...conditional.length > 0 ? { allOf: conditional } : {}
+	};
+}
+/**
+* Whether `value` has a definition's outline: steps with a key and fields with
+* a key. `FORM_DEFINITION_SCHEMA` checks the rest.
+*/
+function isFormDefinition(value) {
+	return isRecord(value) && Array.isArray(value["steps"]) && value["steps"].every((step) => isRecord(step) && typeof step["key"] === "string" && Array.isArray(step["fields"]) && step["fields"].every((field) => isRecord(field) && typeof field["key"] === "string"));
+}
+/**
+* What the definition's shape can't say: duplicate keys, conditions on a field
+* that isn't earlier in the form, a field without a label and type (and no
+* `customField`), and a choice field without options. Empty when the definition
+* is fine.
+*/
+function formDefinitionProblems(definition) {
+	const problems = [];
+	const steps = /* @__PURE__ */ new Set();
+	const fields = /* @__PURE__ */ new Set();
+	const refers = (condition, where) => {
+		if (condition !== void 0 && !fields.has(condition.field)) problems.push(`${where}: showIf names ${condition.field}, which isn't an earlier field`);
+	};
+	for (const step of definition.steps) {
+		if (steps.has(step.key)) problems.push(`step ${step.key} is listed twice`);
+		steps.add(step.key);
+		refers(step.showIf, `step ${step.key}`);
+		for (const field of step.fields) {
+			if (fields.has(field.key)) problems.push(`field ${field.key} is listed twice`);
+			refers(field.showIf, `field ${field.key}`);
+			fields.add(field.key);
+			if (field.customField === void 0 && (field.label === void 0 || field.type === void 0)) problems.push(`field ${field.key} needs a label and a type, or a customField`);
+			if (field.customField === void 0 && (field.type === "option" || field.type === "multi") && (field.options?.length ?? 0) === 0) problems.push(`field ${field.key} needs options`);
+		}
+	}
+	return problems;
+}
+//#endregion
+export { formDefinitionProblems as a, formsSqlOptions as c, FORM_SCHEMA_DIALECT as i, signaturesSqlOptions as l, FORM_FIELD_TYPES as n, formSchema as o, FORM_MAX_LENGTH as r, isFormDefinition as s, FORM_DEFINITION_SCHEMA as t };

package/dist/form-definition-DcVnFzl4.d.ts

@@ -0,0 +1,95 @@
+//#region src/core/contracts/form-definition.d.ts
+/**
+ * The forms block's definition format and the JSON Schema each published
+ * version gets. The SQL module embeds `FORM_DEFINITION_SCHEMA` and builds the
+ * same answer schema as `formSchema`, so the two can't drift.
+ */
+/** A JSON value in a definition or an answer. */
+type FormJson = string | number | boolean | null | readonly FormJson[] | {
+  readonly [key: string]: FormJson;
+};
+/** A JSON Schema document, as the generator writes it. */
+type FormJsonSchema = {
+  readonly [key: string]: FormJson;
+};
+type FormFieldType = "text" | "textarea" | "email" | "url" | "number" | "integer" | "date" | "bool" | "consent" | "option" | "multi" | "json";
+declare const FORM_FIELD_TYPES: readonly FormFieldType[];
+/**
+ * When a step or field shows: an earlier field's answer `equals` a value, is
+ * one of `in`, or is `filled` (present and not `null`, `""` or `[]`).
+ */
+type FormCondition = {
+  readonly field: string;
+  readonly equals: FormJson;
+} | {
+  readonly field: string;
+  readonly in: readonly FormJson[];
+} | {
+  readonly field: string;
+  readonly filled: true;
+};
+interface FormOption {
+  readonly value: string;
+  readonly label: string;
+}
+interface FormField {
+  /** The answer's key: a letter, then letters, digits or `_`. */
+  readonly key: string;
+  readonly label?: string;
+  readonly type?: FormFieldType;
+  readonly required?: boolean;
+  readonly help?: string;
+  readonly placeholder?: string;
+  /** The choices of an `option` or `multi` field. */
+  readonly options?: readonly FormOption[];
+  /** The bounds of a number, or the number of choices of a `multi` field. */
+  readonly min?: number;
+  readonly max?: number;
+  readonly minLength?: number;
+  readonly maxLength?: number;
+  readonly pattern?: string;
+  readonly showIf?: FormCondition;
+  /**
+   * A custom-fields definition id. Publishing copies its label, type, options
+   * and `required` into the field; the field's own keys win.
+   */
+  readonly customField?: string;
+}
+interface FormStep {
+  readonly key: string;
+  readonly title?: string;
+  readonly description?: string;
+  readonly showIf?: FormCondition;
+  readonly fields: readonly FormField[];
+}
+interface FormDefinition {
+  readonly steps: readonly FormStep[];
+}
+/** The dialect every generated schema declares (`SPEC_PINS.jsonSchema`). */
+declare const FORM_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+/**
+ * The shape of a definition. It uses only keywords whose meaning is the same in
+ * drafts 7 and 2020-12, because pg_jsonschema validates by draft 7 rules.
+ */
+declare const FORM_DEFINITION_SCHEMA: FormJsonSchema;
+/**
+ * The JSON Schema 2020-12 a version's submissions validate against. A required
+ * field with a `showIf` (its own or its step's) is required only while the
+ * condition holds. Like `FORM_DEFINITION_SCHEMA`, it keeps to the keywords
+ * drafts 7 and 2020-12 share.
+ */
+declare function formSchema(definition: FormDefinition): FormJsonSchema;
+/**
+ * Whether `value` has a definition's outline: steps with a key and fields with
+ * a key. `FORM_DEFINITION_SCHEMA` checks the rest.
+ */
+declare function isFormDefinition(value: unknown): value is FormDefinition;
+/**
+ * What the definition's shape can't say: duplicate keys, conditions on a field
+ * that isn't earlier in the form, a field without a label and type (and no
+ * `customField`), and a choice field without options. Empty when the definition
+ * is fine.
+ */
+declare function formDefinitionProblems(definition: FormDefinition): readonly string[];
+//#endregion
+export { FormDefinition as a, FormJson as c, FormStep as d, formDefinitionProblems as f, FormCondition as i, FormJsonSchema as l, isFormDefinition as m, FORM_FIELD_TYPES as n, FormField as o, formSchema as p, FORM_SCHEMA_DIALECT as r, FormFieldType as s, FORM_DEFINITION_SCHEMA as t, FormOption as u };

package/dist/format-AYHceC2m.d.ts

@@ -0,0 +1,79 @@
+import { t as ApiModel } from "./model-Btl8X9cs.js";
+//#region src/spec/format.d.ts
+/**
+ * How a version of a format is supported. `preview` follows a draft and is
+ * never a default.
+ */
+type VersionStatus = "stable" | "legacy" | "preview";
+interface FormatVersion {
+  /** The exact version or commit the output follows (a `SPEC_PINS` value). */
+  readonly pin: string;
+  readonly status: VersionStatus;
+}
+type DiagnosticSeverity = "error" | "warning" | "info";
+/**
+ * A finding from building, lowering or checking a document. `code` is stable:
+ * tools and `--fail-on` read it, and a retired code stays reserved.
+ */
+interface SpecDiagnostic {
+  readonly code: string;
+  readonly severity: DiagnosticSeverity;
+  readonly message: string;
+  /** A JSON Pointer into the document or the model, when there is one. */
+  readonly pointer?: string;
+}
+interface LowerContext {
+  /** Records a diagnostic; lowering continues. */
+  report(diagnostic: SpecDiagnostic): void;
+}
+/**
+ * The plugin contract every document format implements, the first-party ones
+ * included (API v1). `lower` is pure: it reads the model and returns a new
+ * document, so the same model renders to every version. `Docs` maps each
+ * version to its document type, so `transform` hooks can switch on the version;
+ * it defaults to `Doc` for every version.
+ */
+interface DocumentFormat<Id extends string = string, V extends string = string, Doc = unknown, Docs extends Readonly<Record<V, Doc>> = Readonly<Record<V, Doc>>> {
+  readonly apiVersion: 1;
+  readonly id: Id;
+  readonly versions: Readonly<Record<V, FormatVersion>>;
+  readonly defaultVersion: V;
+  lower(model: ApiModel, version: V, ctx: LowerContext): Doc;
+  /**
+   * Semantic checks a schema cannot express (unique ids, resolvable
+   * references).
+   */
+  lint?(doc: Doc, version: V): readonly SpecDiagnostic[];
+  /** Default file name for a version, e.g. `openapi.json`. */
+  fileName(version: V): string;
+  /** Phantom carrying the per-version document types. */
+  readonly "~documents"?: Docs;
+}
+type AnyDocumentFormat = DocumentFormat<string, any, any, any>;
+type VersionOf<F> = F extends DocumentFormat<string, infer V> ? V : never;
+type DocumentOf<F> = F extends DocumentFormat<string, any, infer D, any> ? D : never;
+/**
+ * What a `transform` hook receives: the document with its format and version, a
+ * union discriminated by `version`.
+ */
+type RenderedOf<F> = F extends DocumentFormat<infer Id, infer V, any, infer Docs> ? { [K in V]: {
+  readonly format: Id;
+  readonly version: K;
+  readonly document: K extends keyof Docs ? Docs[K] : never;
+}; }[V] : never;
+/**
+ * Identity helper that fixes `apiVersion` and checks that the default version
+ * exists.
+ */
+declare function defineDocumentFormat<const Id extends string, const V extends string, Doc, Docs extends Readonly<Record<V, Doc>> = Readonly<Record<V, Doc>>>(format: {
+  readonly apiVersion?: 1;
+  readonly id: Id;
+  readonly versions: Readonly<Record<V, FormatVersion>>;
+  readonly defaultVersion: NoInfer<V>;
+  lower(model: ApiModel, version: NoInfer<V>, ctx: LowerContext): Doc;
+  lint?(doc: Doc, version: NoInfer<V>): readonly SpecDiagnostic[];
+  fileName(version: NoInfer<V>): string;
+  readonly "~documents"?: Docs;
+}): DocumentFormat<Id, V, Doc, Docs>;
+//#endregion
+export { FormatVersion as a, SpecDiagnostic as c, defineDocumentFormat as d, DocumentOf as i, VersionOf as l, DiagnosticSeverity as n, LowerContext as o, DocumentFormat as r, RenderedOf as s, AnyDocumentFormat as t, VersionStatus as u };

package/dist/framework-BpEnOfAo.js

@@ -0,0 +1,57 @@
+import { n as toSession } from "./view-CfUd5vI9.js";
+import { t as withBetterSupabase } from "./composite-BgSdL5tk.js";
+//#region src/server/framework.ts
+/**
+* Every caller: the framework factories guard per loader, action or route
+* instead.
+*/
+const EVERY_CALLER = [
+	"user",
+	"anonymous",
+	"anon",
+	"service",
+	"apiKey"
+];
+/**
+* The `withBetterSupabase` entry the framework factories run, admitting every
+* caller.
+*/
+function frameworkEntry(server, options, expose) {
+	return withBetterSupabase(server, {
+		refresh: options.refresh ?? "navigation",
+		allow: EVERY_CALLER,
+		expose,
+		...options.checkSession === void 0 ? {} : { checkSession: options.checkSession },
+		...options.cookieScopes === void 0 ? {} : { cookieScopes: options.cookieScopes },
+		...options.encode === void 0 ? {} : { encode: options.encode },
+		...options.waitUntil === void 0 ? {} : { waitUntil: options.waitUntil }
+	});
+}
+/** The contributions plus the serializable `session`. */
+function localsOf(contributions) {
+	const base = contributions;
+	return {
+		...base,
+		session: toSession(base.bs.auth)
+	};
+}
+function isWaitUntilHost(value) {
+	return typeof value === "object" && value !== null && "waitUntil" in value && typeof value.waitUntil === "function";
+}
+/** `platform.context.waitUntil` on Cloudflare, `platform.waitUntil` elsewhere. */
+function platformWaitUntil(platform) {
+	if (typeof platform !== "object" || platform === null) return;
+	const context = "context" in platform ? platform.context : platform;
+	if (!isWaitUntilHost(context)) return;
+	return (promise) => {
+		context.waitUntil(promise);
+	};
+}
+/** The form body as `FormData`, JSON as a value, nothing as `undefined`. */
+async function actionInput(request) {
+	const type = request.headers.get("content-type") ?? "";
+	if (type.includes("application/json")) return request.json();
+	if (type.includes("form-data") || type.includes("application/x-www-form-urlencoded")) return request.formData();
+}
+//#endregion
+export { platformWaitUntil as a, localsOf as i, actionInput as n, frameworkEntry as r, EVERY_CALLER as t };

package/dist/framework-CMeAuJts.d.ts

@@ -0,0 +1,41 @@
+import { a as AnyModels, i as AnyFunctions } from "./types-DmshMaXz.js";
+import { t as AuthSession } from "./view-CKzCp8FW.js";
+import { c as ServerOptions } from "./server-types-D_cQ6OxZ.js";
+import { n as SessionEntryConfig } from "./session-DNRYXIOU.js";
+import { n as BetterSupabaseContributions } from "./composite-BgBzdYP-.js";
+import { c as ResourceLoaderContext } from "./kit-LeQGMzLH.js";
+import { t as RefusalRedirects } from "./refusal-BEyNVFy7.js";
+//#region src/server/framework.d.ts
+/**
+ * What the framework factories (`createSvelteKit`, `createReactRouter`,
+ * `createTanStackStart`) take.
+ */
+interface FrameworkOptions extends ServerOptions, RefusalRedirects, Pick<SessionEntryConfig, "checkSession" | "cookieScopes" | "encode"> {
+  /**
+   * When the middleware refreshes an expired session cookie. Defaults to
+   * `'navigation'`: page loads, client navigations and form posts.
+   */
+  readonly refresh?: SessionEntryConfig["refresh"];
+  /**
+   * Include internal error messages in Problem Details. Defaults to development
+   * only.
+   */
+  readonly exposeErrors?: boolean;
+  /**
+   * Keeps the invocation alive for event sink sends, e.g. the Workers
+   * `ctx.waitUntil`.
+   */
+  readonly waitUntil?: (promise: Promise<unknown>) => void;
+}
+/** The keys the framework factories put on `locals` or `context`. */
+type FrameworkLocals<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> = BetterSupabaseContributions<M, F, E, C, P, B> & {
+  /** The caller as plain data, safe to return from a loader to the browser. */
+  readonly session: AuthSession<C, P>;
+};
+/**
+ * What a `resource` loader gets in a framework adapter: the locals, with the
+ * checked tenant.
+ */
+type LocalsResource<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> = FrameworkLocals<M, F, E, C, P, B> & ResourceLoaderContext<C, P>;
+//#endregion
+export { FrameworkOptions as n, LocalsResource as r, FrameworkLocals as t };

package/dist/function-contract-4vfi93Y5.d.ts

@@ -0,0 +1,27 @@
+import { t as StandardSchemaV1 } from "./standard-16AIDny5.js";
+//#region src/core/function-contract.d.ts
+/** What a typed Edge Function takes and returns, as the caller sees them. */
+interface FunctionContract<In = unknown, Out = unknown> {
+  readonly input: In;
+  readonly output: Out;
+}
+/**
+ * The key `defineFunction` stores its schemas under, so `better-supabase/spec`
+ * can read them without importing `edge`.
+ */
+declare const FUNCTION_DESCRIPTOR: unique symbol;
+/**
+ * The schemas and docs of a `defineFunction` handler, kept on the handler for
+ * spec generation.
+ */
+interface FunctionDescriptor {
+  readonly input: StandardSchemaV1;
+  readonly output?: StandardSchemaV1;
+  readonly summary?: string;
+}
+/** A handler that carries a `FunctionDescriptor`. */
+interface DescribedFunction {
+  readonly [FUNCTION_DESCRIPTOR]: FunctionDescriptor;
+}
+//#endregion
+export { FunctionContract as n, DescribedFunction as t };

package/dist/function-contract-pEmsaUIf.js

@@ -0,0 +1,8 @@
+//#region src/core/function-contract.ts
+/**
+* The key `defineFunction` stores its schemas under, so `better-supabase/spec`
+* can read them without importing `edge`.
+*/
+const FUNCTION_DESCRIPTOR = Symbol.for("better-supabase.function");
+//#endregion
+export { FUNCTION_DESCRIPTOR as t };