better-supabase 0.7.0 → 0.8.0

package/dist/api-DtHFC037.js

@@ -0,0 +1,676 @@
+import { r as isPlainObject } from "./clone-dN9XOL1K.js";
+import { t as SPEC_PINS } from "./spec-pins-DsLfUH7l.js";
+import { c as mergeJson, l as pointerToken, s as pascal, t as buildApiModel } from "./build-hPwk3_X5.js";
+//#region src/spec/format.ts
+/** Identity helper that fixes `apiVersion` and checks that the default version exists. */
+function defineDocumentFormat(format) {
+	if (!Object.hasOwn(format.versions, format.defaultVersion)) throw new TypeError(`Document format "${format.id}": the default version "${format.defaultVersion}" is not in versions`);
+	if (format.versions[format.defaultVersion].status === "preview") throw new TypeError(`Document format "${format.id}": a preview version cannot be the default`);
+	return {
+		...format,
+		apiVersion: 1
+	};
+}
+//#endregion
+//#region src/openapi/schema30.ts
+/** Keywords whose value is one subschema. */
+const SINGLE = /* @__PURE__ */ new Set([
+	"items",
+	"additionalProperties",
+	"not"
+]);
+/** Keywords whose value is a list of subschemas. */
+const LISTS = /* @__PURE__ */ new Set([
+	"allOf",
+	"anyOf",
+	"oneOf"
+]);
+/** 2020-12 keywords the OpenAPI 3.0 Schema Object does not have. */
+const DROPPED = /* @__PURE__ */ new Set([
+	"$schema",
+	"$id",
+	"$anchor",
+	"$dynamicAnchor",
+	"$dynamicRef",
+	"$comment",
+	"$defs",
+	"$vocabulary",
+	"prefixItems",
+	"contains",
+	"minContains",
+	"maxContains",
+	"propertyNames",
+	"patternProperties",
+	"dependentRequired",
+	"dependentSchemas",
+	"unevaluatedItems",
+	"unevaluatedProperties",
+	"if",
+	"then",
+	"else",
+	"contentMediaType",
+	"contentSchema"
+]);
+const isNullSchema = (value) => isPlainObject(value) && value["type"] === "null" && Object.keys(value).length === 1;
+/**
+* Rewrites a JSON Schema 2020-12 schema into the OpenAPI 3.0 Schema Object:
+* `null` in `type` or in an `anyOf`/`oneOf` becomes `nullable`, a type list
+* becomes `anyOf`, `const` becomes a one-value `enum`, `examples` becomes
+* `example`, numeric `exclusiveMinimum`/`exclusiveMaximum` become the
+* boolean form, `contentEncoding: base64` becomes `format: byte`, and a
+* `$ref` with siblings is wrapped in `allOf`. Keywords 3.0 does not have
+* are left out. The input is not changed.
+*/
+function toOpenApi30Schema(schema) {
+	const out = {};
+	let nullable = false;
+	for (const [key, value] of Object.entries(schema)) {
+		if (DROPPED.has(key)) continue;
+		if (key === "properties" && isPlainObject(value)) out[key] = Object.fromEntries(Object.entries(value).map(([name, child]) => [name, isPlainObject(child) ? toOpenApi30Schema(child) : child]));
+		else if (SINGLE.has(key) && isPlainObject(value)) out[key] = toOpenApi30Schema(value);
+		else if (LISTS.has(key) && Array.isArray(value)) {
+			const branches = value;
+			const rest = branches.filter((branch) => !isNullSchema(branch));
+			if (key !== "allOf" && rest.length < branches.length) nullable = true;
+			out[key] = rest.map((branch) => isPlainObject(branch) ? toOpenApi30Schema(branch) : branch);
+		} else if (key === "examples" && Array.isArray(value)) {
+			if (value.length > 0) out["example"] = value[0];
+		} else if ((key === "exclusiveMinimum" || key === "exclusiveMaximum") && typeof value === "number") {
+			out[key === "exclusiveMinimum" ? "minimum" : "maximum"] = value;
+			out[key] = true;
+		} else if (key === "const") out["enum"] = [value];
+		else if (key === "contentEncoding") {
+			if (value === "base64" && schema["format"] === void 0) out["format"] = "byte";
+		} else if (key === "type" && Array.isArray(value)) {
+			const types = value;
+			const rest = types.filter((type) => type !== "null");
+			if (rest.length < types.length) nullable = true;
+			if (rest.length === 1) out["type"] = rest[0];
+			else if (rest.length > 1) out["anyOf"] = rest.map((type) => ({ type }));
+		} else if (key === "type" && value === "null") {
+			nullable = true;
+			out["enum"] = [null];
+		} else out[key] = value;
+	}
+	for (const key of ["anyOf", "oneOf"]) {
+		const branches = out[key];
+		if (!Array.isArray(branches) || branches.length !== 1) continue;
+		const only = branches[0];
+		if (!isPlainObject(only)) continue;
+		delete out[key];
+		if (typeof only["$ref"] === "string") out["allOf"] = [only];
+		else for (const [name, entry] of Object.entries(only)) if (!(name in out)) out[name] = entry;
+	}
+	if (typeof out["$ref"] === "string" && Object.keys(out).length > 1) {
+		const { $ref, ...siblings } = out;
+		return {
+			allOf: [{ $ref }],
+			...siblings,
+			...nullable ? { nullable: true } : {}
+		};
+	}
+	if (nullable) {
+		if (typeof out["$ref"] === "string") return {
+			allOf: [{ $ref: out["$ref"] }],
+			nullable: true
+		};
+		out["nullable"] = true;
+	}
+	return out;
+}
+const mapEntries = (value, convert) => isPlainObject(value) ? Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, isPlainObject(entry) ? convert(entry) : entry])) : value;
+const withSchema = (holder) => {
+	const out = { ...holder };
+	for (const key of ["schema", "x-oai-itemSchema"]) {
+		const schema = out[key];
+		if (isPlainObject(schema)) out[key] = toOpenApi30Schema(schema);
+	}
+	if (isPlainObject(out["content"])) out["content"] = mapEntries(out["content"], withSchema);
+	if (isPlainObject(out["headers"])) out["headers"] = mapEntries(out["headers"], withSchema);
+	return out;
+};
+const lowerParameters = (value) => Array.isArray(value) ? value.map((entry) => isPlainObject(entry) ? withSchema(entry) : entry) : value;
+const lowerOperation$1 = (operation) => {
+	const out = { ...operation };
+	out["parameters"] = lowerParameters(out["parameters"]);
+	if (out["parameters"] === void 0) delete out["parameters"];
+	if (isPlainObject(out["requestBody"])) out["requestBody"] = withSchema(out["requestBody"]);
+	if (isPlainObject(out["responses"])) out["responses"] = mapEntries(out["responses"], withSchema);
+	return out;
+};
+const PATH_ITEM_LISTS = /* @__PURE__ */ new Set(["parameters"]);
+const lowerPathItem = (item) => {
+	const out = {};
+	for (const [key, value] of Object.entries(item)) if (PATH_ITEM_LISTS.has(key)) out[key] = lowerParameters(value);
+	else if (isPlainObject(value) && !key.startsWith("x-") && key !== "servers") out[key] = lowerOperation$1(value);
+	else out[key] = value;
+	return out;
+};
+/** Lowers every Schema Object position of an OpenAPI document to the 3.0 dialect. */
+function lowerDocumentSchemas30(document) {
+	const out = { ...document };
+	if (isPlainObject(out["paths"])) out["paths"] = mapEntries(out["paths"], lowerPathItem);
+	const components = out["components"];
+	if (isPlainObject(components)) {
+		const lowered = {
+			...components,
+			schemas: mapEntries(components["schemas"], toOpenApi30Schema)
+		};
+		for (const key of [
+			"responses",
+			"parameters",
+			"requestBodies",
+			"headers"
+		]) if (isPlainObject(components[key])) lowered[key] = mapEntries(components[key], withSchema);
+		if (lowered["schemas"] === void 0) delete lowered["schemas"];
+		out["components"] = lowered;
+	}
+	return out;
+}
+//#endregion
+//#region src/openapi/types.ts
+/** The `openapi` field `3.3-preview` emits, as in the v3.3-dev branch. */
+const OPENAPI_33_PREVIEW_VERSION = "3.3.0";
+/** The file name `openapiFormat` writes for every version. */
+const OPENAPI_FILE_NAME = "openapi.json";
+//#endregion
+//#region src/openapi/format.ts
+const DIALECT = "https://json-schema.org/draft/2020-12/schema";
+const OPENAPI_FIELD = {
+	"3.0": SPEC_PINS.openapi30,
+	"3.1": SPEC_PINS.openapi31,
+	"3.2": SPEC_PINS.openapi32,
+	"3.3-preview": OPENAPI_33_PREVIEW_VERSION
+};
+/** Path Item fields that hold an Operation Object. */
+const METHODS = /* @__PURE__ */ new Set([
+	"get",
+	"put",
+	"post",
+	"delete",
+	"options",
+	"head",
+	"patch",
+	"trace",
+	"query"
+]);
+const omitUndefined = (value) => Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+function lowerContent(content, features) {
+	return Object.fromEntries(Object.entries(content).map(([type, media]) => [type, omitUndefined({
+		schema: media.schema,
+		[features.native32 ? "itemSchema" : "x-oai-itemSchema"]: media.itemSchema,
+		examples: media.examples ? Object.fromEntries(Object.entries(media.examples).map(([name, example]) => [name, omitUndefined({ ...example })])) : void 0
+	})]));
+}
+function lowerResponse(response, features) {
+	return omitUndefined({
+		[features.native32 ? "summary" : "x-oai-summary"]: response.summary,
+		description: response.description,
+		headers: response.headers ? Object.fromEntries(Object.entries(response.headers).map(([name, header]) => [name, omitUndefined({ ...header })])) : void 0,
+		content: response.content ? lowerContent(response.content, features) : void 0
+	});
+}
+const lowerResponseOrRef = (response, features) => "ref" in response ? { $ref: `#/components/responses/${response.ref}` } : lowerResponse(response, features);
+const lowerParameter = (parameter) => omitUndefined({ ...parameter });
+function lowerSecurity(requirements, features) {
+	return requirements.filter((requirement) => Object.keys(requirement).every((name) => !features.dropped.has(name))).map((requirement) => ({ ...requirement }));
+}
+function lowerScheme(scheme, features) {
+	switch (scheme.type) {
+		case "http":
+		case "apiKey":
+		case "openIdConnect": return omitUndefined({ ...scheme });
+		case "oauth2": {
+			const { metadataUrl, ...rest } = scheme;
+			return omitUndefined({
+				...rest,
+				[features.native32 ? "oauth2MetadataUrl" : `${features.prefix}oauth2MetadataUrl`]: metadataUrl
+			});
+		}
+		case "profile": return features.is33 ? omitUndefined({ ...scheme }) : void 0;
+		default: return scheme;
+	}
+}
+function lowerOperation(operation, features) {
+	return omitUndefined({
+		operationId: operation.id,
+		summary: operation.summary,
+		description: operation.description,
+		tags: operation.tags.length > 0 ? [...operation.tags] : void 0,
+		deprecated: operation.deprecated,
+		parameters: operation.parameters.length > 0 ? operation.parameters.map(lowerParameter) : void 0,
+		requestBody: operation.requestBody ? omitUndefined({
+			description: operation.requestBody.description,
+			required: operation.requestBody.required,
+			content: lowerContent(operation.requestBody.content, features)
+		}) : void 0,
+		responses: Object.fromEntries(Object.entries(operation.responses).map(([status, response]) => [status, lowerResponseOrRef(response, features)])),
+		security: operation.security ? lowerSecurity(operation.security, features) : void 0,
+		...operation.extensions
+	});
+}
+const sameJson = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/**
+* Builds one Path Item. Path parameters every operation shares move to the
+* Path Item; in 3.3 a `security` every operation shares does too.
+*/
+function pathItem(operations, features) {
+	const pathParameters = (operation) => Array.isArray(operation["parameters"]) ? operation["parameters"].filter((parameter) => isPlainObject(parameter) && parameter["in"] === "path") : [];
+	const first = operations[0];
+	const shared = first ? pathParameters(first.operation) : [];
+	const hoist = shared.length > 0 && operations.every(({ operation }) => sameJson(pathParameters(operation), shared));
+	const firstSecurity = first?.operation["security"];
+	const hoistSecurity = features.is33 && firstSecurity !== void 0 && operations.every(({ operation }) => sameJson(operation["security"], firstSecurity));
+	const item = {};
+	if (hoist) item["parameters"] = shared;
+	if (hoistSecurity) item["security"] = firstSecurity;
+	for (const { method, operation } of operations) {
+		const out = { ...operation };
+		if (hoist) {
+			const rest = Array.isArray(out["parameters"]) ? out["parameters"].filter((parameter) => !isPlainObject(parameter) || parameter["in"] !== "path") : [];
+			if (rest.length > 0) out["parameters"] = rest;
+			else delete out["parameters"];
+		}
+		if (hoistSecurity) delete out["security"];
+		item[method] = out;
+	}
+	return item;
+}
+const STANDARD_WEBHOOK_HEADERS = [
+	{
+		name: "webhook-id",
+		in: "header",
+		required: true,
+		description: "Unique message id; the same on every retry.",
+		schema: { type: "string" }
+	},
+	{
+		name: "webhook-timestamp",
+		in: "header",
+		required: true,
+		description: "Unix time in seconds when the message was sent.",
+		schema: {
+			type: "string",
+			pattern: "^[0-9]+$"
+		}
+	},
+	{
+		name: "webhook-signature",
+		in: "header",
+		required: true,
+		description: "Space-separated signatures of `id.timestamp.body`, each `v1,<base64>`.",
+		schema: { type: "string" }
+	}
+];
+function lowerWebhook(webhook) {
+	return { post: omitUndefined({
+		operationId: `on${pascal(webhook.id.replaceAll(".", "_"))}`,
+		summary: webhook.summary,
+		description: webhook.description,
+		parameters: webhook.standardWebhooks ? STANDARD_WEBHOOK_HEADERS.map((header) => ({ ...header })) : void 0,
+		requestBody: {
+			required: true,
+			content: { "application/json": { schema: webhook.payload } }
+		},
+		responses: { "2XX": { description: "The receiver accepted the event." } }
+	}) };
+}
+function lowerTags(model, features) {
+	return model.tags.map((tag) => features.native32 ? omitUndefined({ ...tag }) : omitUndefined({
+		name: tag.name,
+		description: tag.description,
+		[`${features.prefix}summary`]: tag.summary,
+		[`${features.prefix}parent`]: tag.parent,
+		[`${features.prefix}kind`]: tag.kind
+	}));
+}
+function lowerOpenApi(model, version, ctx) {
+	const is33 = version === "3.3-preview";
+	const dropped = new Set(is33 ? [] : Object.entries(model.securitySchemes).filter(([, scheme]) => scheme.type === "profile").map(([name]) => name));
+	const features = {
+		version,
+		native32: version === "3.2" || is33,
+		is30: version === "3.0",
+		is33,
+		prefix: model.extensionPrefix,
+		dropped
+	};
+	for (const name of dropped) ctx.report({
+		code: "preview-only",
+		severity: "info",
+		message: `Security scheme "${name}" uses Security Profiles, which only 3.3-preview emits; it and the requirements that name it are left out`,
+		pointer: `/components/securitySchemes/${pointerToken(name)}`
+	});
+	const grouped = /* @__PURE__ */ new Map();
+	const placed = [];
+	for (const operation of model.operations) {
+		if (operation.method === "query" && !features.native32) {
+			ctx.report({
+				code: "method-unsupported",
+				severity: "warning",
+				message: `Operation "${operation.id}" uses the QUERY method, which OpenAPI ${version} cannot describe; it is left out`,
+				pointer: `/paths/${pointerToken(operation.path)}`
+			});
+			continue;
+		}
+		const list = grouped.get(operation.path) ?? [];
+		list.push({
+			method: operation.method,
+			operation: lowerOperation(operation, features)
+		});
+		grouped.set(operation.path, list);
+		placed.push(operation);
+	}
+	const paths = {};
+	for (const [path, operations] of grouped) paths[path] = pathItem(operations, features);
+	const securitySchemes = {};
+	for (const [name, scheme] of Object.entries(model.securitySchemes)) {
+		const lowered = lowerScheme(scheme, features);
+		if (lowered) securitySchemes[name] = lowered;
+	}
+	const components = {
+		schemas: structuredClone(model.schemas),
+		responses: Object.fromEntries(Object.entries(model.responses).map(([name, response]) => [name, lowerResponse(response, features)])),
+		securitySchemes
+	};
+	if (is33 && model.securityProfileRequirements) components["securityProfileRequirements"] = structuredClone(model.securityProfileRequirements);
+	let webhooks;
+	if (model.webhooks.length > 0) {
+		if (features.is30) ctx.report({
+			code: "webhooks-unsupported",
+			severity: "warning",
+			message: `OpenAPI 3.0 has no webhooks; ${model.webhooks.length} webhook(s) are left out`
+		});
+		else webhooks = Object.fromEntries(model.webhooks.map((webhook) => [webhook.id, lowerWebhook(webhook)]));
+	}
+	const info = features.is30 ? omitUndefined({
+		...model.info,
+		summary: void 0,
+		license: model.info.license ? omitUndefined({
+			...model.info.license,
+			identifier: void 0
+		}) : void 0
+	}) : omitUndefined({ ...model.info });
+	let document = omitUndefined({
+		openapi: OPENAPI_FIELD[version],
+		[features.native32 ? "$self" : "x-oai-$self"]: model.self,
+		info: structuredClone(info),
+		jsonSchemaDialect: features.is30 ? void 0 : DIALECT,
+		servers: model.servers.length > 0 ? model.servers.map((server) => omitUndefined({
+			url: server.url,
+			description: server.description,
+			[features.native32 ? "name" : "x-oai-name"]: server.name
+		})) : void 0,
+		tags: lowerTags(model, features),
+		security: lowerSecurity(model.security, features),
+		paths,
+		webhooks,
+		components,
+		[`${features.prefix}preview`]: is33 ? SPEC_PINS.openapi33Preview : void 0
+	});
+	model.fragments.forEach((fragment, index) => {
+		document = mergeJson(document, fragment, (pointer) => {
+			ctx.report({
+				code: "fragment-conflict",
+				severity: "warning",
+				message: `Fragment ${index} replaces a generated value`,
+				pointer
+			});
+		});
+	});
+	for (const operation of placed) {
+		if (!operation.extend) continue;
+		const patch = { paths: { [operation.path]: { [operation.method]: operation.extend } } };
+		document = mergeJson(document, patch);
+	}
+	if (features.is30) document = lowerDocumentSchemas30(document);
+	if (!isOpenApiDocument(document)) throw new TypeError("better-supabase/openapi: a fragment removed a required document field");
+	return document;
+}
+/** The fields every OpenAPI document this format renders has. */
+function isOpenApiDocument(value) {
+	return typeof value["openapi"] === "string" && isPlainObject(value["info"]) && isPlainObject(value["paths"]) && isPlainObject(value["components"]) && Array.isArray(value["tags"]) && Array.isArray(value["security"]);
+}
+const PATH_PARAM = /\{([^}]+)\}/g;
+function resolves(document, ref) {
+	if (!ref.startsWith("#")) return true;
+	let node = document;
+	for (const raw of ref.slice(2).split("/")) {
+		if (raw === "" && ref === "#") break;
+		const key = raw.replaceAll("~1", "/").replaceAll("~0", "~");
+		if (Array.isArray(node)) node = node[Number(key)];
+		else if (isPlainObject(node)) node = node[key];
+		else return false;
+		if (node === void 0) return false;
+	}
+	return true;
+}
+function collectRefs(value, pointer, out) {
+	if (Array.isArray(value)) value.forEach((item, index) => {
+		collectRefs(item, `${pointer}/${index}`, out);
+	});
+	else if (isPlainObject(value)) for (const [key, item] of Object.entries(value)) if (key === "$ref" && typeof item === "string") out.push([pointer, item]);
+	else collectRefs(item, `${pointer}/${pointerToken(key)}`, out);
+}
+/** The keys of `value[key]` when it is an object; documents read from disk may omit any field. */
+function keysAt(value, key) {
+	if (!isPlainObject(value)) return [];
+	const child = value[key];
+	return isPlainObject(child) ? Object.keys(child) : [];
+}
+function lintOpenApi(document) {
+	const diagnostics = [];
+	const ids = /* @__PURE__ */ new Map();
+	const components = document.components;
+	const schemes = new Set(keysAt(components, "securitySchemes"));
+	const checkSecurity = (requirements, pointer) => {
+		if (!Array.isArray(requirements)) return;
+		const list = requirements;
+		for (const requirement of list) {
+			if (!isPlainObject(requirement)) continue;
+			for (const name of Object.keys(requirement)) if (!schemes.has(name)) diagnostics.push({
+				code: "security-unresolved",
+				severity: "error",
+				message: `Security requirement names an unknown scheme "${name}"`,
+				pointer
+			});
+		}
+	};
+	checkSecurity(document.security, "/security");
+	const paths = document.paths;
+	for (const [path, item] of Object.entries(isPlainObject(paths) ? paths : {})) {
+		if (!isPlainObject(item)) continue;
+		const base = `/paths/${pointerToken(path)}`;
+		const templated = new Set([...path.matchAll(PATH_PARAM)].map((match) => match[1] ?? ""));
+		const shared = Array.isArray(item["parameters"]) ? item["parameters"] : [];
+		checkSecurity(item["security"], `${base}/security`);
+		for (const [method, operation] of Object.entries(item)) {
+			if (!METHODS.has(method) || !isPlainObject(operation)) continue;
+			const pointer = `${base}/${method}`;
+			const id = operation["operationId"];
+			if (typeof id === "string") {
+				const seen = ids.get(id);
+				if (seen) diagnostics.push({
+					code: "operation-id-duplicate",
+					severity: "error",
+					message: `operationId "${id}" is also used at ${seen}`,
+					pointer
+				});
+				else ids.set(id, pointer);
+			}
+			checkSecurity(operation["security"], `${pointer}/security`);
+			const own = Array.isArray(operation["parameters"]) ? operation["parameters"] : [];
+			const declared = /* @__PURE__ */ new Set();
+			for (const parameter of [...shared, ...own]) {
+				if (!isPlainObject(parameter) || parameter["in"] !== "path") continue;
+				const name = String(parameter["name"]);
+				declared.add(name);
+				if (!templated.has(name)) diagnostics.push({
+					code: "path-param-unknown",
+					severity: "error",
+					message: `Path parameter "${name}" is not in the path template`,
+					pointer
+				});
+			}
+			for (const name of templated) if (!declared.has(name)) diagnostics.push({
+				code: "path-param-missing",
+				severity: "error",
+				message: `Path template parameter "${name}" has no parameter`,
+				pointer
+			});
+		}
+	}
+	const refs = [];
+	collectRefs(document, "", refs);
+	for (const [pointer, ref] of refs) if (!resolves(document, ref)) diagnostics.push({
+		code: "ref-unresolved",
+		severity: "error",
+		message: `$ref "${ref}" does not resolve inside the document`,
+		pointer
+	});
+	return diagnostics;
+}
+/**
+* OpenAPI as a `DocumentFormat`. 3.1 is the default; 3.0 is legacy (schemas
+* lowered to the 3.0 Schema Object); 3.2 has native `$self`, nested tags,
+* `itemSchema`, `oauth2MetadataUrl` and `query`; `3.3-preview` follows the
+* v3.3-dev branch at `SPEC_PINS.openapi33Preview`, with Path Item
+* `security` and the Security Profiles proposal. Below 3.2, the 3.2 fields
+* travel as the registered `x-oai-*` extensions where one exists, and as
+* the model's prefixed extensions otherwise.
+*/
+const openapiFormat = defineDocumentFormat({
+	id: "openapi",
+	versions: {
+		"3.0": {
+			pin: SPEC_PINS.openapi30,
+			status: "legacy"
+		},
+		"3.1": {
+			pin: SPEC_PINS.openapi31,
+			status: "stable"
+		},
+		"3.2": {
+			pin: SPEC_PINS.openapi32,
+			status: "stable"
+		},
+		"3.3-preview": {
+			pin: SPEC_PINS.openapi33Preview,
+			status: "preview"
+		}
+	},
+	defaultVersion: "3.1",
+	lower: lowerOpenApi,
+	lint: lintOpenApi,
+	fileName: () => OPENAPI_FILE_NAME
+});
+//#endregion
+//#region src/spec/api.ts
+function dedupe(diagnostics) {
+	const seen = /* @__PURE__ */ new Set();
+	return diagnostics.filter((diagnostic) => {
+		const key = `${diagnostic.code}\u0000${diagnostic.pointer ?? ""}\u0000${diagnostic.message}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+/**
+* The API model for a `defineSupabase()` result, and the documents it
+* renders. The model is built once per options object; each format and
+* version is lowered once and copied for every render.
+*
+* ```ts
+* const api = defineApi(betterSupabase, {
+*   info: { title: "CRM API", version: "1.0.0" },
+*   resources: { customers: { list: customerList } },
+* });
+* const { document } = api.openapi({ version: "3.2" });
+* ```
+*/
+function defineApi(source, options) {
+	const built = buildApiModel(source, options);
+	const lowered = /* @__PURE__ */ new WeakMap();
+	const lower = (format, version) => {
+		let byVersion = lowered.get(format);
+		if (!byVersion) {
+			byVersion = /* @__PURE__ */ new Map();
+			lowered.set(format, byVersion);
+		}
+		let hit = byVersion.get(version);
+		if (!hit) {
+			const diagnostics = [];
+			hit = {
+				document: format.lower(built.model, version, { report: (diagnostic) => {
+					diagnostics.push(diagnostic);
+				} }),
+				diagnostics
+			};
+			byVersion.set(version, hit);
+		}
+		return hit;
+	};
+	const render = (format, renderOptions = {}) => {
+		const fallback = format.defaultVersion;
+		const version = renderOptions.version ?? fallback;
+		const status = format.versions[version];
+		if (!status) throw new TypeError(`Document format "${format.id}" has no version "${String(version)}"`);
+		const diagnostics = [...built.diagnostics];
+		if (status.status === "preview") diagnostics.push({
+			code: "preview-version",
+			severity: "warning",
+			message: `${format.id} ${String(version)} follows a draft (${status.pin}); its fields may change before release`
+		});
+		const base = lower(format, version);
+		diagnostics.push(...base.diagnostics);
+		let document = structuredClone(base.document);
+		if (renderOptions.transform) {
+			const rendered = {
+				format: format.id,
+				version,
+				document
+			};
+			document = renderOptions.transform(rendered) ?? document;
+		}
+		const overlays = renderOptions.overlays ?? [];
+		if (overlays.length > 0) {
+			const engine = renderOptions.applyOverlays ?? options.applyOverlays;
+			if (!engine) throw new TypeError("better-supabase/spec: overlays need applyOverlays (from better-supabase/overlay)");
+			const result = engine(document, overlays);
+			document = result.document;
+			diagnostics.push(...result.diagnostics ?? []);
+		}
+		diagnostics.push(...format.lint?.(document, version) ?? []);
+		return {
+			format: format.id,
+			version,
+			document,
+			diagnostics: dedupe(diagnostics),
+			fileName: format.fileName(version)
+		};
+	};
+	return {
+		model: built.model,
+		diagnostics: built.diagnostics,
+		render,
+		openapi(openapiOptions = {}) {
+			const { transform, version, overlays, applyOverlays } = openapiOptions;
+			const renderOptions = {
+				...version === void 0 ? {} : { version },
+				...overlays === void 0 ? {} : { overlays },
+				...applyOverlays === void 0 ? {} : { applyOverlays },
+				...transform === void 0 ? {} : { transform: (rendered) => transform(rendered) }
+			};
+			const result = render(openapiFormat, renderOptions);
+			return {
+				format: "openapi",
+				version: result.version,
+				document: result.document,
+				diagnostics: result.diagnostics,
+				fileName: result.fileName
+			};
+		}
+	};
+}
+//#endregion
+export { toOpenApi30Schema as a, OPENAPI_FILE_NAME as i, openapiFormat as n, defineDocumentFormat as o, OPENAPI_33_PREVIEW_VERSION as r, defineApi as t };

package/dist/{api-keys-CIjghYjV.d.ts → api-keys-C8BlF3L2.d.ts}

@@ -1,8 +1,8 @@
 /// <reference lib="esnext.temporal" />
-import { t as AsyncResult } from "./result-D7y2fT87.js";
-import { t as BlockTransport } from "./block-transport-DvaoPuZ9.js";
-import { n as AuthResolver } from "./resolve-ChTYeTEl.js";
-import { r as BlockTemporalOptions } from "./block-helpers-CKtbFcRv.js";
+import { t as AsyncResult } from "./result-BchM1XZn.js";
+import { t as BlockTransport } from "./block-transport-inD4fFq-.js";
+import { n as AuthResolver } from "./resolve-MxXVWyhd.js";
+import { r as BlockTemporalOptions } from "./block-helpers-C0Xj8War.js";
 import { JWTClaims } from "@supabase/server";
 //#region src/blocks/api-keys/api-keys.d.ts
 type ApiKeyState = "active" | "grace" | "revoked" | "expired";