@storybooker/azure/dist/functions.cjs

StoryBooker Adapter for interacting with Azure services.

const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
let __storybooker_core_constants = require("@storybooker/core/constants");
__storybooker_core_constants = require_rolldown_runtime.__toESM(__storybooker_core_constants);
let __storybooker_core = require("@storybooker/core");
__storybooker_core = require_rolldown_runtime.__toESM(__storybooker_core);
let __storybooker_core_utils = require("@storybooker/core/utils");
__storybooker_core_utils = require_rolldown_runtime.__toESM(__storybooker_core_utils);

//#region src/functions.ts
const DEFAULT_PURGE_SCHEDULE_CRON = "0 0 0 * * *";
/**
* Register the Storybooker router with the Azure Functions App.
*
* - It enabled streaming responses for HTTP functions.
* - It registers the HTTP function with provided route and auth-level.
* - It registers the Timer function for purge if `purgeScheduleCron` is not `null`.
*
* @param app Azure Functions App instance
* @param options Options for registering the router
*/
function registerStoryBookerRouter(app, options) {
	app.setup({ enableHttpStream: true });
	const route = options.route || "";
	const logger = options.logger ?? console;
	const requestHandler = (0, __storybooker_core.createRequestHandler)({
		...options,
		errorParser: options.errorParser ?? parseAzureRestError,
		logger,
		prefix: (0, __storybooker_core_utils.generatePrefixFromBaseRoute)(route) || "/"
	});
	logger.log("Registering Storybooker Router (route: %s)", route || "/");
	app.http(__storybooker_core_constants.SERVICE_NAME, {
		authLevel: options.authLevel,
		handler: async (httpRequest, context) => {
			const request = transformHttpRequestToWebRequest(httpRequest);
			const response = await requestHandler(request, { logger: options.logger ?? context });
			return transformWebResponseToHttpResponse(response);
		},
		methods: [
			"DELETE",
			"GET",
			"PATCH",
			"POST",
			"PUT"
		],
		route: (0, __storybooker_core_utils.urlJoin)(route, "{**path}")
	});
	if (options.purgeScheduleCron !== null) {
		const schedule = options.purgeScheduleCron || DEFAULT_PURGE_SCHEDULE_CRON;
		const purgeHandler = (0, __storybooker_core.createPurgeHandler)({
			database: options.database,
			errorParser: options.errorParser ?? parseAzureRestError,
			logger,
			storage: options.storage
		});
		logger.log("Registering Storybooker Timer-Purge (cron: %s)", schedule);
		app.timer(`${__storybooker_core_constants.SERVICE_NAME}-timer_purge`, {
			handler: async (_timer, context) => purgeHandler({}, { logger: context }),
			runOnStartup: false,
			schedule
		});
	}
}
const parseAzureRestError = (error) => {
	if (error instanceof Error && error.name === "RestError") {
		const restError = error;
		const details = restError.details ?? {};
		const message = details["errorMessage"] ?? restError.message;
		return {
			errorMessage: `${details["errorCode"] ?? restError.name} (${restError.code ?? restError.statusCode}): ${message}`,
			errorStatus: restError.statusCode,
			errorType: "AzureRest"
		};
	}
};
function transformHttpRequestToWebRequest(httpRequest) {
	return new Request(httpRequest.url, {
		body: httpRequest.body ?? void 0,
		duplex: "half",
		headers: new Headers(httpRequest.headers),
		method: httpRequest.method
	});
}
async function transformWebResponseToHttpResponse(response) {
	let body = null;
	if (response.body) body = response.body;
	else body = await response.text();
	return {
		body,
		headers: response.headers,
		status: response.status
	};
}

//#endregion
exports.registerStoryBookerRouter = registerStoryBookerRouter;
//# sourceMappingURL=functions.cjs.map