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

package/README.md

@@ -287,6 +287,51 @@ export default defineConfig({
 The plugin runs on both `vite serve` and `vite build`, and watches local OpenAPI files in dev mode.
 If you provide `formatGeneratedFile`, the plugin formats each generated file in memory before comparing and writing it, which helps avoid unnecessary HMR when the formatted output is unchanged.
 
+For Tiny projects that generate the OpenAPI JSON from ORPC before client codegen, use the wrapper plugin:
+
+```ts
+import { defineConfig } from "vite";
+import { generateOpenApiFile as writeOpenApiFile, generateORPCOpenAPISpec } from "@povio/openapi-codegen-cli/tiny";
+import { tinyOpenApiCodegen } from "@povio/openapi-codegen-cli/vite";
+import { apiModules } from "../packages/fake-be/src/orpc/api/modules";
+import { contract } from "../packages/fake-be/src/orpc/api/contract";
+import { getOpenApiSchemaName } from "../packages/fake-be/src/orpc/spec";
+import { userRoles } from "../packages/fake-be/src/roles";
+
+const generateOpenApiFile = (options) =>
+  writeOpenApiFile({
+    ...options,
+    generateOpenApiSpec: () =>
+      generateORPCOpenAPISpec({
+        contract,
+        apiModules,
+        userRoles,
+        apiRoot: "../packages/fake-be/src/orpc/api",
+        dbTablesRoot: "../packages/fake-be/src/db/tables",
+        getOpenApiSchemaName,
+      }),
+  });
+
+export default defineConfig({
+  plugins: [
+    tinyOpenApiCodegen(
+      {
+        input: "./openapi.generated.json",
+        output: "./src/data",
+        inlineEndpoints: true,
+        incremental: true,
+      },
+      {
+        generateOpenApiFile,
+        watchFolders: ["../packages/fake-be/src/orpc", "../packages/fake-be/src/db"],
+      },
+    ),
+  ],
+});
+```
+
+When `VITE_PUBLIC_API_MODE` or `EXPO_PUBLIC_API_MODE` is `real`, the Tiny wrapper skips ORPC OpenAPI generation and behaves like `openApiCodegen`.
+
 ### Metro Plugin
 
 You can run codegen directly from React Native Metro config:
@@ -318,6 +363,49 @@ export default withOpenApiCodegen(
 The Metro wrapper runs generation when the config is loaded, waits for it before Metro transforms or serves the first request, and watches local OpenAPI files while the dev server is running.
 If you provide `formatGeneratedFile`, it behaves the same way as the Vite plugin.
 
+For Tiny projects, use the Metro wrapper:
+
+```ts
+import { getDefaultConfig } from "@react-native/metro-config";
+import { generateOpenApiFile as writeOpenApiFile, generateORPCOpenAPISpec } from "@povio/openapi-codegen-cli/tiny";
+import { tinyOpenApiCodegenMetro } from "@povio/openapi-codegen-cli/metro";
+import { apiModules } from "../../packages/fake-be/src/orpc/api/modules";
+import { contract } from "../../packages/fake-be/src/orpc/api/contract";
+import { getOpenApiSchemaName } from "../../packages/fake-be/src/orpc/spec";
+import { userRoles } from "../../packages/fake-be/src/roles";
+
+const root = __dirname;
+const config = getDefaultConfig(root);
+const generateOpenApiFile = (options) =>
+  writeOpenApiFile({
+    ...options,
+    generateOpenApiSpec: () =>
+      generateORPCOpenAPISpec({
+        contract,
+        apiModules,
+        userRoles,
+        apiRoot: "../../packages/fake-be/src/orpc/api",
+        dbTablesRoot: "../../packages/fake-be/src/db/tables",
+        getOpenApiSchemaName,
+      }),
+  });
+
+export default tinyOpenApiCodegenMetro(
+  config,
+  {
+    input: "./assets/openapi/main.json",
+    output: "./utils/rest/openapi",
+    inlineEndpoints: true,
+    incremental: true,
+  },
+  {
+    root,
+    generateOpenApiFile,
+    watchFolders: ["../../packages/fake-be/src/orpc", "../../packages/fake-be/src/db"],
+  },
+);
+```
+
 ### Enums
 
 If you're using Enums in your backend DTOs with `@Expose()` and `@IsEnum`, they may still not appear correctly in the OpenAPI schema unless you also provide both `enum` **and** `enumName` to `@ApiProperty`.

package/dist/acl.d.mts

@@ -1,4 +1,4 @@
-import { a as ErrorHandler } from "./error-handling-oM5YJYYH.mjs";
+import { a as ErrorHandler } from "./error-handling-CDeKUFHF.mjs";
 import * as react from "react";
 import { PropsWithChildren } from "react";
 import * as react_jsx_runtime0 from "react/jsx-runtime";

package/dist/{config-CrZa_Jbm.d.mts → config-BU7wVf7U.d.mts}

@@ -1,4 +1,4 @@
-import { t as GenerateOptions } from "./options-BZOw7Hx4.mjs";
+import { t as GenerateOptions } from "./options-CE4Koxof.mjs";
 
 //#region src/generators/types/config.d.ts
 type OpenAPICodegenConfig = Partial<GenerateOptions>;

package/dist/generator.d.mts

@@ -1,4 +1,4 @@
-import { n as GenerateFileData, t as GenerateOptions } from "./options-BZOw7Hx4.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/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-oM5YJYYH.mjs";
-import "./options-BZOw7Hx4.mjs";
-import { t as OpenAPICodegenConfig } from "./config-CrZa_Jbm.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";

package/dist/metro.d.mts

@@ -1,5 +1,6 @@
-import { r as GenerateFileFormatter } from "./options-BZOw7Hx4.mjs";
-import { t as OpenAPICodegenConfig } from "./config-CrZa_Jbm.mjs";
+import { r as GenerateFileFormatter } from "./options-CE4Koxof.mjs";
+import { t as OpenAPICodegenConfig } from "./config-BU7wVf7U.mjs";
+import { a as GenerateOpenApiFile } from "./openapi-D9apjIRy.mjs";
 import { IncomingMessage, ServerResponse } from "http";
 
 //#region src/metro/openapi-codegen.plugin.d.ts
@@ -29,4 +30,16 @@ type MetroConfig = {
 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
-export { type MetroConfig, type MetroMiddleware, type OpenAPICodegenConfig, type OpenApiCodegenMetroConfig, type OpenApiCodegenMetroOptions, withOpenApiCodegen };
+//#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

@@ -1,12 +1,13 @@
 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(metroConfig)) return metroConfig.then((resolvedConfig) => withResolvedOpenApiCodegen(resolvedConfig, codegenConfig, options));
+	if (isPromiseLike$1(metroConfig)) return metroConfig.then((resolvedConfig) => withResolvedOpenApiCodegen(resolvedConfig, codegenConfig, options));
 	return withResolvedOpenApiCodegen(metroConfig, codegenConfig, options);
 }
 function withResolvedOpenApiCodegen(metroConfig, codegenConfig, options) {
@@ -37,11 +38,11 @@ function withResolvedOpenApiCodegen(metroConfig, codegenConfig, options) {
 		try {
 			inputWatcher = fs.watch(inputPath, { persistent: false }, () => {
 				startupSucceeded = false;
-				requestStartupGenerate().catch(reportGenerateError);
+				requestStartupGenerate().catch(reportGenerateError$1);
 			});
-			inputWatcher.on("error", reportWatcherError);
+			inputWatcher.on("error", reportWatcherError$1);
 		} catch (error) {
-			reportWatcherError(error);
+			reportWatcherError$1(error);
 		}
 	};
 	const wrappedConfig = {
@@ -72,15 +73,113 @@ function withResolvedOpenApiCodegen(metroConfig, codegenConfig, options) {
 	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("[openapi-codegen] Failed to generate OpenAPI client from Metro config.", error);
+	console.error("[tiny-openapi] Failed to generate OpenAPI spec from Metro config.", error);
 }
 function reportWatcherError(error) {
-	console.error("[openapi-codegen] Failed to watch OpenAPI input from Metro config.", error);
+	console.error("[tiny-openapi] Failed to watch OpenAPI inputs from Metro config.", error);
 }
 
 //#endregion
-export { withOpenApiCodegen };
+export { tinyOpenApiCodegenMetro, withOpenApiCodegen };

package/dist/openapi-D9apjIRy.d.mts

@@ -0,0 +1,172 @@
+//#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 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 routeHasPathParameters(routePath?: string): boolean;
+declare function getProcedureInputSchemaRole(route: OrpcContractProcedureData["route"]): "Params" | "Query" | "Request";
+declare function procedureSchemaName(procedureName: string, role: "Params" | "Query" | "Request" | "Response"): string;
+declare function addContractSchema(schemas: OpenApiSchemaRegistry, schema: AnySchema | undefined, name: string, getSchemaName: (schema: unknown) => string | undefined, strategy?: "input" | "output"): void;
+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 { getStringEnumValues as $, collectModuleModelSchemaExports as A, generateOpenApiFile as B, collectApiModelSchemaExports as C, toPascalCase as Ct, collectDbTableModelSchemaExports as D, collectDbTableModelSchemaExport as E, compactTagName as F, getModuleOpenApiTag as G, getContractProcedureData as H, defineOpenApiSchemas as I, getOperationAction as J, getObjectPropertySchema as K, findComponentEnumNames as L, collectOperationTags as M, collectReachableModelSchemas as N, collectExtraSchemas as O, collectSchemaRegistryRoots as P, getRobodevModuleRoles as Q, findEnumNames as R, asStringArray as S, toOpenAPIAclRule as St, collectContractSchemas as T, getDerivedOperationId as U, getComponentSchemas as V, getModuleOpenApiController as W, getPaginatedItemSchema as X, getOperationController as Y, getProcedureInputSchemaRole as Z, applyOperationMeta as _, schemaExportName as _t, GenerateOpenApiFile as a, isZodSchema as at, applyRobodevModuleExtensions as b, toOpenAPI30Document as bt, GenerateTinyOpenApiFileOptions as c, namedOpenApiOutputSchema as ct, ProcedureMeta as d, namedOpenApiSchema as dt, isContractProcedure as et, TinyOpenApiModule as f, operationKey as ft, applyEnumExtensions as g, schemaComponentRef as gt, addContractSchema as h, routeHasPathParameters as ht, GenerateORPCOpenAPISpecOptions as i, isProcedureMeta as it, collectOperationMeta as j, collectModelSchemaExports as k, JsonObject as l, namedOpenApiRequestSchema as lt, ZodSchema as m, resolveOpenApiOutputPath as mt, AnyContractRouter as n, isNullableOnlySchema as nt, GenerateOpenApiFileOptions as o, namedControllerActionInputDtoSchema as ot, TinyOpenApiUserRole as p, procedureSchemaName as pt, getOpenApiSchemaName as q, AnySchema as r, isObject as rt, GenerateOpenApiFileResult as s, namedControllerActionSchema as st, AclRule as t, isNullSchema as tt, OpenApiSchemaRegistry as u, namedOpenApiResponseSchema as ut, applyPaginatedItemSchemas as v, sharedSchemaExportName as vt, collectContractSchemaRoots as w, visitZodSchema as wt, applyRobodevUserRolesExtension as x, toOpenAPI30Schema as xt, applyParameterExtensions as y, stripNoContentResponseBodies as yt, generateORPCOpenAPISpec as z };

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

@@ -39,7 +39,7 @@ function logBanner(message) {
 * Fetch the version from package.json
 */
 function getVersion() {
-	return "3.0.0";
+	return "3.1.0-rc.2";
 }
 
 //#endregion

package/dist/tiny.d.mts

@@ -0,0 +1,21 @@
+import "./options-CE4Koxof.mjs";
+import { t as OpenAPICodegenConfig } from "./config-BU7wVf7U.mjs";
+import { $ as getStringEnumValues, A as collectModuleModelSchemaExports, B as generateOpenApiFile, C as collectApiModelSchemaExports, Ct as toPascalCase, D as collectDbTableModelSchemaExports, E as collectDbTableModelSchemaExport, F as compactTagName, G as getModuleOpenApiTag, H as getContractProcedureData, I as defineOpenApiSchemas, J as getOperationAction, K as getObjectPropertySchema, L as findComponentEnumNames, M as collectOperationTags, N as collectReachableModelSchemas, O as collectExtraSchemas, P as collectSchemaRegistryRoots, Q as getRobodevModuleRoles, R as findEnumNames, S as asStringArray, St as toOpenAPIAclRule, T as collectContractSchemas, U as getDerivedOperationId, V as getComponentSchemas, W as getModuleOpenApiController, X as getPaginatedItemSchema, Y as getOperationController, Z as getProcedureInputSchemaRole, _ as applyOperationMeta, _t as schemaExportName, a as GenerateOpenApiFile, at as isZodSchema, b as applyRobodevModuleExtensions, bt as toOpenAPI30Document, c as GenerateTinyOpenApiFileOptions, ct as namedOpenApiOutputSchema, d as ProcedureMeta, dt as namedOpenApiSchema, et as isContractProcedure, f as TinyOpenApiModule, ft as operationKey, g as applyEnumExtensions, gt as schemaComponentRef, h as addContractSchema, ht as routeHasPathParameters, i as GenerateORPCOpenAPISpecOptions, it as isProcedureMeta, j as collectOperationMeta, k as collectModelSchemaExports, l as JsonObject, lt as namedOpenApiRequestSchema, m as ZodSchema, mt as resolveOpenApiOutputPath, n as AnyContractRouter, nt as isNullableOnlySchema, o as GenerateOpenApiFileOptions, ot as namedControllerActionInputDtoSchema, p as TinyOpenApiUserRole, pt as procedureSchemaName, q as getOpenApiSchemaName, r as AnySchema, rt as isObject, s as GenerateOpenApiFileResult, st as namedControllerActionSchema, t as AclRule, tt as isNullSchema, u as OpenApiSchemaRegistry, ut as namedOpenApiResponseSchema, v as applyPaginatedItemSchemas, vt as sharedSchemaExportName, w as collectContractSchemaRoots, wt as visitZodSchema, x as applyRobodevUserRolesExtension, xt as toOpenAPI30Schema, y as applyParameterExtensions, yt as stripNoContentResponseBodies, z as generateORPCOpenAPISpec } from "./openapi-D9apjIRy.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, addContractSchema, applyEnumExtensions, applyOperationMeta, applyPaginatedItemSchemas, applyParameterExtensions, applyRobodevModuleExtensions, applyRobodevUserRolesExtension, asStringArray, collectApiModelSchemaExports, collectContractSchemaRoots, collectContractSchemas, collectDbTableModelSchemaExport, collectDbTableModelSchemaExports, collectExtraSchemas, collectModelSchemaExports, collectModuleModelSchemaExports, collectOperationMeta, collectOperationTags, collectReachableModelSchemas, collectSchemaRegistryRoots, compactTagName, 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, namedControllerActionInputDtoSchema, namedControllerActionSchema, namedOpenApiOutputSchema, namedOpenApiRequestSchema, namedOpenApiResponseSchema, namedOpenApiSchema, normalizeWatchFolders as normalizeTinyOpenApiWatchFolders, operationKey, procedureSchemaName, resolveOpenApiOutputPath, routeHasPathParameters, schemaComponentRef, schemaExportName, sharedSchemaExportName, stripNoContentResponseBodies, toOpenAPI30Document, toOpenAPI30Schema, toOpenAPIAclRule, toPascalCase, visitZodSchema };