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

package/dist/openapi-source.runner-wLs5vqw6.mjs

@@ -0,0 +1,705 @@
+import fs from "fs";
+import path, { join } from "path";
+import { pathToFileURL } from "url";
+import { access, readdir } from "fs/promises";
+
+//#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
+//#region src/tiny/openapi-source.runner.ts
+function createTinyOpenApiSourceRunner(config) {
+	let queue = Promise.resolve();
+	const getOutputPath = () => getLocalInputPath(config.input, config.root);
+	const runGenerate = async () => {
+		const outputPath = getOutputPath();
+		if (!outputPath) return;
+		const generateOpenApiFileOptions = {
+			argv: ["--output", outputPath],
+			cwd: config.cwd ?? config.root,
+			defaultOutput: outputPath,
+			env: config.env ?? process.env
+		};
+		if (config.generateOpenApiFile) {
+			await config.generateOpenApiFile(generateOpenApiFileOptions);
+			return;
+		}
+		const generateOpenApiSpec = config.generateOpenApiSpec ?? await loadOpenApiSpecGenerator(config);
+		if (!generateOpenApiSpec) throw new Error("Missing Tiny OpenAPI generator. Pass generateOpenApiFile, generateOpenApiSpec, or generateOpenApiSpecModule.");
+		await generateOpenApiFile({
+			...generateOpenApiFileOptions,
+			generateOpenApiSpec
+		});
+	};
+	const enqueueGenerate = () => {
+		const run = queue.catch(() => void 0).then(runGenerate);
+		queue = run.then(() => void 0, () => void 0);
+		return run;
+	};
+	return {
+		enqueueGenerate,
+		getOutputPath
+	};
+}
+function isTinyOpenApiFakeMode(apiMode = process.env.VITE_PUBLIC_API_MODE ?? process.env.EXPO_PUBLIC_API_MODE) {
+	return apiMode !== "real";
+}
+function getLocalInputPath(input, root) {
+	if (typeof input !== "string" || /^https?:\/\//i.test(input)) return;
+	return path.resolve(root, input);
+}
+function normalizeWatchFolders(root, watchFolders = []) {
+	return watchFolders.map((folder) => path.isAbsolute(folder) ? folder : path.resolve(root, folder));
+}
+async function loadOpenApiSpecGenerator(config) {
+	if (!config.generateOpenApiSpecModule) return;
+	const moduleConfig = typeof config.generateOpenApiSpecModule === "string" ? { path: config.generateOpenApiSpecModule } : config.generateOpenApiSpecModule;
+	const modulePath = path.isAbsolute(moduleConfig.path) ? moduleConfig.path : path.resolve(config.root, moduleConfig.path);
+	const exportName = moduleConfig.exportName ?? "generateTinyOpenApiSpec";
+	const generateOpenApiSpec = (await import(pathToFileURL(modulePath).href))[exportName];
+	if (typeof generateOpenApiSpec !== "function") throw new Error(`Tiny OpenAPI spec module "${moduleConfig.path}" does not export function "${exportName}".`);
+	return generateOpenApiSpec;
+}
+
+//#endregion
+export { namedControllerActionInputDtoSchema as $, generateORPCOpenAPISpec as A, getOperationController as B, collectReachableModelSchemas as C, defineOpenApiSchemas as D, createModelSchemaNameGetter as E, getModuleOpenApiController as F, isContractProcedure as G, getProcedureInputSchemaRole as H, getModuleOpenApiTag as I, isObject as J, isNullSchema as K, getObjectPropertySchema as L, getComponentSchemas as M, getContractProcedureData as N, findComponentEnumNames as O, getDerivedOperationId as P, modelSchemaNameEntries as Q, getOpenApiSchemaName as R, collectOperationTags as S, compactTagName as T, getRobodevModuleRoles as U, getPaginatedItemSchema as V, getStringEnumValues as W, isZodSchema as X, isProcedureMeta as Y, modelSchemaExportName as Z, collectDbTableModelSchemaExports as _, visitZodSchema as _t, addContractSchema as a, operationKey as at, collectModuleModelSchemaExports as b, applyPaginatedItemSchemas as c, routeHasPathParameters as ct, applyRobodevUserRolesExtension as d, sharedSchemaExportName as dt, namedControllerActionSchema as et, asStringArray as f, stripNoContentResponseBodies as ft, collectDbTableModelSchemaExport as g, toPascalCase as gt, collectContractSchemas as h, toOpenAPIAclRule as ht, normalizeWatchFolders as i, namedOpenApiSchema as it, generateOpenApiFile as j, findEnumNames as k, applyParameterExtensions as l, schemaComponentRef as lt, collectContractSchemaRoots as m, toOpenAPI30Schema as mt, getLocalInputPath as n, namedOpenApiRequestSchema as nt, applyEnumExtensions as o, procedureSchemaName as ot, collectApiModelSchemaExports as p, toOpenAPI30Document as pt, isNullableOnlySchema as q, isTinyOpenApiFakeMode as r, namedOpenApiResponseSchema as rt, applyOperationMeta as s, resolveOpenApiOutputPath as st, createTinyOpenApiSourceRunner as t, namedOpenApiOutputSchema as tt, applyRobodevModuleExtensions as u, schemaExportName as ut, collectExtraSchemas as v, collectSchemaRegistryRoots as w, collectOperationMeta as x, collectModelSchemaExports as y, getOperationAction as z };