@povio/openapi-codegen-cli 2.0.8-rc.23 → 2.0.8-rc.24

package/dist/{generate.runner-DKpRoYsX.mjs → generate.runner-DRRxZ7ZJ.mjs}

@@ -1,4 +1,4 @@
-import { a as deepMerge, p as DEFAULT_GENERATE_OPTIONS, r as writeGenerateFileData, t as generateCodeFromOpenAPIDoc, x as Profiler } from "./generateCodeFromOpenAPIDoc-vrPucfhY.mjs";
+import { a as deepMerge, p as DEFAULT_GENERATE_OPTIONS, r as writeGenerateFileData, t as generateCodeFromOpenAPIDoc, x as Profiler } from "./generateCodeFromOpenAPIDoc-DYOqSvuQ.mjs";
 import fs from "fs";
 import path from "path";
 import SwaggerParser from "@apidevtools/swagger-parser";

package/dist/{generateCodeFromOpenAPIDoc-vrPucfhY.mjs → generateCodeFromOpenAPIDoc-DYOqSvuQ.mjs}

@@ -3206,42 +3206,55 @@ function getBuilderConfigs({ data, tag, resolver }) {
 		if (createEndpoint) {
 			importedEndpoints.push(createEndpoint);
 			const body = getEndpointBody$1(createEndpoint);
-			if (body) importedZodSchemas.push(body.zodSchema);
-			config.create = {
-				acl: getAclConfig(createEndpoint, resolver.options),
-				mutation: getImportedQueryName(createEndpoint, resolver.options),
-				inputDefs: getInputsConfig(resolver, body)
-			};
+			if (body) {
+				importedZodSchemas.push(body.zodSchema);
+				config.create = {
+					acl: getAclConfig(createEndpoint, resolver.options),
+					schema: getImportedZodSchemaName(resolver, body.zodSchema),
+					mutation: createEndpoint,
+					inputDefs: getInputsConfig(resolver, body)
+				};
+			}
 		}
 		const updateEndpoint = extendedEndpoints.find((endpoint) => isUpdateEndpoint(endpoint, readAllEndpoint));
 		if (updateEndpoint) {
 			importedEndpoints.push(updateEndpoint);
 			const body = getEndpointBody$1(updateEndpoint);
-			if (body) importedZodSchemas.push(body.zodSchema);
-			config.update = {
-				acl: getAclConfig(updateEndpoint, resolver.options),
-				mutation: getImportedQueryName(updateEndpoint, resolver.options),
-				inputDefs: getInputsConfig(resolver, body)
-			};
+			if (body) {
+				importedZodSchemas.push(body.zodSchema);
+				config.update = {
+					acl: getAclConfig(updateEndpoint, resolver.options),
+					schema: getImportedZodSchemaName(resolver, body.zodSchema),
+					mutation: updateEndpoint,
+					inputDefs: getInputsConfig(resolver, body)
+				};
+			}
 		}
 		const deleteEndpoint = extendedEndpoints.find((endpoint) => isDeleteEndpoint(endpoint, readAllEndpoint));
 		if (deleteEndpoint) {
 			importedEndpoints.push(deleteEndpoint);
-			config.delete = {
-				acl: getAclConfig(deleteEndpoint, resolver.options),
-				mutation: getImportedQueryName(deleteEndpoint, resolver.options)
-			};
+			const body = getEndpointBody$1(deleteEndpoint);
+			if (body) {
+				importedZodSchemas.push(body.zodSchema);
+				config.delete = {
+					acl: getAclConfig(deleteEndpoint, resolver.options),
+					mutation: deleteEndpoint
+				};
+			}
 		}
 		const bulkDeleteEndpoint = extendedEndpoints.find((endpoint) => isBulkDeleteEndpoint(endpoint, readAllEndpoint));
 		if (bulkDeleteEndpoint) {
 			importedEndpoints.push(bulkDeleteEndpoint);
 			const body = getEndpointBody$1(bulkDeleteEndpoint);
-			if (body) importedZodSchemas.push(body.zodSchema);
-			config.bulkDelete = {
-				acl: getAclConfig(bulkDeleteEndpoint, resolver.options),
-				mutation: getImportedQueryName(bulkDeleteEndpoint, resolver.options),
-				inputDefs: getInputsConfig(resolver, body)
-			};
+			if (body) {
+				importedZodSchemas.push(body.zodSchema);
+				config.bulkDelete = {
+					acl: getAclConfig(bulkDeleteEndpoint, resolver.options),
+					schema: getImportedZodSchemaName(resolver, body.zodSchema),
+					mutation: bulkDeleteEndpoint,
+					inputDefs: getInputsConfig(resolver, body)
+				};
+			}
 		}
 		return config;
 	});
