@povio/openapi-codegen-cli 3.1.0-rc.3 → 3.1.0-rc.4

package/dist/tiny.mjs

@@ -1,651 +1,3 @@
-import { i as normalizeWatchFolders, n as getLocalInputPath, r as isTinyOpenApiFakeMode, t as createTinyOpenApiSourceRunner } from "./openapi-source.runner-D19XnvMe.mjs";
-import fs from "fs";
-import path, { join } from "path";
-import { pathToFileURL } from "url";
-import { access, readdir } from "fs/promises";
+import { $ as namedControllerActionInputDtoSchema, A as generateORPCOpenAPISpec, B as getOperationController, C as collectReachableModelSchemas, D as defineOpenApiSchemas, E as createModelSchemaNameGetter, F as getModuleOpenApiController, G as isContractProcedure, H as getProcedureInputSchemaRole, I as getModuleOpenApiTag, J as isObject, K as isNullSchema, L as getObjectPropertySchema, M as getComponentSchemas, N as getContractProcedureData, O as findComponentEnumNames, P as getDerivedOperationId, Q as modelSchemaNameEntries, R as getOpenApiSchemaName, S as collectOperationTags, T as compactTagName, U as getRobodevModuleRoles, V as getPaginatedItemSchema, W as getStringEnumValues, X as isZodSchema, Y as isProcedureMeta, Z as modelSchemaExportName, _ as collectDbTableModelSchemaExports, _t as visitZodSchema, a as addContractSchema, at as operationKey, b as collectModuleModelSchemaExports, c as applyPaginatedItemSchemas, ct as routeHasPathParameters, d as applyRobodevUserRolesExtension, dt as sharedSchemaExportName, et as namedControllerActionSchema, f as asStringArray, ft as stripNoContentResponseBodies, g as collectDbTableModelSchemaExport, gt as toPascalCase, h as collectContractSchemas, ht as toOpenAPIAclRule, i as normalizeWatchFolders, it as namedOpenApiSchema, j as generateOpenApiFile, k as findEnumNames, l as applyParameterExtensions, lt as schemaComponentRef, m as collectContractSchemaRoots, mt as toOpenAPI30Schema, n as getLocalInputPath, nt as namedOpenApiRequestSchema, o as applyEnumExtensions, ot as procedureSchemaName, p as collectApiModelSchemaExports, pt as toOpenAPI30Document, q as isNullableOnlySchema, r as isTinyOpenApiFakeMode, rt as namedOpenApiResponseSchema, s as applyOperationMeta, st as resolveOpenApiOutputPath, t as createTinyOpenApiSourceRunner, tt as namedOpenApiOutputSchema, u as applyRobodevModuleExtensions, ut as schemaExportName, v as collectExtraSchemas, w as collectSchemaRegistryRoots, x as collectOperationMeta, y as collectModelSchemaExports, z as getOperationAction } from "./openapi-source.runner-wLs5vqw6.mjs";
 
