@farming-labs/docs 0.2.114 → 0.2.116

package/dist/openapi-operations-DFpaqOqA.mjs

@@ -0,0 +1,324 @@
+//#region src/openapi-operations.ts
+const OPENAPI_OPERATION_METHODS = [
+	"get",
+	"put",
+	"post",
+	"delete",
+	"options",
+	"head",
+	"patch",
+	"trace"
+];
+function buildNormalizedOpenApiModel(document) {
+	const info = asRecord(document.info);
+	const specificationVersion = stringValue(document.openapi) ?? stringValue(document.swagger) ?? "unknown";
+	const servers = normalizeServers(document);
+	const globalSecurity = normalizeSecurity(document.security);
+	const securitySchemes = normalizeSecuritySchemes(document);
+	const paths = asRecord(document.paths) ?? {};
+	const operations = [];
+	const operationIds = /* @__PURE__ */ new Map();
+	for (const path of Object.keys(paths).sort()) {
+		if (path.startsWith("x-")) continue;
+		const pathItem = resolveRecord(document, paths[path]);
+		if (!pathItem) continue;
+		for (const method of OPENAPI_OPERATION_METHODS) {
+			const operation = resolveRecord(document, pathItem[method]);
+			if (!operation) continue;
+			const selector = `${method.toUpperCase()} ${path}`;
+			const explicitOperationId = stringValue(operation.operationId);
+			const operationId = explicitOperationId ?? createGeneratedOperationId(method, path);
+			const pointer = `/paths/${escapeJsonPointer(path)}/${method}`;
+			const previousPointer = operationIds.get(operationId);
+			if (previousPointer) throw new Error(`OpenAPI operation ID collision: \`${operationId}\` is used at ${previousPointer} and ${pointer}.`);
+			operationIds.set(operationId, pointer);
+			const parameters = normalizeParameters(document, pathItem.parameters, operation.parameters);
+			const requestBody = normalizeRequestBody(document, operation.requestBody, parameters, document, operation);
+			const responses = normalizeResponses(document, operation.responses, document, operation);
+			const security = operation.security === void 0 ? globalSecurity : normalizeSecurity(operation.security);
+			const usedSchemeNames = new Set(security.flatMap((requirement) => Object.keys(requirement)));
+			const usedSecuritySchemes = Object.fromEntries(Object.entries(securitySchemes).filter(([name]) => usedSchemeNames.has(name)));
+			const tags = normalizeTags(operation.tags, path);
+			const summary = stringValue(operation.summary);
+			const description = stringValue(operation.description);
+			const operationServers = normalizeServerValues(operation.servers);
+			const pathServers = normalizeServerValues(pathItem.servers);
+			const examples = [
+				...parameters.flatMap((parameter) => parameter.examples),
+				...requestBody?.content.flatMap((entry) => entry.examples) ?? [],
+				...responses.flatMap((response) => response.content.flatMap((entry) => entry.examples))
+			];
+			operations.push({
+				id: operationId,
+				operationId,
+				operationIdSource: explicitOperationId ? "explicit" : "generated",
+				slug: createOperationSlug(operationId),
+				selector,
+				pointer,
+				method: method.toUpperCase(),
+				path,
+				title: summary ?? description ?? selector,
+				...summary ? { summary } : {},
+				...description ? { description } : {},
+				tags,
+				deprecated: operation.deprecated === true,
+				parameters,
+				...requestBody ? { requestBody } : {},
+				responses,
+				examples,
+				security,
+				securitySchemes: usedSecuritySchemes,
+				servers: operationServers.length > 0 ? operationServers : pathServers.length > 0 ? pathServers : servers,
+				extensions: Object.fromEntries(Object.entries(operation).filter(([key]) => key.startsWith("x-")))
+			});
+		}
+	}
+	const declaredTags = Array.isArray(document.tags) ? document.tags.flatMap((tag) => {
+		const name = stringValue(asRecord(tag)?.name);
+		return name ? [name] : [];
+	}) : [];
+	const tags = Array.from(new Set([...declaredTags, ...operations.flatMap((operation) => operation.tags)]));
+	return {
+		title: stringValue(info?.title) ?? "API Reference",
+		version: stringValue(info?.version) ?? "0.0.0",
+		specificationVersion,
+		servers,
+		tags,
+		operationCount: operations.length,
+		operations
+	};
+}
+function normalizeParameters(document, pathParameters, operationParameters) {
+	const parameters = /* @__PURE__ */ new Map();
+	for (const value of [pathParameters, operationParameters]) {
+		if (!Array.isArray(value)) continue;
+		for (const item of value) {
+			const parameter = resolveRecord(document, item);
+			if (!parameter) continue;
+			const name = stringValue(parameter.name);
+			const location = stringValue(parameter.in);
+			if (!name || !location) continue;
+			const examples = normalizeParameterExamples(document, parameter);
+			const description = stringValue(parameter.description);
+			parameters.set(`${location}:${name}`, {
+				name,
+				in: location,
+				required: parameter.required === true || location === "path",
+				...description ? { description } : {},
+				...parameter.schema !== void 0 ? { schema: parameter.schema } : {},
+				examples
+			});
+		}
+	}
+	return Array.from(parameters.values());
+}
+function normalizeParameterExamples(document, parameter) {
+	const examples = [];
+	if (parameter.example !== void 0) examples.push({
+		name: "default",
+		location: "parameter",
+		value: parameter.example
+	});
+	const exampleMap = asRecord(parameter.examples);
+	if (exampleMap) for (const name of Object.keys(exampleMap).sort()) examples.push(normalizeExample(document, name, exampleMap[name], "parameter"));
+	return examples;
+}
+function normalizeRequestBody(document, value, parameters, root, operation) {
+	const requestBody = resolveRecord(document, value);
+	if (requestBody) {
+		const description = stringValue(requestBody.description);
+		return {
+			required: requestBody.required === true,
+			...description ? { description } : {},
+			content: normalizeContent(document, requestBody.content, "request")
+		};
+	}
+	const bodyParameter = parameters.find((parameter) => parameter.in === "body");
+	if (!bodyParameter) return void 0;
+	const consumes = normalizeStringArray(operation.consumes);
+	const mediaTypes = consumes.length > 0 ? consumes : normalizeStringArray(root.consumes);
+	return {
+		required: bodyParameter.required,
+		...bodyParameter.description ? { description: bodyParameter.description } : {},
+		content: (mediaTypes.length > 0 ? mediaTypes : ["application/json"]).map((mediaType) => ({
+			mediaType,
+			...bodyParameter.schema !== void 0 ? { schema: bodyParameter.schema } : {},
+			examples: bodyParameter.examples
+		}))
+	};
+}
+function normalizeResponses(document, value, root, operation) {
+	const responses = asRecord(value);
+	if (!responses) return [];
+	const produces = normalizeStringArray(operation.produces);
+	const fallbackMediaTypes = produces.length > 0 ? produces : normalizeStringArray(root.produces);
+	return Object.keys(responses).sort(compareResponseStatus).flatMap((status) => {
+		const response = resolveRecord(document, responses[status]);
+		if (!response) return [];
+		const description = stringValue(response.description);
+		let content = normalizeContent(document, response.content, "response", status);
+		if (content.length === 0 && response.schema !== void 0) {
+			const legacyExamples = asRecord(response.examples);
+			content = (fallbackMediaTypes.length > 0 ? fallbackMediaTypes : ["application/json"]).map((mediaType) => ({
+				mediaType,
+				schema: response.schema,
+				examples: legacyExamples && Object.hasOwn(legacyExamples, mediaType) ? [{
+					name: "default",
+					location: "response",
+					status,
+					mediaType,
+					value: legacyExamples[mediaType]
+				}] : []
+			}));
+		}
+		return [{
+			status,
+			...description ? { description } : {},
+			content
+		}];
+	});
+}
+function normalizeContent(document, value, location, status) {
+	const content = asRecord(value);
+	if (!content) return [];
+	return Object.keys(content).sort().flatMap((mediaType) => {
+		const media = resolveRecord(document, content[mediaType]);
+		if (!media) return [];
+		const examples = [];
+		if (media.example !== void 0) examples.push({
+			name: "default",
+			location,
+			mediaType,
+			...status ? { status } : {},
+			value: media.example
+		});
+		const exampleMap = asRecord(media.examples);
+		if (exampleMap) for (const name of Object.keys(exampleMap).sort()) examples.push(normalizeExample(document, name, exampleMap[name], location, mediaType, status));
+		return [{
+			mediaType,
+			...media.schema !== void 0 ? { schema: media.schema } : {},
+			examples
+		}];
+	});
+}
+function normalizeExample(document, name, value, location, mediaType, status) {
+	const example = resolveRecord(document, value);
+	if (!example) return {
+		name,
+		location,
+		...mediaType ? { mediaType } : {},
+		...status ? { status } : {},
+		value
+	};
+	const summary = stringValue(example.summary);
+	const description = stringValue(example.description);
+	const externalValue = stringValue(example.externalValue);
+	return {
+		name,
+		location,
+		...summary ? { summary } : {},
+		...description ? { description } : {},
+		...mediaType ? { mediaType } : {},
+		...status ? { status } : {},
+		...Object.hasOwn(example, "value") ? { value: example.value } : {},
+		...externalValue ? { externalValue } : {}
+	};
+}
+function normalizeSecuritySchemes(document) {
+	const schemes = asRecord(asRecord(document.components)?.securitySchemes) ?? asRecord(document.securityDefinitions);
+	if (!schemes) return {};
+	return Object.fromEntries(Object.entries(schemes).map(([name, value]) => [name, resolveRecord(document, value) ?? value]));
+}
+function normalizeSecurity(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((requirement) => {
+		const record = asRecord(requirement);
+		if (!record) return [];
+		return [Object.fromEntries(Object.entries(record).map(([name, scopes]) => [name, normalizeStringArray(scopes)]))];
+	});
+}
+function normalizeServers(document) {
+	const servers = normalizeServerValues(document.servers);
+	if (servers.length > 0) return servers;
+	const host = stringValue(document.host);
+	if (!host) return [];
+	const schemes = normalizeStringArray(document.schemes);
+	const basePath = stringValue(document.basePath) ?? "";
+	return (schemes.length > 0 ? schemes : ["https"]).map((scheme) => `${scheme}://${host}${basePath}`);
+}
+function normalizeServerValues(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((server) => {
+		const url = stringValue(asRecord(server)?.url);
+		return url ? [url] : [];
+	});
+}
+function normalizeTags(value, path) {
+	const tags = normalizeStringArray(value);
+	return tags.length > 0 ? tags : [inferTag(path)];
+}
+function inferTag(path) {
+	const segment = path.split("/").filter(Boolean).find((part) => !part.startsWith("{"));
+	if (!segment) return "General";
+	return segment.replace(/[-_]+/g, " ").replace(/\b\w/g, (character) => character.toUpperCase());
+}
+function resolveRecord(document, value, activeReferences = /* @__PURE__ */ new Set()) {
+	const record = asRecord(value);
+	if (!record) return void 0;
+	const reference = stringValue(record.$ref);
+	if (!reference || !reference.startsWith("#/")) return record;
+	if (activeReferences.has(reference)) return Object.fromEntries(Object.entries(record).filter(([key]) => key !== "$ref"));
+	const resolved = resolveRecord(document, resolveJsonPointer(document, reference.slice(1)), new Set(activeReferences).add(reference));
+	const siblings = Object.fromEntries(Object.entries(record).filter(([key]) => key !== "$ref"));
+	return resolved ? {
+		...resolved,
+		...siblings
+	} : Object.keys(siblings).length > 0 ? siblings : record;
+}
+function resolveJsonPointer(document, pointer) {
+	let current = document;
+	for (const token of pointer.slice(1).split("/")) {
+		if (!current || typeof current !== "object") return void 0;
+		const key = token.replaceAll("~1", "/").replaceAll("~0", "~");
+		current = current[key];
+	}
+	return current;
+}
+function createGeneratedOperationId(method, path) {
+	return `${method}_${path.replace(/[^a-zA-Z0-9]+/g, "_")}`;
+}
+function createOperationSlug(operationId) {
+	return `${operationId.trim().replace(/([a-z\d])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "operation"}-${fnv1a32(operationId).toString(36)}`;
+}
+function fnv1a32(value) {
+	let hash = 2166136261;
+	for (let index = 0; index < value.length; index += 1) {
+		hash ^= value.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return hash >>> 0;
+}
+function compareResponseStatus(left, right) {
+	if (left === "default") return 1;
+	if (right === "default") return -1;
+	return left.localeCompare(right, void 0, { numeric: true });
+}
+function normalizeStringArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((item) => {
+		const normalized = stringValue(item);
+		return normalized ? [normalized] : [];
+	});
+}
+function stringValue(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function escapeJsonPointer(value) {
+	return value.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+
+//#endregion
+export { buildNormalizedOpenApiModel as n, OPENAPI_OPERATION_METHODS as t };