better-supabase 0.13.0 → 0.15.0

package/dist/build-DxzJf79X.js

@@ -1,1839 +0,0 @@
-import { r as isPlainObject } from "./clone-CkG0-hlI.js";
-import { n as isRecord } from "./guards-6F2bCtQR.js";
-import { s as problemType, t as PROBLEM_CONTENT_TYPE } from "./problem-D0KDiYPk.js";
-import { t as buildJsonSchema } from "./json-schema-Bu4YCRbZ.js";
-import { r as dataschemaOf } from "./cloud-event-XsM53POL.js";
-import { n as planResource } from "./resource-BRRU-A7j.js";
-import { n as pageQuery, r as pageSchema } from "./resource-schemas-up6bKOUi.js";
-import { ROW_EVENT_TYPES } from "./events/index.js";
-import { t as topicStatus } from "./realtime-status-asHvhiOh.js";
-//#region src/spec/merge.ts
-/** Escapes a key for a JSON Pointer (RFC 6901). */
-function pointerToken(key) {
-	return key.replaceAll("~", "~0").replaceAll("/", "~1");
-}
-/**
-* Deep merge: objects merge key by key, anything else (arrays included) is
-* replaced by the patch. `onConflict` hears each replaced leaf whose value
-* differs, with its JSON Pointer. Neither input is changed.
-*/
-function mergeJson(base, patch, onConflict, pointer = "") {
-	if (!isPlainObject(base) || !isPlainObject(patch)) {
-		if (onConflict && base !== void 0 && JSON.stringify(base) !== JSON.stringify(patch)) onConflict(pointer);
-		return patch;
-	}
-	const out = { ...base };
-	for (const [key, value] of Object.entries(patch)) out[key] = Object.hasOwn(base, key) ? mergeJson(base[key], value, onConflict, `${pointer}/${pointerToken(key)}`) : value;
-	return out;
-}
-//#endregion
-//#region src/spec/schemas.ts
-/** `customer_tags` to `CustomerTags`. */
-function pascal(value) {
-	return value.replaceAll(/(^|[_\-.\s])(\w)/g, (_, _sep, char) => char.toUpperCase());
-}
-const schemaRef = (name) => ({ $ref: `#/components/schemas/${name}` });
-const tableDefs = /* @__PURE__ */ new WeakMap();
-/**
-* The 2020-12 `$defs` for every table (`customersRow`, `customersInsert`),
-* built once per metadata object and JSON column config.
-*/
-function tableSchemas(meta, json = {}) {
-	let byJson = tableDefs.get(meta);
-	if (!byJson) {
-		byJson = /* @__PURE__ */ new Map();
-		tableDefs.set(meta, byJson);
-	}
-	const key = JSON.stringify(json);
-	let defs = byJson.get(key);
-	if (!defs) {
-		defs = buildJsonSchema({
-			meta,
-			config: { json }
-		})["$defs"];
-		byJson.set(key, defs);
-	}
-	return defs;
-}
-const converted = /* @__PURE__ */ new WeakMap();
-function nameOf(schema) {
-	const id = schema["$id"] ?? schema["id"];
-	if (typeof id !== "string" || id === "") return;
-	return (id.split(/[/#]/u).findLast((part) => part !== "") ?? id).replace(/\.(?:schema\.)?json$/u, "");
-}
-/**
-* Converts a Standard Schema through Standard JSON Schema (2020-12), or
-* `undefined` when the library does not implement it. The schema's `$id`, `id`
-* and `$schema` are lifted out: the id becomes the component name.
-*/
-function convertStandard(schema, direction) {
-	let cache = converted.get(schema);
-	if (!cache) {
-		cache = /* @__PURE__ */ new Map();
-		converted.set(schema, cache);
-	}
-	const hit = cache.get(direction);
-	if (hit !== void 0) return hit ?? void 0;
-	const convert = schema["~standard"].jsonSchema?.[direction];
-	if (typeof convert !== "function") {
-		cache.set(direction, null);
-		return;
-	}
-	const raw = convert({ target: "draft-2020-12" });
-	const name = nameOf(raw);
-	const { $schema: _schema, $id: _id, id: _plainId, ...rest } = raw;
-	const result = {
-		schema: rest,
-		...name ? { name } : {}
-	};
-	cache.set(direction, result);
-	return result;
-}
-//#endregion
-//#region src/spec/presets.ts
-/** JSON Schema for RFC 9457 Problem Details as better-supabase sends them. */
-const PROBLEM_SCHEMA = {
-	type: "object",
-	required: [
-		"type",
-		"title",
-		"status"
-	],
-	properties: {
-		type: {
-			type: "string",
-			format: "uri-reference",
-			examples: [problemType("not_found").type]
-		},
-		title: { type: "string" },
-		status: {
-			type: "integer",
-			minimum: 100,
-			maximum: 599
-		},
-		detail: { type: "string" },
-		instance: { type: "string" },
-		kind: { type: "string" },
-		code: { type: "string" },
-		hint: { type: "string" },
-		constraint: { type: "string" },
-		column: { type: "string" },
-		columns: {
-			type: "array",
-			items: { type: "string" }
-		},
-		required: {
-			type: "string",
-			enum: ["aal1", "aal2"]
-		},
-		scopes: {
-			type: "array",
-			items: { type: "string" }
-		},
-		permission: { type: "string" },
-		approval: {
-			type: "object",
-			required: ["id"],
-			properties: { id: { type: "string" } }
-		},
-		issues: {
-			type: "array",
-			items: {
-				type: "object",
-				required: ["message"],
-				properties: {
-					message: { type: "string" },
-					path: {
-						type: "array",
-						items: { type: ["string", "integer"] }
-					}
-				}
-			}
-		}
-	}
-};
-/** The default error responses: today's Problem Details answers, 400 to 422. */
-const DEFAULT_ERRORS = [
-	{
-		name: "BadRequest",
-		status: 400,
-		description: "The request is invalid."
-	},
-	{
-		name: "Unauthorized",
-		status: 401,
-		description: "Missing or invalid credentials."
-	},
-	{
-		name: "Forbidden",
-		status: 403,
-		description: "Row-level security or a plugin denied the request."
-	},
-	{
-		name: "NotFound",
-		status: 404,
-		description: "No row matches."
-	},
-	{
-		name: "Conflict",
-		status: 409,
-		description: "A unique or foreign key constraint failed."
-	},
-	{
-		name: "Unprocessable",
-		status: 422,
-		description: "Validation or a check constraint failed."
-	}
-];
-/** Name of the shared 403 response of operations that declare a permission. */
-const PERMISSION_DENIED = "PermissionDenied";
-const problem = (code, detail, extra = {}) => ({ value: {
-	...problemType("forbidden"),
-	status: 403,
-	kind: "forbidden",
-	code,
-	detail,
-	...extra
-} });
-/** The 403 of an operation with a permission, with one example per problem code. */
-function permissionDeniedResponse() {
-	return {
-		description: "The authorizer denied the permission (`PERMISSION_DENIED`), the token lacks an OAuth scope (`INSUFFICIENT_SCOPE`), the action needs an approval (`APPROVAL_REQUIRED`), or row-level security denied the request.",
-		content: { [PROBLEM_CONTENT_TYPE]: {
-			schema: schemaRef("Problem"),
-			examples: {
-				permissionDenied: {
-					summary: "PERMISSION_DENIED",
-					...problem("PERMISSION_DENIED", "Permission invoices.update is required", { permission: "invoices.update" })
-				},
-				insufficientScope: {
-					summary: "INSUFFICIENT_SCOPE",
-					...problem("INSUFFICIENT_SCOPE", "The token lacks a required scope", { scopes: ["invoices.update"] })
-				},
-				approvalRequired: {
-					summary: "APPROVAL_REQUIRED",
-					...problem("APPROVAL_REQUIRED", "invoices.update needs an approval", {
-						permission: "invoices.update",
-						approval: { id: "apr_123" }
-					})
-				}
-			}
-		} }
-	};
-}
-function errorResponse(error) {
-	return {
-		description: error.description,
-		content: { [PROBLEM_CONTENT_TYPE]: { schema: schemaRef("Problem") } }
-	};
-}
-/** The scheme name of the `oauth2` preset. */
-const OAUTH_SCHEME = "supabaseOAuth";
-/** Security schemes and top-level requirements for the presets. */
-function resolveSecurity(presets, supabaseUrl, oauthScopes = {}) {
-	const schemes = {};
-	const requirements = [];
-	for (const preset of presets) {
-		if (typeof preset === "object") {
-			schemes[preset.name] = preset.scheme;
-			requirements.push({ [preset.name]: preset.scopes ?? [] });
-			continue;
-		}
-		switch (preset) {
-			case "bearer":
-				schemes["supabaseJwt"] = {
-					type: "http",
-					scheme: "bearer",
-					bearerFormat: "JWT",
-					description: "A Supabase access token. Requests run as that user under row-level security."
-				};
-				requirements.push({ supabaseJwt: [] });
-				break;
-			case "oauth2": {
-				if (!supabaseUrl) throw new TypeError("better-supabase/spec: oauth2 security needs supabaseUrl");
-				const origin = supabaseUrl.replace(/\/$/, "");
-				const auth = `${origin}/auth/v1`;
-				schemes[OAUTH_SCHEME] = {
-					type: "oauth2",
-					description: "The Supabase OAuth 2.1 server.",
-					flows: { authorizationCode: {
-						authorizationUrl: `${auth}/oauth/authorize`,
-						tokenUrl: `${auth}/oauth/token`,
-						scopes: oauthScopes
-					} },
-					metadataUrl: `${origin}/.well-known/oauth-authorization-server/auth/v1`
-				};
-				requirements.push({ [OAUTH_SCHEME]: [] });
-				break;
-			}
-			case "apiKey":
-				schemes["supabaseApiKey"] = {
-					type: "apiKey",
-					name: "apikey",
-					in: "header",
-					description: "The project's publishable key."
-				};
-				requirements.push({ supabaseApiKey: [] });
-				break;
-			default: throw new TypeError(`Unknown security preset "${String(preset)}"`);
-		}
-	}
-	return {
-		schemes,
-		requirements
-	};
-}
-//#endregion
-//#region src/spec/build-resource.ts
-const METHODS = /* @__PURE__ */ new Set([
-	"get",
-	"put",
-	"post",
-	"patch",
-	"delete",
-	"head",
-	"options",
-	"trace",
-	"query"
-]);
-function isMethod(value) {
-	return METHODS.has(value);
-}
-/** The error statuses each operation can answer with. */
-const OPERATION_STATUSES = {
-	list: [
-		400,
-		401,
-		403
-	],
-	create: [
-		400,
-		401,
-		403,
-		409,
-		422
-	],
-	get: [
-		401,
-		403,
-		404
-	],
-	update: [
-		400,
-		401,
-		403,
-		404,
-		409,
-		422
-	],
-	delete: [
-		401,
-		403,
-		404,
-		409
-	]
-};
-/**
-* Statuses an operation only documents when it can answer with them; other
-* errors apply everywhere.
-*/
-const SCOPED_STATUSES = /* @__PURE__ */ new Set([
-	400,
-	401,
-	403,
-	404,
-	409,
-	422
-]);
-const JSON_TYPE = "application/json";
-function pageParameters(cursor, maxPageSize) {
-	return pageQuery(cursor, maxPageSize).map((p) => ({
-		name: p.name,
-		in: "query",
-		required: false,
-		description: p.description,
-		schema: p.schema
-	}));
-}
-function isParameter(value) {
-	return isPlainObject(value) && typeof value["name"] === "string" && typeof value["in"] === "string" && isPlainObject(value["schema"]);
-}
-function isPlanCarrier(input) {
-	return typeof input === "object" && "plan" in input;
-}
-/**
-* `description` and `deprecated` from comments, read structurally so older
-* metadata still works.
-*/
-function docsOf(value) {
-	if (!value) return {};
-	const description = "description" in value ? value.description : void 0;
-	const deprecated = "deprecated" in value ? value.deprecated : void 0;
-	return {
-		...typeof description === "string" && description !== "" ? { description } : {},
-		...deprecated === true ? { deprecated: true } : {}
-	};
-}
-function jsonContent(schema) {
-	return { [JSON_TYPE]: { schema } };
-}
-function jsonResponse(schema, description) {
-	return {
-		description,
-		content: jsonContent(schema)
-	};
-}
-function mutableProperties(schema) {
-	const properties = schema["properties"];
-	if (!isPlainObject(properties)) return;
-	const copy = {};
-	for (const [key, value] of Object.entries(properties)) if (isPlainObject(value)) copy[key] = { ...value };
-	schema["properties"] = copy;
-	return copy;
-}
-function createBuildContext(meta, options) {
-	const prefix = options.extensionPrefix ?? "x-better-supabase-";
-	const diagnostics = [];
-	const report = (diagnostic) => {
-		diagnostics.push(diagnostic);
-	};
-	const base = (options.basePath ?? "").replace(/\/$/, "");
-	const globalErrors = options.errors ?? DEFAULT_ERRORS;
-	const schemas = { Problem: structuredClone(PROBLEM_SCHEMA) };
-	const responses = {};
-	for (const error of globalErrors) responses[error.name] = errorResponse(error);
-	const operations = [];
-	const tags = [...options.tags ?? []];
-	const served = /* @__PURE__ */ new Map();
-	const { authorizer } = options;
-	const addTag = (name, description) => {
-		if (tags.some((tag) => tag.name === name)) return;
-		tags.push({
-			name,
-			...description ? { description } : {}
-		});
-	};
-	const addComponent = (name, schema) => {
-		const existing = schemas[name];
-		if (existing && JSON.stringify(existing) !== JSON.stringify(schema)) {
-			report({
-				code: "component-conflict",
-				severity: "error",
-				message: `Two different schemas are named "${name}"; the first one is kept`,
-				pointer: `/components/schemas/${pointerToken(name)}`
-			});
-			return;
-		}
-		schemas[name] = schema;
-	};
-	const keyOf = (ref, where) => {
-		if (authorizer) try {
-			return authorizer.key(ref);
-		} catch {
-			report({
-				code: "permission-unresolved",
-				severity: "error",
-				message: `${where}: the authorizer has no key for this permission`
-			});
-			return;
-		}
-		if (typeof ref === "string") return ref;
-		report({
-			code: "permission-unresolved",
-			severity: "error",
-			message: `${where}: a permission that is not a string needs an authorizer`
-		});
-	};
-	const converted = (standard, direction, where) => {
-		const result = convertStandard(standard, direction);
-		if (!result) report({
-			code: "schema-unconvertible",
-			severity: "warning",
-			message: `${where}: the schema does not implement Standard JSON Schema, so the spec allows any value`
-		});
-		return result;
-	};
-	const schemaOf = (standard, direction, role, operationId) => {
-		const result = converted(standard, direction, `${operationId} ${role}`);
-		if (!result) return {};
-		const name = options.componentName ? options.componentName({
-			kind: "schema",
-			id: result.name,
-			schema: result.schema,
-			role,
-			operationId
-		}) : result.name;
-		if (!name) return structuredClone(result.schema);
-		addComponent(name, structuredClone(result.schema));
-		return schemaRef(name);
-	};
-	const objectParameters = (standard, location, where) => {
-		const result = converted(standard, "input", where);
-		const properties = result?.schema["properties"];
-		if (!result || !isPlainObject(properties)) return [];
-		const required = result.schema["required"];
-		const requiredNames = Array.isArray(required) ? required : [];
-		return Object.entries(properties).flatMap(([name, schema]) => {
-			if (!isPlainObject(schema)) return [];
-			const description = schema["description"];
-			return [{
-				name,
-				in: location,
-				required: location === "path" || requiredNames.includes(name),
-				...typeof description === "string" ? { description } : {},
-				schema: structuredClone(schema)
-			}];
-		});
-	};
-	const usedErrors = (errors, statuses, permission) => {
-		const out = {};
-		for (const error of errors) {
-			if (SCOPED_STATUSES.has(error.status) && !statuses.includes(error.status)) continue;
-			const status = String(error.status);
-			if (Object.hasOwn(out, status)) continue;
-			if (error.status === 403 && permission) continue;
-			responses[error.name] ??= errorResponse(error);
-			out[status] = { ref: error.name };
-		}
-		if (permission) {
-			responses[PERMISSION_DENIED] ??= permissionDeniedResponse();
-			out["403"] = { ref: PERMISSION_DENIED };
-		}
-		return out;
-	};
-	const extendFor = (extend, name) => {
-		if (!extend) return;
-		const all = extend["*"];
-		const own = extend[name];
-		if (!all && !own) return;
-		return mergeJson(all ?? {}, own ?? {});
-	};
-	return {
-		meta,
-		options,
-		prefix,
-		base,
-		globalErrors,
-		diagnostics,
-		schemas,
-		responses,
-		operations,
-		tags,
-		served,
-		report,
-		addTag,
-		addComponent,
-		keyOf,
-		schemaOf,
-		objectParameters,
-		usedErrors,
-		extendFor
-	};
-}
-function resourceScope(ctx, key, input) {
-	const { meta, options, prefix, base, globalErrors, operations, served, report, addTag, addComponent, keyOf, schemaOf, usedErrors, extendFor } = ctx;
-	const { authorizer } = options;
-	let plan;
-	if (isPlanCarrier(input)) plan = input.plan;
-	else {
-		if (!meta.tables[key]) throw new TypeError(`better-supabase/spec: unknown table "${key}"`);
-		plan = planResource(meta, key, input === true ? {} : input, authorizer);
-	}
-	const tableKey = plan.table;
-	const table = plan.meta;
-	const description = plan.description;
-	const name = pascal(tableKey);
-	const tableDocs = docsOf(table);
-	const defs = tableSchemas(meta, options.json ?? {});
-	const componentFor = (variant) => {
-		const defaultName = `${name}${variant}`;
-		return options.componentName?.({
-			kind: "table",
-			table: tableKey,
-			variant,
-			defaultName
-		}) ?? defaultName;
-	};
-	const components = {};
-	for (const variant of [
-		"Row",
-		"Insert",
-		"Update"
-	]) {
-		const def = defs[`${tableKey}${variant}`];
-		if (!def) continue;
-		const schema = structuredClone(def);
-		if (tableDocs.description && schema["description"] === void 0) schema["description"] = tableDocs.description;
-		if (tableDocs.deprecated) schema["deprecated"] = true;
-		const properties = mutableProperties(schema);
-		for (const [column, property] of Object.entries(properties ?? {})) {
-			const docs = docsOf(table.columns[column]);
-			if (docs.description && property["description"] === void 0) property["description"] = docs.description;
-			if (docs.deprecated) property["deprecated"] = true;
-		}
-		const examples = options.examples?.[tableKey];
-		if (variant === "Row" && examples && examples.length > 0) schema["examples"] = structuredClone(examples);
-		const componentName = componentFor(variant);
-		components[variant] = componentName;
-		addComponent(componentName, schema);
-	}
-	const rowName = components.Row ?? componentFor("Row");
-	const cursor = plan.pagination === "cursor";
-	const pageName = componentFor("Page");
-	addComponent(pageName, pageSchema(schemaRef(rowName), cursor));
-	const tag = description.tag ?? tableKey;
-	addTag(tag, description.description ?? tableDocs.description);
-	const collection = `${base}${description.path ?? `/${tableKey}`}`;
-	const keyParam = plan.keyParam;
-	const rowProperties = defs[`${tableKey}Row`]?.["properties"];
-	const keySchema = keyParam && isPlainObject(rowProperties) ? rowProperties[keyParam] : void 0;
-	const idParameter = keyParam ? {
-		name: keyParam,
-		in: "path",
-		required: true,
-		schema: isPlainObject(keySchema) ? structuredClone(keySchema) : { type: "string" }
-	} : void 0;
-	const item = keyParam ? `${collection}/{${keyParam}}` : void 0;
-	const errors = description.errors ?? globalErrors;
-	const servedTable = {
-		table,
-		components,
-		operations: []
-	};
-	served.set(tableKey, servedTable);
-	const names = /* @__PURE__ */ new Set([...plan.operations, ...plan.actions.map((action) => action.name)]);
-	for (const extendKey of Object.keys(description.extend ?? {})) if (extendKey !== "*" && !names.has(extendKey)) report({
-		code: "extend-unknown",
-		severity: "warning",
-		message: `${tableKey}.extend.${extendKey} names no operation or action of the resource`
-	});
-	const add = (opName, source, method, path, fields) => {
-		const defaultId = `${opName}${name}`;
-		const id = options.operationId?.({
-			source,
-			method,
-			path,
-			defaultId
-		}) ?? defaultId;
-		const ref = plan.permissions[opName];
-		const permission = ref === void 0 ? void 0 : keyOf(ref, `${tableKey}.${opName}`);
-		const extend = extendFor(description.extend, opName);
-		const { extensions, ...rest } = fields;
-		const operation = {
-			id,
-			method,
-			path,
-			tags: [tag],
-			source,
-			...rest,
-			extensions: {
-				[`${prefix}table`]: `${table.schema}.${table.name}`,
-				...extensions,
-				...permission === void 0 ? {} : { [`${prefix}permission`]: permission }
-			},
-			...permission === void 0 ? {} : { permission },
-			...description.security ? { security: description.security } : {},
-			...extend ? { extend } : {},
-			...tableDocs.deprecated ? { deprecated: true } : {}
-		};
-		operations.push(operation);
-		servedTable.operations.push(operation);
-	};
-	const outputOf = (operation, fallback) => {
-		const output = description.output?.[operation];
-		return output ? schemaOf(output, "output", "output", `${operation}${name}`) : fallback;
-	};
-	const resourceOp = (operation) => ({
-		kind: "resource",
-		table: tableKey,
-		operation
-	});
-	const errorsFor = (operation) => usedErrors(errors, OPERATION_STATUSES[operation], plan.permissions[operation] !== void 0);
-	const opExtension = (operation) => ({ [`${prefix}operation`]: operation });
-	return {
-		ctx,
-		plan,
-		tableKey,
-		name,
-		description,
-		components,
-		componentFor,
-		rowName,
-		pageName,
-		cursor,
-		collection,
-		item,
-		idParameter,
-		errors,
-		add,
-		outputOf,
-		resourceOp,
-		errorsFor,
-		opExtension
-	};
-}
-function addTableOperation(scope, operation) {
-	const { plan, tableKey, name, description, components, componentFor, rowName, pageName, cursor, collection, item, idParameter, add, outputOf, resourceOp, errorsFor, opExtension } = scope;
-	const { schemaOf } = scope.ctx;
-	switch (operation) {
-		case "list": {
-			const listOutput = description.output?.list;
-			const pageRef = listOutput ? pageSchema(schemaOf(listOutput, "output", "item", `list${name}`), cursor) : schemaRef(pageName);
-			add("list", resourceOp("list"), "get", collection, {
-				summary: `List ${tableKey}`,
-				extensions: opExtension("list"),
-				parameters: description.list ? description.list.openapi.filter(isParameter) : pageParameters(cursor, plan.maxPageSize),
-				responses: {
-					"200": jsonResponse(pageRef, `A page of ${tableKey}.`),
-					...errorsFor("list")
-				}
-			});
-			break;
-		}
-		case "create": {
-			const body = description.input?.create ? schemaOf(description.input.create, "input", "input", `create${name}`) : schemaRef(components.Insert ?? componentFor("Insert"));
-			add("create", resourceOp("create"), "post", collection, {
-				summary: `Create a ${tableKey} row`,
-				extensions: opExtension("create"),
-				parameters: [],
-				requestBody: {
-					required: true,
-					content: jsonContent(body)
-				},
-				responses: {
-					"201": jsonResponse(outputOf("create", schemaRef(rowName)), "Created."),
-					...errorsFor("create")
-				}
-			});
-			break;
-		}
-		case "get":
-			if (!item || !idParameter) break;
-			add("get", resourceOp("get"), "get", item, {
-				summary: `Get a ${tableKey} row`,
-				extensions: opExtension("get"),
-				parameters: [idParameter],
-				responses: {
-					"200": jsonResponse(outputOf("get", schemaRef(rowName)), "The row."),
-					...errorsFor("get")
-				}
-			});
-			break;
-		case "update": {
-			if (!item || !idParameter) break;
-			const body = description.input?.update ? schemaOf(description.input.update, "input", "input", `update${name}`) : schemaRef(components.Update ?? componentFor("Update"));
-			add("update", resourceOp("update"), "patch", item, {
-				summary: `Update a ${tableKey} row`,
-				extensions: opExtension("update"),
-				parameters: [idParameter],
-				requestBody: {
-					required: true,
-					content: jsonContent(body)
-				},
-				responses: {
-					"200": jsonResponse(outputOf("update", schemaRef(rowName)), "Updated."),
-					...errorsFor("update")
-				}
-			});
-			break;
-		}
-		case "delete":
-			if (!item || !idParameter) break;
-			add("delete", resourceOp("delete"), "delete", item, {
-				summary: `Delete a ${tableKey} row`,
-				extensions: opExtension("delete"),
-				parameters: [idParameter],
-				responses: {
-					"204": { description: "Deleted." },
-					...errorsFor("delete")
-				}
-			});
-			break;
-		default: throw new TypeError(`better-supabase/spec: unknown operation "${String(operation)}"`);
-	}
-}
-function addAction(scope, action) {
-	const { tableKey, name, idParameter, collection, errors, add } = scope;
-	const { prefix, schemaOf, objectParameters, usedErrors } = scope.ctx;
-	const method = action.method.toLowerCase();
-	if (!isMethod(method)) throw new TypeError(`${tableKey}.actions.${action.name}: unknown method`);
-	const operationId = `${action.name}${name}`;
-	const parameters = [...action.params.length > 0 && idParameter ? [idParameter] : [], ...action.query ? objectParameters(action.query, "query", `${operationId} query`) : []];
-	const status = String(action.status ?? (action.output ? 200 : 204));
-	const statuses = [
-		...action.input || action.query ? [400] : [],
-		401,
-		403,
-		...action.params.length > 0 ? [404] : [],
-		...action.input ? [422] : []
-	];
-	add(action.name, {
-		kind: "action",
-		table: tableKey,
-		action: action.name
-	}, method, `${collection}${action.path}`, {
-		...action.summary ? { summary: action.summary } : {},
-		...action.description ? { description: action.description } : {},
-		...action.deprecated ? { deprecated: true } : {},
-		extensions: {
-			[`${prefix}action`]: action.name,
-			...action.emits ? { [`${prefix}emits`]: [...action.emits] } : {}
-		},
-		parameters,
-		...action.input ? { requestBody: {
-			required: true,
-			content: jsonContent(schemaOf(action.input, "input", "input", operationId))
-		} } : {},
-		responses: {
-			[status]: action.output ? jsonResponse(schemaOf(action.output, "output", "output", operationId), action.summary ?? "Done.") : { description: action.summary ?? "Done." },
-			...usedErrors(errors, statuses, action.permission !== void 0)
-		}
-	});
-}
-/** Adds one resource's components, tag and operations to the build. */
-function buildResource(ctx, key, input) {
-	const scope = resourceScope(ctx, key, input);
-	for (const operation of scope.plan.operations) addTableOperation(scope, operation);
-	for (const action of scope.plan.actions) addAction(scope, action);
-}
-//#endregion
-//#region src/spec/data-api.ts
-const REST = "/rest/v1";
-const DEFAULT_TAG = "Data API";
-const ERROR = "DataApiError";
-/** The error body PostgREST answers with. */
-const ERROR_SCHEMA = {
-	type: "object",
-	required: ["message"],
-	properties: {
-		code: { type: "string" },
-		message: { type: "string" },
-		details: { type: ["string", "null"] },
-		hint: { type: ["string", "null"] }
-	}
-};
-/**
-* Query parameters PostgREST reserves, so a column with the name gets no
-* filter.
-*/
-const RESERVED = /* @__PURE__ */ new Set([
-	"select",
-	"order",
-	"limit",
-	"offset",
-	"columns",
-	"on_conflict",
-	"or",
-	"and",
-	"not"
-]);
-const INTEGER = /* @__PURE__ */ new Set([
-	"int2",
-	"int4",
-	"int8"
-]);
-const NUMBER = /* @__PURE__ */ new Set([
-	"float4",
-	"float8",
-	"numeric",
-	"oid",
-	"money"
-]);
-/** The scheme names the `apiKey` and `bearer` presets register. */
-const DATA_API_SECURITY = [{
-	supabaseApiKey: [],
-	supabaseJwt: []
-}, { supabaseApiKey: [] }];
-/** JSON Schema for a Postgres type as PostgREST writes it. */
-function typeSchema(meta, type) {
-	if (type.startsWith("_")) return {
-		type: "array",
-		items: typeSchema(meta, type.slice(1))
-	};
-	const values = meta.enums[type];
-	if (values) return {
-		type: "string",
-		enum: [...values]
-	};
-	if (INTEGER.has(type)) return { type: "integer" };
-	if (NUMBER.has(type)) return { type: "number" };
-	switch (type) {
-		case "bool": return { type: "boolean" };
-		case "uuid": return {
-			type: "string",
-			format: "uuid"
-		};
-		case "timestamptz": return {
-			type: "string",
-			format: "date-time"
-		};
-		case "date": return {
-			type: "string",
-			format: "date"
-		};
-		case "json":
-		case "jsonb":
-		case "record":
-		case "void": return {};
-		default: return { type: "string" };
-	}
-}
-/**
-* A table schema with database column names, as the Data API reads and writes
-* them.
-*/
-function databaseCased(schema, table) {
-	const dbName = (name) => table.columns[name]?.db ?? name;
-	const properties = schema["properties"];
-	const required = schema["required"];
-	return {
-		...schema,
-		...isPlainObject(properties) ? { properties: Object.fromEntries(Object.entries(properties).map(([name, value]) => [dbName(name), value])) } : {},
-		...Array.isArray(required) ? { required: required.map((name) => typeof name === "string" ? dbName(name) : name) } : {}
-	};
-}
-const qualified = (schema, name) => schema === "public" ? name : `${schema}.${name}`;
-const STRING = { type: "string" };
-const header = (name, description, schema, required = false) => ({
-	name,
-	in: "header",
-	required,
-	description,
-	schema: schema ?? STRING
-});
-const query = (name, description, schema) => ({
-	name,
-	in: "query",
-	required: false,
-	description,
-	schema: schema ?? STRING
-});
-/**
-* The `Accept-Profile` or `Content-Profile` header a table outside `public`
-* needs.
-*/
-function profile(schema, write) {
-	return schema === "public" ? [] : [header(write ? "Content-Profile" : "Accept-Profile", `The schema of the table, \`${schema}\`.`, {
-		type: "string",
-		enum: [schema]
-	}, true)];
-}
-const PREFER_WRITE = header("Prefer", "`return=representation` answers with the written rows; `return=minimal` (the default) answers without a body.");
-/**
-* Documents the Data API: table operations under `/rest/v1/<table>` and RPCs
-* under `/rest/v1/rpc/<name>`.
-*/
-function buildDataApi(ctx, dataApi) {
-	const { meta, options, operations, report, addTag, addComponent, responses } = ctx;
-	const tag = dataApi.tag ?? DEFAULT_TAG;
-	const origin = options.supabaseUrl?.replace(/\/$/, "");
-	if (!origin) report({
-		code: "data-api-server-missing",
-		severity: "warning",
-		message: "dataApi needs supabaseUrl: without it the /rest/v1 paths resolve against the document's servers"
-	});
-	const servers = origin ? [{
-		url: origin,
-		description: "The Supabase project."
-	}] : void 0;
-	const defs = tableSchemas(meta, options.json ?? {});
-	const tableKeys = /* @__PURE__ */ new Set();
-	const unknownTable = (key, where) => {
-		report({
-			code: "data-api-table-unknown",
-			severity: "error",
-			message: `${where}: no table or view "${key}"`
-		});
-	};
-	if (dataApi.tables === true) for (const key of Object.keys(meta.tables).toSorted()) tableKeys.add(key);
-	else for (const key of dataApi.tables ?? []) if (meta.tables[key]) tableKeys.add(key);
-	else unknownTable(key, "dataApi.tables");
-	for (const key of Object.keys(dataApi.operations ?? {})) if (!meta.tables[key]) unknownTable(key, "dataApi.operations");
-	else if (!tableKeys.has(key)) tableKeys.add(key);
-	const functionKeys = [];
-	if (dataApi.functions === true) functionKeys.push(...Object.keys(meta.functions).toSorted());
-	else for (const key of dataApi.functions ?? []) if (meta.functions[key]) functionKeys.push(key);
-	else report({
-		code: "data-api-function-unknown",
-		severity: "error",
-		message: `dataApi.functions: no function "${key}"`
-	});
-	if (tableKeys.size === 0 && functionKeys.length === 0) return;
-	addTag(tag, "The Supabase Data API (PostgREST). Every request runs under row-level security.");
-	addComponent(ERROR, structuredClone(ERROR_SCHEMA));
-	responses[ERROR] ??= {
-		description: "PostgREST rejected the request.",
-		content: jsonContent(schemaRef(ERROR))
-	};
-	const errors = { "4XX": { ref: ERROR } };
-	/**
-	* The database-cased component of a table variant, or `undefined` when the
-	* table has none.
-	*/
-	const component = (key, variant) => {
-		const table = meta.tables[key];
-		const schema = defs[`${key}${variant}`];
-		if (!table || !schema) return;
-		const name = `DataApi${pascal(table.schema === "public" ? "" : `${table.schema}_`)}${pascal(table.name)}${variant}`;
-		addComponent(name, databaseCased(structuredClone(schema), table));
-		return schemaRef(name);
-	};
-	const push = (draft) => {
-		const { defaultId, ...rest } = draft;
-		operations.push({
-			...rest,
-			id: options.operationId?.({
-				source: draft.source,
-				method: draft.method,
-				path: draft.path,
-				defaultId
-			}) ?? defaultId,
-			tags: [tag],
-			...servers ? { servers } : {},
-			security: DATA_API_SECURITY,
-			extensions: {}
-		});
-	};
-	for (const key of tableKeys) {
-		const table = meta.tables[key];
-		if (table) buildTable(key, table);
-	}
-	for (const key of functionKeys) {
-		const fn = meta.functions[key];
-		if (fn) buildFunction(key, fn);
-	}
-	function buildTable(key, table) {
-		const row = component(key, "Row") ?? {};
-		const insert = component(key, "Insert");
-		const update = component(key, "Update");
-		const rows = {
-			type: "array",
-			items: row
-		};
-		const path = `${REST}/${table.name}`;
-		const name = pascal(table.schema === "public" ? table.name : `${table.schema}_${table.name}`);
-		const label = qualified(table.schema, table.name);
-		const filters = Object.values(table.columns).filter((column) => !RESERVED.has(column.db)).map((column) => query(column.db, `Filters on \`${column.db}\` with an operator and a value: \`eq.<value>\`, \`in.(a,b)\`, \`is.null\`.`));
-		const viewOperations = ["select"];
-		if (insert) viewOperations.push("insert");
-		if (update) viewOperations.push("update", "delete");
-		const allowed = dataApi.operations?.[key] ?? (table.kind === "view" ? viewOperations : [
-			"select",
-			"insert",
-			"update",
-			"delete"
-		]);
-		const source = (operation) => ({
-			kind: "data-api",
-			table: key,
-			operation
-		});
-		const written = (status, description) => ({ [status]: jsonResponse(rows, `${description} The body holds the rows with \`Prefer: return=representation\`.`) });
-		for (const operation of allowed) switch (operation) {
-			case "select":
-				push({
-					defaultId: `dataApiSelect${name}`,
-					method: "get",
-					path,
-					summary: `Read rows of ${label}`,
-					parameters: [
-						query("select", "The columns to return, comma separated, and embedded relations as `relation(columns)`. Defaults to `*`."),
-						query("order", "Sort order, such as `created_at.desc,id`."),
-						query("limit", "The most rows to return.", {
-							type: "integer",
-							minimum: 0
-						}),
-						query("offset", "The rows to skip.", {
-							type: "integer",
-							minimum: 0
-						}),
-						...filters,
-						header("Range", "A row range, such as `0-24`."),
-						header("Prefer", "`count=exact`, `count=planned` or `count=estimated` adds the total to `Content-Range`."),
-						...profile(table.schema, false)
-					],
-					responses: {
-						"200": {
-							...jsonResponse(rows, "The rows."),
-							headers: { "Content-Range": {
-								description: "The returned range and the total, such as `0-24/100`.",
-								schema: { type: "string" }
-							} }
-						},
-						"206": jsonResponse(rows, "Part of the rows, for a `Range` request."),
-						...errors
-					},
-					source: source("select")
-				});
-				break;
-			case "insert":
-				push({
-					defaultId: `dataApiInsert${name}`,
-					method: "post",
-					path,
-					summary: `Insert rows into ${label}`,
-					parameters: [
-						query("columns", "The columns to read from the body, comma separated."),
-						query("on_conflict", "The unique columns an upsert matches on, comma separated."),
-						PREFER_WRITE,
-						...profile(table.schema, true)
-					],
-					requestBody: {
-						required: true,
-						content: jsonContent(insert ? { oneOf: [insert, {
-							type: "array",
-							items: insert
-						}] } : {})
-					},
-					responses: {
-						...written("201", "Created."),
-						...errors
-					},
-					source: source("insert")
-				});
-				break;
-			case "update":
-				push({
-					defaultId: `dataApiUpdate${name}`,
-					method: "patch",
-					path,
-					summary: `Update rows of ${label}`,
-					description: "Updates every row the filters match.",
-					parameters: [
-						...filters,
-						PREFER_WRITE,
-						...profile(table.schema, true)
-					],
-					requestBody: {
-						required: true,
-						content: jsonContent(update ?? {})
-					},
-					responses: {
-						...written("200", "Updated."),
-						"204": { description: "Updated, without a body." },
-						...errors
-					},
-					source: source("update")
-				});
-				break;
-			case "delete":
-				push({
-					defaultId: `dataApiDelete${name}`,
-					method: "delete",
-					path,
-					summary: `Delete rows of ${label}`,
-					description: "Deletes every row the filters match.",
-					parameters: [
-						...filters,
-						PREFER_WRITE,
-						...profile(table.schema, true)
-					],
-					responses: {
-						...written("200", "Deleted."),
-						"204": { description: "Deleted, without a body." },
-						...errors
-					},
-					source: source("delete")
-				});
-				break;
-			default: throw new TypeError(`Unknown Data API operation "${String(operation)}"`);
-		}
-	}
-	function argumentsSchema(signature) {
-		const required = signature.args.filter((arg) => arg.optional !== true).map((arg) => arg.name);
-		return {
-			type: "object",
-			properties: Object.fromEntries(signature.args.map((arg) => [arg.name, typeSchema(meta, arg.type)])),
-			...required.length > 0 ? { required } : {},
-			additionalProperties: false
-		};
-	}
-	function resultSchema(fn) {
-		const { result } = fn;
-		let one;
-		if (result && "table" in result) one = component(result.table, "Row") ?? {};
-		else if (result) one = {
-			type: "object",
-			properties: Object.fromEntries(result.columns.map((column) => [column.db, {}])),
-			required: result.columns.map((column) => column.db)
-		};
-		else {
-			const rowTable = Object.entries(meta.tables).find(([, table]) => table.name === fn.returns && table.schema === fn.schema);
-			one = rowTable ? component(rowTable[0], "Row") ?? {} : typeSchema(meta, fn.returns);
-		}
-		return fn.returnsSet ? {
-			type: "array",
-			items: one
-		} : one;
-	}
-	function buildFunction(key, fn) {
-		const signatures = fn.overloads ?? [fn];
-		const bodies = signatures.map(argumentsSchema);
-		const [only] = bodies;
-		const body = bodies.length === 1 && only ? only : { oneOf: bodies };
-		const takesArgs = signatures.some((signature) => signature.args.length > 0);
-		push({
-			defaultId: `dataApiRpc${pascal(fn.schema === "public" ? fn.name : `${fn.schema}_${fn.name}`)}`,
-			method: "post",
-			path: `${REST}/rpc/${fn.name}`,
-			summary: `Call ${qualified(fn.schema, fn.name)}`,
-			description: `A ${fn.volatility} function.${fn.volatility === "volatile" ? "" : " A GET with the arguments as query parameters calls it too."}`,
-			parameters: profile(fn.schema, true),
-			requestBody: {
-				required: takesArgs,
-				content: jsonContent(body)
-			},
-			responses: {
-				...fn.returns === "void" && !fn.returnsSet ? { "204": { description: "Done." } } : { "200": jsonResponse(resultSchema(fn), "The result.") },
-				...errors
-			},
-			source: {
-				kind: "data-api",
-				function: key,
-				operation: "rpc"
-			}
-		});
-	}
-}
-/** Adds the `apiKey` and `bearer` schemes the Data API operations require. */
-function withDataApiSchemes(security, operations, supabaseUrl) {
-	if (!operations.some((operation) => operation.source.kind === "data-api")) return security;
-	const { schemes } = resolveSecurity(["apiKey", "bearer"], supabaseUrl);
-	return {
-		schemes: {
-			...schemes,
-			...security.schemes
-		},
-		requirements: security.requirements
-	};
-}
-//#endregion
-//#region src/spec/events.ts
-/**
-* Whether a value is a `defineTopic()` result: a template string and the `sql`,
-* `trigger` and `subscribe` methods. `better-supabase sql sync` and `spec` use
-* the same check.
-*/
-function isTopicLike(value) {
-	return isRecord(value) && typeof value["template"] === "string" && typeof value["sql"] === "function" && typeof value["trigger"] === "function" && typeof value["subscribe"] === "function";
-}
-/**
-* The `defineTopic()` results in modules or arrays, for `events.topics`. A
-* module's topics are keyed by export name; a topic in an array by its `name`.
-* Other values are skipped, and a topic reached twice is kept once.
-*
-* ```ts
-* import * as topics from "../realtime/topics";
-* defineApi(betterSupabase, {
-*   info,
-*   events: { topics: topicsFrom(topics) },
-* });
-* ```
-*/
-function topicsFrom(...sources) {
-	const topics = {};
-	const seen = /* @__PURE__ */ new Set();
-	for (const source of sources) {
-		const entries = Array.isArray(source) ? source.map((value) => [void 0, value]) : Object.entries(source);
-		for (const [key, value] of entries) {
-			if (!isTopicLike(value) || seen.has(value)) continue;
-			seen.add(value);
-			topics[key ?? value.name ?? value.template] = value;
-		}
-	}
-	return topics;
-}
-const OPEN = { type: "object" };
-const DEFAULT_INTENTS = [
-	"insert",
-	"update",
-	"delete"
-];
-/** An id safe for AsyncAPI channel, operation and component keys. */
-function safeKey(value) {
-	return value.replaceAll(/[^A-Za-z0-9_-]/g, "_");
-}
-const keyPart = (value) => safeKey(pascal(value));
-/** The CloudEvents attributes in HTTP binary mode (`ce-*` headers). */
-const CLOUD_EVENT_TRAIT = {
-	description: "CloudEvents 1.0 attributes in HTTP binary mode.",
-	contentType: "application/json",
-	headers: {
-		type: "object",
-		properties: {
-			"ce-specversion": {
-				type: "string",
-				const: "1.0"
-			},
-			"ce-id": { type: "string" },
-			"ce-source": {
-				type: "string",
-				format: "uri-reference"
-			},
-			"ce-type": { type: "string" },
-			"ce-subject": { type: "string" },
-			"ce-time": {
-				type: "string",
-				format: "date-time"
-			},
-			"ce-dataschema": {
-				type: "string",
-				format: "uri"
-			},
-			"ce-partitionkey": { type: "string" }
-		}
-	}
-};
-function cloudEventHeaders(type, dataschema) {
-	return {
-		type: "object",
-		required: [
-			"ce-specversion",
-			"ce-id",
-			"ce-source",
-			"ce-type"
-		],
-		properties: {
-			"ce-type": {
-				type: "string",
-				const: type
-			},
-			...dataschema ? { "ce-dataschema": {
-				type: "string",
-				const: dataschema
-			} } : {}
-		}
-	};
-}
-function convert(schema, where, ctx) {
-	if (schema === true) return OPEN;
-	const converted = convertStandard(schema, "output");
-	if (converted) return converted.schema;
-	ctx.report({
-		code: "asyncapi-schema-opaque",
-		severity: "warning",
-		message: `${where}: the schema does not implement Standard JSON Schema; the payload is left open`
-	});
-	return OPEN;
-}
-function tableChannels(ctx, selection, channels, messages) {
-	if (selection === false) return;
-	const realtime = ctx.meta.realtime ?? {};
-	const keys = selection === true ? Object.keys(realtime) : selection;
-	for (const key of keys) {
-		const table = ctx.meta.tables[key];
-		const config = realtime[key];
-		if (!table || !config) {
-			ctx.report({
-				code: "asyncapi-table-unknown",
-				severity: "error",
-				message: `events.tables names "${key}", which is not in realtime.tables`
-			});
-			continue;
-		}
-		const id = `table${keyPart(key)}`;
-		const base = `bs:t:${table.schema}.${table.name}`;
-		const address = config.user ? `${base}:u:{userId}` : config.tenant ? `${base}:{tenant}` : base;
-		const messageId = `${id}Change`;
-		messages[messageId] = {
-			id: messageId,
-			name: "change",
-			title: `${key} changed`,
-			summary: `A row of ${table.schema}.${table.name} was inserted, updated or deleted. Clients refetch through row-level security.`,
-			contentType: "application/json",
-			payload: {
-				type: "object",
-				required: [
-					"schema",
-					"table",
-					"operation"
-				],
-				properties: {
-					schema: {
-						type: "string",
-						const: table.schema
-					},
-					table: {
-						type: "string",
-						const: table.name
-					},
-					operation: {
-						type: "string",
-						enum: [
-							"INSERT",
-							"UPDATE",
-							"DELETE"
-						]
-					}
-				}
-			},
-			extensions: { [`${ctx.prefix}event`]: "change" }
-		};
-		channels.push({
-			id,
-			address,
-			title: `${key} changes`,
-			protocol: "ws",
-			...config.user ? { parameters: { userId: { description: "The signed-in user's id." } } } : config.tenant ? { parameters: { tenant: { description: `The row's \`${config.tenant}\` value.` } } } : {},
-			messages: [messageId],
-			operations: [{
-				id: `receive${keyPart(key)}Changes`,
-				action: "receive",
-				summary: `Change signals for ${key}`
-			}],
-			extensions: {
-				[`${ctx.prefix}table`]: `${table.schema}.${table.name}`,
-				[`${ctx.prefix}realtime-status`]: topicStatus({ private: true })
-			}
-		});
-	}
-}
-function topicChannels(ctx, topics, channels, messages) {
-	for (const [key, topic] of Object.entries(topics)) {
-		const id = `topic${keyPart(key)}`;
-		const ids = [];
-		const events = Object.entries(topic.events ?? {});
-		if (events.length === 0) {
-			ctx.report({
-				code: "asyncapi-topic-open",
-				severity: "info",
-				message: `Topic "${key}" lists no events; it is documented with one open message`
-			});
-			events.push(["*", true]);
-		}
-		for (const [event, schema] of events) {
-			const messageId = `${id}${event === "*" ? "Any" : keyPart(event)}`;
-			ids.push(messageId);
-			messages[messageId] = {
-				id: messageId,
-				...event === "*" ? {} : { name: event },
-				title: event === "*" ? `${key} broadcast` : `${key} ${event}`,
-				contentType: "application/json",
-				payload: convert(schema, `topics.${key}.events.${event}`, ctx),
-				extensions: { [`${ctx.prefix}event`]: event }
-			};
-		}
-		if (topic.presence) {
-			const messageId = `${id}Presence`;
-			ids.push(messageId);
-			messages[messageId] = {
-				id: messageId,
-				name: "presence",
-				title: `${key} presence`,
-				contentType: "application/json",
-				payload: topic.presenceSchema ? convert(topic.presenceSchema, `topics.${key}.presence`, ctx) : OPEN,
-				extensions: { [`${ctx.prefix}event`]: "presence" }
-			};
-		}
-		const permission = topic.permission === void 0 ? void 0 : ctx.keyOf(topic.permission, `topics.${key}`);
-		const extra = permission === void 0 ? {} : { permission };
-		const operations = [{
-			id: `receive${keyPart(key)}`,
-			action: "receive",
-			...topic.summary ? { summary: topic.summary } : {},
-			...extra
-		}];
-		if (topic.send === true || topic.clientSend === true || topic.presence) operations.push({
-			id: `send${keyPart(key)}`,
-			action: "send",
-			...extra
-		});
-		const params = [...topic.template.matchAll(/\{([^}]+)\}/g)].map((match) => match[1] ?? "");
-		channels.push({
-			id,
-			address: topic.template,
-			...topic.summary ? { summary: topic.summary } : {},
-			...topic.description ? { description: topic.description } : {},
-			title: topic.name ?? key,
-			...params.length > 0 ? { parameters: Object.fromEntries(params.map((name) => [name, {}])) } : {},
-			protocol: "ws",
-			messages: ids,
-			operations,
-			extensions: {
-				[`${ctx.prefix}private`]: topic.private ?? true,
-				[`${ctx.prefix}realtime-status`]: topic.status ?? topicStatus(topic)
-			}
-		});
-	}
-}
-function withActor(schema) {
-	const properties = schema["properties"];
-	if (!isPlainObject(properties) || "actorId" in properties) return schema;
-	return {
-		...schema,
-		properties: {
-			...properties,
-			actorId: {
-				type: "string",
-				description: "Who caused the event."
-			}
-		}
-	};
-}
-function cloudEventChannel(ctx, input, channels, messages) {
-	const ids = [];
-	const add = (messageId, type, title, payload, table) => {
-		const { dataschema } = dataschemaOf(input, {
-			type,
-			...table ? { table } : {}
-		});
-		ids.push(messageId);
-		messages[messageId] = {
-			id: messageId,
-			name: type,
-			title,
-			contentType: "application/json",
-			headers: cloudEventHeaders(type, dataschema),
-			payload,
-			traits: ["cloudEvent"],
-			extensions: {
-				[`${ctx.prefix}cloudevent-type`]: type,
-				...dataschema ? { [`${ctx.prefix}dataschema`]: dataschema } : {}
-			}
-		};
-	};
-	const rows = input.rows ?? false;
-	const rowTables = rows === true ? Object.keys(ctx.meta.tables) : rows === false ? [] : rows;
-	const defs = rowTables.length > 0 ? tableSchemas(ctx.meta, ctx.json) : {};
-	for (const table of rowTables) {
-		if (!ctx.meta.tables[table]) {
-			ctx.report({
-				code: "asyncapi-table-unknown",
-				severity: "error",
-				message: `events.cloudEvents.rows names an unknown table "${table}"`
-			});
-			continue;
-		}
-		const component = ctx.served.get(table)?.components.Row;
-		const row = component ? schemaRef(component) : defs[`${table}Row`] ?? OPEN;
-		for (const intent of input.intents ?? DEFAULT_INTENTS) {
-			const last = ROW_EVENT_TYPES[intent].split(".").at(-1) ?? intent;
-			const type = input.typePrefix ? `${input.typePrefix}.row.${last}` : ROW_EVENT_TYPES[intent];
-			add(`row${keyPart(table)}${keyPart(last)}`, type, `${table} ${last}`, {
-				type: "object",
-				required: ["table", "row"],
-				properties: {
-					table: {
-						type: "string",
-						const: table
-					},
-					row,
-					actorId: { type: "string" }
-				}
-			}, table);
-		}
-	}
-	for (const [event, schema] of Object.entries(input.blocks ?? {})) {
-		if (schema === void 0) continue;
-		const type = `${input.typePrefix ?? "dev.better-supabase"}.${event}`;
-		add(`block${keyPart(event)}`, type, event, withActor(convert(schema, `events.cloudEvents.blocks.${event}`, ctx)));
-	}
-	if (ids.length === 0) return false;
-	channels.push({
-		id: "cloudEvents",
-		address: input.address ?? "events",
-		title: "CloudEvents",
-		description: `CloudEvents from \`${input.source}\`, sent to the event sink.`,
-		protocol: "http",
-		messages: ids,
-		operations: [{
-			id: "sendCloudEvents",
-			action: "send"
-		}]
-	});
-	return true;
-}
-/**
-* The built channels and messages first, then the app's own (which win on an
-* id), and the workflows with every `WorkflowSource` run on `operations`.
-*/
-function eventParts(options, ctx, operations) {
-	const built = buildEvents(options.events, ctx);
-	return {
-		channels: [...built.channels, ...options.channels ?? []],
-		messages: {
-			...built.messages,
-			...options.messages
-		},
-		...Object.keys(built.messageTraits).length > 0 ? { messageTraits: built.messageTraits } : {},
-		workflows: (options.workflows ?? []).flatMap((workflow) => typeof workflow === "function" ? workflow(operations) : [workflow])
-	};
-}
-/** Channels and messages from the realtime tables, topics and CloudEvents. */
-function buildEvents(events, ctx) {
-	const channels = [];
-	const messages = {};
-	const messageTraits = {};
-	if (!events) return {
-		channels,
-		messages,
-		messageTraits
-	};
-	tableChannels(ctx, events.tables ?? true, channels, messages);
-	topicChannels(ctx, events.topics ?? {}, channels, messages);
-	if (events.cloudEvents && cloudEventChannel(ctx, events.cloudEvents, channels, messages)) messageTraits["cloudEvent"] = CLOUD_EVENT_TRAIT;
-	return {
-		channels,
-		messages,
-		messageTraits
-	};
-}
-//#endregion
-//#region src/spec/build.ts
-const READ_METHODS = /* @__PURE__ */ new Set([
-	"get",
-	"head",
-	"options",
-	"query"
-]);
-const modelCache = /* @__PURE__ */ new WeakMap();
-const NO_PLUGINS = [];
-/**
-* Builds the version-neutral API model once per metadata, plugin list and
-* options object. Formats lower it to each version; `defineApi` wraps it.
-*/
-function buildApiModel(source, options) {
-	const plugins = source.plugins ?? NO_PLUGINS;
-	let byPlugins = modelCache.get(source.meta);
-	if (!byPlugins) {
-		byPlugins = /* @__PURE__ */ new WeakMap();
-		modelCache.set(source.meta, byPlugins);
-	}
-	let byOptions = byPlugins.get(plugins);
-	if (!byOptions) {
-		byOptions = /* @__PURE__ */ new WeakMap();
-		byPlugins.set(plugins, byOptions);
-	}
-	let built = byOptions.get(options);
-	if (!built) {
-		built = build(source.meta, plugins, options);
-		byOptions.set(options, built);
-	}
-	return built;
-}
-function build(meta, plugins, options) {
-	const ctx = createBuildContext(meta, options);
-	for (const [key, input] of Object.entries(options.resources ?? {})) buildResource(ctx, key, input);
-	for (const [index, route] of (options.routes ?? []).entries()) buildRoute(ctx, route, index);
-	if (options.dataApi) buildDataApi(ctx, options.dataApi);
-	const security = withDataApiSchemes(buildSecurity(ctx), ctx.operations, options.supabaseUrl);
-	applyPlugins(ctx, plugins);
-	validateOperations(ctx);
-	return finalizeModel(ctx, security);
-}
-function buildRoute(ctx, route, index) {
-	const { options, base, globalErrors, operations, prefix, addTag, keyOf, schemaOf, objectParameters, usedErrors } = ctx;
-	const method = route.method.toLowerCase();
-	if (!isMethod(method)) throw new TypeError(`better-supabase/spec: routes[${index}] has an unknown method "${route.method}"`);
-	const path = `${base}${route.path}`;
-	const defaultId = `${method}${route.path.split("/").filter(Boolean).map((segment) => segment.replaceAll(/[{}]/g, "")).map(pascal).join("")}`;
-	const source = { kind: "route" };
-	const id = route.operationId ?? options.operationId?.({
-		source,
-		method,
-		path,
-		defaultId
-	}) ?? defaultId;
-	const declared = route.params ? objectParameters(route.params, "path", `${id} params`) : [];
-	const parameters = [];
-	for (const [, param] of path.matchAll(/\{(\w+)\}/g)) parameters.push(declared.find((entry) => entry.name === param) ?? {
-		name: param,
-		in: "path",
-		required: true,
-		schema: { type: "string" }
-	});
-	if (route.query) parameters.push(...objectParameters(route.query, "query", `${id} query`));
-	const permission = route.permission === void 0 ? void 0 : keyOf(route.permission, `routes[${index}]`);
-	const secured = route.security === void 0 || route.security.length > 0;
-	const status = String(route.status ?? (route.output || route.stream ? 200 : 204));
-	const success = route.stream ? {
-		description: route.summary ?? "A stream of events.",
-		content: { [route.stream.contentType ?? "text/event-stream"]: { itemSchema: schemaOf(route.stream.item, "output", "item", id) } }
-	} : route.output ? jsonResponse(schemaOf(route.output, "output", "output", id), route.summary ?? "OK.") : { description: route.summary ?? "Done." };
-	const routeTags = [...route.tags ?? []];
-	for (const tag of routeTags) addTag(tag);
-	operations.push({
-		id,
-		method,
-		path,
-		tags: routeTags,
-		source,
-		...route.summary ? { summary: route.summary } : {},
-		...route.description ? { description: route.description } : {},
-		...route.deprecated ? { deprecated: true } : {},
-		parameters,
-		...route.input ? { requestBody: {
-			required: true,
-			content: jsonContent(schemaOf(route.input, "input", "input", id))
-		} } : {},
-		responses: {
-			[status]: success,
-			...usedErrors(route.errors ?? globalErrors, [...route.input || route.query ? [400, 422] : [], ...secured ? [401, 403] : []], permission !== void 0)
-		},
-		...route.security ? { security: route.security } : {},
-		...permission === void 0 ? {} : { permission },
-		extensions: permission === void 0 ? {} : { [`${prefix}permission`]: permission },
-		...route.extend ? { extend: route.extend } : {}
-	});
-}
-function buildSecurity(ctx) {
-	const { options, operations } = ctx;
-	const oauthScopes = {};
-	if (options.permissionScopes === "keys") {
-		for (const operation of operations) if (operation.permission) oauthScopes[operation.permission] = `Permission ${operation.permission}.`;
-	}
-	const security = resolveSecurity(options.security ?? ["bearer"], options.supabaseUrl, oauthScopes);
-	if (options.permissionScopes === "keys") for (const operation of operations) {
-		const key = operation.permission;
-		if (!key || operation.security?.length === 0) continue;
-		operation.security = (operation.security ?? security.requirements).map((requirement) => {
-			const scopes = requirement[OAUTH_SCHEME];
-			return scopes ? {
-				...requirement,
-				[OAUTH_SCHEME]: [...scopes, key]
-			} : requirement;
-		});
-	}
-	return security;
-}
-function applyPlugins(ctx, plugins) {
-	const { meta, prefix, served, schemas, report } = ctx;
-	const describe = describeApi(meta, prefix, served, schemas);
-	for (const plugin of plugins) {
-		if (!plugin.describe) continue;
-		try {
-			plugin.describe(describe);
-		} catch (error) {
-			report({
-				code: "plugin-describe-failed",
-				severity: "warning",
-				message: `The ${plugin.name} plugin's describe() threw: ${error instanceof Error ? error.message : String(error)}`
-			});
-		}
-	}
-}
-/** Reports writes without a permission and duplicate operation ids. */
-function validateOperations(ctx) {
-	const { options, operations, report } = ctx;
-	if (options.requirePermissions) for (const operation of operations) {
-		if (operation.source.kind === "data-api") continue;
-		if ((operation.source.kind === "resource" ? operation.source.operation !== "list" && operation.source.operation !== "get" : !READ_METHODS.has(operation.method)) && operation.permission === void 0) report({
-			code: "permission-missing",
-			severity: "error",
-			message: `${operation.id} writes but declares no permission`,
-			pointer: `/operations/${pointerToken(operation.id)}`
-		});
-	}
-	const seen = /* @__PURE__ */ new Set();
-	for (const operation of operations) {
-		if (seen.has(operation.id)) report({
-			code: "operation-id-duplicate",
-			severity: "error",
-			message: `Two operations have the id "${operation.id}"`,
-			pointer: `/operations/${pointerToken(operation.id)}`
-		});
-		seen.add(operation.id);
-	}
-}
-function finalizeModel(ctx, security) {
-	const { meta, options, prefix, served, keyOf, report, schemas, operations, tags, responses, diagnostics } = ctx;
-	const { enrich } = options;
-	const finalSchemas = {};
-	for (const [name, schema] of Object.entries(schemas)) finalSchemas[name] = enrich?.schema?.(schema, { name }) ?? schema;
-	const finalOperations = operations.map((operation) => enrich?.operation?.(operation) ?? operation);
-	const { messageTraits, ...parts } = eventParts(options, {
-		meta,
-		json: options.json ?? {},
-		prefix,
-		served,
-		keyOf,
-		report
-	}, finalOperations);
-	const messages = {};
-	for (const [id, message] of Object.entries(parts.messages)) messages[id] = enrich?.message?.(message, { id }) ?? message;
-	return {
-		model: {
-			info: options.info,
-			...options.self ? { self: options.self } : {},
-			servers: options.servers ?? [],
-			tags,
-			operations: finalOperations,
-			schemas: finalSchemas,
-			responses,
-			securitySchemes: security.schemes,
-			security: security.requirements,
-			...options.securityProfileRequirements ? { securityProfileRequirements: options.securityProfileRequirements } : {},
-			channels: parts.channels.map((channel) => enrich?.channel?.(channel) ?? channel),
-			messages,
-			...messageTraits ? { messageTraits } : {},
-			webhooks: options.webhooks ?? [],
-			workflows: parts.workflows.map((workflow) => enrich?.workflow?.(workflow) ?? workflow),
-			fragments: options.fragments ?? [],
-			...options.realtimeUrl ? { realtimeUrl: options.realtimeUrl } : {},
-			extensionPrefix: prefix
-		},
-		diagnostics
-	};
-}
-function describeApi(meta, prefix, served, schemas) {
-	const columnSchemas = (table, column) => {
-		const entry = served.get(table);
-		if (!entry) return [];
-		return [
-			"Row",
-			"Insert",
-			"Update"
-		].flatMap((variant) => {
-			const name = entry.components[variant];
-			const schema = name ? schemas[name] : void 0;
-			const properties = schema?.["properties"];
-			if (!schema || !isPlainObject(properties)) return [];
-			const property = properties[column];
-			if (!isPlainObject(property)) return [];
-			return [{
-				variant,
-				schema,
-				properties,
-				property
-			}];
-		});
-	};
-	const replace = (schema, properties, column, property) => {
-		schema["properties"] = {
-			...properties,
-			[column]: property
-		};
-	};
-	return {
-		schema: meta,
-		extensionPrefix: prefix,
-		resources: [...served.values()].map((entry) => ({
-			table: entry.table,
-			operations: entry.operations.map((operation) => operation.source.kind === "action" ? operation.source.action : operation.source.kind === "resource" ? operation.source.operation : operation.id)
-		})),
-		addParameter(table, parameter, names) {
-			for (const operation of served.get(table)?.operations ?? []) {
-				const name = operation.source.kind === "action" ? operation.source.action : operation.source.kind === "resource" ? operation.source.operation : operation.id;
-				if (names && !names.includes(name)) continue;
-				if (operation.parameters.some((entry) => entry.name === parameter.name && entry.in === parameter.in)) continue;
-				operation.parameters.push({ ...parameter });
-			}
-		},
-		markReadOnly(table, column, description) {
-			for (const { variant, schema, properties, property } of columnSchemas(table, column)) {
-				replace(schema, properties, column, {
-					...property,
-					readOnly: true,
-					...description && property["description"] === void 0 ? { description } : {}
-				});
-				const required = schema["required"];
-				if (variant !== "Row" && Array.isArray(required)) schema["required"] = required.filter((name) => name !== column);
-			}
-		},
-		describeColumn(table, column, patch) {
-			for (const { schema, properties, property } of columnSchemas(table, column)) replace(schema, properties, column, mergeJson(property, patch));
-		}
-	};
-}
-//#endregion
-export { DEFAULT_ERRORS as a, pascal as c, topicsFrom as i, mergeJson as l, CLOUD_EVENT_TRAIT as n, PROBLEM_SCHEMA as o, safeKey as r, convertStandard as s, buildApiModel as t, pointerToken as u };