kitcn/dist/middleware-Bg-PdtrI.js

kitcn - React Query integration and CLI tools for Convex

import { a as createMiddlewareFactory } from "./builder-DBgto1yn.js";

//#region src/plugins/middleware.ts
const PLUGIN_CONFIG_RESOLVERS = Symbol.for("kitcn:PluginConfigResolvers");
function isPlainObject(value) {
	return typeof value === "object" && value !== null && !Array.isArray(value);
}
function mergeOptions(currentOptions, nextOptions) {
	if (nextOptions === void 0) return currentOptions;
	if (currentOptions === void 0) return nextOptions;
	if (isPlainObject(currentOptions) && isPlainObject(nextOptions)) return {
		...currentOptions,
		...nextOptions
	};
	return nextOptions;
}
function toConfigureResolver(input) {
	if (typeof input === "function") return input;
	return () => input;
}
function resolvePluginOptions(plugin, args) {
	const resolvers = plugin[PLUGIN_CONFIG_RESOLVERS];
	if (!resolvers || resolvers.length === 0) return;
	let resolvedOptions;
	for (const resolver of resolvers) resolvedOptions = mergeOptions(resolvedOptions, resolver(args));
	return resolvedOptions;
}
function createConfiguredPlugin(definition, resolvers, extensionBuilders = []) {
	let plugin;
	const createBaseMiddleware = () => {
		return createMiddlewareFactory()(async ({ ctx, next }) => {
			const options = resolvePluginOptions(plugin, { ctx });
			const providedApi = definition.provide({
				ctx,
				options
			});
			const nextApi = {
				...isPlainObject(ctx.api) ? ctx.api ?? {} : {},
				[definition.key]: providedApi
			};
			return next({ ctx: {
				...ctx,
				api: nextApi
			} });
		});
	};
	const middlewareHelpers = { middleware: createBaseMiddleware };
	let middlewareOverride;
	const basePlugin = {
		key: definition.key,
		configure: (input) => createConfiguredPlugin(definition, [...resolvers, toConfigureResolver(input)], extensionBuilders),
		middleware: () => middlewareOverride ? middlewareOverride() : createBaseMiddleware(),
		extend: (build) => createConfiguredPlugin(definition, resolvers, [...extensionBuilders, build]),
		[PLUGIN_CONFIG_RESOLVERS]: resolvers
	};
	const middlewarePresets = {};
	for (const build of extensionBuilders) {
		const builtExtensions = build(middlewareHelpers);
		for (const [name, preset] of Object.entries(builtExtensions)) {
			if (typeof preset !== "function") throw new Error(`Duplicate plugin middleware "${name}" on plugin "${definition.key}".`);
			if (name === "middleware") {
				if (middlewareOverride) throw new Error(`Duplicate plugin middleware override on plugin "${definition.key}".`);
				middlewareOverride = preset;
				continue;
			}
			if (name in middlewarePresets || name in basePlugin) throw new Error(`Duplicate plugin middleware "${name}" on plugin "${definition.key}".`);
			middlewarePresets[name] = preset;
		}
	}
	plugin = {
		...basePlugin,
		...middlewarePresets
	};
	return Object.freeze(plugin);
}
function definePlugin(key, provide) {
	return createConfiguredPlugin({
		key,
		provide
	}, []);
}

//#endregion
export { resolvePluginOptions as n, definePlugin as t };