@@ -3359,12 +3372,70 @@ function getSchemaProperties(resolver, schema) {
 	return {};
 }
 
+//#endregion
+//#region src/generators/const/queries.const.ts
+const QUERY_HOOKS = {
+	query: "useQuery",
+	infiniteQuery: "useInfiniteQuery",
+	mutation: "useMutation"
+};
+const QUERY_IMPORT = {
+	bindings: [
+		QUERY_HOOKS.query,
+		QUERY_HOOKS.infiniteQuery,
+		QUERY_HOOKS.mutation
+	],
+	from: "@tanstack/react-query"
+};
+const QUERIES_MODULE_NAME = "moduleName";
+
 //#endregion
 //#region src/generators/generate/generateConfigs.ts
 function generateConfigs(generateTypeParams) {
-	const { configs, hasZodImport, modelsImports, queriesImports, aclImports } = getBuilderConfigs(generateTypeParams);
+	const { configs, hasZodImport, modelsImports, aclImports } = getBuilderConfigs(generateTypeParams);
 	if (configs.length === 0) return;
 	const { resolver, tag } = generateTypeParams;
+	const endpoints = configs.flatMap((config) => [
+		config.create?.mutation,
+		config.update?.mutation,
+		config.delete?.mutation,
+		config.bulkDelete?.mutation
+	]).filter((m) => typeof m !== "string" && m !== void 0);
+	const hasMutation = endpoints.length > 0;
+	resolver.options.checkAcl && endpoints.some((e) => e.acl);
+	const hasMutationEffects = resolver.options.mutationEffects && hasMutation;
+	const hasWorkspaceContext = resolver.options.workspaceContext && endpoints.some((e) => resolver.options.workspaceContext);
+	const endpointsImports = getEndpointsImports({
+		tag,
+		endpoints,
+		options: resolver.options
+	});
+	const queryImport = {
+		bindings: [QUERY_HOOKS.mutation],
+		from: "@tanstack/react-query"
+	};
+	const queryTypesImport = {
+		bindings: ["OpenApiQueryConfig"],
+		typeBindings: [QUERY_OPTIONS_TYPES.mutation],
+		from: getQueryTypesImportPath(resolver.options)
+	};
+	const mutationEffectsImport = {
+		bindings: [MUTATION_EFFECTS.hookName],
+		typeBindings: [MUTATION_EFFECTS.optionsType],
+		from: PACKAGE_IMPORT_PATH
+	};
+	const queryModulesImport = {
+		bindings: [QUERY_MODULE_ENUM],
+		from: getQueryModulesImportPath(resolver.options)
+	};
+	const aclCheckImport = {
+		bindings: [ACL_CHECK_HOOK],
+		from: ACL_PACKAGE_IMPORT_PATH
+	};
+	const workspaceContextImport = {
+		bindings: ["OpenApiWorkspaceContext"],
+		from: PACKAGE_IMPORT_PATH
+	};
 	const hasDynamicInputsImport = configs.some((config) => config.readAll.filters || config.create?.inputDefs || config.update?.inputDefs);
 	const dynamicInputsImport = {
 		bindings: [BUILDERS_UTILS.dynamicInputs],
@@ -3380,7 +3451,17 @@ function generateConfigs(generateTypeParams) {
 	if (hasDynamicInputsImport) lines.push(renderImport$3(dynamicInputsImport));
 	if (hasDynamicColumnsImport) lines.push(renderImport$3(dynamicColumnsImport));
 	for (const modelsImport of modelsImports) lines.push(renderImport$3(modelsImport));
-	for (const queriesImport of queriesImports) lines.push(renderImport$3(queriesImport));
+	for (const endpointsImport of endpointsImports) lines.push(renderImport$3(endpointsImport));
+	if (hasMutation) {
+		lines.push(renderImport$3(queryImport));
+		lines.push(renderImport$3(queryTypesImport));
+		if (hasMutationEffects) {
+			lines.push(renderImport$3(queryModulesImport));
+			lines.push(renderImport$3(mutationEffectsImport));
+		}
+		lines.push(renderImport$3(aclCheckImport));
+		if (hasWorkspaceContext) lines.push(renderImport$3(workspaceContextImport));
+	}
 	for (const aclImport of aclImports) lines.push(renderImport$3(aclImport));
 	lines.push("");
 	if (resolver.options.tsNamespaces) lines.push(`export namespace ${getNamespaceName({
@@ -3389,7 +3470,7 @@ function generateConfigs(generateTypeParams) {
 		options: resolver.options
 	})} {`);
 	for (const config of configs) {
-		lines.push(renderBuilderConfig(config));
+		lines.push(renderBuilderConfig(config, generateTypeParams));
 		lines.push("");
 	}
 	if (resolver.options.tsNamespaces) lines.push("}");
@@ -3425,7 +3506,48 @@ function renderColumnsConfig(columnsConfig) {
 	lines.push("}");
 	return lines.join("\n");
 }
-function renderBuilderConfig(config) {
+function renderMutationContent(resolver, endpoint, tag) {
+	const hasAclCheck = resolver.options.checkAcl && endpoint.acl;
+	const hasMutationEffects = resolver.options.mutationEffects;
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const endpointTag = getEndpointTag(endpoint, resolver.options);
+	const endpointParams = mapEndpointParamsToFunctionParams(resolver, endpoint, {
+		includeFileParam: true,
+		modelNamespaceTag: endpointTag
+	});
+	const endpointParamsStr = endpointParams.map((p) => `${p.name}${p.required ? "" : "?"}: ${p.type}`).join("; ");
+	const destructuredMutationArgs = endpointParams.map((p) => p.name).join(", ");
+	const endpointFunction = getImportedEndpointName(endpoint, resolver.options);
+	const mutationVariablesType = endpoint.mediaUpload ? `{ ${endpointParamsStr}${endpointParamsStr ? "; " : ""}abortController?: AbortController; onUploadProgress?: (progress: { loaded: number; total: number }) => void }` : `{ ${endpointParamsStr} }`;
+	const lines = [];
+	lines.push(`(options?: AppMutationOptions<typeof ${endpointFunction}, ${mutationVariablesType}>${hasAxiosRequestConfig ? `, config?: AxiosRequestConfig` : ""}) => {`);
+	lines.push("  const queryConfig = OpenApiQueryConfig.useConfig();");
+	if (hasMutationEffects) lines.push(`  const { runMutationEffects } = useMutationEffects<typeof ${QUERY_MODULE_ENUM}.${endpointTag}>({ currentModule: ${QUERY_MODULE_ENUM}.${tag} });`);
+	lines.push(`  const { checkAcl } = ${ACL_CHECK_HOOK}();`);
+	lines.push("");
+	lines.push(`  return ${QUERY_HOOKS.mutation}({`);
+	const mutationFnArg = destructuredMutationArgs ? `{ ${destructuredMutationArgs}${endpoint.mediaUpload ? `${destructuredMutationArgs ? ", " : ""}abortController, onUploadProgress` : ""} }` : "";
+	lines.push(`    mutationFn: (${mutationFnArg}) => {`);
+	if (hasAclCheck) lines.push(`      checkAcl(${getNamespaceName({
+		type: GenerateType.Acl,
+		tag: endpointTag,
+		options: resolver.options
+	})}.canUse${capitalize(snakeToCamel(endpoint.operationName))}({ ${destructuredMutationArgs} }));`);
+	lines.push(`      return ${endpointFunction}(${destructuredMutationArgs}${hasAxiosRequestConfig ? `${destructuredMutationArgs ? ", " : ""}config` : ""});`);
+	lines.push("    },");
+	if (hasMutationEffects) {
+		lines.push("    onSuccess: async (...args) => {");
+		lines.push("      await runMutationEffects();");
+		lines.push("      await options?.onSuccess?.(...args);");
+		lines.push("    },");
+	}
+	lines.push("    ...options,");
+	lines.push("  });");
+	lines.push("}");
+	return lines.map((line) => "        " + line).join("\n").trimStart();
+}
+function renderBuilderConfig(config, params) {
+	const { resolver, tag } = params;
 	const lines = [];
 	lines.push(`export const ${config.name} = {`);
 	lines.push("    meta: {");
@@ -3454,23 +3576,31 @@ function renderBuilderConfig(config) {
 	if (config.create) {
 		lines.push("    create: {");
 		if (config.create.acl) lines.push(`        acl: ${config.create.acl},`);
-		if (config.create.inputDefs) lines.push(`        schema: ${config.create.inputDefs.schema},`);
-		lines.push(`        mutation: ${config.create.mutation},`);
+		if (config.create.schema) lines.push(`        schema: ${config.create.schema},`);
+		lines.push(`        mutation: ${typeof config.create.mutation === "string" ? config.create.mutation : renderMutationContent(resolver, config.create.mutation, tag)},`);
 		if (config.create.inputDefs) lines.push(`        inputDefs: ${BUILDERS_UTILS.dynamicInputs}(${renderInputsConfig(config.create.inputDefs)})`);
 		lines.push("    },");
 	}
 	if (config.update) {
 		lines.push("    update: {");
 		if (config.update.acl) lines.push(`        acl: ${config.update.acl},`);
-		if (config.update.inputDefs) lines.push(`        schema: ${config.update.inputDefs.schema},`);
-		lines.push(`        mutation: ${config.update.mutation},`);
+		if (config.update.schema) lines.push(`        schema: ${config.update.schema},`);
+		lines.push(`        mutation: ${typeof config.update.mutation === "string" ? config.update.mutation : renderMutationContent(resolver, config.update.mutation, tag)},`);
 		if (config.update.inputDefs) lines.push(`        inputDefs: ${BUILDERS_UTILS.dynamicInputs}(${renderInputsConfig(config.update.inputDefs)})`);
 		lines.push("    },");
 	}
 	if (config.delete) {
 		lines.push("    delete: {");
 		if (config.delete.acl) lines.push(`        acl: ${config.delete.acl},`);
-		lines.push(`        mutation: ${config.delete.mutation},`);
+		lines.push(`        mutation: ${typeof config.delete.mutation === "string" ? config.delete.mutation : renderMutationContent(resolver, config.delete.mutation, tag)},`);
+		lines.push("    },");
+	}
+	if (config.bulkDelete) {
+		lines.push("    bulkDelete: {");
+		if (config.bulkDelete.acl) lines.push(`        acl: ${config.bulkDelete.acl},`);
+		if (config.bulkDelete.schema) lines.push(`        schema: ${config.bulkDelete.schema},`);
+		lines.push(`        mutation: ${typeof config.bulkDelete.mutation === "string" ? config.bulkDelete.mutation : renderMutationContent(resolver, config.bulkDelete.mutation, tag)},`);
+		if (config.bulkDelete.inputDefs) lines.push(`        inputDefs: ${BUILDERS_UTILS.dynamicInputs}(${renderInputsConfig(config.bulkDelete.inputDefs)})`);
 		lines.push("    },");
 	}
 	lines.push("};");
@@ -3725,23 +3855,6 @@ function renderModelJsDocs({ name, zodSchema, tag, resolver }) {
 	return lines.join("\n");
 }
 
-//#endregion
-//#region src/generators/const/queries.const.ts
-const QUERY_HOOKS = {
-	query: "useQuery",
-	infiniteQuery: "useInfiniteQuery",
-	mutation: "useMutation"
-};
-const QUERY_IMPORT = {
-	bindings: [
-		QUERY_HOOKS.query,
-		QUERY_HOOKS.infiniteQuery,
-		QUERY_HOOKS.mutation
-	],
-	from: "@tanstack/react-query"
-};
-const QUERIES_MODULE_NAME = "moduleName";
-
 //#endregion
 //#region src/generators/generate/generateQueries.ts
 const endpointParamMappingCache = /* @__PURE__ */ new WeakMap();

package/dist/generator.mjs

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

package/dist/sh.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { S as VALIDATION_ERROR_TYPE_TITLE, g as groupByType, h as GenerateType, i as getDataFromOpenAPIDoc, n as getOutputFileName, u as getTagFileName, x as Profiler } from "./generateCodeFromOpenAPIDoc-vrPucfhY.mjs";
-import { n as resolveConfig, t as runGenerate } from "./generate.runner-DKpRoYsX.mjs";
+import { S as VALIDATION_ERROR_TYPE_TITLE, g as groupByType, h as GenerateType, i as getDataFromOpenAPIDoc, n as getOutputFileName, u as getTagFileName, x as Profiler } from "./generateCodeFromOpenAPIDoc-DYOqSvuQ.mjs";
+import { n as resolveConfig, t as runGenerate } from "./generate.runner-DRRxZ7ZJ.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 "2.0.8-rc.23";
+	return "2.0.8-rc.24";
 }
 
 //#endregion

package/dist/vite.mjs

@@ -1,5 +1,5 @@
-import { x as Profiler } from "./generateCodeFromOpenAPIDoc-vrPucfhY.mjs";
-import { t as runGenerate } from "./generate.runner-DKpRoYsX.mjs";
+import { x as Profiler } from "./generateCodeFromOpenAPIDoc-DYOqSvuQ.mjs";
+import { t as runGenerate } from "./generate.runner-DRRxZ7ZJ.mjs";
 import path from "path";
 
 //#region src/vite/openapi-codegen.plugin.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@povio/openapi-codegen-cli",
-  "version": "2.0.8-rc.23",
+  "version": "2.0.8-rc.24",
   "keywords": [
     "codegen",
     "openapi",