mobx-tanstack-query-api 0.40.0 → 0.41.0

package/cli.d.ts

@@ -1,5 +1,5 @@
 import { ParsedRoute, ModelType, RawRouteInfo, GenerateApiConfiguration, GenerateApiParams } from 'swagger-typescript-api';
-import { AnyObject, PartialKeys, Maybe, KeyOfByValue, Defined } from 'yummies/types';
+import { AnyObject, PartialKeys, Maybe, MaybeFn, KeyOfByValue, Defined } from 'yummies/types';
 import { LoDashStatic } from '/home/runner/work/mobx-tanstack-query-api/mobx-tanstack-query-api/node_modules/.pnpm/@types+lodash@4.17.24/node_modules/@types/lodash/index.d.ts';
 
 type AnyFilterOptionFn = (...args: any[]) => boolean;
@@ -27,6 +27,7 @@ interface ImportFileParams {
 
 type TypeInfo = PartialKeys<ModelType, 'rawContent'>;
 
+type RuntimeExpressionOrBoolean = string | boolean;
 interface GenerateQueryApiParams {
     /**
      * [**Documentation**](https://js2me.github.io/mobx-tanstack-query-api/codegen/config/#output)
@@ -186,15 +187,15 @@ interface GenerateQueryApiParams {
      */
     noBarrelFiles?: boolean;
     /**
-     * Generate Zod contracts (params + data schemas) for each endpoint and add `contracts` to the endpoint config.
-     * When truthy, can also enable validation via `validateContracts` in the endpoint config.
+     * Generate Zod contracts (params + data schemas) for each endpoint and add `contract` to the endpoint config.
+     * When truthy, can also enable validation via `validateContract` in the endpoint config.
      * Requires `zod` to be installed.
      *
-     * - `true`: generate contracts and set `validateContracts: true` (validate params + data).
+     * - `true`: generate contracts and set `validateContract: true` (validate params + data).
      * - `false`: no contracts, no validation.
-     * - `{ validate: boolean }`: set `validateContracts` to that boolean.
-     * - `{ validate: string }`: set `validateContracts` to the expression (inserted as-is). E.g. `"process.env.NODE_ENV === 'development'"`.
-     * - `{ validate: { params?: boolean | string; data?: boolean | string } }`: set `validateContracts` to an object; each value is literal or expression (string inserted as-is).
+     * - `{ validate: boolean }`: set `validateContract` to that boolean.
+     * - `{ validate: string }`: set `validateContract` to the expression (inserted as-is). E.g. `"process.env.NODE_ENV === 'development'"`.
+     * - `{ validate: { params?: boolean | string; data?: boolean | string } }`: set `validateContract` to an object; each value is literal or expression (string inserted as-is).
      *
      * When using an object form, optional `throw` controls `throwContracts` (throw on validation errors vs warn):
      * - `{ throw: boolean }`: set `throwContracts` to that boolean.
@@ -202,20 +203,34 @@ interface GenerateQueryApiParams {
      * - `{ throw: { params?: boolean | string; data?: boolean | string } }`: set `throwContracts` to an object; each value is literal or expression (string inserted as-is).
      *
      * Optional `appendRule`: either a string (runtime) or a function (codegen-time).
-     * - **string**: expression inserted as-is → `contracts: <expr> ? <contractsVar> : undefined`. E.g. `"process.env.NODE_ENV === \"development\""`.
-     * - **function** (contractName, routeInfo) => boolean: at codegen time, if true → `contracts: <contractsVar>`, if false → `contracts: undefined`.
+     * - **string**: expression inserted as-is → `contract: <expr> ? <contractVar> : undefined`. E.g. `"process.env.NODE_ENV === \"development\""`.
+     * - **function** (contractName, routeInfo) => boolean: at codegen time, if true → `contract: <contractVar>`, if false → `contract: undefined`.
+     *
+     * Optional `suffix`: suffix for generated Zod contract variables.
+     * Default: `"Contract"`.
      */
     zodContracts?: boolean | {
-        validate: boolean | string | {
-            params?: boolean | string;
-            data?: boolean | string;
-        };
-        throw?: boolean | string | {
-            params?: boolean | string;
-            data?: boolean | string;
-        };
+        validate: MaybeFn<RuntimeExpressionOrBoolean | {
+            params?: RuntimeExpressionOrBoolean;
+            data?: RuntimeExpressionOrBoolean;
+        }, [
+            contractName: string,
+            routeInfo: ZodContractsRouteInfo
+        ]>;
+        throw?: MaybeFn<RuntimeExpressionOrBoolean | {
+            params?: RuntimeExpressionOrBoolean;
+            data?: RuntimeExpressionOrBoolean;
+        }, [
+            contractName: string,
+            routeInfo: ZodContractsRouteInfo
+        ]>;
         /** String: runtime condition. Function: codegen-time filter for (contractName, routeInfo). */
-        appendRule?: string | ((contractName: string, routeInfo: ZodContractsRouteInfo) => boolean);
+        appendRule?: MaybeFn<RuntimeExpressionOrBoolean, [
+            contractName: string,
+            routeInfo: ZodContractsRouteInfo
+        ]>;
+        /** Suffix for all generated Zod contract variables. Default: "Contract". */
+        suffix?: string;
     };
 }
 /** Route info passed to zodContracts.appendRule at codegen time. */

package/cli.js

@@ -4,7 +4,6 @@ import { cloneDeep } from "lodash-es";
 import { generateApi as generateApi$1 } from "swagger-typescript-api";
 import { splitTextByLines } from "yummies/text";
 import { Project, SyntaxKind, Node } from "ts-morph";
-const fs = {};
 const LINTERS_IGNORE = `/* eslint-disable */
 /* tslint:disable */`;
 const buildGenerics = (contract) => {
@@ -217,6 +216,10 @@ const createShortModelType = (shortModelType) => {
     description: shortModelType.description || ""
   };
 };
+const DEFAULT_ZOD_CONTRACT_SUFFIX = "Contract";
+function getZodContractSuffix(zodContracts) {
+  return (typeof zodContracts === "object" && zodContracts !== null && typeof zodContracts.suffix === "string" ? zodContracts.suffix : void 0) ?? DEFAULT_ZOD_CONTRACT_SUFFIX;
+}
 const REF_PREFIX = "#/components/schemas/";
 const REF_PREFIX_PARAMS = "#/components/parameters/";
 function parseRef(ref) {
@@ -268,14 +271,14 @@ function schemaToNumber(schema) {
   if (schema.maximum != null) n += `.max(${schema.maximum})`;
   return n;
 }
-function schemaToArray(schema, schemas, schemaKeyToVarName2, visited) {
-  const items = schema.items ? schemaToZodExpr(schema.items, schemas, schemaKeyToVarName2, visited) : "z.any()";
+function schemaToArray(schema, schemas, schemaKeyToVarName, visited) {
+  const items = schema.items ? schemaToZodExpr(schema.items, schemas, schemaKeyToVarName, visited) : "z.any()";
   let a = `z.array(${items})`;
   if (schema.minItems != null) a += `.min(${schema.minItems})`;
   if (schema.maxItems != null) a += `.max(${schema.maxItems})`;
   return a;
 }
-function schemaToObject(schema, schemas, schemaKeyToVarName2, visited) {
+function schemaToObject(schema, schemas, schemaKeyToVarName, visited) {
   if (schema.properties && Object.keys(schema.properties).length > 0) {
     const required = new Set(schema.required ?? []);
     const entries = Object.entries(schema.properties).map(
@@ -283,7 +286,7 @@ function schemaToObject(schema, schemas, schemaKeyToVarName2, visited) {
         const expr = schemaToZodExpr(
           propSchema,
           schemas,
-          schemaKeyToVarName2,
+          schemaKeyToVarName,
           visited
         );
         const optional = !required.has(propName);
@@ -301,26 +304,26 @@ ${entries.join(",\n")}
     const value = schemaToZodExpr(
       schema.additionalProperties,
       schemas,
-      schemaKeyToVarName2,
+      schemaKeyToVarName,
       visited
     );
     return `z.record(z.string(), ${value})`;
   }
   return "z.record(z.string(), z.any())";
 }
-function schemaToZodExpr(schema, schemas, schemaKeyToVarName2, visited) {
+function schemaToZodExpr(schema, schemas, schemaKeyToVarName, visited) {
   if (!schema) return "z.any()";
   if (schema.$ref) {
     const key = parseRef(schema.$ref);
     if (key && key in schemas) {
       const isCycle = visited.has(key);
-      return isCycle ? `z.lazy((): z.ZodTypeAny => ${schemaKeyToVarName2(key)})` : `z.lazy(() => ${schemaKeyToVarName2(key)})`;
+      return isCycle ? `z.lazy((): z.ZodTypeAny => ${schemaKeyToVarName(key)})` : `z.lazy(() => ${schemaKeyToVarName(key)})`;
     }
     return "z.any()";
   }
   if (schema.allOf && schema.allOf.length > 0) {
     const parts = schema.allOf.map(
-      (part) => schemaToZodExpr(part, schemas, schemaKeyToVarName2, visited)
+      (part) => schemaToZodExpr(part, schemas, schemaKeyToVarName, visited)
     );
     const base2 = parts.length === 1 ? parts[0] : parts.reduce((acc, p) => `z.intersection(${acc}, ${p})`);
     return schema.nullable === true ? `${base2}.nullable()` : base2;
@@ -339,10 +342,10 @@ function schemaToZodExpr(schema, schemas, schemaKeyToVarName2, visited) {
       base = "z.boolean()";
       break;
     case "array":
-      base = schemaToArray(schema, schemas, schemaKeyToVarName2, visited);
+      base = schemaToArray(schema, schemas, schemaKeyToVarName, visited);
       break;
     case "object":
-      base = schemaToObject(schema, schemas, schemaKeyToVarName2, visited);
+      base = schemaToObject(schema, schemas, schemaKeyToVarName, visited);
       break;
     default:
       base = "z.any()";
@@ -372,9 +375,9 @@ function collectRefs(schema, schemas, out) {
     collectRefs(schema.additionalProperties, schemas, out);
   }
 }
-function schemaKeyToVarName(key, utils) {
+function schemaKeyToContractVarName(key, utils, contractSuffix = DEFAULT_ZOD_CONTRACT_SUFFIX) {
   const _ = utils._;
-  return `${_.camelCase(key)}Schema`;
+  return `${_.camelCase(key)}${contractSuffix}`;
 }
 function resolveQueryParameters(operation, componentsParameters) {
   const list = [];
@@ -403,13 +406,13 @@ function resolveQueryParameters(operation, componentsParameters) {
   }
   return list;
 }
-function queryParamsToZodObject(queryParams, schemas, schemaKeyToVarName2) {
+function queryParamsToZodObject(queryParams, schemas, schemaKeyToContractVarName2) {
   if (queryParams.length === 0) return "z.object({})";
   const entries = queryParams.map(({ name, required, schema }) => {
     const expr = schemaToZodExpr(
       schema,
       schemas,
-      schemaKeyToVarName2,
+      schemaKeyToContractVarName2,
       /* @__PURE__ */ new Set()
     );
     const field = required ? expr : `${expr}.optional()`;
@@ -419,32 +422,36 @@ function queryParamsToZodObject(queryParams, schemas, schemaKeyToVarName2) {
 ${entries.join(",\n")}
 })`;
 }
-function generateAuxiliarySchemas(schemaKeys, schemas, schemaKeyToVarNameFn, visited) {
+function generateAuxiliarySchemas(schemaKeys, schemas, schemaKeyToContractVarNameFn, visited) {
   const lines = [];
   for (const key of schemaKeys) {
     if (visited.has(key)) continue;
     visited.add(key);
     const schema = schemas[key];
     if (!schema) continue;
-    const varName = schemaKeyToVarNameFn(key);
+    const varName = schemaKeyToContractVarNameFn(key);
     const cyclePath = /* @__PURE__ */ new Set([key]);
     const expr = schemaToZodExpr(
       schema,
       schemas,
-      schemaKeyToVarNameFn,
+      schemaKeyToContractVarNameFn,
       cyclePath
     );
     lines.push(`export const ${varName} = ${expr};`);
   }
   return lines;
 }
-function buildCentralZodSchemasFile(params) {
-  const { componentsSchemas, utils } = params;
-  const schemaKeyToVarNameFn = (key) => schemaKeyToVarName(key, utils);
+function buildCentralZodContractsFile(params) {
+  const {
+    componentsSchemas,
+    utils,
+    contractSuffix = DEFAULT_ZOD_CONTRACT_SUFFIX
+  } = params;
+  const schemaKeyToContractVarNameFn = (key) => schemaKeyToContractVarName(key, utils, contractSuffix);
   const lines = generateAuxiliarySchemas(
     Object.keys(componentsSchemas),
     componentsSchemas,
-    schemaKeyToVarNameFn,
+    schemaKeyToContractVarNameFn,
     /* @__PURE__ */ new Set()
   );
   return `import * as z from "zod";
@@ -466,7 +473,7 @@ function typeToZodSchemaFallback(typeStr) {
   if (t === "unknown") return "z.unknown()";
   return "z.any()";
 }
-function typeToZodSchemaWithSchema(typeStr, schemas, utils, typeSuffix) {
+function typeToZodSchemaWithSchema(typeStr, schemas, utils, typeSuffix, contractSuffix = DEFAULT_ZOD_CONTRACT_SUFFIX) {
   const t = typeStr.trim();
   if (!schemas || Object.keys(schemas).length === 0) {
     return { expr: typeToZodSchemaFallback(t), refs: [] };
@@ -479,36 +486,36 @@ function typeToZodSchemaWithSchema(typeStr, schemas, utils, typeSuffix) {
   }
   const refs = /* @__PURE__ */ new Set();
   collectRefs(schema, schemas, refs);
-  const schemaKeyToVarNameFn = (key) => schemaKeyToVarName(key, utils);
+  const schemaKeyToContractVarNameFn = (key) => schemaKeyToContractVarName(key, utils, contractSuffix);
   const expr = schemaToZodExpr(
     schema,
     schemas,
-    schemaKeyToVarNameFn,
+    schemaKeyToContractVarNameFn,
     /* @__PURE__ */ new Set()
   );
   return { expr, refs: [...refs] };
 }
-function schemaKeyToZod(schemaKey, schemas, utils) {
+function schemaKeyToZod(schemaKey, schemas, utils, contractSuffix = DEFAULT_ZOD_CONTRACT_SUFFIX) {
   const schema = schemas[schemaKey];
   if (!schema) return { expr: "z.any()", refs: [] };
   const refs = /* @__PURE__ */ new Set();
   collectRefs(schema, schemas, refs);
-  const schemaKeyToVarNameFn = (key) => schemaKeyToVarName(key, utils);
+  const schemaKeyToContractVarNameFn = (key) => schemaKeyToContractVarName(key, utils, contractSuffix);
   const expr = schemaToZodExpr(
     schema,
     schemas,
-    schemaKeyToVarNameFn,
+    schemaKeyToContractVarNameFn,
     /* @__PURE__ */ new Set()
   );
   return { expr, refs: [...refs] };
 }
 function buildEndpointZodContractsCode(params) {
   const {
-    routeNameUsage,
     inputParams,
     responseDataTypeName,
-    contractsVarName,
+    contractVarName,
     utils,
+    contractSuffix = DEFAULT_ZOD_CONTRACT_SUFFIX,
     componentsSchemas = null,
     typeSuffix = "DC",
     responseSchemaKey,
@@ -517,13 +524,11 @@ function buildEndpointZodContractsCode(params) {
     openApiComponentsParameters = null,
     queryParamName = "query"
   } = params;
-  const _ = utils._;
-  const paramsSchemaName = `${_.camelCase(routeNameUsage)}ParamsSchema`;
-  const dataSchemaName = `${_.camelCase(routeNameUsage)}DataSchema`;
+  utils._;
   const allAuxiliaryKeys = /* @__PURE__ */ new Set();
   const paramParts = [];
   const resolvedQueryParams = openApiOperation && (openApiComponentsParameters || openApiOperation.parameters?.length) ? resolveQueryParameters(openApiOperation, openApiComponentsParameters) : [];
-  const schemaKeyToVarNameFn = (key) => schemaKeyToVarName(key, utils);
+  const schemaKeyToContractVarNameFn = (key) => schemaKeyToContractVarName(key, utils, contractSuffix);
   for (const p of inputParams) {
     let expr;
     let refKeys = [];
@@ -531,14 +536,15 @@ function buildEndpointZodContractsCode(params) {
       expr = queryParamsToZodObject(
         resolvedQueryParams,
         componentsSchemas,
-        schemaKeyToVarNameFn
+        schemaKeyToContractVarNameFn
       );
     } else {
       const result = typeToZodSchemaWithSchema(
         p.type,
         componentsSchemas,
         utils,
-        typeSuffix
+        typeSuffix,
+        contractSuffix
       );
       expr = result.expr;
       refKeys = result.refs;
@@ -547,11 +553,17 @@ function buildEndpointZodContractsCode(params) {
     const schemaWithOptional = p.optional ? `${expr}.optional()` : expr;
     paramParts.push(`${p.name}: ${schemaWithOptional}`);
   }
-  const responseResult = responseSchemaKey && componentsSchemas && responseSchemaKey in componentsSchemas ? schemaKeyToZod(responseSchemaKey, componentsSchemas, utils) : typeToZodSchemaWithSchema(
+  const responseResult = responseSchemaKey && componentsSchemas && responseSchemaKey in componentsSchemas ? schemaKeyToZod(
+    responseSchemaKey,
+    componentsSchemas,
+    utils,
+    contractSuffix
+  ) : typeToZodSchemaWithSchema(
     responseDataTypeName,
     componentsSchemas,
     utils,
-    typeSuffix
+    typeSuffix,
+    contractSuffix
   );
   const useDataSchemaFromCentral = useExternalZodSchemas && responseSchemaKey && componentsSchemas && responseSchemaKey in componentsSchemas;
   if (useDataSchemaFromCentral) {
@@ -559,31 +571,27 @@ function buildEndpointZodContractsCode(params) {
   } else {
     for (const k of responseResult.refs) allAuxiliaryKeys.add(k);
   }
-  const zodSchemaImportNames = useExternalZodSchemas && allAuxiliaryKeys.size > 0 ? [...allAuxiliaryKeys].map(schemaKeyToVarNameFn) : [];
+  const zodContractImportNames = useExternalZodSchemas && allAuxiliaryKeys.size > 0 ? [...allAuxiliaryKeys].map(schemaKeyToContractVarNameFn) : [];
   const allAuxiliary = useExternalZodSchemas ? [] : generateAuxiliarySchemas(
     [...allAuxiliaryKeys],
     componentsSchemas ?? {},
-    schemaKeyToVarNameFn,
+    schemaKeyToContractVarNameFn,
     /* @__PURE__ */ new Set()
   );
-  const paramsFields = paramParts.join(",\n  ");
-  const paramsSchemaCode = `export const ${paramsSchemaName} = z.object({
-  ${paramsFields},
-});`;
-  const dataSchemaCode = useDataSchemaFromCentral ? `export const ${dataSchemaName} = ${schemaKeyToVarNameFn(responseSchemaKey)};` : `export const ${dataSchemaName} = ${responseResult.expr};`;
-  const contractsCode = `export const ${contractsVarName} = {
-  params: ${paramsSchemaName},
-  data: ${dataSchemaName},
+  const paramsFields = paramParts.join(",\n    ");
+  const paramsSchemaExpr = `z.object({
+    ${paramsFields},
+  })`;
+  const dataSchemaExpr = useDataSchemaFromCentral ? schemaKeyToContractVarNameFn(responseSchemaKey) : responseResult.expr;
+  const contractsCode = `export const ${contractVarName} = {
+  params: ${paramsSchemaExpr},
+  data: ${dataSchemaExpr},
 };`;
   const auxiliaryBlock = allAuxiliary.length > 0 ? `${allAuxiliary.join("\n\n")}
 
 ` : "";
-  const content = `${auxiliaryBlock}${paramsSchemaCode}
-
-${dataSchemaCode}
-
-${contractsCode}`;
-  return { content, zodSchemaImportNames };
+  const content = `${auxiliaryBlock}${contractsCode}`;
+  return { content, zodContractImportNames };
 }
 const formatGroupNameEnumKey = (groupName, { _ }) => _.upperFirst(_.camelCase(groupName));
 const formatTagNameEnumKey = (tagName, utils) => formatGroupNameEnumKey(tagName, utils);
@@ -743,10 +751,7 @@ const newEndpointTmpl = ({
 }) => {
   const zodContractsIsObject = typeof zodContracts === "object" && zodContracts !== null;
   const hasZodContracts = zodContracts === true || zodContractsIsObject;
-  const validateOpt = zodContractsIsObject ? zodContracts.validate : zodContracts === true ? true : void 0;
-  const throwOpt = zodContractsIsObject ? zodContracts.throw : void 0;
-  const validateOptObj = validateOpt != null && typeof validateOpt === "object" && !Array.isArray(validateOpt) ? validateOpt : null;
-  const throwOptObj = throwOpt != null && typeof throwOpt === "object" && !Array.isArray(throwOpt) ? throwOpt : null;
+  const contractSuffix = getZodContractSuffix(zodContracts);
   const { _ } = utils;
   const positiveResponseTypes = route.raw.responsesTypes?.filter(
     (it) => +it.status >= 200 && +it.status < 300 && (!it.typeData || filterTypes(it.typeData))
@@ -860,7 +865,24 @@ const newEndpointTmpl = ({
   });
   const isAllowedInputType = filterTypes(requestInputTypeDc);
   const defaultOkResponseType = positiveResponseTypes?.[0]?.type ?? "unknown";
-  const contractsVarName = hasZodContracts ? `${_.camelCase(route.routeName.usage)}Contracts` : null;
+  const contractVarName = hasZodContracts ? `${_.camelCase(route.routeName.usage)}${contractSuffix}` : null;
+  const routeInfoForContracts = contractVarName != null ? {
+    operationId: raw.operationId ?? "",
+    path: path2,
+    method,
+    contractName: contractVarName
+  } : null;
+  const resolveZodContractsMaybeFn = (value) => {
+    if (typeof value === "function" && routeInfoForContracts != null) {
+      return value(routeInfoForContracts.contractName, routeInfoForContracts);
+    }
+    return value;
+  };
+  const validateOpt = zodContractsIsObject ? resolveZodContractsMaybeFn(zodContracts.validate) : zodContracts === true ? true : void 0;
+  const throwOpt = zodContractsIsObject ? resolveZodContractsMaybeFn(zodContracts.throw) : void 0;
+  const isRuntimeContractsRuleObject = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+  const validateOptObj = isRuntimeContractsRuleObject(validateOpt) ? validateOpt : null;
+  const throwOptObj = isRuntimeContractsRuleObject(throwOpt) ? throwOpt : null;
   const swaggerSchema = configuration.config?.swaggerSchema ?? configuration?.swaggerSchema;
   const componentsSchemas = swaggerSchema?.components?.schemas;
   let operationFromSpec = null;
@@ -897,46 +919,36 @@ const newEndpointTmpl = ({
       if (candidate in componentsSchemas) responseSchemaKey = candidate;
     }
   }
-  const contractsCode = hasZodContracts && contractsVarName ? buildEndpointZodContractsCode({
+  const contractsCode = hasZodContracts && contractVarName ? buildEndpointZodContractsCode({
     routeNameUsage: route.routeName.usage,
     inputParams,
     responseDataTypeName: defaultOkResponseType,
-    contractsVarName,
+    contractVarName,
     utils,
     componentsSchemas: componentsSchemas ?? void 0,
     typeSuffix: "DC",
     responseSchemaKey: responseSchemaKey ?? void 0,
     useExternalZodSchemas: Boolean(relativePathZodSchemas),
+    contractSuffix,
     openApiOperation: operationFromSpec ?? void 0,
     openApiComponentsParameters: swaggerSchema?.components?.parameters ?? void 0,
     queryParamName: queryName
   }) : null;
-  const appendRuleOpt = zodContractsIsObject && zodContracts.appendRule != null ? zodContracts.appendRule : null;
-  const routeInfoForAppend = contractsVarName != null ? {
-    operationId: raw.operationId ?? "",
-    path: path2,
-    method,
-    contractName: contractsVarName
-  } : null;
-  const contractsLine = (() => {
-    if (contractsVarName == null) return "";
+  const appendRuleOpt = zodContractsIsObject && zodContracts.appendRule != null ? resolveZodContractsMaybeFn(zodContracts.appendRule) : null;
+  const contractLine = (() => {
+    if (contractVarName == null) return "";
     if (typeof appendRuleOpt === "string")
-      return `contracts: ${appendRuleOpt} ? ${contractsVarName} : undefined,`;
-    if (typeof appendRuleOpt === "function" && routeInfoForAppend) {
-      const include = appendRuleOpt(
-        routeInfoForAppend.contractName,
-        routeInfoForAppend
-      );
-      return include ? `contracts: ${contractsVarName},` : "contracts: undefined,";
-    }
-    return `contracts: ${contractsVarName},`;
+      return `contract: ${appendRuleOpt} ? ${contractVarName} : undefined,`;
+    if (appendRuleOpt === false) return "contract: undefined,";
+    if (appendRuleOpt === true) return `contract: ${contractVarName},`;
+    return `contract: ${contractVarName},`;
   })();
-  const validateContractsLine = (() => {
+  const validateContractLine = (() => {
     if (validateOpt === void 0) return "";
     if (typeof validateOpt === "string")
-      return `validateContracts: ${validateOpt},`;
+      return `validateContract: ${validateOpt},`;
     if (typeof validateOpt === "boolean")
-      return `validateContracts: ${validateOpt},`;
+      return `validateContract: ${validateOpt},`;
     if (validateOptObj !== null) {
       const parts = [];
       if (validateOptObj.params !== void 0)
@@ -947,7 +959,7 @@ const newEndpointTmpl = ({
         parts.push(
           `data: ${typeof validateOptObj.data === "string" ? validateOptObj.data : validateOptObj.data}`
         );
-      return parts.length > 0 ? `validateContracts: { ${parts.join(", ")} },` : "";
+      return parts.length > 0 ? `validateContract: { ${parts.join(", ")} },` : "";
     }
     return "";
   })();
@@ -969,7 +981,7 @@ const newEndpointTmpl = ({
     reservedDataContractNames,
     localModelTypes: isAllowedInputType ? [requestInputTypeDc] : [],
     contractsCode: contractsCode ?? void 0,
-    contractsVarName: contractsVarName ?? void 0,
+    contractVarName: contractVarName ?? void 0,
     content: `
 new ${importFileParams.endpoint.exportName}<
   ${getHttpRequestGenerics()},
@@ -1002,8 +1014,8 @@ new ${importFileParams.endpoint.exportName}<
         ${groupName ? `group: ${metaInfo ? `Group.${formatGroupNameEnumKey(groupName, utils)}` : `"${groupName}"`},` : ""}
         ${metaInfo?.namespace ? `namespace,` : ""}
         meta: ${requestInfoMeta?.tmplData ?? "{} as any"},
-        ${contractsLine}
-        ${validateContractsLine}
+        ${contractLine}
+        ${validateContractLine}
         ${throwContractsLine}
     },
     ${importFileParams.queryClient.exportName},
@@ -1053,17 +1065,17 @@ const allEndpointPerFileTmpl = async (params) => {
   const hasAnyZodContracts = newEndpointTemplates.some(
     (t) => t.contractsCode != null
   );
-  const allZodSchemaImportNames = /* @__PURE__ */ new Set();
+  const allZodContractImportNames = /* @__PURE__ */ new Set();
   newEndpointTemplates.forEach((t) => {
     const c = t.contractsCode;
-    if (c != null && typeof c === "object" && c.zodSchemaImportNames?.length) {
-      for (const n of c.zodSchemaImportNames) {
-        allZodSchemaImportNames.add(n);
+    if (c != null && typeof c === "object" && c.zodContractImportNames?.length) {
+      for (const n of c.zodContractImportNames) {
+        allZodContractImportNames.add(n);
       }
     }
   });
   const zodImportLine = hasAnyZodContracts ? 'import * as z from "zod";' : "";
-  const zodSchemasImportLine = allZodSchemaImportNames.size && relativePathZodSchemas ? `import { ${[...allZodSchemaImportNames].sort().join(", ")} } from "${relativePathZodSchemas}";` : "";
+  const zodSchemasImportLine = allZodContractImportNames.size && relativePathZodSchemas ? `import { ${[...allZodContractImportNames].sort().join(", ")} } from "${relativePathZodSchemas}";` : "";
   const endpointTemplates = await Promise.all(
     newEndpointTemplates.map(
       async ({
@@ -1167,7 +1179,7 @@ const allExportsTmpl = async ({
 }) => {
   return await formatTSContent(`${LINTERS_IGNORE}
   export * from './data-contracts';
-  ${exportSchemas ? "  export * from './schemas';\n  " : ""}${collectedExportFiles.map((fileName) => `export * from './${fileName}';`).join("\n")}
+  ${exportSchemas ? "  export * from './contracts';\n  " : ""}${collectedExportFiles.map((fileName) => `export * from './${fileName}';`).join("\n")}
   ${metaInfo ? 'export * from "./meta-info";' : ""}
     `);
 };
@@ -1249,7 +1261,7 @@ const endpointPerFileTmpl = async (params) => {
   const dataContractImportToken = "/*__DATA_CONTRACT_IMPORTS__*/";
   const contractsResult = contractsCode != null && typeof contractsCode === "object" ? contractsCode : null;
   const zodImportLine = contractsResult != null ? 'import * as z from "zod";' : "";
-  const zodSchemasImportLine = contractsResult?.zodSchemaImportNames?.length && relativePathZodSchemas ? `import { ${contractsResult.zodSchemaImportNames.join(", ")} } from "${relativePathZodSchemas}";` : "";
+  const zodSchemasImportLine = contractsResult?.zodContractImportNames?.length && relativePathZodSchemas ? `import { ${contractsResult.zodContractImportNames.join(", ")} } from "${relativePathZodSchemas}";` : "";
   const contractsBlock = contractsResult != null ? `
 
 ${contractsResult.content}
@@ -1632,7 +1644,6 @@ const generateApi = async (params) => {
   }
   const codegenFs = codegenProcess.fileSystem;
   await Promise.resolve(codegenFs.cleanDir(paths.outputDir));
-  await fs.mkdir(paths.outputDir, { recursive: true });
   await Promise.resolve(codegenFs.createDir(paths.outputDir));
   const filterTypes = unpackFilterOption(
     params.filterTypes,
@@ -1660,7 +1671,8 @@ const generateApi = async (params) => {
   };
   const reservedDataContractNamesMap = /* @__PURE__ */ new Map();
   const componentsSchemasForZod = generated.configuration.config?.swaggerSchema?.components?.schemas ?? generated.configuration.swaggerSchema?.components?.schemas;
-  const hasZodSchemasFile = (params.zodContracts === true || typeof params.zodContracts === "object" && params.zodContracts != null) && componentsSchemasForZod && typeof componentsSchemasForZod === "object" && Object.keys(componentsSchemasForZod).length > 0;
+  const zodContractSuffix = getZodContractSuffix(params.zodContracts);
+  const hasZodContractsFile = (params.zodContracts === true || typeof params.zodContracts === "object" && params.zodContracts != null) && componentsSchemasForZod && typeof componentsSchemasForZod === "object" && Object.keys(componentsSchemasForZod).length > 0;
   const collectedExportFilesFromIndexFile = [];
   const groupsMap = /* @__PURE__ */ new Map();
   const nonEmptyGroups = /* @__PURE__ */ new Set();
@@ -1668,12 +1680,7 @@ const generateApi = async (params) => {
   if (params.groupBy == null) {
     collectedExportFilesFromIndexFile.push("endpoints");
     if (outputType === "one-endpoint-per-file") {
-      await fs.mkdir(path.resolve(paths.outputDir, "endpoints"), {
-        recursive: true
-      });
-      await Promise.resolve(
-        codegenFs.createDir(path.resolve(params.output, "endpoints"))
-      );
+      codegenFs.createDir(path.resolve(params.output, "endpoints"));
       const fileNamesWithRequestInfo = [];
       for await (const route of allRoutes) {
         const {
@@ -1688,7 +1695,7 @@ const generateApi = async (params) => {
             groupNames: [],
             namespace
           },
-          relativePathZodSchemas: hasZodSchemasFile ? "../schemas" : null
+          relativePathZodSchemas: hasZodContractsFile ? "../contracts" : null
         });
         if (Array.isArray(route.raw.tags)) {
           route.raw.tags.forEach((tag) => {
@@ -1733,7 +1740,7 @@ const generateApi = async (params) => {
           namespace,
           groupNames: []
         },
-        relativePathZodSchemas: hasZodSchemasFile ? "./schemas" : null
+        relativePathZodSchemas: hasZodContractsFile ? "./contracts" : null
       });
       reservedDataContractNames.forEach((name) => {
         reservedDataContractNamesMap.set(
@@ -1806,6 +1813,7 @@ const generateApi = async (params) => {
             ...baseTmplParams,
             route,
             relativePathDataContracts: "../../data-contracts",
+            relativePathZodSchemas: hasZodContractsFile ? "../../contracts" : null,
             groupName,
             metaInfo: params.noMetaInfo ? null : {
               namespace,
@@ -1848,6 +1856,7 @@ const generateApi = async (params) => {
           ...baseTmplParams,
           routes,
           relativePathDataContracts: "../data-contracts",
+          relativePathZodSchemas: hasZodContractsFile ? "../contracts" : null,
           groupName,
           metaInfo: params.noMetaInfo ? null : {
             namespace,
@@ -1929,20 +1938,21 @@ export * as ${exportGroupName} from './endpoints';
     withPrefix: false,
     content: dataContractsContent
   });
-  if (hasZodSchemasFile && componentsSchemasForZod) {
-    const schemasTsContent = buildCentralZodSchemasFile({
+  if (hasZodContractsFile && componentsSchemasForZod) {
+    const contractsTsContent = buildCentralZodContractsFile({
       componentsSchemas: componentsSchemasForZod,
-      utils
+      utils,
+      contractSuffix: zodContractSuffix
     });
-    const formattedSchemasContent = await generated.formatTSContent(
+    const formattedContractsContent = await generated.formatTSContent(
       `${LINTERS_IGNORE}
-${schemasTsContent}`
+${contractsTsContent}`
     );
     codegenFs.createFile({
       path: paths.outputDir,
-      fileName: "schemas.ts",
+      fileName: "contracts.ts",
       withPrefix: false,
-      content: formattedSchemasContent
+      content: formattedContractsContent
     });
   }
   if (metaInfo) {
@@ -1965,7 +1975,7 @@ ${schemasTsContent}`
         ...baseTmplParams,
         collectedExportFiles: collectedExportFilesFromIndexFile,
         metaInfo,
-        exportSchemas: hasZodSchemasFile
+        exportSchemas: hasZodContractsFile
       })
     });
     if (shouldGenerateBarrelFiles) {
@@ -1988,7 +1998,7 @@ export * as ${namespace} from './__exports';
           ...baseTmplParams,
           collectedExportFiles: collectedExportFilesFromIndexFile,
           metaInfo,
-          exportSchemas: hasZodSchemasFile
+          exportSchemas: hasZodContractsFile
         })
       });
     }