@povio/openapi-codegen-cli 2.0.8-rc.4 → 2.0.8-rc.7

package/README.md

@@ -69,6 +69,7 @@ yarn openapi-codegen generate --config my-config.ts
   --config                            Path to TS config file (default: 'openapi-codegen.config.ts')
   --input                             Path/URL to OpenAPI JSON/YAML document
   --output                            Output directory path (default: 'output')
+  --incremental                       Skip generation when OpenAPI and config are unchanged (default: true)
   --format                            Format the generated code using Oxfmt (default: true)
   --verbose                           Display detailed log messages during execution (default: false)
 
@@ -84,11 +85,16 @@ yarn openapi-codegen generate --config my-config.ts
   --tsPath                            (Requires `--importPath` to be 'ts') Typescript import path (default: '@/data')
   --removeOperationPrefixEndingWith   Remove operation name prefixes that end with the specified string (default: 'Controller_')
   --extractEnums                      Extract enums into separate Zod schemas (default: true)
+  --modelsInCommon                    Keep all schema declarations in defaultTag models and emit per-module proxy exports (default: false)
   --replaceOptionalWithNullish        Replace `.optional()` chains with `.nullish()` in generated Zod schemas (default: false)
 
   --axiosRequestConfig                Include Axios request config parameters in query hooks (default: false)
   --infiniteQueries                   Generate infinite queries for paginated API endpoints (default: false)
   --mutationEffects                   Add mutation effects options to mutation hooks (default: true)
+  --workspaceContext                  Allow generated hooks to resolve path/ACL params from OpenApiWorkspaceContext (default: false)
+  --inlineEndpoints                   Inline endpoint implementations into generated query files (default: false)
+  --inlineEndpointsExcludeModules     Comma-separated modules/tags to keep as separate API files while inlineEndpoints=true
+  --modelsOnly                        Generate only model files (default: false)
   --parseRequestParams                Add Zod parsing to API endpoints (default: true)
 
   --acl                               Generate ACL related files (default: true)
