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

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-B14GzSA_.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-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-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.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 };