better-supabase 0.7.1 → 0.9.0

package/dist/arazzo/index.js

@@ -0,0 +1,622 @@
+import { r as isPlainObject } from "../clone-dN9XOL1K.js";
+import { t as SPEC_PINS } from "../spec-pins-S4PymRxp.js";
+import { o as defineDocumentFormat, t as defineApi } from "../api-CFjuYKFY.js";
+import { c as pascal, r as safeKey, s as convertStandard } from "../build-Cm0T5MVG.js";
+import "../types-BRTSpOIh.js";
+//#region src/arazzo/format.ts
+const ARAZZO_FIELD = {
+	"1.0": SPEC_PINS.arazzo10,
+	"1.1": SPEC_PINS.arazzo11
+};
+const ID = /^[A-Za-z0-9_-]+$/;
+const STEP_OUTPUT = /\$steps\.([A-Za-z0-9_-]+)\.outputs\.([A-Za-z0-9_-]+)/g;
+const INPUT = /\$inputs\.([A-Za-z0-9_-]+)/g;
+const SOURCE = /\$sourceDescriptions\.([A-Za-z0-9_-]+)\./g;
+const omitUndefined = (value) => Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+function firstSuccess(operation) {
+	return Object.keys(operation.responses).filter((status) => /^2\d\d$/.test(status)).toSorted()[0];
+}
+function stripActionParameters(actions, version, report, pointer) {
+	if (!actions) return;
+	return actions.map((action, index) => {
+		const copy = structuredClone({ ...action });
+		if (version === "1.0" && "parameters" in copy) {
+			delete copy["parameters"];
+			report(`${pointer}/${String(index)}/parameters`);
+		}
+		return copy;
+	});
+}
+function lowerStep(step, pointer, state) {
+	const { ctx, version } = state;
+	const operation = step.operationId === void 0 ? void 0 : state.operations.get(step.operationId);
+	let target = {};
+	if (step.operationId !== void 0) {
+		if (!operation) ctx.report({
+			code: "arazzo-operation-unknown",
+			severity: "error",
+			message: `Step "${step.id}" calls operation "${step.operationId}", which the API does not have`,
+			pointer: `${pointer}/operationId`
+		});
+		target = { operationId: state.qualify ? `$sourceDescriptions.${state.apiName}.${step.operationId}` : step.operationId };
+	} else if (step.workflowId !== void 0) target = { workflowId: step.workflowId };
+	else if (step.channel) {
+		if (version === "1.0") {
+			ctx.report({
+				code: "arazzo-channel-step-unsupported",
+				severity: "error",
+				message: `Step "${step.id}" uses an AsyncAPI channel, which needs Arazzo 1.1; the step is left out`,
+				pointer
+			});
+			return;
+		}
+		if (!state.channels.has(step.channel.id)) ctx.report({
+			code: "arazzo-channel-unknown",
+			severity: "error",
+			message: `Step "${step.id}" uses channel "${step.channel.id}", which the API does not have`,
+			pointer: `${pointer}/channelPath`
+		});
+		target = {
+			channelPath: `{$sourceDescriptions.${state.eventsName}.url}#/channels/${safeKey(step.channel.id)}`,
+			action: step.channel.action,
+			...step.channel.correlationId === void 0 ? {} : { correlationId: step.channel.correlationId }
+		};
+	}
+	const parameters = step.parameters?.map((parameter, index) => {
+		const location = parameter.in ?? operation?.parameters.find((candidate) => candidate.name === parameter.name)?.in;
+		if (location === void 0 && step.operationId !== void 0) ctx.report({
+			code: "arazzo-parameter-in-missing",
+			severity: "error",
+			message: `Parameter "${parameter.name}" of step "${step.id}" has no "in", and operation "${step.operationId}" has no parameter by that name`,
+			pointer: `${pointer}/parameters/${String(index)}`
+		});
+		return omitUndefined({
+			name: parameter.name,
+			in: location,
+			value: structuredClone(parameter.value)
+		});
+	});
+	const contentType = operation?.requestBody ? Object.keys(operation.requestBody.content)[0] : void 0;
+	const success = operation ? firstSuccess(operation) : void 0;
+	const successCriteria = step.successCriteria?.map((criterion) => ({ ...criterion })) ?? (success === void 0 ? void 0 : [{ condition: `$statusCode == ${success}` }]);
+	const reportParameters = (where) => {
+		ctx.report({
+			code: "arazzo-action-parameters-unsupported",
+			severity: "warning",
+			message: `Action parameters need Arazzo 1.1; they are left out of step "${step.id}"`,
+			pointer: where
+		});
+	};
+	const onSuccess = stripActionParameters(step.onSuccess, version, reportParameters, `${pointer}/onSuccess`);
+	const onFailure = stripActionParameters(step.onFailure, version, reportParameters, `${pointer}/onFailure`);
+	return {
+		stepId: step.id,
+		...step.description === void 0 ? {} : { description: step.description },
+		...target,
+		...parameters === void 0 ? {} : { parameters },
+		...step.requestBody ? { requestBody: omitUndefined({
+			contentType,
+			payload: structuredClone(step.requestBody.payload)
+		}) } : {},
+		...successCriteria === void 0 ? {} : { successCriteria },
+		...onSuccess === void 0 ? {} : { onSuccess },
+		...onFailure === void 0 ? {} : { onFailure },
+		...step.outputs ? { outputs: { ...step.outputs } } : {}
+	};
+}
+function lowerWorkflow(workflow, index, state) {
+	const pointer = `/workflows/${String(index)}`;
+	const steps = workflow.steps.flatMap((step, stepIndex) => {
+		const lowered = lowerStep(step, `${pointer}/steps/${String(stepIndex)}`, state);
+		return lowered ? [lowered] : [];
+	});
+	return {
+		workflowId: workflow.id,
+		...workflow.summary === void 0 ? {} : { summary: workflow.summary },
+		...workflow.description === void 0 ? {} : { description: workflow.description },
+		...workflow.inputs ? { inputs: structuredClone(workflow.inputs) } : {},
+		steps,
+		...workflow.outputs ? { outputs: { ...workflow.outputs } } : {}
+	};
+}
+function lowerArazzo(options, model, version, ctx) {
+	const apiName = options.openapi?.name ?? "api";
+	const eventsName = options.asyncapi?.name ?? "events";
+	const usesChannels = version === "1.1" && model.workflows.some((workflow) => workflow.steps.some((step) => step.channel !== void 0));
+	const usesOperations = model.workflows.some((workflow) => workflow.steps.some((step) => step.operationId !== void 0));
+	const sources = [];
+	if (usesOperations || !usesChannels) sources.push({
+		name: apiName,
+		url: options.openapi?.url ?? model.self ?? "openapi.json",
+		type: "openapi"
+	});
+	if (usesChannels) sources.push({
+		name: eventsName,
+		url: options.asyncapi?.url ?? "asyncapi.json",
+		type: "asyncapi"
+	});
+	const state = {
+		model,
+		version,
+		ctx,
+		operations: new Map(model.operations.map((operation) => [operation.id, operation])),
+		channels: new Set(model.channels.map((channel) => channel.id)),
+		apiName,
+		eventsName,
+		qualify: sources.length > 1
+	};
+	if (model.workflows.length === 0) ctx.report({
+		code: "arazzo-workflows-empty",
+		severity: "error",
+		message: "The API has no workflows; an Arazzo document needs at least one (pass workflows, or a built-in such as paginationWorkflows())",
+		pointer: "/workflows"
+	});
+	const { info } = model;
+	return {
+		arazzo: ARAZZO_FIELD[version],
+		info: {
+			title: info.title,
+			version: info.version,
+			...info.summary === void 0 ? {} : { summary: info.summary },
+			...info.description === void 0 ? {} : { description: info.description }
+		},
+		sourceDescriptions: sources,
+		workflows: model.workflows.map((workflow, index) => lowerWorkflow(workflow, index, state))
+	};
+}
+function strings(value, out) {
+	if (typeof value === "string") out.push(value);
+	else if (Array.isArray(value)) for (const item of value) strings(item, out);
+	else if (isPlainObject(value)) for (const item of Object.values(value)) strings(item, out);
+}
+function inputNames(inputs) {
+	if (!inputs || !isPlainObject(inputs["properties"])) return;
+	return new Set(Object.keys(inputs["properties"]));
+}
+function lintWorkflow(workflow, index, workflowIds, sourceNames, diagnostics) {
+	const pointer = `/workflows/${String(index)}`;
+	const stepIndex = /* @__PURE__ */ new Map();
+	const outputsOf = /* @__PURE__ */ new Map();
+	workflow.steps.forEach((step, position) => {
+		if (stepIndex.has(step.stepId)) diagnostics.push({
+			code: "arazzo-step-id-duplicate",
+			severity: "error",
+			message: `Workflow "${workflow.workflowId}" has two steps "${step.stepId}"`,
+			pointer: `${pointer}/steps/${String(position)}`
+		});
+		else stepIndex.set(step.stepId, position);
+		outputsOf.set(step.stepId, new Set(Object.keys(step.outputs ?? {})));
+	});
+	const inputs = inputNames(workflow.inputs);
+	const checkExpressions = (value, where, position) => {
+		const texts = [];
+		strings(value, texts);
+		for (const text of texts) {
+			for (const [, stepId = "", output = ""] of text.matchAll(STEP_OUTPUT)) {
+				const target = stepIndex.get(stepId);
+				if (target === void 0 || !outputsOf.get(stepId)?.has(output)) diagnostics.push({
+					code: "arazzo-step-output-unknown",
+					severity: "error",
+					message: `"$steps.${stepId}.outputs.${output}" names an output no step "${stepId}" declares`,
+					pointer: where
+				});
+				else if (position !== void 0 && target >= position) diagnostics.push({
+					code: "arazzo-step-output-order",
+					severity: "error",
+					message: `"$steps.${stepId}.outputs.${output}" is read before step "${stepId}" runs`,
+					pointer: where
+				});
+			}
+			if (inputs) {
+				for (const [, name = ""] of text.matchAll(INPUT)) if (!inputs.has(name)) diagnostics.push({
+					code: "arazzo-input-undeclared",
+					severity: "warning",
+					message: `"$inputs.${name}" is not a property of workflow "${workflow.workflowId}" inputs`,
+					pointer: where
+				});
+			}
+			for (const [, name = ""] of text.matchAll(SOURCE)) if (!sourceNames.has(name)) diagnostics.push({
+				code: "arazzo-source-unknown",
+				severity: "error",
+				message: `"$sourceDescriptions.${name}" is not a listed source description`,
+				pointer: where
+			});
+		}
+	};
+	workflow.steps.forEach((step, position) => {
+		const where = `${pointer}/steps/${String(position)}`;
+		if (!ID.test(step.stepId)) diagnostics.push({
+			code: "arazzo-id-invalid",
+			severity: "error",
+			message: `Step id "${step.stepId}" has characters Arazzo ids do not allow`,
+			pointer: where
+		});
+		if ([
+			step.operationId,
+			step.operationPath,
+			step.channelPath,
+			step.workflowId
+		].filter((target) => target !== void 0).length !== 1) diagnostics.push({
+			code: "arazzo-step-target",
+			severity: "error",
+			message: `Step "${step.stepId}" needs exactly one of operationId, operationPath, channelPath or workflowId`,
+			pointer: where
+		});
+		if (step.workflowId !== void 0 && !workflowIds.has(step.workflowId)) diagnostics.push({
+			code: "arazzo-workflow-unknown",
+			severity: "error",
+			message: `Step "${step.stepId}" calls workflow "${step.workflowId}", which the document does not have`,
+			pointer: `${where}/workflowId`
+		});
+		checkExpressions([
+			step.operationId,
+			step.channelPath,
+			step.parameters,
+			step.requestBody,
+			step.successCriteria
+		], where, position);
+		checkExpressions([
+			step.outputs,
+			step.onSuccess,
+			step.onFailure
+		], where);
+		for (const action of [...step.onSuccess ?? [], ...step.onFailure ?? []]) {
+			if (action["type"] !== "goto" && action["type"] !== "retry") continue;
+			const stepId = action["stepId"];
+			const workflowId = action["workflowId"];
+			if (typeof stepId === "string" && !stepIndex.has(stepId) || typeof workflowId === "string" && !workflowIds.has(workflowId) && !workflowId.startsWith("$sourceDescriptions.")) diagnostics.push({
+				code: "arazzo-goto-unknown",
+				severity: "error",
+				message: `Action "${String(action["name"])}" of step "${step.stepId}" goes to a step or workflow that does not exist`,
+				pointer: where
+			});
+		}
+	});
+	checkExpressions(workflow.outputs, `${pointer}/outputs`);
+}
+function lintArazzo(document) {
+	const diagnostics = [];
+	const workflowIds = /* @__PURE__ */ new Set();
+	document.workflows.forEach((workflow, index) => {
+		if (!ID.test(workflow.workflowId)) diagnostics.push({
+			code: "arazzo-id-invalid",
+			severity: "error",
+			message: `Workflow id "${workflow.workflowId}" has characters Arazzo ids do not allow`,
+			pointer: `/workflows/${String(index)}`
+		});
+		if (workflowIds.has(workflow.workflowId)) diagnostics.push({
+			code: "arazzo-workflow-id-duplicate",
+			severity: "error",
+			message: `Two workflows have the id "${workflow.workflowId}"`,
+			pointer: `/workflows/${String(index)}`
+		});
+		workflowIds.add(workflow.workflowId);
+	});
+	const sourceNames = new Set(document.sourceDescriptions.map((source) => source.name));
+	document.workflows.forEach((workflow, index) => {
+		lintWorkflow(workflow, index, workflowIds, sourceNames, diagnostics);
+	});
+	return diagnostics;
+}
+/**
+* An Arazzo format whose source descriptions point at your OpenAPI and
+* AsyncAPI URLs. `arazzoFormat` is this with the defaults: `api` at the
+* model's `self` or `openapi.json`, and `events` at `asyncapi.json`.
+*/
+function createArazzoFormat(options = {}) {
+	return defineDocumentFormat({
+		id: "arazzo",
+		versions: {
+			"1.0": {
+				pin: SPEC_PINS.arazzo10,
+				status: "stable"
+			},
+			"1.1": {
+				pin: SPEC_PINS.arazzo11,
+				status: "stable"
+			}
+		},
+		defaultVersion: "1.0",
+		lower: (model, version, ctx) => lowerArazzo(options, model, version, ctx),
+		lint: lintArazzo,
+		fileName: () => "arazzo.json"
+	});
+}
+/**
+* Arazzo as a `DocumentFormat`, for the model's `workflows`. 1.0 is the
+* default; channel steps (AsyncAPI send and receive) and action
+* `parameters` need 1.1.
+*/
+const arazzoFormat = createArazzoFormat();
+//#endregion
+//#region src/arazzo/builtins.ts
+const resourceOf = (operations, table, operation) => operations.find((candidate) => candidate.source.kind === "resource" && candidate.source.table === table && candidate.source.operation === operation);
+const tablesOf = (operations) => [...new Set(operations.flatMap((operation) => operation.source.kind === "resource" ? [operation.source.table] : []))];
+const inputParameter = (parameter) => ({
+	name: parameter.name,
+	in: "path",
+	value: `$inputs.${parameter.name}`
+});
+const pathParameter = (operation) => operation.parameters.find((parameter) => parameter.in === "path")?.name;
+/**
+* One workflow per cursor-paginated list: read the first page, then the
+* next one from its `nextCursor` when `hasMore` is true. Repeat the second
+* step with its own `nextCursor` to walk the rest.
+*/
+function paginationWorkflows(options = {}) {
+	return (operations) => tablesOf(operations).filter((table) => !options.tables || options.tables.includes(table)).flatMap((table) => {
+		const list = resourceOf(operations, table, "list");
+		if (!list?.parameters.some((parameter) => parameter.name === "after" && parameter.in === "query")) return [];
+		return [{
+			id: `paginate${pascal(table)}`,
+			summary: `Read ${table} page by page`,
+			description: "Reads the first page, then the next one with the cursor the first page returned. Repeat `nextPage` with its own `nextCursor` until `hasMore` is false.",
+			inputs: {
+				type: "object",
+				properties: { size: {
+					type: "integer",
+					minimum: 1,
+					description: "Page size."
+				} }
+			},
+			steps: [{
+				id: "firstPage",
+				operationId: list.id,
+				parameters: [{
+					name: "size",
+					in: "query",
+					value: "$inputs.size"
+				}],
+				successCriteria: [{ condition: "$statusCode == 200" }],
+				outputs: {
+					items: "$response.body#/items",
+					nextCursor: "$response.body#/nextCursor",
+					hasMore: "$response.body#/hasMore"
+				},
+				onSuccess: [{
+					name: "lastPage",
+					type: "end",
+					criteria: [{ condition: "$response.body#/hasMore == false" }]
+				}]
+			}, {
+				id: "nextPage",
+				operationId: list.id,
+				parameters: [{
+					name: "size",
+					in: "query",
+					value: "$inputs.size"
+				}, {
+					name: "after",
+					in: "query",
+					value: "$steps.firstPage.outputs.nextCursor"
+				}],
+				successCriteria: [{ condition: "$statusCode == 200" }],
+				outputs: {
+					items: "$response.body#/items",
+					nextCursor: "$response.body#/nextCursor",
+					hasMore: "$response.body#/hasMore"
+				}
+			}],
+			outputs: {
+				firstPage: "$steps.firstPage.outputs.items",
+				nextCursor: "$steps.nextPage.outputs.nextCursor"
+			}
+		}];
+	});
+}
+/** One workflow per resource with `create` and `get`: create a row, then read it back by its key. */
+function createThenGetWorkflows(options = {}) {
+	return (operations) => tablesOf(operations).filter((table) => !options.tables || options.tables.includes(table)).flatMap((table) => {
+		const create = resourceOf(operations, table, "create");
+		const get = resourceOf(operations, table, "get");
+		const key = get ? pathParameter(get) : void 0;
+		if (!create || !get || key === void 0) return [];
+		return [{
+			id: `createThenGet${pascal(table)}`,
+			summary: `Create a ${table} row, then read it back`,
+			inputs: {
+				type: "object",
+				required: ["row"],
+				properties: { row: {
+					type: "object",
+					description: "The row to insert."
+				} }
+			},
+			steps: [{
+				id: "create",
+				operationId: create.id,
+				requestBody: { payload: "$inputs.row" },
+				successCriteria: [{ condition: "$statusCode == 201" }],
+				outputs: { key: `$response.body#/${key}` }
+			}, {
+				id: "get",
+				operationId: get.id,
+				parameters: [{
+					name: key,
+					in: "path",
+					value: "$steps.create.outputs.key"
+				}],
+				successCriteria: [{ condition: "$statusCode == 200" }],
+				outputs: { row: "$response.body" }
+			}],
+			outputs: { row: "$steps.get.outputs.row" }
+		}];
+	});
+}
+/**
+* Sign in, then call an operation with the access token as a bearer
+* token. A 403 Problem Details answer with code `APPROVAL_REQUIRED` ends the
+* workflow (the `approvalRequired` failure action), so a client can wait for
+* the approval instead of retrying.
+*/
+function authWorkflow(options) {
+	const signIn = options.signIn ?? "signIn";
+	const pointer = options.tokenPointer ?? "/access_token";
+	return (operations) => {
+		const pathParameters = operations.find((operation) => operation.id === options.call)?.parameters.filter((parameter) => parameter.in === "path") ?? [];
+		return [{
+			id: options.id ?? `signInThen${pascal(options.call)}`,
+			summary: `Sign in, then call ${options.call}`,
+			inputs: {
+				type: "object",
+				required: [
+					"email",
+					"password",
+					...pathParameters.map((p) => p.name)
+				],
+				properties: {
+					email: {
+						type: "string",
+						format: "email"
+					},
+					password: {
+						type: "string",
+						format: "password"
+					},
+					...Object.fromEntries(pathParameters.map((parameter) => [parameter.name, { type: "string" }]))
+				}
+			},
+			steps: [{
+				id: "signIn",
+				operationId: signIn,
+				requestBody: { payload: {
+					email: "$inputs.email",
+					password: "$inputs.password"
+				} },
+				successCriteria: [{ condition: "$statusCode == 200" }],
+				outputs: { accessToken: `$response.body#${pointer}` }
+			}, {
+				id: "call",
+				operationId: options.call,
+				parameters: [{
+					name: "Authorization",
+					in: "header",
+					value: "Bearer {$steps.signIn.outputs.accessToken}"
+				}, ...pathParameters.map(inputParameter)],
+				outputs: { body: "$response.body" },
+				onFailure: [{
+					name: "approvalRequired",
+					type: "end",
+					criteria: [{ condition: "$statusCode == 403" }, {
+						context: "$response.body",
+						condition: "$.code == 'APPROVAL_REQUIRED'",
+						type: "jsonpath"
+					}]
+				}]
+			}],
+			outputs: { body: "$steps.call.outputs.body" }
+		}];
+	};
+}
+//#endregion
+//#region src/arazzo/workflow.ts
+function isStandard(value) {
+	return typeof value === "object" && value !== null && "~standard" in value && typeof value["~standard"] === "object";
+}
+function inputsOf(inputs) {
+	if (!isStandard(inputs)) return inputs;
+	const converted = convertStandard(inputs, "input");
+	if (!converted) throw new TypeError("defineWorkflow: inputs is a Standard Schema without Standard JSON Schema; pass a JSON Schema instead");
+	return converted.schema;
+}
+function parametersOf(parameters) {
+	if (parameters === void 0) return;
+	if (Array.isArray(parameters)) return parameters.map((parameter) => parameter.in === void 0 ? {
+		name: parameter.name,
+		value: parameter.value
+	} : {
+		name: parameter.name,
+		in: parameter.in,
+		value: parameter.value
+	});
+	return Object.entries(parameters).map(([name, value]) => ({
+		name,
+		value
+	}));
+}
+function criterionOf(criterion) {
+	return typeof criterion === "string" ? { condition: criterion } : { ...criterion };
+}
+function stepOf(step) {
+	const parameters = parametersOf(step.parameters);
+	let target = {};
+	if (step.operationId) target = { operationId: step.operationId };
+	else if (step.workflowId) target = { workflowId: step.workflowId };
+	else if (step.channel) target = { channel: step.channel };
+	return {
+		id: step.id,
+		...step.description === void 0 ? {} : { description: step.description },
+		...target,
+		...parameters === void 0 ? {} : { parameters },
+		...step.requestBody === void 0 ? {} : { requestBody: { payload: step.requestBody } },
+		...step.successCriteria === void 0 ? {} : { successCriteria: step.successCriteria.map(criterionOf) },
+		...step.outputs === void 0 ? {} : { outputs: { ...step.outputs } },
+		...step.onSuccess === void 0 ? {} : { onSuccess: step.onSuccess },
+		...step.onFailure === void 0 ? {} : { onFailure: step.onFailure }
+	};
+}
+/**
+* A workflow for `defineApi`'s `workflows`, rendered by `arazzoFormat`.
+* Steps name operations by operationId; pass the ids as `Op` (for example
+* `ResourceOperationIds<"customers">`) to type them. Rendering reports
+* unknown operationIds, steps that read outputs of later or unknown steps,
+* and channel steps outside Arazzo 1.1.
+*
+* ```ts
+* const onboarding = defineWorkflow<ResourceOperationIds<"customers">>({
+*   id: "onboardCustomer",
+*   inputs: { type: "object", properties: { row: { type: "object" } } },
+*   steps: [
+*     { id: "create", operationId: "createCustomers", requestBody: "$inputs.row",
+*       outputs: { id: "$response.body#/id" } },
+*     { id: "get", operationId: "getCustomers", parameters: { id: "$steps.create.outputs.id" } },
+*   ],
+* });
+* ```
+*/
+function defineWorkflow(workflow) {
+	return {
+		id: workflow.id,
+		...workflow.summary === void 0 ? {} : { summary: workflow.summary },
+		...workflow.description === void 0 ? {} : { description: workflow.description },
+		...workflow.inputs === void 0 ? {} : { inputs: inputsOf(workflow.inputs) },
+		steps: workflow.steps.map(stepOf),
+		...workflow.outputs === void 0 ? {} : { outputs: { ...workflow.outputs } }
+	};
+}
+//#endregion
+//#region src/arazzo/index.ts
+/**
+* An Arazzo document for the API's workflows: your `defineWorkflow`
+* workflows and the built-ins (`paginationWorkflows()`,
+* `createThenGetWorkflows()`, `authWorkflow()`), checked against the
+* operations the API has. Throws when building or checking the document
+* finds an error; use `defineApi(...).render(arazzoFormat)` to read every
+* finding instead.
+*
+* ```ts
+* const doc = createArazzo(betterSupabase, {
+*   info: { title: "CRM workflows", version: "1.0.0" },
+*   resources: { customers: { pagination: "cursor" } },
+*   workflows: [paginationWorkflows(), createThenGetWorkflows()],
+* });
+* ```
+*/
+function createArazzo(betterSupabase, options) {
+	const { version, transform, overlays, onDiagnostic, openapi, asyncapi, ...apiOptions } = options;
+	const format = createArazzoFormat({
+		...openapi === void 0 ? {} : { openapi },
+		...asyncapi === void 0 ? {} : { asyncapi }
+	});
+	const result = defineApi(betterSupabase, apiOptions).render(format, {
+		...version === void 0 ? {} : { version },
+		...transform === void 0 ? {} : { transform: (rendered) => transform(rendered) },
+		...overlays === void 0 ? {} : { overlays }
+	});
+	const errors = result.diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+	if (errors.length > 0) throw new TypeError(`createArazzo: ${errors.map((error) => `${error.code}: ${error.message}${error.pointer ? ` (${error.pointer})` : ""}`).join("; ")}`);
+	if (onDiagnostic) for (const diagnostic of result.diagnostics) onDiagnostic(diagnostic);
+	return result.document;
+}
+//#endregion
+export { arazzoFormat, authWorkflow, createArazzo, createArazzoFormat, createThenGetWorkflows, defineWorkflow, paginationWorkflows };