@@ -186,6 +192,63 @@ const config: OpenAPICodegenConfig = {
 export default config;
 ```
 
+### OpenApiWorkspaceContext (Path + ACL defaults)
+
+Enable `workspaceContext: true` in codegen config (or pass `--workspaceContext`) and wrap your app subtree with `OpenApiWorkspaceContext.Provider` if generated hooks frequently repeat workspace-scoped params (for example `officeId`).
+
+```tsx
+import { OpenApiWorkspaceContext } from "@povio/openapi-codegen-cli";
+// openapi-codegen.config.ts -> { workspaceContext: true }
+
+<OpenApiWorkspaceContext.Provider values={{ officeId: "office_123" }}>
+  <MyWorkspacePages />
+</OpenApiWorkspaceContext.Provider>;
+```
+
+Generated query/mutation hooks can then omit matching path/ACL params and resolve them from `OpenApiWorkspaceContext`.
+
+### Generation Modes
+
+You can control whether API endpoint files are emitted, inlined into query files, or skipped entirely.
+
+```ts
+import type { OpenAPICodegenConfig } from "@povio/openapi-codegen-cli";
+
+const config: OpenAPICodegenConfig = {
+  // 1) Default mode: separate *.api.ts files are generated
+  // 2) Inline mode: endpoint logic is generated inside *.queries.ts
+  // and can be used without separate api files:
+  // inlineEndpoints: true,
+  // inlineEndpointsExcludeModules: ["Users", "Billing"],
+  // 3) Models-only mode: generate only *.models.ts files
+  // modelsOnly: true,
+  // 4) Keep all model declarations in common.models and generate per-module model proxies
+  // modelsInCommon: true,
+};
+```
+
+### Vite Plugin
+
+You can run codegen directly from Vite config (without CLI config file):
+
+```ts
+import { defineConfig } from "vite";
+import { openApiCodegen } from "@povio/openapi-codegen-cli/vite";
+
+export default defineConfig({
+  plugins: [
+    openApiCodegen({
+      input: "./openapi.yaml",
+      output: "./src/data",
+      inlineEndpoints: true,
+      incremental: true,
+    }),
+  ],
+});
+```
+
+The plugin runs on both `vite serve` and `vite build`, and watches local OpenAPI files in dev mode.
+
 ### 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

@@ -0,0 +1,48 @@
+import * as react from "react";
+import { PropsWithChildren } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { AbilityTuple, PureAbility, RawRuleOf, Subject } from "@casl/ability";
+import { PackRule } from "@casl/ability/extra";
+import { BoundCanProps } from "@casl/react";
+
+//#region src/lib/acl/appAbility.types.d.ts
+type AppAbilities = AbilityTuple<string, Subject>;
+type AppAbility = PureAbility<AppAbilities>;
+//#endregion
+//#region src/lib/acl/ability.context.d.ts
+declare namespace AbilityContext {
+  export const Consumer: react.Consumer<AppAbility>;
+  interface ProviderProps {
+    user?: {
+      aclRules?: PackRule<RawRuleOf<AppAbility>>[];
+    } | null;
+  }
+  export const Provider: ({
+    children
+  }: PropsWithChildren<ProviderProps>) => react_jsx_runtime0.JSX.Element;
+  export const useAbility: <TAppAbilities extends AppAbilities = AppAbilities>() => PureAbility<TAppAbilities>;
+  export {};
+}
+//#endregion
+//#region src/lib/acl/AclGuard.d.ts
+interface AclGuardProps<TAppAbilities extends AppAbilities = AppAbilities> {
+  canUse: TAppAbilities;
+  redirectTo?: string;
+}
+declare const createAclGuard: <TAppAbilities extends AppAbilities = AppAbilities>() => ({
+  canUse,
+  redirectTo,
+  children
+}: PropsWithChildren<AclGuardProps<TAppAbilities>>) => react.ReactNode;
+//#endregion
+//#region src/lib/acl/Can.d.ts
+type CanAbility = PureAbility<AbilityTuple<AppAbilities[0], AppAbilities[1]>>;
+type CanProps<TAppAbilities extends AppAbilities = AppAbilities> = {
+  use: TAppAbilities;
+} & Omit<BoundCanProps<CanAbility>, "do" | "I" | "on" | "a" | "an" | "this">;
+declare const Can: <TAppAbilities extends AppAbilities = AppAbilities>({
+  use,
+  ...props
+}: CanProps<TAppAbilities>) => react_jsx_runtime0.JSX.Element;
+//#endregion
+export { AbilityContext, type AppAbilities, type AppAbility, Can, createAclGuard };

package/dist/acl.mjs

@@ -1,8 +1,63 @@
-import { AbilityContext } from "./lib/acl/ability.context.mjs";
-import { createAclGuard } from "./lib/acl/AclGuard.mjs";
-import { Can } from "./lib/acl/Can.mjs";
-export {
-  AbilityContext,
-  Can,
-  createAclGuard
+import { n as OpenApiRouter, t as AuthContext } from "./auth.context-DKjzWiaA.mjs";
+import { createContext, useEffect, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import { AbilityBuilder, createMongoAbility } from "@casl/ability";
+import { unpackRules } from "@casl/ability/extra";
+import { createContextualCan, useAbility } from "@casl/react";
+
+//#region src/lib/acl/ability.context.tsx
+let AbilityContext;
+(function(_AbilityContext) {
+	const createAppAbilityBuilder = () => new AbilityBuilder(createMongoAbility);
+	const initialAppAbility = createAppAbilityBuilder().build();
+	const Context = createContext({});
+	const { Consumer } = Context;
+	_AbilityContext.Consumer = Consumer;
+	_AbilityContext.Provider = ({ children }) => {
+		const [ability, setAbility] = useState(initialAppAbility);
+		const { user } = AuthContext.useAuth();
+		useEffect(() => {
+			if (!user || !("aclRules" in user)) return;
+			const { can, build } = createAppAbilityBuilder();
+			const packedRules = user.aclRules;
+			unpackRules(packedRules).forEach(({ action, subject, conditions }) => {
+				can(action, subject, conditions);
+			});
+			setAbility(build());
+		}, [user]);
+		return /* @__PURE__ */ jsx(Context.Provider, {
+			value: ability,
+			children
+		});
+	};
+	_AbilityContext.useAbility = () => {
+		return useAbility(Context);
+	};
+})(AbilityContext || (AbilityContext = {}));
+
+//#endregion
+//#region src/lib/acl/AclGuard.tsx
+const createAclGuard = () => ({ canUse, redirectTo = "/", children }) => {
+	const ability = AbilityContext.useAbility();
+	const { replace } = OpenApiRouter.useRouter();
+	if (!ability.can(canUse[0], canUse[1])) {
+		replace(redirectTo);
+		return null;
+	}
+	return children;
 };
+
+//#endregion
+//#region src/lib/acl/Can.tsx
+const ContextualCan = createContextualCan(AbilityContext.Consumer);
+const Can = ({ use, ...props }) => {
+	const [action, subject] = use;
+	return /* @__PURE__ */ jsx(ContextualCan, {
+		...props,
+		do: action,
+		on: subject
+	});
+};
+
+//#endregion
+export { AbilityContext, Can, createAclGuard };

package/dist/auth.context-DKjzWiaA.mjs

@@ -0,0 +1,59 @@
+import { createContext, use, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/lib/config/router.context.tsx
+let OpenApiRouter;
+(function(_OpenApiRouter) {
+	const Context = createContext(null);
+	_OpenApiRouter.Provider = ({ children, replace }) => {
+		return /* @__PURE__ */ jsx(Context, {
+			value: useMemo(() => ({ replace }), [replace]),
+			children
+		});
+	};
+	_OpenApiRouter.useRouter = () => {
+		const context = use(Context);
+		if (!context) throw new Error("useRouter must be used within an OpenApiRouter.Provider");
+		return context;
+	};
+})(OpenApiRouter || (OpenApiRouter = {}));
+
+//#endregion
+//#region src/lib/auth/auth.context.tsx
+let AuthContext;
+(function(_AuthContext) {
+	const Context = createContext({});
+	_AuthContext.Provider = ({ isAuthenticated, isInitializing, logout, updateTokens, accessToken, user, userPromise, routes, loadingState, children }) => {
+		const value = useMemo(() => ({
+			isAuthenticated,
+			isInitializing,
+			logout,
+			updateTokens,
+			accessToken,
+			user,
+			userPromise,
+			routes,
+			loadingState
+		}), [
+			isAuthenticated,
+			isInitializing,
+			logout,
+			updateTokens,
+			accessToken,
+			user,
+			userPromise,
+			routes,
+			loadingState
+		]);
+		return /* @__PURE__ */ jsx(Context.Provider, {
+			value,
+			children
+		});
+	};
+	_AuthContext.useAuth = () => {
+		return use(Context);
+	};
+})(AuthContext || (AuthContext = {}));
+
+//#endregion
+export { OpenApiRouter as n, AuthContext as t };

package/dist/config-Cu_GYfai.d.mts

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

package/dist/generate.runner-DNldmk0f.mjs

@@ -0,0 +1,98 @@
+import { a as deepMerge, p as DEFAULT_GENERATE_OPTIONS, r as writeGenerateFileData, t as generateCodeFromOpenAPIDoc, x as Profiler } from "./generateCodeFromOpenAPIDoc-B5lnFNGB.mjs";
+import fs from "fs";
+import path from "path";
+import SwaggerParser from "@apidevtools/swagger-parser";
+
+//#region src/generators/core/resolveConfig.ts
+function resolveConfig({ fileConfig = {}, params: { excludeTags, inlineEndpointsExcludeModules, ...options } }) {
+	const resolvedConfig = deepMerge(DEFAULT_GENERATE_OPTIONS, fileConfig ?? {}, {
+		...options,
+		excludeTags: excludeTags?.split(","),
+		inlineEndpointsExcludeModules: inlineEndpointsExcludeModules?.split(",")
+	});
+	resolvedConfig.checkAcl = resolvedConfig.acl && resolvedConfig.checkAcl;
+	return resolvedConfig;
+}
+
+//#endregion
+//#region src/generators/run/generate.runner.ts
+const CACHE_FILE_NAME = ".openapi-codegen-cache.json";
+async function runGenerate({ fileConfig, params, profiler = new Profiler(process.env.OPENAPI_CODEGEN_PROFILE === "1") }) {
+	const config = profiler.runSync("config.resolve", () => resolveConfig({
+		fileConfig,
+		params: params ?? {}
+	}));
+	const openApiDoc = await getOpenApiDoc(config.input, profiler);
+	const openApiHash = hashString(stableStringify(openApiDoc));
+	const optionsHash = hashString(stableStringify(getCacheableConfig(config)));
+	const cacheFilePath = path.resolve(config.output, CACHE_FILE_NAME);
+	if (config.incremental) {
+		const cached = readCache(cacheFilePath);
+		if (cached && cached.openApiHash === openApiHash && cached.optionsHash === optionsHash) return {
+			skipped: true,
+			config
+		};
+	}
+	const filesData = profiler.runSync("generate.total", () => generateCodeFromOpenAPIDoc(openApiDoc, config, profiler));
+	profiler.runSync("files.write", () => writeGenerateFileData(filesData));
+	if (config.incremental) writeCache(cacheFilePath, {
+		openApiHash,
+		optionsHash
+	});
+	return {
+		skipped: false,
+		config
+	};
+}
+async function getOpenApiDoc(input, profiler) {
+	const parsedDoc = await profiler.runAsync("openapi.parse", async () => await SwaggerParser.parse(input));
+	if (!profiler.runSync("openapi.detectExternalRefs", () => hasExternalRef(parsedDoc))) return parsedDoc;
+	return await profiler.runAsync("openapi.bundle", async () => await SwaggerParser.bundle(input));
+}
+function hasExternalRef(value) {
+	const stack = [value];
+	const visited = /* @__PURE__ */ new Set();
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current || typeof current !== "object") continue;
+		if (visited.has(current)) continue;
+		visited.add(current);
+		if ("$ref" in current && typeof current.$ref === "string" && !current.$ref.startsWith("#/")) return true;
+		for (const nested of Object.values(current)) if (nested && typeof nested === "object") stack.push(nested);
+	}
+	return false;
+}
+function getCacheableConfig(config) {
+	const { output, incremental, ...cacheableConfig } = config;
+	return cacheableConfig;
+}
+function readCache(filePath) {
+	if (!fs.existsSync(filePath)) return null;
+	try {
+		return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function writeCache(filePath, data) {
+	const dir = path.dirname(filePath);
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(data), "utf-8");
+}
+function hashString(input) {
+	let hash = 2166136261;
+	for (let i = 0; i < input.length; i += 1) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(16);
+}
+function stableStringify(input) {
+	if (input === null || typeof input !== "object") return JSON.stringify(input);
+	if (Array.isArray(input)) return `[${input.map((item) => stableStringify(item)).join(",")}]`;
+	const obj = input;
+	return `{${Object.keys(obj).sort((a, b) => a.localeCompare(b)).map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`).join(",")}}`;
+}
+
+//#endregion
+export { resolveConfig as n, runGenerate as t };