-//#region src/tiny/openapi.ts
-async function importRuntimeModule(specifier) {
-	return new Function("specifier", "return import(specifier)")(specifier);
-}
-const PAGINATED_OUTPUT_SUFFIX = "PaginateOutput";
-const PAGINATED_RESPONSE_SUFFIX = "PaginateResponse";
-const PAGINATION_RESPONSE_OUTPUT_SUFFIX = "PaginationResponseOutput";
-const PAGINATED_ITEM_SUFFIX = "PaginateItem";
-const PAGINATED_ITEM_OUTPUT_SUFFIX = "PaginateItemOutput";
-const PAGINATION_DTO_SCHEMA_NAME = "PaginationDto";
-const PAGINATION_PROPERTY_NAMES = [
-	"page",
-	"cursor",
-	"nextCursor",
-	"limit",
-	"totalItems"
-];
-const OPENAPI_31_ONLY_KEYS = new Set([
-	"$schema",
-	"$id",
-	"$vocabulary",
-	"$dynamicAnchor",
-	"$dynamicRef",
-	"$defs",
-	"jsonSchemaDialect",
-	"unevaluatedItems",
-	"unevaluatedProperties",
-	"dependentRequired",
-	"dependentSchemas",
-	"prefixItems",
-	"propertyNames",
-	"contains",
-	"minContains",
-	"maxContains",
-	"contentEncoding",
-	"contentMediaType",
-	"contentSchema"
-]);
-const openApiSchemaNames = /* @__PURE__ */ new WeakMap();
-function resolveOpenApiOutputPath({ argv = process.argv, cwd = process.cwd(), defaultOutput, env = process.env }) {
-	const outputFlagIndex = argv.indexOf("--output");
-	const output = (outputFlagIndex !== -1 ? argv[outputFlagIndex + 1] : void 0) ?? env.TINY_OPENAPI_OUTPUT ?? defaultOutput;
-	return path.resolve(cwd, output);
-}
-async function generateOpenApiFile(options) {
-	const outputPath = resolveOpenApiOutputPath(options);
-	const spec = await options.generateOpenApiSpec();
-	const output = `${JSON.stringify(spec, null, 2)}\n`;
-	if (fs.existsSync(outputPath) && fs.readFileSync(outputPath, "utf8") === output) return {
-		outputPath,
-		changed: false
-	};
-	fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-	fs.writeFileSync(outputPath, output);
-	return {
-		outputPath,
-		changed: true
-	};
-}
-function defineOpenApiSchemas(schemas) {
-	return schemas;
-}
-function collectExtraSchemas(modules) {
-	return Object.values(modules).reduce((schemas, module) => {
-		Object.assign(schemas, module.extraSchemas ?? {});
-		return schemas;
-	}, {});
-}
-function namedOpenApiSchema(schema, name) {
-	openApiSchemaNames.set(schema, name);
-	return schema;
-}
-function namedOpenApiRequestSchema(schema, name) {
-	return namedOpenApiSchema(schema, `${name}Request`);
-}
-function namedOpenApiResponseSchema(schema, name) {
-	return namedOpenApiSchema(schema, `${name}Response`);
-}
-function namedOpenApiOutputSchema(schema, name) {
-	return namedOpenApiResponseSchema(schema, name);
-}
-function namedControllerActionSchema(schema, controller, action, suffix) {
-	return namedOpenApiSchema(schema, `${controller}Controller${toPascalCase(action)}${suffix}`);
-}
-function namedControllerActionInputDtoSchema(schema, controller, action) {
-	return namedControllerActionSchema(schema, controller, action, "Request");
-}
-function getOpenApiSchemaName(schema) {
-	return typeof schema === "object" && schema !== null ? openApiSchemaNames.get(schema) : void 0;
-}
-function isObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function getContractProcedureData(router) {
-	if (!isObject(router) || !isObject(router["~orpc"])) return;
-	const data = router["~orpc"];
-	if (!isObject(data.route)) return;
-	return {
-		inputSchema: data.inputSchema,
-		meta: data.meta,
-		outputSchema: data.outputSchema,
-		route: {
-			inputStructure: typeof data.route.inputStructure === "string" ? data.route.inputStructure : void 0,
-			method: typeof data.route.method === "string" ? data.route.method : void 0,
-			operationId: typeof data.route.operationId === "string" ? data.route.operationId : void 0,
-			path: typeof data.route.path === "string" ? data.route.path : void 0,
-			successStatus: typeof data.route.successStatus === "number" ? data.route.successStatus : void 0
-		}
-	};
-}
-function isContractProcedure(router) {
-	return Boolean(getContractProcedureData(router));
-}
-function routerEntries(router) {
-	return isObject(router) ? Object.entries(router) : [];
-}
-function asStringArray(value) {
-	return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : [];
-}
-function isNullSchema(value) {
-	return isObject(value) && value.type === "null";
-}
-function isNullableOnlySchema(value) {
-	return isObject(value) && value.nullable === true && Object.keys(value).every((key) => key === "nullable");
-}
-function toOpenAPI30Schema(value) {
-	if (Array.isArray(value)) return value.map(toOpenAPI30Schema);
-	if (!isObject(value)) return value;
-	const next = {};
-	for (const [key, rawValue] of Object.entries(value)) {
-		if (OPENAPI_31_ONLY_KEYS.has(key)) continue;
-		if (key === "const") {
-			next.enum = [rawValue];
-			continue;
-		}
-		next[key] = toOpenAPI30Schema(rawValue);
-	}
-	if (Array.isArray(next.type)) {
-		const types = next.type.filter((item) => item !== "null");
-		if (types.length !== next.type.length) next.nullable = true;
-		if (types.length === 1) {
-			const [type] = types;
-			next.type = type;
-		} else if (types.length > 1) {
-			delete next.type;
-			next.anyOf = types.map((type) => ({ type }));
-		} else delete next.type;
-	}
-	for (const keyword of ["anyOf", "oneOf"]) {
-		const branches = next[keyword];
-		if (Array.isArray(branches) && branches.some((item) => isNullSchema(item) || isNullableOnlySchema(item))) {
-			const nonNullBranches = branches.filter((item) => !isNullSchema(item) && !isNullableOnlySchema(item));
-			next.nullable = true;
-			if (nonNullBranches.length === 1 && isObject(nonNullBranches[0])) {
-				delete next[keyword];
-				Object.assign(next, nonNullBranches[0]);
-				next.nullable = true;
-			} else next[keyword] = nonNullBranches;
-		}
-	}
-	if (next.type === "null") {
-		delete next.type;
-		next.nullable = true;
-	}
-	if (typeof next.$ref === "string" && next.nullable === true) {
-		const { $ref, ...rest } = next;
-		return {
-			...rest,
-			allOf: [{ $ref }]
-		};
-	}
-	return next;
-}
-function stripNoContentResponseBodies(spec) {
-	if (!isObject(spec.paths)) return;
-	for (const pathItem of Object.values(spec.paths)) {
-		if (!isObject(pathItem)) continue;
-		for (const operation of Object.values(pathItem)) {
-			if (!isObject(operation) || !isObject(operation.responses)) continue;
-			const noContentResponse = operation.responses["204"];
-			if (isObject(noContentResponse)) delete noContentResponse.content;
-		}
-	}
-}
-function isProcedureMeta(meta) {
-	return isObject(meta) && typeof meta.bl === "string";
-}
-function operationKey(method, routePath) {
-	return `${method.toLowerCase()} ${routePath}`;
-}
-function toPascalCase(value) {
-	return value.replace(/(^|[-_\s]+)([a-zA-Z0-9]?)/g, (_, _separator, next) => next.toUpperCase());
-}
-function isZodSchema(value) {
-	return isObject(value) && isObject(value["~standard"]) && value["~standard"].vendor === "zod" && isObject(value._zod) && isObject(value._zod.def);
-}
-function schemaExportName(moduleName, exportName, schema, getSchemaName = getOpenApiSchemaName) {
-	const explicitName = getSchemaName(schema);
-	if (explicitName) return explicitName;
-	const schemaName = exportName.replace(/Schema$/, "").replace(/DTO$/u, "");
-	const modulePrefix = toPascalCase(moduleName);
-	const singularModulePrefix = modulePrefix.endsWith("s") ? modulePrefix.slice(0, -1) : modulePrefix;
-	return moduleName === "common" || schemaName.startsWith(modulePrefix) || schemaName.startsWith(singularModulePrefix) ? schemaName : `${modulePrefix}${schemaName}`;
-}
-function modelSchemaExportName(exportName) {
-	return exportName.replace(/Schema$/, "");
-}
-function sharedSchemaExportName(exportName) {
-	return exportName.replace(/Schema$/, "");
-}
-async function collectModelSchemaExports(options) {
-	const apiSchemaGroups = options.apiRoot ? await collectApiModelSchemaExports(options.apiRoot) : [];
-	const dbSchemaExports = options.dbTablesRoot ? await collectDbTableModelSchemaExports(options.dbTablesRoot) : [];
-	return [...apiSchemaGroups, ...dbSchemaExports];
-}
-async function collectApiModelSchemaExports(apiRoot) {
-	const entries = await readdir(apiRoot, { withFileTypes: true });
-	return (await Promise.all(entries.filter((item) => item.isDirectory()).sort((a, b) => a.name.localeCompare(b.name)).map((entry) => collectModuleModelSchemaExports(apiRoot, entry.name)))).flat();
-}
-async function collectModuleModelSchemaExports(apiRoot, moduleName) {
-	const modelsPath = join(apiRoot, moduleName, `${moduleName}.models.ts`);
-	try {
-		await access(modelsPath);
-	} catch {
-		return [];
-	}
-	const models = await import(
-		/* @vite-ignore */
-		pathToFileURL(modelsPath).href
-);
-	const schemas = [];
-	for (const [exportName, schema] of Object.entries(models)) if (exportName.endsWith("Schema") && isZodSchema(schema)) schemas.push({
-		moduleName,
-		name: modelSchemaExportName(exportName),
-		schema
-	});
-	return schemas;
-}
-async function collectDbTableModelSchemaExports(tablesRoot) {
-	const tableEntries = await readdir(tablesRoot, { withFileTypes: true });
-	return (await Promise.all(tableEntries.filter((item) => item.isDirectory()).sort((a, b) => a.name.localeCompare(b.name)).map((entry) => collectDbTableModelSchemaExport(tablesRoot, entry.name)))).flat();
-}
-async function collectDbTableModelSchemaExport(tablesRoot, tableName) {
-	const schemaPath = join(tablesRoot, tableName, `${tableName}.schema.ts`);
-	try {
-		await access(schemaPath);
-	} catch {
-		return [];
-	}
-	const exports = await import(
-		/* @vite-ignore */
-		pathToFileURL(schemaPath).href
-);
-	const schemas = [];
-	for (const [exportName, schema] of Object.entries(exports)) if (exportName.endsWith("TypeSchema") && isZodSchema(schema)) schemas.push({
-		moduleName: "db",
-		name: sharedSchemaExportName(exportName),
-		schema
-	});
-	return schemas;
-}
-function toOpenAPIAclRule(rule) {
-	const [subject, action] = rule.split(":");
-	return {
-		action,
-		subject: toPascalCase(subject)
-	};
-}
-function collectOperationMeta(router, routerPath = [], operationMeta = /* @__PURE__ */ new Map()) {
-	const procedure = getContractProcedureData(router);
-	if (procedure) {
-		const { meta, route } = procedure;
-		if (route.method && route.path && isProcedureMeta(meta)) operationMeta.set(operationKey(route.method, route.path), {
-			meta,
-			path: routerPath,
-			routeOperationId: route.operationId
-		});
-		return operationMeta;
-	}
-	for (const [name, child] of routerEntries(router)) collectOperationMeta(child, [...routerPath, name], operationMeta);
-	return operationMeta;
-}
-function getObjectPropertySchema(schema, property) {
-	if (!isZodSchema(schema) || schema._zod.def.type !== "object") return;
-	const { _zod: { def: { shape } } } = schema;
-	if (!isObject(shape)) return;
-	const propertySchema = shape[property];
-	return isZodSchema(propertySchema) ? propertySchema : void 0;
-}
-function routeHasPathParameters(routePath) {
-	return typeof routePath === "string" && /\{[^}]+\}/u.test(routePath);
-}
-function getProcedureInputSchemaRole(route) {
-	if (routeHasPathParameters(route.path)) return "Params";
-	return route.method?.toUpperCase() === "GET" ? "Query" : "Request";
-}
-function procedureSchemaName(procedureName, role) {
-	if (procedureName.endsWith(role)) return procedureName;
-	return `${procedureName}${role}`;
-}
-function addContractSchema(schemas, schema, name, getSchemaName, strategy) {
-	if (!schema) return;
-	schemas[getSchemaName(schema) ?? name] = {
-		schema,
-		...strategy ? { strategy } : {}
-	};
-}
-function collectContractSchemas(router, routerPath = [], schemas = {}, getSchemaName = getOpenApiSchemaName) {
-	const procedure = getContractProcedureData(router);
-	if (procedure) {
-		const procedureName = routerPath.map(toPascalCase).join("");
-		const { inputSchema, outputSchema, route } = procedure;
-		if (inputSchema) if (route.inputStructure === "detailed") {
-			addContractSchema(schemas, getObjectPropertySchema(inputSchema, "params"), procedureSchemaName(procedureName, "Params"), getSchemaName);
-			addContractSchema(schemas, getObjectPropertySchema(inputSchema, "query"), procedureSchemaName(procedureName, "Query"), getSchemaName);
-			addContractSchema(schemas, getObjectPropertySchema(inputSchema, "body") ?? inputSchema, procedureSchemaName(procedureName, "Request"), getSchemaName);
-		} else addContractSchema(schemas, inputSchema, procedureSchemaName(procedureName, getProcedureInputSchemaRole(route)), getSchemaName);
-		if (outputSchema && route.successStatus !== 204) addContractSchema(schemas, outputSchema, procedureSchemaName(procedureName, "Response"), getSchemaName, "output");
-		return schemas;
-	}
-	for (const [name, child] of routerEntries(router)) collectContractSchemas(child, [...routerPath, name], schemas, getSchemaName);
-	return schemas;
-}
-function collectContractSchemaRoots(router, roots = /* @__PURE__ */ new Set()) {
-	const procedure = getContractProcedureData(router);
-	if (procedure) {
-		const { inputSchema, outputSchema, route } = procedure;
-		if (inputSchema) roots.add(inputSchema);
-		if (outputSchema && route.successStatus !== 204) roots.add(outputSchema);
-		return roots;
-	}
-	for (const [, child] of routerEntries(router)) collectContractSchemaRoots(child, roots);
-	return roots;
-}
-function visitZodSchema(schema, visit, seen = /* @__PURE__ */ new Set()) {
-	if (seen.has(schema)) return;
-	seen.add(schema);
-	visit(schema);
-	const visitValue = (value) => {
-		if (isZodSchema(value)) {
-			visitZodSchema(value, visit, seen);
-			return;
-		}
-		if (Array.isArray(value)) {
-			value.forEach(visitValue);
-			return;
-		}
-		if (isObject(value)) Object.values(value).forEach(visitValue);
-	};
-	const { def } = schema._zod;
-	Object.values(def).forEach(visitValue);
-	if (typeof def.getter === "function") {
-		const lazyValue = def.getter();
-		if (isZodSchema(lazyValue)) visitZodSchema(lazyValue, visit, seen);
-	}
-}
-function collectSchemaRegistryRoots(registry) {
-	return Object.values(registry).reduce((schemas, entry) => {
-		if ("schema" in entry && entry.schema) schemas.add(entry.schema);
-		return schemas;
-	}, /* @__PURE__ */ new Set());
-}
-function modelSchemaNameEntries(modelSchemas) {
-	const schemaNameBySchema = /* @__PURE__ */ new Map();
-	for (const { name, schema } of modelSchemas) {
-		const existingName = schemaNameBySchema.get(schema);
-		if (!existingName || name.length < existingName.length) schemaNameBySchema.set(schema, name);
-	}
-	return schemaNameBySchema;
-}
-function createModelSchemaNameGetter(modelSchemas, getSchemaName = getOpenApiSchemaName) {
-	const schemaNameBySchema = modelSchemaNameEntries(modelSchemas);
-	return (schema) => (isZodSchema(schema) ? schemaNameBySchema.get(schema) : void 0) ?? getSchemaName(schema);
-}
-async function collectReachableModelSchemas(router, options = {}) {
-	const excludedSchemas = options.excludedSchemas ?? /* @__PURE__ */ new Set();
-	const modelSchemas = options.modelSchemas ?? await collectModelSchemaExports(options);
-	const schemaNameBySchema = modelSchemaNameEntries(modelSchemas);
-	const routeRoots = collectContractSchemaRoots(router);
-	const reachableSchemas = {};
-	for (const { moduleName, name, schema } of modelSchemas) if ((moduleName === "common" || name.endsWith("SortableKey") || name.endsWith("OrderParamEnum")) && !excludedSchemas.has(schema)) reachableSchemas[name] = { schema };
-	for (const root of routeRoots) {
-		if (!isZodSchema(root)) continue;
-		visitZodSchema(root, (schema) => {
-			if (routeRoots.has(schema) || excludedSchemas.has(schema)) return;
-			const name = schemaNameBySchema.get(schema);
-			if (name) reachableSchemas[name] = { schema };
-		});
-	}
-	return reachableSchemas;
-}
-function compactTagName(value) {
-	return value.replace(/[^a-zA-Z0-9]/g, "");
-}
-function getModuleOpenApiController(apiModules, moduleName) {
-	const module = apiModules[moduleName];
-	return module?.openApiController ?? `${compactTagName(module?.openApiTag ?? toPascalCase(moduleName))}Controller`;
-}
-function getOperationController(apiModules, operationPath) {
-	const [moduleName, controllerSegment] = operationPath;
-	if (!moduleName) return;
-	if (!controllerSegment || operationPath.length === 2) return getModuleOpenApiController(apiModules, moduleName);
-	return `${getModuleOpenApiController(apiModules, moduleName).replace(/Controller$/, "")}${toPascalCase(controllerSegment)}Controller`;
-}
-function getOperationAction(operationPath) {
-	return operationPath.at(-1);
-}
-function getDerivedOperationId(apiModules, info) {
-	const controller = getOperationController(apiModules, info.path);
-	const action = getOperationAction(info.path);
-	return controller && action ? `${controller}_${action}` : void 0;
-}
-function applyOperationMeta(spec, operationMeta, apiModules) {
-	if (!isObject(spec.paths)) return;
-	for (const [routePath, pathItem] of Object.entries(spec.paths)) {
-		if (!isObject(pathItem)) continue;
-		for (const [method, operation] of Object.entries(pathItem)) {
-			if (!isObject(operation)) continue;
-			const info = operationMeta.get(operationKey(method, routePath));
-			if (!info) continue;
-			operation.operationId = info.routeOperationId ?? getDerivedOperationId(apiModules, info) ?? operation.operationId;
-			const { meta } = info;
-			operation["x-bl"] = meta.bl;
-			if (meta.acl) {
-				operation["x-acl"] = meta.acl.map(toOpenAPIAclRule);
-				operation.responses = {
-					...isObject(operation.responses) ? operation.responses : {},
-					"401": { description: "Unauthorized" },
-					"403": { description: "Forbidden" }
-				};
-			}
-		}
-	}
-}
-function findEnumNames(value) {
-	if (!isObject(value)) return;
-	const enumNames = value["x-enumNames"];
-	if (Array.isArray(enumNames) && enumNames.every((item) => typeof item === "string")) return enumNames;
-	for (const keyword of [
-		"allOf",
-		"anyOf",
-		"oneOf"
-	]) {
-		const schemas = value[keyword];
-		if (!Array.isArray(schemas)) continue;
-		for (const schema of schemas) {
-			const nestedEnumNames = findEnumNames(schema);
-			if (nestedEnumNames) return nestedEnumNames;
-		}
-	}
-}
-function getStringEnumValues(schema) {
-	const { enum: enumValues } = schema;
-	if (!Array.isArray(enumValues) || enumValues.length === 0) return;
-	return enumValues.every((item) => typeof item === "string") ? enumValues : void 0;
-}
-function applyEnumExtensions(value) {
-	if (Array.isArray(value)) {
-		value.forEach(applyEnumExtensions);
-		return;
-	}
-	if (!isObject(value)) return;
-	const enumNames = getStringEnumValues(value);
-	if (enumNames && !Array.isArray(value["x-enumNames"])) value["x-enumNames"] = enumNames;
-	Object.values(value).forEach(applyEnumExtensions);
-}
-function findComponentEnumNames(spec, name) {
-	const { components } = spec;
-	if (!isObject(components) || !isObject(components.schemas)) return;
-	const schema = components.schemas[name];
-	if (!isObject(schema)) return;
-	return findEnumNames(schema) ?? getStringEnumValues(schema);
-}
-function applyParameterExtensions(spec, realBackendSortableSchemaNames = /* @__PURE__ */ new Map()) {
-	if (!isObject(spec.paths)) return;
-	for (const pathItem of Object.values(spec.paths)) {
-		if (!isObject(pathItem)) continue;
-		for (const operation of Object.values(pathItem)) {
-			if (!isObject(operation) || !Array.isArray(operation.parameters)) continue;
-			const [tag] = Array.isArray(operation.tags) ? operation.tags : [];
-			const sortableSchemaName = typeof tag === "string" ? realBackendSortableSchemaNames.get(tag) ?? `${toPascalCase(tag)}SortableKey` : void 0;
-			const sortableEnumNames = sortableSchemaName ? findComponentEnumNames(spec, sortableSchemaName) : void 0;
-			for (const parameter of operation.parameters) {
-				if (!isObject(parameter) || parameter.in !== "query") continue;
-				if (parameter.name === "filter" && parameter.required !== true) parameter.required = false;
-				const enumNames = findEnumNames(parameter.schema) ?? (parameter.name === "order" ? sortableEnumNames : void 0);
-				if (enumNames) parameter["x-enumNames"] = enumNames;
-			}
-		}
-	}
-}
-function getModuleOpenApiTag(apiModules, moduleName) {
-	return apiModules[moduleName]?.openApiTag ?? moduleName;
-}
-function applyRobodevModuleExtensions(spec, moduleExtensions, apiModules) {
-	if (moduleExtensions.size === 0) return;
-	const existingTags = Array.isArray(spec.tags) ? spec.tags.filter(isObject) : [];
-	const tagsByName = /* @__PURE__ */ new Map();
-	for (const tag of existingTags) if (typeof tag.name === "string") tagsByName.set(tag.name, tag);
-	for (const [moduleName, metadata] of moduleExtensions) {
-		const tagName = getModuleOpenApiTag(apiModules, moduleName);
-		const tag = tagsByName.get(tagName) ?? { name: tagName };
-		if (metadata.hidden) tag["x-robodev-hidden"] = true;
-		if (metadata.tables.length > 0) tag["x-robodev-owned-tables"] = metadata.tables;
-		if (metadata.roles.length > 0) tag["x-robodev-roles"] = metadata.roles;
-		tagsByName.set(tagName, tag);
-	}
-	spec.tags = [...tagsByName.values()];
-}
-function applyRobodevUserRolesExtension(spec, userRoles = []) {
-	spec["x-robodev-user-roles"] = userRoles.map((role) => ({
-		name: role.name,
-		description: role.description,
-		...role.isDefault ? { isDefault: true } : {}
-	}));
-}
-function collectOperationTags(spec) {
-	const tags = /* @__PURE__ */ new Set();
-	if (!isObject(spec.paths)) return tags;
-	for (const pathItem of Object.values(spec.paths)) {
-		if (!isObject(pathItem)) continue;
-		for (const operation of Object.values(pathItem)) {
-			if (!isObject(operation)) continue;
-			asStringArray(operation.tags).forEach((tag) => tags.add(tag));
-		}
-	}
-	return tags;
-}
-function getRobodevModuleRoles(hidden, explicitRoles, moduleHasOperations, defaultRoles) {
-	if (hidden) return [];
-	if (explicitRoles) return [...explicitRoles];
-	return moduleHasOperations ? [...defaultRoles] : [];
-}
-function schemaComponentRef(name) {
-	return { $ref: `#/components/schemas/${name}` };
-}
-function getComponentSchemas(spec) {
-	const { components } = spec;
-	if (!isObject(components) || !isObject(components.schemas)) return null;
-	return components.schemas;
-}
-function getPaginatedItemSchema(schema) {
-	const { properties } = schema;
-	if (!isObject(properties) || !PAGINATION_PROPERTY_NAMES.every((name) => name in properties)) return null;
-	const { items } = properties;
-	if (!isObject(items) || items.type !== "array" || !isObject(items.items)) return null;
-	return items.items;
-}
-function applyPaginatedItemSchemas(spec) {
-	const schemas = getComponentSchemas(spec);
-	if (!schemas) return;
-	for (const [name, schema] of Object.entries(schemas)) {
-		if (!(name.endsWith(PAGINATED_OUTPUT_SUFFIX) || name.endsWith(PAGINATED_RESPONSE_SUFFIX) || name.endsWith(PAGINATION_RESPONSE_OUTPUT_SUFFIX)) || !isObject(schema)) continue;
-		const itemSchema = getPaginatedItemSchema(schema);
-		if (!itemSchema) continue;
-		const itemName = name.endsWith(PAGINATION_RESPONSE_OUTPUT_SUFFIX) ? name.replace(new RegExp(`${PAGINATION_RESPONSE_OUTPUT_SUFFIX}$`), PAGINATED_ITEM_OUTPUT_SUFFIX) : name.replace(new RegExp(`${PAGINATED_OUTPUT_SUFFIX}$`), PAGINATED_ITEM_SUFFIX).replace(new RegExp(`${PAGINATED_RESPONSE_SUFFIX}$`), PAGINATED_ITEM_SUFFIX);
-		schemas[itemName] = { allOf: [itemSchema] };
-		schemas[name] = { allOf: [schemaComponentRef(PAGINATION_DTO_SCHEMA_NAME), {
-			type: "object",
-			properties: { items: {
-				type: "array",
-				items: schemaComponentRef(itemName)
-			} },
-			required: ["items"]
-		}] };
-	}
-}
-function toOpenAPI30Document(spec) {
-	const converted = toOpenAPI30Schema(spec);
-	converted.openapi = "3.0.3";
-	const components = isObject(converted.components) ? converted.components : {};
-	components.securitySchemes = {
-		...isObject(components.securitySchemes) ? components.securitySchemes : {},
-		bearerAuth: {
-			type: "http",
-			scheme: "bearer"
-		}
-	};
-	converted.components = components;
-	stripNoContentResponseBodies(converted);
-	return converted;
-}
-async function generateORPCOpenAPISpec(options) {
-	const [{ OpenAPIGenerator }, { ZodToJsonSchemaConverter }] = await Promise.all([importRuntimeModule("@orpc/openapi"), importRuntimeModule("@orpc/zod/zod4")]);
-	const generator = new OpenAPIGenerator({ schemaConverters: [new ZodToJsonSchemaConverter()] });
-	const explicitSchemaName = options.getOpenApiSchemaName ?? getOpenApiSchemaName;
-	const modelSchemas = await collectModelSchemaExports({
-		apiRoot: options.apiRoot,
-		dbTablesRoot: options.dbTablesRoot
-	});
-	const getSchemaName = createModelSchemaNameGetter(modelSchemas, explicitSchemaName);
-	const operationMeta = collectOperationMeta(options.contract);
-	const extraSchemas = collectExtraSchemas(options.apiModules);
-	const reachableModelSchemas = await collectReachableModelSchemas(options.contract, {
-		apiRoot: options.apiRoot,
-		dbTablesRoot: options.dbTablesRoot,
-		excludedSchemas: collectSchemaRegistryRoots(extraSchemas),
-		getOpenApiSchemaName: getSchemaName,
-		modelSchemas
-	});
-	const commonSchemas = {
-		...collectContractSchemas(options.contract, [], {}, getSchemaName),
-		...extraSchemas,
-		...reachableModelSchemas
-	};
-	const spec = await generator.generate(options.contract, {
-		info: options.info ?? {
-			title: "Tiny Template Fake API",
-			description: "OpenAPI spec generated from the oRPC fake backend contract.",
-			version: "3.0.0"
-		},
-		servers: options.servers ?? [{
-			url: "/",
-			description: "Current origin"
-		}],
-		...Object.keys(commonSchemas).length > 0 ? { commonSchemas } : {}
-	});
-	const jsonSpec = spec;
-	const sortableSchemaNames = options.realBackendSortableSchemaNames instanceof Map ? options.realBackendSortableSchemaNames : new Map(Object.entries(options.realBackendSortableSchemaNames ?? {}));
-	applyOperationMeta(jsonSpec, operationMeta, options.apiModules);
-	applyEnumExtensions(spec);
-	applyParameterExtensions(jsonSpec, sortableSchemaNames);
-	applyPaginatedItemSchemas(jsonSpec);
-	const userRoles = options.userRoles ?? [];
-	const defaultRobodevRoles = userRoles.filter((role) => role.isDefault).map((role) => role.name);
-	const operationTags = collectOperationTags(jsonSpec);
-	const robodevModuleExtensions = /* @__PURE__ */ new Map();
-	for (const [name, module] of Object.entries(options.apiModules)) {
-		const tagName = getModuleOpenApiTag(options.apiModules, name);
-		const hidden = module.robodevHidden === true;
-		const explicitRobodevRoles = Array.isArray(module.robodevRoles) ? [...module.robodevRoles] : null;
-		const metadata = {
-			hidden,
-			tables: Array.isArray(module.robodevOwnedTables) ? [...module.robodevOwnedTables] : [],
-			roles: getRobodevModuleRoles(hidden, explicitRobodevRoles, operationTags.has(tagName), defaultRobodevRoles)
-		};
-		if (metadata.hidden || metadata.tables.length > 0 || metadata.roles.length > 0) robodevModuleExtensions.set(name, metadata);
-	}
-	applyRobodevModuleExtensions(jsonSpec, robodevModuleExtensions, options.apiModules);
-	applyRobodevUserRolesExtension(jsonSpec, userRoles);
-	return toOpenAPI30Document(jsonSpec);
-}
-
-//#endregion
 export { addContractSchema, applyEnumExtensions, applyOperationMeta, applyPaginatedItemSchemas, applyParameterExtensions, applyRobodevModuleExtensions, applyRobodevUserRolesExtension, asStringArray, collectApiModelSchemaExports, collectContractSchemaRoots, collectContractSchemas, collectDbTableModelSchemaExport, collectDbTableModelSchemaExports, collectExtraSchemas, collectModelSchemaExports, collectModuleModelSchemaExports, collectOperationMeta, collectOperationTags, collectReachableModelSchemas, collectSchemaRegistryRoots, compactTagName, createModelSchemaNameGetter, createTinyOpenApiSourceRunner, defineOpenApiSchemas, findComponentEnumNames, findEnumNames, generateORPCOpenAPISpec, generateOpenApiFile, getComponentSchemas, getContractProcedureData, getDerivedOperationId, getModuleOpenApiController, getModuleOpenApiTag, getObjectPropertySchema, getOpenApiSchemaName, getOperationAction, getOperationController, getPaginatedItemSchema, getProcedureInputSchemaRole, getRobodevModuleRoles, getStringEnumValues, getLocalInputPath as getTinyOpenApiLocalInputPath, isContractProcedure, isNullSchema, isNullableOnlySchema, isObject, isProcedureMeta, isTinyOpenApiFakeMode, isZodSchema, modelSchemaExportName, modelSchemaNameEntries, namedControllerActionInputDtoSchema, namedControllerActionSchema, namedOpenApiOutputSchema, namedOpenApiRequestSchema, namedOpenApiResponseSchema, namedOpenApiSchema, normalizeWatchFolders as normalizeTinyOpenApiWatchFolders, operationKey, procedureSchemaName, resolveOpenApiOutputPath, routeHasPathParameters, schemaComponentRef, schemaExportName, sharedSchemaExportName, stripNoContentResponseBodies, toOpenAPI30Document, toOpenAPI30Schema, toOpenAPIAclRule, toPascalCase, visitZodSchema };

