@povio/openapi-codegen-cli 3.0.0-rc.9 → 3.1.0-rc.1

package/dist/generator.d.mts

@@ -1,4 +1,4 @@
-import { n as GenerateFileData, t as GenerateOptions } from "./options-BPAjzilp.mjs";
+import { n as GenerateFileData, t as GenerateOptions } from "./options-CE4Koxof.mjs";
 import { OpenAPIV3 } from "openapi-types";
 
 //#region src/generators/types/metadata.d.ts

package/dist/generator.mjs

@@ -1,4 +1,4 @@
-import { _ as getNamespaceName, a as getDataFromOpenAPIDoc, b as isParamMediaTypeAllowed, c as getSchemaTsMetaType, d as getTagImportPath, f as getQueryName, g as invalidVariableNameCharactersToCamel, l as getTsTypeBase, o as isMutation, p as DEFAULT_GENERATE_OPTIONS, s as isQuery, t as generateCodeFromOpenAPIDoc, v as GenerateType, x as formatTag, y as isMediaTypeAllowed } from "./generateCodeFromOpenAPIDoc-NA2XZmIv.mjs";
+import { _ as getNamespaceName, a as getDataFromOpenAPIDoc, b as isParamMediaTypeAllowed, c as getSchemaTsMetaType, d as getTagImportPath, f as getQueryName, g as invalidVariableNameCharactersToCamel, l as getTsTypeBase, o as isMutation, p as DEFAULT_GENERATE_OPTIONS, s as isQuery, t as generateCodeFromOpenAPIDoc, v as GenerateType, x as formatTag, y as isMediaTypeAllowed } from "./generateCodeFromOpenAPIDoc-C-n0Knj8.mjs";
 import SwaggerParser from "@apidevtools/swagger-parser";
 
 //#region src/generators/core/getMetadataFromOpenAPIDoc.ts

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { a as ErrorHandler, c as SharedErrorHandler, i as ErrorEntry, n as DomainErrorEntry, o as ErrorHandlerOptions, r as DomainErrorRegistry, s as GeneralErrorCodes, t as ApplicationException } from "./error-handling-B4aYKmyL.mjs";
-import "./options-BPAjzilp.mjs";
-import { t as OpenAPICodegenConfig } from "./config-C1ME3Ay4.mjs";
+import { a as ErrorHandler, c as SharedErrorHandler, i as ErrorEntry, n as DomainErrorEntry, o as ErrorHandlerOptions, r as DomainErrorRegistry, s as GeneralErrorCodes, t as ApplicationException } from "./error-handling-CDeKUFHF.mjs";
+import "./options-CE4Koxof.mjs";
+import { t as OpenAPICodegenConfig } from "./config-BU7wVf7U.mjs";
 import { AxiosError, AxiosInstance, AxiosRequestConfig, AxiosResponse, AxiosResponseHeaders, CreateAxiosDefaults } from "axios";
 import { z } from "zod";
 import "i18next";
@@ -26,6 +26,7 @@ interface RequestInfo<ZOutput, ECodes extends string> {
 }
 interface RequestConfig<IsRawRes extends boolean = false> {
   rawResponse?: IsRawRes;
+  allowInvalidResponseData?: boolean;
 }
 type Response<ZOutput, IsRawRes extends boolean = false> = IsRawRes extends true ? AxiosResponse<ZOutput> : ZOutput;
 interface RestClient {
@@ -90,6 +91,7 @@ declare namespace OpenApiQueryConfig {
     invalidateCurrentModule?: boolean;
     invalidationMap?: InvalidationMap<TQueryModule>;
     crossTabInvalidation?: boolean;
+    allowInvalidResponseData?: boolean;
     onError?: (error: unknown) => void;
   }
   type ProviderProps<TQueryModule extends QueryModule = QueryModule> = Type<TQueryModule>;
@@ -98,6 +100,7 @@ declare namespace OpenApiQueryConfig {
     invalidateCurrentModule,
     invalidationMap,
     crossTabInvalidation,
+    allowInvalidResponseData,
     onError,
     children
   }: PropsWithChildren<ProviderProps<TQueryModule>>): react_jsx_runtime0.JSX.Element;

package/dist/index.mjs

