swaggie 1.9.0-dev.1 → 2.0.0

package/dist/utils/fileUtils.js

@@ -1,6 +1,28 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});var _nodefs = require('node:fs');
 var _nodepath = require('node:path');
 
+/**
+ * Computes the relative import path from `fromFile` to `toFile`, stripping the
+ * file extension and ensuring the result always starts with `./` or `../`.
+ *
+ * @param fromFile - The file that will contain the import statement (e.g. the mock file)
+ * @param toFile   - The file being imported (e.g. the generated API client file)
+ *
+ * @example
+ * deriveRelativeImport('src/__mocks__/api.ts', 'src/generated/api.ts')
+ * // → '../generated/api'
+ *
+ * deriveRelativeImport('src/api.mock.ts', 'src/api.ts')
+ * // → './api'
+ */
+ function deriveRelativeImport(fromFile, toFile) {
+  const rel = _nodepath.relative.call(void 0, _nodepath.dirname.call(void 0, fromFile), toFile);
+  const withoutExt = rel.replace(/\.[jt]sx?$/i, '');
+  // Normalise backslashes on Windows and ensure a leading ./
+  const normalised = withoutExt.replace(/\\/g, '/');
+  return normalised.startsWith('.') ? normalised : './' + normalised;
+} exports.deriveRelativeImport = deriveRelativeImport;
+
  function saveFile(filePath, contents) {
   return new Promise((resolve, reject) => {
     _nodefs.mkdir.call(void 0, _nodepath.dirname.call(void 0, filePath), { recursive: true }, (err) => {

package/dist/utils/refResolver.js

@@ -5,10 +5,6 @@ var _yaml = require('yaml');
 
 
 
-
-
-
-
 const SUPPORTED_COMPONENT_SECTIONS = new Set([
   'schemas',
   'parameters',
@@ -26,8 +22,6 @@ const SUPPORTED_COMPONENT_SECTIONS = new Set([
 
 
 
-
-
 /**
  * Resolves external file refs into local component refs.
  * For now we only support local file refs (no http/https) and component targets.
@@ -109,9 +103,7 @@ async function resolveRef(
   }
 
   if (!fragment) {
-    throw new Error(
-      `External refs must include a JSON pointer fragment: '${rawRef}'`
-    );
+    throw new Error(`External refs must include a JSON pointer fragment: '${rawRef}'`);
   }
 
   if (!fragment.startsWith('/')) {
@@ -136,9 +128,7 @@ async function importRefFromFile(
 
   if (!targetInfo) {
     if (context.resolvingRefs.has(importKey)) {
-      throw new Error(
-        `Circular non-component external ref is not supported: '${rawRef}'`
-      );
+      throw new Error(`Circular non-component external ref is not supported: '${rawRef}'`);
     }
 
     const targetCopy = structuredClone(target);
@@ -172,10 +162,7 @@ async function importRefFromFile(
 }
 
 function parseImportTarget(pointer) {
-  const parts = pointer
-    .replace(/^#\//, '')
-    .split('/')
-    .map(unescapePointerSegment);
+  const parts = pointer.replace(/^#\//, '').split('/').map(unescapePointerSegment);
 
   if (parts.length === 2) {
     const [legacySection, name] = parts;
@@ -250,12 +237,13 @@ function getOrCreateComponentAlias(
   return candidate;
 }
 
-async function getValueByPointer(filePath, pointer, context) {
+async function getValueByPointer(
+  filePath,
+  pointer,
+  context
+) {
   const doc = await loadDocument(filePath, context);
-  const parts = pointer
-    .replace(/^#\//, '')
-    .split('/')
-    .map(unescapePointerSegment);
+  const parts = pointer.replace(/^#\//, '').split('/').map(unescapePointerSegment);
 
   let current = doc;
   for (const part of parts) {

package/dist/utils/templateEngine.js

@@ -1,9 +1,11 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _eta = require('eta');
 
 let engine;
+let loadedFiles = null;
 
  function initTemplateEngineFromDirectory(templatesDir) {
   engine = new (0, _eta.Eta)({ views: templatesDir });
+  loadedFiles = null;
 } exports.initTemplateEngineFromDirectory = initTemplateEngineFromDirectory;
 
  function initTemplateEngineFromBundled(templateFiles) {
@@ -18,8 +20,24 @@ let engine;
     const baseName = _nullishCoalesce(_optionalChain([templatePath, 'access', _ => _.split, 'call', _2 => _2('/'), 'access', _3 => _3.pop, 'call', _4 => _4(), 'optionalAccess', _5 => _5.split, 'call', _6 => _6('\\'), 'access', _7 => _7.pop, 'call', _8 => _8()]), () => ( templatePath));
     return templateFiles[baseName];
   };
+  loadedFiles = templateFiles;
 } exports.initTemplateEngineFromBundled = initTemplateEngineFromBundled;
 
+/**
+ * Returns true if the given template file is available in the currently loaded
+ * bundled template store.  Always returns false when using a directory-based
+ * engine (filesystem templates are checked via renderFile directly).
+ */
+ function hasTemplateFile(templateFile) {
+  if (!loadedFiles) {
+    return false;
+  }
+  return (
+    templateFile in loadedFiles ||
+    Object.keys(loadedFiles).some((k) => _optionalChain([k, 'access', _9 => _9.split, 'call', _10 => _10('/'), 'access', _11 => _11.pop, 'call', _12 => _12(), 'optionalAccess', _13 => _13.split, 'call', _14 => _14('\\'), 'access', _15 => _15.pop, 'call', _16 => _16()]) === templateFile)
+  );
+} exports.hasTemplateFile = hasTemplateFile;
+
 /**
  * Get's a template file and renders it with the provided data.
  */

package/dist/utils/templateManager.js

@@ -1,6 +1,8 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _nodefs = require('node:fs'); var _nodefs2 = _interopRequireDefault(_nodefs);
 var _nodepath = require('node:path'); var _nodepath2 = _interopRequireDefault(_nodepath);
 var _templateEngine = require('./templateEngine');
+
+
 let bundledTemplates = null;
 
 
@@ -9,34 +11,141 @@ let bundledTemplates = null;
   bundledTemplates = templates;
 } exports.setBundledTemplates = setBundledTemplates;
 
- function loadAllTemplateFiles(templateName) {
-  if (!templateName) {
+/**
+ * Loads template files for the given template spec and initializes the
+ * template engine.
+ *
+ * Accepts:
+ * - A single template name or filesystem path (L1 or custom).
+ * - A [L2, L1] tuple: the two template sets are merged, with L2 winning on
+ *   filename conflicts except for `baseClient.ejs` which is stored as
+ *   `baseClientL2.ejs` so that both L1 and L2 base clients can be rendered.
+ */
+ function loadAllTemplateFiles(template) {
+  if (!template) {
     throw new Error('No template name was provided');
   }
 
-  if (loadFromBundledTemplates(templateName)) {
+  if (Array.isArray(template)) {
+    const [l2, l1] = template;
+    const l1Files = resolveTemplateFiles(l1);
+    const l2Files = resolveTemplateFiles(l2);
+
+    if (!l1Files || !l2Files) {
+      // At least one side was a filesystem path — use directory overlay
+      loadCompositeFromFilesystem(l2, l1);
+      return;
+    }
+
+    // Both sides are bundled: merge in memory
+    const merged = mergeTemplateFiles(l1Files, l2Files);
+    _templateEngine.initTemplateEngineFromBundled.call(void 0, merged);
     return;
   }
 
-  const templatesDir = _nodefs2.default.existsSync(templateName)
-    ? templateName
-    : _nodepath2.default.join(__dirname, '..', '..', 'templates', templateName);
-
-  if (!_nodefs2.default.existsSync(templatesDir)) {
-    throw new Error(
-      `Could not find directory with the template (we tried ${templatesDir}). Is the template name correct?`
-    );
+  // Single template
+  if (!loadFromBundledTemplates(template)) {
+    loadFromFilesystem(template);
   }
-  _templateEngine.initTemplateEngineFromDirectory.call(void 0, templatesDir);
 } exports.loadAllTemplateFiles = loadAllTemplateFiles;
 
+/**
+ * Merges L1 and L2 file sets.  L2 wins on filename conflicts, EXCEPT that
+ * `baseClient.ejs` from L2 is stored under the key `baseClientL2.ejs` so
+ * both L1 and L2 base clients can be rendered independently.
+ */
+ function mergeTemplateFiles(
+  l1Files,
+  l2Files
+) {
+  const merged = { ...l1Files };
+
+  for (const [name, content] of Object.entries(l2Files)) {
+    if (name === 'baseClient.ejs') {
+      merged['baseClientL2.ejs'] = content;
+    } else {
+      merged[name] = content;
+    }
+  }
+
+  return merged;
+} exports.mergeTemplateFiles = mergeTemplateFiles;
+
+// ---------------------------------------------------------------------------
+// Private helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns the bundled file map for a named template, or null if the name
+ * refers to a filesystem path (i.e. the bundled store does not have it).
+ */
+function resolveTemplateFiles(templateName) {
+  const bundled = _optionalChain([bundledTemplates, 'optionalAccess', _ => _[templateName]]);
+  if (bundled) return bundled;
+
+  // Could be a bundled name that just isn't in the store yet, or a filesystem
+  // path. Return null to signal "use filesystem".
+  return null;
+}
+
 function loadFromBundledTemplates(templateName) {
-  const templateFiles = _optionalChain([bundledTemplates, 'optionalAccess', _ => _[templateName]]);
+  const templateFiles = _optionalChain([bundledTemplates, 'optionalAccess', _2 => _2[templateName]]);
   if (!templateFiles) {
     return false;
   }
 
   _templateEngine.initTemplateEngineFromBundled.call(void 0, templateFiles);
-
   return true;
 }
+
+function loadFromFilesystem(templateName) {
+  const templatesDir = resolveDir(templateName);
+  _templateEngine.initTemplateEngineFromDirectory.call(void 0, templatesDir);
+}
+
+/**
+ * For composite [L2, L1] pairs where at least one side lives on the
+ * filesystem: read both directories into memory, merge, and initialize a
+ * bundled-style engine so the merge logic is uniform.
+ */
+function loadCompositeFromFilesystem(l2, l1) {
+  const l1Files = getFilesFromSource(l1);
+  const l2Files = getFilesFromSource(l2);
+  const merged = mergeTemplateFiles(l1Files, l2Files);
+  _templateEngine.initTemplateEngineFromBundled.call(void 0, merged);
+}
+
+/**
+ * Reads all `.ejs` files from a template source (bundled store or filesystem
+ * directory) into a plain `Record<filename, content>` map.
+ */
+function getFilesFromSource(templateName) {
+  // Prefer bundled store
+  const bundled = _optionalChain([bundledTemplates, 'optionalAccess', _3 => _3[templateName]]);
+  if (bundled) return bundled;
+
+  const dir = resolveDir(templateName);
+  return readEjsFilesFromDir(dir);
+}
+
+function resolveDir(templateName) {
+  const resolved = _nodefs2.default.existsSync(templateName)
+    ? templateName
+    : _nodepath2.default.join(__dirname, '..', '..', 'templates', templateName);
+
+  if (!_nodefs2.default.existsSync(resolved)) {
+    throw new Error(
+      `Could not find directory with the template (we tried ${resolved}). Is the template name correct?`
+    );
+  }
+  return resolved;
+}
+
+function readEjsFilesFromDir(dir) {
+  const files = _nodefs2.default.readdirSync(dir).filter((f) => f.endsWith('.ejs'));
+  const result = {};
+  for (const file of files) {
+    result[file] = _nodefs2.default.readFileSync(_nodepath2.default.join(dir, file), 'utf8');
+  }
+  return result;
+}

package/dist/utils/templateValidator.js

@@ -0,0 +1,127 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+const L1_TEMPLATES = ['axios', 'fetch', 'xior', 'ng1', 'ng2'];
+const L2_TEMPLATES = ['swr', 'tsq'];
+
+/** L1 templates that are incompatible with any L2 (framework-specific clients) */
+const L2_INCOMPATIBLE_L1 = ['ng1', 'ng2'];
+
+/** Legacy composite template names and their replacements */
+const LEGACY_TEMPLATES = {
+  'swr-axios': ['swr', 'axios'],
+  'tsq-xior': ['tsq', 'xior'],
+};
+
+/** Default L1 to use when only an L2 template is specified */
+const DEFAULT_L1_FOR_L2 = 'fetch';
+
+ function isL1Template(name) {
+  return (L1_TEMPLATES ).includes(name);
+} exports.isL1Template = isL1Template;
+
+ function isL2Template(name) {
+  return (L2_TEMPLATES ).includes(name);
+} exports.isL2Template = isL2Template;
+
+/**
+ * Validates that a raw template input is acceptable and throws a descriptive
+ * error if not.  Does NOT normalize — call `normalizeTemplate` for that.
+ *
+ * Rules:
+ * - Legacy composite names ('swr-axios', 'tsq-xior') → migration error
+ * - Single L2 name → allowed (will be normalized to [L2, default-L1] later)
+ * - Single L1 name or custom path → allowed
+ * - Array with wrong element count → error
+ * - Array where first element is not an L2 → error
+ * - Array where second element is an incompatible L1 (ng1/ng2) → error
+ */
+ function validateTemplate(template) {
+  if (Array.isArray(template)) {
+    const arr = template ;
+    if (arr.length !== 2) {
+      throw new Error(
+        `Invalid template: array must have exactly 2 elements [L2, L1], e.g. ["swr", "axios"]. Got ${arr.length} element(s).`
+      );
+    }
+
+    const [l2, l1] = template;
+
+    // First element must be an L2 template (or a custom path — we can't validate
+    // custom paths statically, so we only reject known-bad L1 names here).
+    if (isL1Template(l2)) {
+      throw new Error(
+        `Invalid template pair: "${l2}" is an L1 (HTTP client) template and cannot be used as the first element. ` +
+          `The first element must be an L2 template (${L2_TEMPLATES.join(', ')}) or a custom path. ` +
+          `To use "${l2}" alone, pass it as a string: template: "${l2}".`
+      );
+    }
+
+    if (isL2Template(l2) && isL1Template(l1) && (L2_INCOMPATIBLE_L1 ).includes(l1)) {
+      throw new Error(
+        `Invalid template pair: "${l1}" is a framework-specific client and is not compatible with L2 template "${l2}". ` +
+          `Compatible L1 templates for L2 are: ${L1_TEMPLATES.filter((t) => !L2_INCOMPATIBLE_L1.includes(t)).join(', ')}.`
+      );
+    }
+
+    return;
+  }
+
+  // Single string
+  if (typeof template === 'string') {
+    const legacy = LEGACY_TEMPLATES[template];
+    if (legacy) {
+      throw new Error(
+        `"${template}" is no longer a valid template name. ` +
+          `It has been split into separate L1 and L2 templates. ` +
+          `Use template: ["${legacy[0]}", "${legacy[1]}"] instead.`
+      );
+    }
+    // Single L2, single L1, or custom path are all fine — L2 alone gets a
+    // default L1 applied during normalization.
+  }
+} exports.validateTemplate = validateTemplate;
+
+/**
+ * Normalizes a validated template input into a `ResolvedTemplate`:
+ * - Single L2 name → [L2, DEFAULT_L1_FOR_L2]
+ * - Everything else passes through unchanged.
+ *
+ * Call `validateTemplate` before this function.
+ */
+ function normalizeTemplate(template) {
+  if (typeof template === 'string' && isL2Template(template)) {
+    return [template, DEFAULT_L1_FOR_L2];
+  }
+  return template ;
+} exports.normalizeTemplate = normalizeTemplate;
+
+/**
+ * Returns the effective L1 template name from a resolved template.
+ * For arrays, returns the second element; for single strings, returns the string.
+ */
+ function getL1Template(template) {
+  return Array.isArray(template) ? template[1] : template;
+} exports.getL1Template = getL1Template;
+
+/**
+ * Returns the TypeScript type name for the `$httpConfig` parameter that the
+ * L1 template exposes on each operation method.
+ *
+ * Used by L2 operation partials so the `$httpConfig` parameter they forward
+ * to the underlying client method has the correct type regardless of which L1
+ * is paired with the L2.
+ */
+ function getHttpConfigType(template) {
+  const l1 = getL1Template(template);
+  switch (l1) {
+    case 'axios':
+      return 'AxiosRequestConfig';
+    case 'xior':
+      return 'XiorRequestConfig';
+    case 'fetch':
+      return 'RequestInit';
+    default:
+      // Custom path or unknown — fall back to a permissive type
+      return 'Record<string, unknown>';
+  }
+} exports.getHttpConfigType = getHttpConfigType;

package/dist/utils/utils.js

@@ -74,7 +74,7 @@ const reservedKeywords = new Set([
  */
  function escapeIdentifier(name) {
   if (!name) {
-    return name;
+    return _nullishCoalesce(name, () => ( ''));
   }
 
   if (reservedKeywords.has(name) || /^[0-9]/.test(name)) {
@@ -139,10 +139,11 @@ const reservedKeywords = new Set([
   }
 
   return operations.reduce((groups, op) => {
-    if (!groups[op.group]) {
-      groups[op.group] = [];
+    const groupKey = _nullishCoalesce(op.group, () => ( 'default'));
+    if (!groups[groupKey]) {
+      groups[groupKey] = [];
     }
-    groups[op.group].push(op);
+    groups[groupKey].push(op);
     return groups;
   }, {});
 } exports.groupOperationsByGroupName = groupOperationsByGroupName;
@@ -219,11 +220,13 @@ function resolveResponseRef(
     return [];
   }
 
-  return arr.concat().sort(sortByKey(key));
+  return arr.concat().sort((a, b) => {
+    const aVal = (a )[key] ;
+    const bVal = (b )[key] ;
+    return aVal != null && bVal != null ? (aVal > bVal ? 1 : bVal > aVal ? -1 : 0) : 0;
+  });
 } exports.orderBy = orderBy;
 
-const sortByKey = (key) => (a, b) => (a[key] > b[key] ? 1 : b[key] > a[key] ? -1 : 0);
-
 const orderedContentTypes = [
   'text/plain',
   'application/x-www-form-urlencoded',
@@ -233,32 +236,35 @@ const preferredJsonContentTypes = ['application/json', 'text/json'];
  function getBestContentType(
   reqBody
 ) {
-  const contentTypes = Object.keys(reqBody.content);
+  const content = _nullishCoalesce(reqBody.content, () => ( {}));
+  const contentTypes = Object.keys(content);
   if (contentTypes.length === 0) {
     return [null, null];
   }
 
-  const preferredJsonContentType = preferredJsonContentTypes.find((ct) => contentTypes.includes(ct));
+  const preferredJsonContentType = preferredJsonContentTypes.find((ct) =>
+    contentTypes.includes(ct)
+  );
   if (preferredJsonContentType) {
-    const typeObject = reqBody.content[preferredJsonContentType];
+    const typeObject = content[preferredJsonContentType];
     const type = getContentType(preferredJsonContentType);
     return [typeObject, type];
   }
 
   const jsonLikeContentType = contentTypes.find(isJsonLikeContentType);
   if (jsonLikeContentType) {
-    const typeObject = reqBody.content[jsonLikeContentType];
+    const typeObject = content[jsonLikeContentType];
     return [typeObject, 'json'];
   }
 
   const firstContentType = orderedContentTypes.find((ct) => contentTypes.includes(ct));
   if (firstContentType) {
-    const typeObject = reqBody.content[firstContentType];
+    const typeObject = content[firstContentType];
     const type = getContentType(firstContentType);
     return [typeObject, type];
   }
 
-  const typeObject = reqBody.content[contentTypes[0]];
+  const typeObject = content[contentTypes[0]];
   const type = getContentType(contentTypes[0]);
   return [typeObject, type];
 } exports.getBestContentType = getBestContentType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swaggie",
-  "version": "1.9.0-dev.1",
+  "version": "2.0.0",
   "description": "Generate a fully typed TypeScript API client from your OpenAPI 3 spec",
   "author": {
     "name": "Piotr Dabrowski",
@@ -40,7 +40,7 @@
     "build": "bun run bundle-templates && sucrase ./src -d ./dist --transforms typescript,imports && bun run rm-tests && bun run types",
     "bundle-templates": "bun scripts/bundle-templates.ts",
     "rm-tests": "find dist/ \\( -name '*.spec.js' -o -name 'types.js' \\) -type f -delete",
-    "types": "tsc src/types.ts --outDir dist/ --declaration --emitDeclarationOnly && cp test/index.d.ts ./dist/",
+    "types": "tsc --project tsconfig.types.json && cp test/index.d.ts ./dist/",
     "docs:build": "vitepress build docs",
     "docs:dev": "vitepress dev docs",
     "docs:preview": "vitepress preview docs"
@@ -66,7 +66,8 @@
     "service",
     "typescript",
     "codegen",
-    "TanStack Query"
+    "TanStack Query",
+    "mocks"
   ],
   "dependencies": {
     "case": "^1.6.3",
@@ -79,7 +80,7 @@
     "bun-types": "1.3.11",
     "openapi-types": "^12.1.3",
     "sucrase": "3.35.1",
-    "typescript": "5.9.3",
+    "typescript": "6.0.2",
     "vitepress": "^2.0.0-alpha.17",
     "vitepress-plugin-tabs": "0.8.0"
   }

package/templates/axios/operation.ejs

@@ -10,31 +10,35 @@ $config?: AxiosRequestConfig
     return axios.request<<%~ it.returnType %>>({
       url: url,
       method: '<%= it.method %>',
-<% if(it.body) { %>
-<% if(it.body.contentType === 'urlencoded') { %>
+<% if(it.body) { -%>
+<% if(it.body.contentType === 'urlencoded') { -%>
       data: new URLSearchParams(<%= it.body.name %> as any),
-<% } else { %>
+<% } else { -%>
       data: <%= it.body.name %>,
-<% } %>
-<% } %>
-<% if(it.query && it.query.length > 0) { %>
+<% } -%>
+<% } -%>
+<% if(it.query && it.query.length > 0) { -%>
       params: {
-    <% it.query.forEach((parameter) => { %>
-    '<%= parameter.originalName %>': <%= parameter.name %>,
-    <% }); %>
-  },
-<% } %>
-<% if(it.headers && it.headers.length > 0) { %>
+<% it.query.forEach((parameter) => { -%>
+<% if (it.queryParamObject) { -%>
+        '<%= parameter.originalName %>': <%= it.queryParamObject.name %>?.<%= parameter.name %>,
+<% } else { -%>
+        '<%= parameter.originalName %>': <%= parameter.name %>,
+<% } -%>
+<% }); -%>
+      },
+<% } -%>
+<% if(it.headers && it.headers.length > 0) { -%>
       headers: {
-  <% it.headers.forEach((parameter) => { %>
-    <% if (parameter.value) { %>
-  '<%= parameter.originalName %>': '<%= parameter.value %>',
-    <% } else { %>
-  '<%= parameter.originalName %>': <%= parameter.name %>,
-    <% } %>
-  <% }); %>
-},
-<% } %>
+<% it.headers.forEach((parameter) => { -%>
+<% if (parameter.value) { -%>
+        '<%= parameter.originalName %>': '<%= parameter.value %>',
+<% } else { -%>
+        '<%= parameter.originalName %>': <%= parameter.name %>,
+<% } -%>
+<% }); -%>
+      },
+<% } -%>
       ...$config,
     });
   },

package/templates/fetch/operation.ejs

@@ -8,7 +8,11 @@ $config?: RequestInit
     const url = `${defaults.baseUrl}<%= it.url %>?<%
     if(it.query && it.query.length > 0) { %>${defaults.paramsSerializer({<%
       it.query.forEach((parameter) => { %>
+<% if (it.queryParamObject) { %>
+'<%= parameter.originalName %>': <%= it.queryParamObject.name %>?.<%= parameter.name %>,
+<% } else { %>
 '<%= parameter.originalName %>': <%= parameter.name %>,
+<% } %>
       <% }); %>})}<% } %>`;
 
 <% if(it.headers && it.headers.length > 0) { %>

package/templates/ng1/operation.ejs

@@ -8,16 +8,24 @@
     let url = `<%= it.url %>?`;
 <% if(it.query && it.query.length > 0) { %>
   <% it.query.forEach((parameter) => { %>
-  if (<%= parameter.name %> !== undefined) {
+  if (<%= it.queryParamObject ? `${it.queryParamObject.name}?.${parameter.name}` : parameter.name %> !== undefined) {
   <% if(!!parameter.original && parameter.original.type === 'array') { %>
-    <%= parameter.name %>.forEach(item => { url += serializeQueryParam(item, '<%= parameter.originalName %>') + "&"; });
+    <%= it.queryParamObject ? `${it.queryParamObject.name}.${parameter.name}` : parameter.name %>.forEach(item => { url += serializeQueryParam(item, '<%= parameter.originalName %>') + "&"; });
   <% } else {%>
-    url += serializeQueryParam(<%= parameter.name %>, '<%= parameter.originalName %>') + "&";
+    url += serializeQueryParam(<%= it.queryParamObject ? `${it.queryParamObject.name}.${parameter.name}` : parameter.name %>, '<%= parameter.originalName %>') + "&";
   <% } %>
   }
   <% }); %>
 <% } %>
 
+<% if(it.headers && it.headers.length > 0) { it.headers.forEach((parameter) => { %>
+<% if (parameter.value) { %>
+    config = { ...config, headers: { ...config?.headers, '<%= parameter.originalName %>': '<%= parameter.value %>' } };
+<% } else { %>
+    if (<%= parameter.name %>) {
+      config = { ...config, headers: { ...config?.headers, '<%= parameter.originalName %>': <%= parameter.name %> } };
+    }
+<% } %><% }); } %>
     return this.$<%= it.method.toLowerCase() %>(
       url,
 <% if(['POST', 'PUT', 'PATCH'].includes(it.method)) { %>