package/dist/vite.d.mts

@@ -1,6 +1,6 @@
 import { r as GenerateFileFormatter } from "./options-CE4Koxof.mjs";
 import { t as OpenAPICodegenConfig } from "./config-BU7wVf7U.mjs";
-import { a as GenerateOpenApiFile } from "./openapi-BkC5yZ-W.mjs";
+import { d as GenerateOpenApiFile, m as GenerateOpenApiSpec, n as TinyOpenApiSpecModuleConfig } from "./openapi-source.runner-BSIrB6ny.mjs";
 import { Plugin, PluginOption } from "vite";
 
 //#region src/plugins/openapi-codegen.runner.d.ts
@@ -18,7 +18,9 @@ interface TinyOpenApiCodegenViteOptions {
   cwd?: string;
   debounceMs?: number;
   env?: NodeJS.ProcessEnv;
-  generateOpenApiFile: GenerateOpenApiFile;
+  generateOpenApiFile?: GenerateOpenApiFile;
+  generateOpenApiSpec?: GenerateOpenApiSpec;
+  generateOpenApiSpecModule?: string | TinyOpenApiSpecModuleConfig;
   watchFolders: readonly string[];
 }
 declare function tinyOpenApiCodegen(codegenConfig: OpenApiCodegenViteConfig, options: TinyOpenApiCodegenViteOptions): PluginOption[];