@@ -66,9 +66,18 @@ var RestClient = class {
 	async makeRequest(requestInfo, requestConfig) {
 		const errorStack = (/* @__PURE__ */ new Error()).stack;
 		try {
-			const { rawResponse, ...config } = requestConfig;
+			const { rawResponse, allowInvalidResponseData, ...config } = requestConfig;
 			const res = await this.client(config);
-			const resData = requestInfo.resSchema.parse(res.data);
+			const responseData = res.status === 204 && res.data === "" ? void 0 : res.data;
+			const parseResult = requestInfo.resSchema.safeParse(responseData);
+			let resData;
+			if (parseResult.success) resData = parseResult.data;
+			else if (allowInvalidResponseData && config.method === "get") {
+				parseResult.error.name = "BE Response schema mismatch - ZodError";
+				parseResult.error.stack = [parseResult.error.stack, ...errorStack?.split("\n").slice(2) ?? []].join("\n");
+				console.error(parseResult.error);
+				resData = res.data;
+			} else throw parseResult.error;
 			return rawResponse ? {
 				...res,
 				data: resData
@@ -113,18 +122,20 @@ var RestInterceptor = class {
 let OpenApiQueryConfig;
 (function(_OpenApiQueryConfig) {
 	const Context = createContext({});
-	function Provider({ preferUpdate, invalidateCurrentModule, invalidationMap, crossTabInvalidation, onError, children }) {
+	function Provider({ preferUpdate, invalidateCurrentModule, invalidationMap, crossTabInvalidation, allowInvalidResponseData, onError, children }) {
 		const value = useMemo(() => ({
 			preferUpdate,
 			invalidateCurrentModule,
 			invalidationMap,
 			crossTabInvalidation,
+			allowInvalidResponseData,
 			onError
 		}), [
 			preferUpdate,
 			invalidateCurrentModule,
 			invalidationMap,
 			crossTabInvalidation,
+			allowInvalidResponseData,
 			onError
 		]);
 		return /* @__PURE__ */ jsx(Context.Provider, {

package/dist/metro.d.mts

@@ -0,0 +1,45 @@
+import { r as GenerateFileFormatter } from "./options-CE4Koxof.mjs";
+import { t as OpenAPICodegenConfig } from "./config-BU7wVf7U.mjs";
+import { a as GenerateOpenApiFile } from "./openapi-B14GzSA_.mjs";
+import { IncomingMessage, ServerResponse } from "http";
+
+//#region src/metro/openapi-codegen.plugin.d.ts
+type OpenApiCodegenMetroConfig = OpenAPICodegenConfig & {
+  formatGeneratedFile?: GenerateFileFormatter;
+};
+type OpenApiCodegenMetroOptions = {
+  root?: string;
+  watchOpenApiInput?: boolean;
+};
+type MetroNextFunction = (error?: unknown) => void;
+type MetroMiddleware = (request: IncomingMessage, response: ServerResponse, next: MetroNextFunction) => unknown;
+type MetroServer = unknown;
+type MetroConfig = {
+  projectRoot?: string;
+  server?: {
+    enhanceMiddleware?: (middleware: MetroMiddleware, server: MetroServer) => MetroMiddleware;
+    [key: string]: unknown;
+  };
+  transformer?: {
+    getTransformOptions?: (...args: unknown[]) => unknown;
+    [key: string]: unknown;
+  };
+  watchFolders?: readonly string[];
+  [key: string]: unknown;
+};
+declare function withOpenApiCodegen<TMetroConfig extends MetroConfig>(metroConfig: Promise<TMetroConfig>, codegenConfig: OpenApiCodegenMetroConfig, options?: OpenApiCodegenMetroOptions): Promise<TMetroConfig>;
+declare function withOpenApiCodegen<TMetroConfig extends MetroConfig>(metroConfig: TMetroConfig, codegenConfig: OpenApiCodegenMetroConfig, options?: OpenApiCodegenMetroOptions): TMetroConfig;
+//#endregion
+//#region src/metro/tiny-openapi-codegen.plugin.d.ts
+interface TinyOpenApiCodegenMetroOptions extends OpenApiCodegenMetroOptions {
+  apiMode?: string;
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  generateOpenApiFile: GenerateOpenApiFile;
+  watchFolders: readonly string[];
+  watchTinyOpenApiInput?: boolean;
+}
+declare function tinyOpenApiCodegenMetro<TMetroConfig extends MetroConfig>(metroConfig: Promise<TMetroConfig>, codegenConfig: OpenApiCodegenMetroConfig, options: TinyOpenApiCodegenMetroOptions): Promise<TMetroConfig>;
+declare function tinyOpenApiCodegenMetro<TMetroConfig extends MetroConfig>(metroConfig: TMetroConfig, codegenConfig: OpenApiCodegenMetroConfig, options: TinyOpenApiCodegenMetroOptions): TMetroConfig;
+//#endregion
+export { type MetroConfig, type MetroMiddleware, type OpenAPICodegenConfig, type OpenApiCodegenMetroConfig, type OpenApiCodegenMetroOptions, type TinyOpenApiCodegenMetroOptions, tinyOpenApiCodegenMetro, withOpenApiCodegen };

package/dist/metro.mjs

@@ -0,0 +1,185 @@
+import "./generateCodeFromOpenAPIDoc-C-n0Knj8.mjs";
+import "./generate.runner-BXTc97I0.mjs";
+import { t as createOpenApiCodegenRunner } from "./openapi-codegen.runner-QGd35-a3.mjs";
+import { i as normalizeWatchFolders, r as isTinyOpenApiFakeMode, t as createTinyOpenApiSourceRunner } from "./openapi-source.runner-D19XnvMe.mjs";
+import fs from "fs";
+import path from "path";
+
+//#region src/metro/openapi-codegen.plugin.ts
+function withOpenApiCodegen(metroConfig, codegenConfig, options = {}) {
+	if (isPromiseLike$1(metroConfig)) return metroConfig.then((resolvedConfig) => withResolvedOpenApiCodegen(resolvedConfig, codegenConfig, options));
+	return withResolvedOpenApiCodegen(metroConfig, codegenConfig, options);
+}
+function withResolvedOpenApiCodegen(metroConfig, codegenConfig, options) {
+	const root = path.resolve(options.root ?? metroConfig.projectRoot ?? process.cwd());
+	const codegen = createOpenApiCodegenRunner(codegenConfig);
+	const originalEnhanceMiddleware = metroConfig.server?.enhanceMiddleware;
+	const originalGetTransformOptions = metroConfig.transformer?.getTransformOptions;
+	let startupSucceeded = false;
+	let inflightGenerate;
+	let inputWatcher;
+	const requestStartupGenerate = () => {
+		if (startupSucceeded) return Promise.resolve();
+		if (inflightGenerate) return inflightGenerate;
+		const attempt = codegen.enqueueGenerate(root).then(() => {
+			startupSucceeded = true;
+			inflightGenerate = void 0;
+		}, (error) => {
+			inflightGenerate = void 0;
+			throw error;
+		});
+		inflightGenerate = attempt;
+		return attempt;
+	};
+	const ensureInputWatcher = () => {
+		if (options.watchOpenApiInput === false || inputWatcher) return;
+		const inputPath = codegen.getLocalInputPath(root);
+		if (!inputPath) return;
+		try {
+			inputWatcher = fs.watch(inputPath, { persistent: false }, () => {
+				startupSucceeded = false;
+				requestStartupGenerate().catch(reportGenerateError$1);
+			});
+			inputWatcher.on("error", reportWatcherError$1);
+		} catch (error) {
+			reportWatcherError$1(error);
+		}
+	};
+	const wrappedConfig = {
+		...metroConfig,
+		server: {
+			...metroConfig.server,
+			enhanceMiddleware(middleware, server) {
+				ensureInputWatcher();
+				const enhancedMiddleware = originalEnhanceMiddleware ? originalEnhanceMiddleware(middleware, server) : middleware;
+				return async (request, response, next) => {
+					try {
+						await requestStartupGenerate();
+						return await enhancedMiddleware(request, response, next);
+					} catch (error) {
+						next(error);
+					}
+				};
+			}
+		},
+		transformer: {
+			...metroConfig.transformer,
+			async getTransformOptions(...args) {
+				await requestStartupGenerate();
+				return originalGetTransformOptions ? originalGetTransformOptions(...args) : void 0;
+			}
+		}
+	};
+	if (options.root || metroConfig.projectRoot) wrappedConfig.projectRoot = root;
+	return wrappedConfig;
+}
+function isPromiseLike$1(value) {
+	return typeof value.then === "function";
+}
+function reportGenerateError$1(error) {
+	console.error("[openapi-codegen] Failed to generate OpenAPI client from Metro config.", error);
+}
+function reportWatcherError$1(error) {
+	console.error("[openapi-codegen] Failed to watch OpenAPI input from Metro config.", error);
+}
+
+//#endregion
+//#region src/metro/tiny-openapi-codegen.plugin.ts
+const watchedEvents = new Set(["change", "rename"]);
+function tinyOpenApiCodegenMetro(metroConfig, codegenConfig, options) {
+	if (isPromiseLike(metroConfig)) return metroConfig.then((resolvedConfig) => withResolvedTinyOpenApiCodegen(resolvedConfig, codegenConfig, options));
+	return withResolvedTinyOpenApiCodegen(metroConfig, codegenConfig, options);
+}
+function withResolvedTinyOpenApiCodegen(metroConfig, codegenConfig, options) {
+	if (!isTinyOpenApiFakeMode(options.apiMode)) return withOpenApiCodegen(metroConfig, codegenConfig, options);
+	const root = path.resolve(options.root ?? metroConfig.projectRoot ?? process.cwd());
+	const sourceRunner = createTinyOpenApiSourceRunner({
+		cwd: options.cwd,
+		env: options.env,
+		generateOpenApiFile: options.generateOpenApiFile,
+		input: codegenConfig.input,
+		root
+	});
+	const codegenRunner = createOpenApiCodegenRunner(codegenConfig);
+	const originalEnhanceMiddleware = metroConfig.server?.enhanceMiddleware;
+	const originalGetTransformOptions = metroConfig.transformer?.getTransformOptions;
+	let startupSucceeded = false;
+	let inflightGenerate;
+	let watcherReady = false;
+	const requestGenerateAll = () => {
+		if (startupSucceeded) return Promise.resolve();
+		if (inflightGenerate) return inflightGenerate;
+		const attempt = sourceRunner.enqueueGenerate().then(() => codegenRunner.enqueueGenerate(root)).then(() => {
+			startupSucceeded = true;
+			inflightGenerate = void 0;
+		}, (error) => {
+			inflightGenerate = void 0;
+			throw error;
+		});
+		inflightGenerate = attempt;
+		return attempt;
+	};
+	const requestSourceChangeGenerate = () => {
+		startupSucceeded = false;
+		return requestGenerateAll();
+	};
+	const ensureWatcher = () => {
+		if (watcherReady || options.watchTinyOpenApiInput === false) return;
+		watcherReady = true;
+		normalizeWatchFolders(root, options.watchFolders).flatMap(watchPath);
+	};
+	const enhancedConfig = {
+		...metroConfig,
+		server: {
+			...metroConfig.server,
+			enhanceMiddleware(middleware, server) {
+				ensureWatcher();
+				const enhancedMiddleware = originalEnhanceMiddleware ? originalEnhanceMiddleware(middleware, server) : middleware;
+				return async (request, response, next) => {
+					try {
+						await requestGenerateAll();
+						return await enhancedMiddleware(request, response, next);
+					} catch (error) {
+						next(error);
+					}
+				};
+			}
+		},
+		transformer: {
+			...metroConfig.transformer,
+			async getTransformOptions(...args) {
+				await requestGenerateAll();
+				return originalGetTransformOptions ? originalGetTransformOptions(...args) : void 0;
+			}
+		}
+	};
+	if (options.root || metroConfig.projectRoot) enhancedConfig.projectRoot = root;
+	return enhancedConfig;
+	function watchPath(target) {
+		try {
+			const watcher = fs.watch(target, {
+				persistent: false,
+				recursive: fs.existsSync(target) && fs.statSync(target).isDirectory()
+			}, (event) => {
+				if (watchedEvents.has(event)) requestSourceChangeGenerate().catch(reportGenerateError);
+			});
+			watcher.on("error", reportWatcherError);
+			return [watcher];
+		} catch (error) {
+			reportWatcherError(error);
+			return [];
+		}
+	}
+}
+function isPromiseLike(value) {
+	return typeof value.then === "function";
+}
+function reportGenerateError(error) {
+	console.error("[tiny-openapi] Failed to generate OpenAPI spec from Metro config.", error);
+}
+function reportWatcherError(error) {
+	console.error("[tiny-openapi] Failed to watch OpenAPI inputs from Metro config.", error);
+}
+
+//#endregion
+export { tinyOpenApiCodegenMetro, withOpenApiCodegen };

package/dist/openapi-B14GzSA_.d.mts

@@ -0,0 +1,170 @@
+//#region src/tiny/openapi.d.ts
+interface GenerateOpenApiFileOptions {
+  argv?: readonly string[];
+  cwd?: string;
+  defaultOutput: string;
+  env?: NodeJS.ProcessEnv;
+}
+interface GenerateTinyOpenApiFileOptions extends GenerateOpenApiFileOptions {
+  generateOpenApiSpec: () => Promise<unknown> | unknown;
+}
+interface GenerateOpenApiFileResult {
+  changed: boolean;
+  outputPath: string;
+}
+type GenerateOpenApiFile = (options: GenerateOpenApiFileOptions) => Promise<unknown> | unknown;
+type JsonObject = Record<string, unknown>;
+type AnySchema = unknown;
+type AnyContractRouter = unknown;
+type OpenApiSchemaRegistry = Record<string, {
+  schema?: AnySchema;
+  strategy?: "input" | "output";
+}>;
+type AclRule = `${string}:${string}`;
+type ZodSchema = AnySchema & {
+  _zod: {
+    def: JsonObject;
+  };
+};
+interface ProcedureMeta {
+  bl: string;
+  acl?: AclRule[];
+}
+interface TinyOpenApiUserRole {
+  description?: string;
+  isDefault?: boolean;
+  name: string;
+}
+interface TinyOpenApiModule {
+  extraSchemas?: OpenApiSchemaRegistry;
+  openApiController?: string;
+  openApiTag?: string;
+  robodevHidden?: boolean;
+  robodevOwnedTables?: readonly string[];
+  robodevRoles?: readonly string[];
+}
+interface GenerateORPCOpenAPISpecOptions {
+  apiModules: Record<string, TinyOpenApiModule>;
+  apiRoot?: string;
+  contract: AnyContractRouter;
+  dbTablesRoot?: string;
+  getOpenApiSchemaName?: (schema: unknown) => string | undefined;
+  info?: JsonObject;
+  realBackendSortableSchemaNames?: ReadonlyMap<string, string> | Record<string, string>;
+  servers?: JsonObject[];
+  userRoles?: readonly TinyOpenApiUserRole[];
+}
+interface ModelSchemaExport {
+  moduleName: string;
+  name: string;
+  schema: ZodSchema;
+}
+interface OperationContractInfo {
+  meta: ProcedureMeta;
+  path: string[];
+  routeOperationId?: string;
+}
+interface OrpcContractProcedureData {
+  inputSchema?: AnySchema;
+  meta?: unknown;
+  outputSchema?: AnySchema;
+  route: {
+    inputStructure?: string;
+    method?: string;
+    operationId?: string;
+    path?: string;
+    successStatus?: number;
+  };
+}
+declare function resolveOpenApiOutputPath({
+  argv,
+  cwd,
+  defaultOutput,
+  env
+}: GenerateOpenApiFileOptions): string;
+declare function generateOpenApiFile(options: GenerateTinyOpenApiFileOptions): Promise<GenerateOpenApiFileResult>;
+declare function defineOpenApiSchemas<const TSchemas extends OpenApiSchemaRegistry>(schemas: TSchemas): TSchemas;
+declare function collectExtraSchemas<TModules extends Record<string, {
+  extraSchemas?: OpenApiSchemaRegistry;
+}>>(modules: TModules): OpenApiSchemaRegistry;
+declare function namedOpenApiSchema<TSchema extends object>(schema: TSchema, name: string): TSchema;
+declare function namedOpenApiRequestSchema<TSchema extends object>(schema: TSchema, name: string): TSchema;
+declare function namedOpenApiResponseSchema<TSchema extends object>(schema: TSchema, name: string): TSchema;
+declare function namedOpenApiOutputSchema<TSchema extends object>(schema: TSchema, name: string): TSchema;
+declare function namedControllerActionSchema<TSchema extends object>(schema: TSchema, controller: string, action: string, suffix: string): TSchema;
+declare function namedControllerActionInputDtoSchema<TSchema extends object>(schema: TSchema, controller: string, action: string): TSchema;
+declare function getOpenApiSchemaName(schema: unknown): string | undefined;
+declare function isObject(value: unknown): value is JsonObject;
+declare function getContractProcedureData(router: AnyContractRouter): OrpcContractProcedureData | undefined;
+declare function isContractProcedure(router: AnyContractRouter): boolean;
+declare function asStringArray(value: unknown): string[];
+declare function isNullSchema(value: unknown): boolean;
+declare function isNullableOnlySchema(value: unknown): boolean;
+declare function toOpenAPI30Schema(value: unknown): unknown;
+declare function stripNoContentResponseBodies(spec: JsonObject): void;
+declare function isProcedureMeta(meta: unknown): meta is ProcedureMeta;
+declare function operationKey(method: string, routePath: string): string;
+declare function toPascalCase(value: string): string;
+declare function isZodSchema(value: unknown): value is ZodSchema;
+declare function dtoSchemaName(name: string): string;
+declare function shouldUseDtoSchemaName(moduleName: string, schema: ZodSchema): boolean;
+declare function schemaExportName(moduleName: string, exportName: string, schema: ZodSchema, getSchemaName?: typeof getOpenApiSchemaName): string;
+declare function sharedSchemaExportName(exportName: string): string;
+declare function collectModelSchemaExports(options: {
+  apiRoot?: string;
+  dbTablesRoot?: string;
+  getOpenApiSchemaName?: (schema: unknown) => string | undefined;
+}): Promise<ModelSchemaExport[]>;
+declare function collectApiModelSchemaExports(apiRoot: string, options?: {
+  getOpenApiSchemaName?: (schema: unknown) => string | undefined;
+}): Promise<ModelSchemaExport[]>;
+declare function collectModuleModelSchemaExports(apiRoot: string, moduleName: string, options?: {
+  getOpenApiSchemaName?: (schema: unknown) => string | undefined;
+}): Promise<ModelSchemaExport[]>;
+declare function collectDbTableModelSchemaExports(tablesRoot: string): Promise<ModelSchemaExport[]>;
+declare function collectDbTableModelSchemaExport(tablesRoot: string, tableName: string): Promise<ModelSchemaExport[]>;
+declare function toOpenAPIAclRule(rule: string): JsonObject;
+declare function collectOperationMeta(router: AnyContractRouter, routerPath?: string[], operationMeta?: Map<string, OperationContractInfo>): Map<string, OperationContractInfo>;
+declare function getObjectPropertySchema(schema: AnySchema, property: string): AnySchema | undefined;
+declare function collectContractSchemas(router: AnyContractRouter, routerPath?: string[], schemas?: OpenApiSchemaRegistry, getSchemaName?: typeof getOpenApiSchemaName): OpenApiSchemaRegistry;
+declare function collectContractSchemaRoots(router: AnyContractRouter, roots?: Set<unknown>): Set<AnySchema>;
+declare function visitZodSchema(schema: ZodSchema, visit: (schema: ZodSchema) => void, seen?: Set<{
+  _zod: {
+    def: JsonObject;
+  };
+}>): void;
+declare function collectSchemaRegistryRoots(registry: OpenApiSchemaRegistry): Set<AnySchema>;
+declare function collectReachableModelSchemas(router: AnyContractRouter, options?: {
+  apiRoot?: string;
+  dbTablesRoot?: string;
+  excludedSchemas?: Set<AnySchema>;
+  getOpenApiSchemaName?: (schema: unknown) => string | undefined;
+}): Promise<OpenApiSchemaRegistry>;
+declare function compactTagName(value: string): string;
+declare function getModuleOpenApiController(apiModules: Record<string, TinyOpenApiModule>, moduleName: string): string;
+declare function getOperationController(apiModules: Record<string, TinyOpenApiModule>, operationPath: string[]): string | undefined;
+declare function getOperationAction(operationPath: string[]): string | undefined;
+declare function getDerivedOperationId(apiModules: Record<string, TinyOpenApiModule>, info: OperationContractInfo): string | undefined;
+declare function applyOperationMeta(spec: JsonObject, operationMeta: Map<string, OperationContractInfo>, apiModules: Record<string, TinyOpenApiModule>): void;
+declare function findEnumNames(value: unknown): string[] | undefined;
+declare function getStringEnumValues(schema: JsonObject): string[] | undefined;
+declare function applyEnumExtensions(value: unknown): void;
+declare function findComponentEnumNames(spec: JsonObject, name: string): string[] | undefined;
+declare function applyParameterExtensions(spec: JsonObject, realBackendSortableSchemaNames?: ReadonlyMap<string, string>): void;
+declare function getModuleOpenApiTag(apiModules: Record<string, TinyOpenApiModule>, moduleName: string): string;
+declare function applyRobodevModuleExtensions(spec: JsonObject, moduleExtensions: Map<string, {
+  hidden: boolean;
+  tables: string[];
+  roles: string[];
+}>, apiModules: Record<string, TinyOpenApiModule>): void;
+declare function applyRobodevUserRolesExtension(spec: JsonObject, userRoles?: readonly TinyOpenApiUserRole[]): void;
+declare function collectOperationTags(spec: JsonObject): Set<string>;
+declare function getRobodevModuleRoles(hidden: boolean, explicitRoles: readonly string[] | null, moduleHasOperations: boolean, defaultRoles: readonly string[]): string[];
+declare function schemaComponentRef(name: string): JsonObject;
+declare function getComponentSchemas(spec: JsonObject): JsonObject | null;
+declare function getPaginatedItemSchema(schema: JsonObject): unknown;
+declare function applyPaginatedItemSchemas(spec: JsonObject): void;
+declare function toOpenAPI30Document(spec: JsonObject): JsonObject;
+declare function generateORPCOpenAPISpec(options: GenerateORPCOpenAPISpecOptions): Promise<JsonObject>;
+//#endregion
+export { isContractProcedure as $, collectOperationMeta as A, generateOpenApiFile as B, collectContractSchemaRoots as C, collectExtraSchemas as D, collectDbTableModelSchemaExports as E, defineOpenApiSchemas as F, getModuleOpenApiTag as G, getContractProcedureData as H, dtoSchemaName as I, getOperationAction as J, getObjectPropertySchema as K, findComponentEnumNames as L, collectReachableModelSchemas as M, collectSchemaRegistryRoots as N, collectModelSchemaExports as O, compactTagName as P, getStringEnumValues as Q, findEnumNames as R, collectApiModelSchemaExports as S, visitZodSchema as St, collectDbTableModelSchemaExport as T, getDerivedOperationId as U, getComponentSchemas as V, getModuleOpenApiController as W, getPaginatedItemSchema as X, getOperationController as Y, getRobodevModuleRoles as Z, applyPaginatedItemSchemas as _, stripNoContentResponseBodies as _t, GenerateOpenApiFile as a, namedControllerActionInputDtoSchema as at, applyRobodevUserRolesExtension as b, toOpenAPIAclRule as bt, GenerateTinyOpenApiFileOptions as c, namedOpenApiRequestSchema as ct, ProcedureMeta as d, operationKey as dt, isNullSchema as et, TinyOpenApiModule as f, resolveOpenApiOutputPath as ft, applyOperationMeta as g, shouldUseDtoSchemaName as gt, applyEnumExtensions as h, sharedSchemaExportName as ht, GenerateORPCOpenAPISpecOptions as i, isZodSchema as it, collectOperationTags as j, collectModuleModelSchemaExports as k, JsonObject as l, namedOpenApiResponseSchema as lt, ZodSchema as m, schemaExportName as mt, AnyContractRouter as n, isObject as nt, GenerateOpenApiFileOptions as o, namedControllerActionSchema as ot, TinyOpenApiUserRole as p, schemaComponentRef as pt, getOpenApiSchemaName as q, AnySchema as r, isProcedureMeta as rt, GenerateOpenApiFileResult as s, namedOpenApiOutputSchema as st, AclRule as t, isNullableOnlySchema as tt, OpenApiSchemaRegistry as u, namedOpenApiSchema as ut, applyParameterExtensions as v, toOpenAPI30Document as vt, collectContractSchemas as w, asStringArray as x, toPascalCase as xt, applyRobodevModuleExtensions as y, toOpenAPI30Schema as yt, generateORPCOpenAPISpec as z };

package/dist/openapi-codegen.runner-QGd35-a3.mjs

@@ -0,0 +1,42 @@
+import { S as Profiler } from "./generateCodeFromOpenAPIDoc-C-n0Knj8.mjs";
+import { t as runGenerate } from "./generate.runner-BXTc97I0.mjs";
+import path from "path";
+
+//#region src/plugins/openapi-codegen.runner.ts
+function createOpenApiCodegenRunner(config) {
+	let queue = Promise.resolve();
+	const { formatGeneratedFile, ...fileConfig } = config;
+	const enqueueGenerate = (root) => {
+		const run = queue.catch(() => void 0).then(async () => {
+			const profiler = new Profiler(process.env.OPENAPI_CODEGEN_PROFILE === "1");
+			await runGenerate({
+				fileConfig: normalizeOpenApiCodegenPaths(fileConfig, root),
+				formatGeneratedFile,
+				profiler
+			});
+		});
+		queue = run.then(() => void 0, () => void 0);
+		return run;
+	};
+	return {
+		enqueueGenerate,
+		getLocalInputPath: (root) => getLocalInputPath(config.input, root),
+		isLocalInput: isLocalOpenApiInput(config.input)
+	};
+}
+function normalizeOpenApiCodegenPaths(config, root) {
+	const normalized = { ...config };
+	if (typeof normalized.output === "string" && !path.isAbsolute(normalized.output)) normalized.output = path.resolve(root, normalized.output);
+	if (typeof normalized.input === "string" && !path.isAbsolute(normalized.input) && isLocalOpenApiInput(normalized.input)) normalized.input = path.resolve(root, normalized.input);
+	return normalized;
+}
+function getLocalInputPath(input, root) {
+	if (!isLocalOpenApiInput(input)) return;
+	return path.resolve(root, input);
+}
+function isLocalOpenApiInput(input) {
+	return typeof input === "string" && !/^https?:\/\//i.test(input);
+}
+
+//#endregion
+export { createOpenApiCodegenRunner as t };

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

@@ -0,0 +1,39 @@
+import path from "path";
+
+//#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;
+		await config.generateOpenApiFile({
+			argv: ["--output", outputPath],
+			cwd: config.cwd ?? config.root,
+			defaultOutput: outputPath,
+			env: config.env ?? process.env
+		});
+	};
+	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));
+}
+
+//#endregion
+export { normalizeWatchFolders as i, getLocalInputPath as n, isTinyOpenApiFakeMode as r, createTinyOpenApiSourceRunner as t };

package/dist/sh.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { C as VALIDATION_ERROR_TYPE_TITLE, S as Profiler, a as getDataFromOpenAPIDoc, m as groupByType, n as getOutputFileName, u as getTagFileName, v as GenerateType } from "./generateCodeFromOpenAPIDoc-NA2XZmIv.mjs";
-import { n as resolveConfig, t as runGenerate } from "./generate.runner-DSZ2ivlU.mjs";
+import { C as VALIDATION_ERROR_TYPE_TITLE, S as Profiler, a as getDataFromOpenAPIDoc, m as groupByType, n as getOutputFileName, u as getTagFileName, v as GenerateType } from "./generateCodeFromOpenAPIDoc-C-n0Knj8.mjs";
+import { n as resolveConfig, t as runGenerate } from "./generate.runner-BXTc97I0.mjs";
 import { createRequire } from "node:module";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
@@ -39,7 +39,7 @@ function logBanner(message) {
 * Fetch the version from package.json
 */
 function getVersion() {
-	return "3.0.0-rc.9";
+	return "3.1.0-rc.1";
 }
 
 //#endregion

package/dist/tiny.d.mts

@@ -0,0 +1,21 @@
+import "./options-CE4Koxof.mjs";
+import { t as OpenAPICodegenConfig } from "./config-BU7wVf7U.mjs";
+import { $ as isContractProcedure, A as collectOperationMeta, B as generateOpenApiFile, C as collectContractSchemaRoots, D as collectExtraSchemas, E as collectDbTableModelSchemaExports, F as defineOpenApiSchemas, G as getModuleOpenApiTag, H as getContractProcedureData, I as dtoSchemaName, J as getOperationAction, K as getObjectPropertySchema, L as findComponentEnumNames, M as collectReachableModelSchemas, N as collectSchemaRegistryRoots, O as collectModelSchemaExports, P as compactTagName, Q as getStringEnumValues, R as findEnumNames, S as collectApiModelSchemaExports, St as visitZodSchema, T as collectDbTableModelSchemaExport, U as getDerivedOperationId, V as getComponentSchemas, W as getModuleOpenApiController, X as getPaginatedItemSchema, Y as getOperationController, Z as getRobodevModuleRoles, _ as applyPaginatedItemSchemas, _t as stripNoContentResponseBodies, a as GenerateOpenApiFile, at as namedControllerActionInputDtoSchema, b as applyRobodevUserRolesExtension, bt as toOpenAPIAclRule, c as GenerateTinyOpenApiFileOptions, ct as namedOpenApiRequestSchema, d as ProcedureMeta, dt as operationKey, et as isNullSchema, f as TinyOpenApiModule, ft as resolveOpenApiOutputPath, g as applyOperationMeta, gt as shouldUseDtoSchemaName, h as applyEnumExtensions, ht as sharedSchemaExportName, i as GenerateORPCOpenAPISpecOptions, it as isZodSchema, j as collectOperationTags, k as collectModuleModelSchemaExports, l as JsonObject, lt as namedOpenApiResponseSchema, m as ZodSchema, mt as schemaExportName, n as AnyContractRouter, nt as isObject, o as GenerateOpenApiFileOptions, ot as namedControllerActionSchema, p as TinyOpenApiUserRole, pt as schemaComponentRef, q as getOpenApiSchemaName, r as AnySchema, rt as isProcedureMeta, s as GenerateOpenApiFileResult, st as namedOpenApiOutputSchema, t as AclRule, tt as isNullableOnlySchema, u as OpenApiSchemaRegistry, ut as namedOpenApiSchema, v as applyParameterExtensions, vt as toOpenAPI30Document, w as collectContractSchemas, x as asStringArray, xt as toPascalCase, y as applyRobodevModuleExtensions, yt as toOpenAPI30Schema, z as generateORPCOpenAPISpec } from "./openapi-B14GzSA_.mjs";
+
+//#region src/tiny/openapi-source.runner.d.ts
+interface TinyOpenApiSourceRunnerConfig {
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  generateOpenApiFile: GenerateOpenApiFile;
+  input: OpenAPICodegenConfig["input"];
+  root: string;
+}
+declare function createTinyOpenApiSourceRunner(config: TinyOpenApiSourceRunnerConfig): {
+  enqueueGenerate: () => Promise<void>;
+  getOutputPath: () => string | undefined;
+};
+declare function isTinyOpenApiFakeMode(apiMode?: string | undefined): boolean;
+declare function getLocalInputPath(input: OpenAPICodegenConfig["input"], root: string): string | undefined;
+declare function normalizeWatchFolders(root: string, watchFolders?: readonly string[]): string[];
+//#endregion
+export { AclRule, AnyContractRouter, AnySchema, GenerateORPCOpenAPISpecOptions, GenerateOpenApiFile, GenerateOpenApiFileOptions, GenerateOpenApiFileResult, GenerateTinyOpenApiFileOptions, JsonObject, OpenApiSchemaRegistry, ProcedureMeta, TinyOpenApiModule, type TinyOpenApiSourceRunnerConfig, TinyOpenApiUserRole, ZodSchema, applyEnumExtensions, applyOperationMeta, applyPaginatedItemSchemas, applyParameterExtensions, applyRobodevModuleExtensions, applyRobodevUserRolesExtension, asStringArray, collectApiModelSchemaExports, collectContractSchemaRoots, collectContractSchemas, collectDbTableModelSchemaExport, collectDbTableModelSchemaExports, collectExtraSchemas, collectModelSchemaExports, collectModuleModelSchemaExports, collectOperationMeta, collectOperationTags, collectReachableModelSchemas, collectSchemaRegistryRoots, compactTagName, createTinyOpenApiSourceRunner, defineOpenApiSchemas, dtoSchemaName, findComponentEnumNames, findEnumNames, generateORPCOpenAPISpec, generateOpenApiFile, getComponentSchemas, getContractProcedureData, getDerivedOperationId, getModuleOpenApiController, getModuleOpenApiTag, getObjectPropertySchema, getOpenApiSchemaName, getOperationAction, getOperationController, getPaginatedItemSchema, getRobodevModuleRoles, getStringEnumValues, getLocalInputPath as getTinyOpenApiLocalInputPath, isContractProcedure, isNullSchema, isNullableOnlySchema, isObject, isProcedureMeta, isTinyOpenApiFakeMode, isZodSchema, namedControllerActionInputDtoSchema, namedControllerActionSchema, namedOpenApiOutputSchema, namedOpenApiRequestSchema, namedOpenApiResponseSchema, namedOpenApiSchema, normalizeWatchFolders as normalizeTinyOpenApiWatchFolders, operationKey, resolveOpenApiOutputPath, schemaComponentRef, schemaExportName, sharedSchemaExportName, shouldUseDtoSchemaName, stripNoContentResponseBodies, toOpenAPI30Document, toOpenAPI30Schema, toOpenAPIAclRule, toPascalCase, visitZodSchema };