codz-cli 0.0.0-stage → 0.1.0

package/dist/adapters/nextjs.js

@@ -0,0 +1,243 @@
+// Next.js adapter. Supported setup: App Router, TypeScript, fetch (directly
+// or through a shared helper such as apiFetch) or axios (an axios.create
+// instance, or axios itself), optionally with TanStack Query hooks. The Pages
+// Router is detected and reported as not supported yet.
+import { join } from 'node:path';
+import { detectEol, exists, readText, walk, withEol } from "../core/fsutil.js";
+import { ToolError } from "../core/types.js";
+import { fileName, plural, singular } from "../input/naming.js";
+import { referencedModels, resolveModels } from "./models.js";
+import { nextArchitectures, planNextSetup } from "./nextjsSetup.js";
+import { renderQueryHook, splitTsParams } from "./reactQuery.js";
+import { applyTemplate } from "../core/templates.js";
+import { addDefaultImport, addImports, appendBlock, chooseBase, findTsBlock, importPath, renderFunction, renderInterface, resourceOf, styled, tsType } from "./nextjsGen.js";
+import { baseNoExt, dirOf, scan } from "./nextjsScan.js";
+// Other modules import these from here.
+export { findTsBlock, importPath } from "./nextjsGen.js";
+export { stripJsonc } from "./nextjsScan.js";
+export const VERSION = '0.1.0';
+export const NEXT_CONVENTION_DOCS = {
+    templatesFolder: 'folder with custom templates (codz templates list)',
+    appDir: 'App Router folder',
+    apiFolder: 'where API functions live',
+    apiFileNaming: 'file naming in the API folder: kebab, camel, pascal or snake',
+    apiFileSuffix: 'word after the resource in API file names (for example "service"), or empty',
+    apiFileResource: 'resource form in API file names: plural (users.ts) or singular (user.ts)',
+    httpHelper: 'shared request helper to call, or "fetch" to call fetch directly',
+    httpHelperFile: 'file that exports the request helper',
+    baseUrlEnv: 'environment variable that holds the API base URL',
+    modelsFolder: 'where TypeScript interfaces for API data live',
+    modelsLayout: 'per-file (one interface per file) or single (all in modelsFile)',
+    modelsFile: 'the single models file, when modelsLayout is single',
+    modelFileNaming: 'file naming in the models folder',
+    importAlias: 'path alias prefix from tsconfig, for example @/',
+    aliasBase: 'folder the alias points to ("." for the project root)',
+    importStyle: 'how API files import models: alias or relative',
+    quote: 'string quote: single or double',
+    semicolons: 'true or false',
+    indent: 'indentation: 2, 4 or tab',
+    http: 'HTTP client: fetch or axios',
+    axiosInstance: 'axios instance API functions call (axios: the name exported from axiosInstanceFile, or "axios")',
+    axiosInstanceFile: 'file that creates the axios instance with axios.create (axios only)',
+    dataFetching: 'react-query to also write a TanStack Query hook for each endpoint, or none',
+    hooksFolder: 'where the query hooks go (react-query only)',
+    i18n: 'internationalization library, if any',
+    styling: 'styling library, if any',
+};
+async function planEndpoint(ctx, input, overlay, opts = {}) {
+    const { root, map } = ctx;
+    const c = map.conventions;
+    const files = new Map(overlay ?? []);
+    const read = (p) => files.get(p) ?? readText(join(root, p));
+    const summary = [];
+    const warnings = [...input.warnings];
+    const { spec, reused, replaced, notes } = resolveModels(input, map.models, (n) => n, { replace: opts.replaceModels });
+    warnings.push(...notes);
+    // Same endpoint already present?
+    const sameName = map.endpoints.find((e) => e.name === spec.name);
+    if (sameName) {
+        const base0 = chooseBase(spec, map, root);
+        if (sameName.method === spec.method && sameName.path.replace(/\{\w+\}/g, '{}') === base0.path.replace(/\{\w+\}/g, '{}')) {
+            return { files, summary: [`${spec.name} already exists in ${sameName.file}; nothing to do.`], warnings: [], generated: [] };
+        }
+        throw new ToolError('name_conflict', `A function called ${spec.name} already exists in ${sameName.file} for ${sameName.method} ${sameName.path}.`, 'Pass --name <functionName> to use another name.');
+    }
+    const quote = c.quote === 'double' ? '"' : "'";
+    const indent = c.indent === 'tab' ? '\t' : ' '.repeat(Number(c.indent) || 2);
+    const g = { c, style: { quote, semi: c.semicolons !== 'false', indent }, q: quote };
+    // Where each model lives (new or reused).
+    const modelFile = new Map();
+    for (const [name, info] of reused)
+        modelFile.set(name, info.file);
+    for (const m of spec.models) {
+        modelFile.set(m.name, replaced.get(m.name)?.file ?? (c.modelsLayout === 'single' && c.modelsFile ? c.modelsFile : `${c.modelsFolder}/${fileName(m.name, c.modelFileNaming)}.ts`));
+    }
+    // Write models.
+    const newModelFiles = [];
+    for (const m of spec.models) {
+        const file = modelFile.get(m.name);
+        const existing = read(file);
+        let content = existing ?? '';
+        const block = existing ? findTsBlock(existing, m.name) : null;
+        if (block && !replaced.has(m.name))
+            continue;
+        const deps = new Set();
+        for (const f of m.fields)
+            referencedModels(f.type, deps);
+        const byFile = new Map();
+        for (const d of deps) {
+            const df = modelFile.get(d);
+            if (!df || df === file)
+                continue;
+            byFile.set(df, [...(byFile.get(df) ?? []), d]);
+        }
+        const rendered = applyTemplate(root, 'model.ts', styled(renderInterface(m, g), g), { name: m.name }, warnings);
+        content = block ? content.slice(0, block.start) + rendered + content.slice(block.end) : appendBlock(content, rendered);
+        for (const [df, names] of [...byFile.entries()].sort())
+            content = addImports(content, importPath(file, df, { ...c, importStyle: c.modelsLayout === 'single' ? c.importStyle : 'relative' }), names, true, g);
+        if (existing === null)
+            newModelFiles.push(file);
+        files.set(file, existing === null ? content : withEol(content, detectEol(existing)));
+        summary.push(`${existing === null ? 'Create' : 'Update'} ${file}: interface ${m.name}${block ? ' (rewritten)' : ''}`);
+    }
+    // Models barrel file.
+    const modelsIndex = `${c.modelsFolder}/index.ts`;
+    const modelsIndexText = read(modelsIndex);
+    if (modelsIndexText && /export \* from/.test(modelsIndexText)) {
+        let t = modelsIndexText;
+        for (const f of newModelFiles) {
+            const spec2 = `./${baseNoExt(f)}`;
+            if (f === modelsIndex || t.includes(`'${spec2}'`) || t.includes(`"${spec2}"`))
+                continue;
+            t = t.replace(/\s*$/, '\n') + `export * from ${quote}${spec2}${quote}${g.style.semi ? ';' : ''}\n`;
+        }
+        if (t !== modelsIndexText) {
+            files.set(modelsIndex, withEol(t, detectEol(modelsIndexText)));
+            summary.push(`Update ${modelsIndex}: export the new models`);
+        }
+    }
+    // API function file.
+    const resource = spec.resource;
+    const existingForResource = map.endpoints.find((e) => resourceOf(e.path) === resourceOf(spec.path) && dirOf(e.file) === c.apiFolder);
+    let apiFile;
+    if (opts.targetFile) {
+        apiFile = opts.targetFile;
+    }
+    else if (existingForResource) {
+        apiFile = existingForResource.file;
+    }
+    else {
+        const word = c.apiFileResource === 'singular' ? singular(resource) : plural(singular(resource));
+        apiFile = `${c.apiFolder}/${fileName(c.apiFileSuffix ? `${word} ${c.apiFileSuffix}` : word, c.apiFileNaming)}.ts`;
+    }
+    const apiExisting = read(apiFile);
+    if (apiExisting && new RegExp(`(function|const)\\s+${spec.name}\\b`).test(apiExisting)) {
+        throw new ToolError('name_conflict', `${apiFile} already defines ${spec.name}.`, 'Pass --name <functionName> to use another name.');
+    }
+    const base = chooseBase(spec, map, root);
+    warnings.push(...base.warnings);
+    const fnText = styled(renderFunction(spec, base, g), g);
+    const fnParams = new RegExp(`function\\s+${spec.name}\\s*\\(([^)]*)\\)`).exec(fnText)?.[1] ?? '';
+    const fnReturn = fnText.match(/\):\s*Promise<(.+)>\s*\{/)?.[1] ?? '';
+    let apiText = appendBlock(apiExisting ?? '', applyTemplate(root, 'api-function.ts', fnText, { name: spec.name, method: spec.method, path: base.path, params: fnParams, returnType: fnReturn }, warnings));
+    const typeNames = new Set();
+    referencedModels(spec.response, typeNames);
+    referencedModels(spec.request, typeNames);
+    const typesByFile = new Map();
+    for (const t of typeNames) {
+        const f = modelFile.get(t);
+        typesByFile.set(f, [...(typesByFile.get(f) ?? []), t]);
+    }
+    for (const [f, names] of [...typesByFile.entries()].sort())
+        apiText = addImports(apiText, importPath(apiFile, f, c), names, true, g);
+    if (c.http === 'axios') {
+        const inst = c.axiosInstance || 'axios';
+        if (inst === 'axios' || !c.axiosInstanceFile)
+            apiText = addDefaultImport(apiText, 'axios', 'axios', g);
+        else {
+            let p = importPath(apiFile, c.axiosInstanceFile, { ...c, importStyle: 'relative' });
+            if (dirOf(c.axiosInstanceFile) !== dirOf(apiFile))
+                p = importPath(apiFile, c.axiosInstanceFile, c);
+            apiText = inst.startsWith('default:') ? addDefaultImport(apiText, p, inst.slice(8), g) : addImports(apiText, p, [inst], false, g);
+        }
+    }
+    else if (base.kind === 'helper') {
+        let helperPath = importPath(apiFile, c.httpHelperFile, { ...c, importStyle: 'relative' });
+        if (dirOf(c.httpHelperFile) !== dirOf(apiFile))
+            helperPath = importPath(apiFile, c.httpHelperFile, c);
+        apiText = addImports(apiText, helperPath, [c.httpHelper], false, g);
+    }
+    files.set(apiFile, apiExisting === null ? apiText : withEol(apiText, detectEol(apiExisting)));
+    summary.push(`${apiExisting === null ? 'Create' : 'Update'} ${apiFile}: ${spec.name}() for ${spec.method} ${spec.path}`);
+    // API barrel file.
+    if (apiExisting === null) {
+        const apiIndex = `${c.apiFolder}/index.ts`;
+        const indexText = read(apiIndex);
+        if (indexText !== null && /export \* from/.test(indexText)) {
+            const spec2 = `./${baseNoExt(apiFile)}`;
+            if (!indexText.includes(`'${spec2}'`) && !indexText.includes(`"${spec2}"`)) {
+                const t = indexText.replace(/\s*$/, '\n') + `export * from ${quote}${spec2}${quote}${g.style.semi ? ';' : ''}\n`;
+                files.set(apiIndex, withEol(t, detectEol(indexText)));
+                summary.push(`Update ${apiIndex}: export ${spec2}`);
+            }
+        }
+        else if (indexText !== null) {
+            warnings.push(`${apiIndex} does not use "export * from", so the new file was not added to it.`);
+        }
+    }
+    // TanStack Query hook.
+    if (c.dataFetching === 'react-query') {
+        const sig = new RegExp(`export\\s+(?:async\\s+)?function\\s+${spec.name}\\s*\\(([^)]*)\\)`).exec(apiText);
+        const hooksFolder = c.hooksFolder || (c.appDir?.startsWith('src/') ? 'src/hooks' : 'hooks');
+        const fromHook = (hf) => [importPath(hf, apiFile, c), importPath(hf, apiFile, { ...c, importStyle: 'relative' })];
+        const hookFiles = [...new Set([...walk(root, hooksFolder, { exts: ['.ts', '.tsx'] }), ...[...files.keys()].filter((f) => dirOf(f) === hooksFolder)])].sort();
+        let hookFile = hookFiles.find((hf) => fromHook(hf).some((ip) => new RegExp(`from\\s*['"]${ip.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&')}['"]`).test(read(hf) ?? '')));
+        if (!hookFile) {
+            const camelNames = hookFiles.some((hf) => /^use[A-Z]/.test(baseNoExt(hf)));
+            const word = c.apiFileResource === 'singular' ? singular(resourceOf(base.path)) : plural(singular(resourceOf(base.path)));
+            hookFile = `${hooksFolder}/${fileName(`use ${word}`, camelNames ? 'camel' : 'kebab')}.ts`;
+        }
+        const hookExisting = read(hookFile);
+        const hook = renderQueryHook(spec, spec.name, splitTsParams(sig?.[1] ?? ''), resourceOf(base.path), { q: quote, semi: g.style.semi ? ';' : '', indent });
+        if (sig && !new RegExp(`\\b(?:function|const)\\s+${hook.name}\\b`).test(hookExisting ?? '')) {
+            let ht = appendBlock(hookExisting ?? '', hook.code);
+            ht = addImports(ht, '@tanstack/react-query', hook.uses, false, g);
+            ht = addImports(ht, importPath(hookFile, apiFile, c), [spec.name], false, g);
+            const used = [...typesByFile.entries()].map(([f, names]) => [f, names.filter((n) => new RegExp(`\\b${n}\\b`).test(sig[1]))]).filter(([, n]) => n.length);
+            for (const [f, names] of used)
+                ht = addImports(ht, importPath(hookFile, f, c), [...names], true, g);
+            files.set(hookFile, hookExisting === null ? ht : withEol(ht, detectEol(hookExisting)));
+            summary.push(`${hookExisting === null ? 'Create' : 'Update'} ${hookFile}: ${hook.name}() (TanStack Query ${spec.method === 'GET' ? 'query' : 'mutation'})`);
+        }
+    }
+    return {
+        files,
+        summary,
+        warnings,
+        generated: [{ skill: 'api add', file: apiFile, symbol: spec.name, inputHash: '' }],
+        endpoints: [{ name: spec.name, method: spec.method, path: base.path, response: spec.response ? tsType(spec.response) : undefined, file: apiFile, calledFrom: [] }],
+        models: spec.models.map((m) => ({ name: m.name, file: modelFile.get(m.name), fields: m.fields.map((f) => ({ name: f.jsonName, type: tsType(f.type), nullable: f.nullable })) })),
+    };
+}
+export const nextjsAdapter = {
+    id: 'nextjs',
+    version: VERSION,
+    capabilities: { explain: true, apiAdd: true },
+    supportedSetup: 'Next.js App Router, TypeScript, fetch (directly or through a shared helper) or axios, optionally with TanStack Query hooks. Not yet: Pages Router, SWR.',
+    scan,
+    planEndpoint,
+    architectures: nextArchitectures,
+    planSetup: planNextSetup,
+    formatCommand(root, files) {
+        const bin = join(root, 'node_modules', '.bin', process.platform === 'win32' ? 'prettier.cmd' : 'prettier');
+        if (!exists(bin))
+            return null;
+        return { cmd: bin, args: ['--write', ...files] };
+    },
+    verifyCommand(root) {
+        const bin = join(root, 'node_modules', '.bin', process.platform === 'win32' ? 'tsc.cmd' : 'tsc');
+        if (!exists(bin) || !exists(join(root, 'tsconfig.json')))
+            return null;
+        return { cmd: bin, args: ['--noEmit', '-p', 'tsconfig.json', '--pretty', 'false'] };
+    },
+};

package/dist/adapters/nextjsGen.js

@@ -0,0 +1,285 @@
+// Next.js adapter, part 2: writing code (types, interfaces, imports, the API
+// function for each HTTP client style, and where its base URL comes from).
+import { commentText, jsString, jsTemplateText } from "../core/safe.js";
+import { join, posix } from 'node:path';
+import { readText } from "../core/fsutil.js";
+import {} from "../core/types.js";
+import { specRelativePath } from "./common.js";
+import { matchBrace } from "./source.js";
+import { dirOf } from "./nextjsScan.js";
+export function tsType(t) {
+    if (!t)
+        return 'unknown';
+    switch (t.kind) {
+        case 'string':
+        case 'date':
+            return 'string';
+        case 'int':
+        case 'double':
+            return 'number';
+        case 'bool':
+            return 'boolean';
+        case 'unknown':
+            return 'unknown';
+        case 'object':
+            return t.model;
+        case 'array': {
+            const inner = tsType(t.item);
+            return /[\s|]/.test(inner) ? `(${inner})[]` : `${inner}[]`;
+        }
+    }
+}
+export const IDENT = /^[A-Za-z_$][\w$]*$/;
+export function propKey(key, q) {
+    return IDENT.test(key) ? key : jsString(key, q);
+}
+/** Applies the project's semicolon and indent style to generated text (written with 2 spaces and semicolons). */
+export function styled(code, g) {
+    return code
+        .split('\n')
+        .map((line) => {
+        let l = line;
+        if (!g.style.semi)
+            l = l.replace(/;(\s*)$/, '$1');
+        const m = l.match(/^( +)/);
+        if (m && g.style.indent !== '  ')
+            l = g.style.indent.repeat(m[1].length / 2) + l.slice(m[1].length);
+        return l;
+    })
+        .join('\n');
+}
+export function renderInterface(m, g) {
+    const lines = [`export interface ${m.name} {`];
+    for (const f of m.fields) {
+        if (f.type.kind === 'date')
+            lines.push(`  /** ISO 8601 date string. */`);
+        if (f.type.kind === 'unknown' || (f.type.kind === 'array' && f.type.item.kind === 'unknown'))
+            lines.push(`  // codz: type unknown from the samples; set it by hand.`);
+        const t = tsType(f.type);
+        lines.push(`  ${propKey(f.jsonName, g.q)}${f.nullable ? '?' : ''}: ${f.nullable && t !== 'unknown' ? `${t} | null` : t};`);
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+export function importPath(fromFile, toFile, c) {
+    const toNoExt = toFile.replace(/\.(tsx?|jsx?|mjs)$/, '').replace(/\/index$/, '');
+    const base = c.aliasBase === '.' ? '' : c.aliasBase + '/';
+    if (c.importStyle === 'alias' && c.importAlias && (base === '' || toNoExt.startsWith(base))) {
+        return c.importAlias + toNoExt.slice(base.length);
+    }
+    let r = posix.relative(dirOf(fromFile), toNoExt);
+    if (!r.startsWith('.'))
+        r = `./${r}`;
+    return r;
+}
+/** Adds named imports to a file, merging into an existing import from the same path. */
+export function addImports(text, path, names, typeOnly, g) {
+    if (!names.length)
+        return text;
+    const q = g.q;
+    const esc = path.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+    const existing = new RegExp(`import\\s+${typeOnly ? 'type\\s+' : ''}\\{([^}]*)\\}\\s*from\\s*['"]${esc}['"];?`).exec(text);
+    if (existing) {
+        const have = existing[1].split(',').map((s) => s.trim()).filter(Boolean);
+        const merged = [...new Set([...have, ...names])].sort();
+        if (merged.length === have.length)
+            return text;
+        const line = `import ${typeOnly ? 'type ' : ''}{ ${merged.join(', ')} } from ${q}${path}${q}${g.style.semi ? ';' : ''}`;
+        return text.slice(0, existing.index) + line + text.slice(existing.index + existing[0].length);
+    }
+    const line = `import ${typeOnly ? 'type ' : ''}{ ${[...names].sort().join(', ')} } from ${q}${path}${q}${g.style.semi ? ';' : ''}`;
+    const imports = [...text.matchAll(/^import[\s\S]*?from\s*['"][^'"]+['"];?[ \t]*$/gm)];
+    if (imports.length) {
+        const last = imports[imports.length - 1];
+        const at = last.index + last[0].length;
+        return `${text.slice(0, at)}\n${line}${text.slice(at)}`;
+    }
+    return text.length ? `${line}\n\n${text}` : `${line}\n`;
+}
+/** Adds `import name from 'path'` unless the file already imports that default. */
+export function addDefaultImport(text, path, name, g) {
+    const esc = path.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+    if (new RegExp(`import\\s+${name}\\b[^;\\n]*from\\s*['"]${esc}['"]`).test(text))
+        return text;
+    const line = `import ${name} from ${g.q}${path}${g.q}${g.style.semi ? ';' : ''}`;
+    const imports = [...text.matchAll(/^import[\s\S]*?from\s*['"][^'"]+['"];?[ \t]*$/gm)];
+    if (imports.length)
+        return `${line}\n${text}`;
+    return text.length ? `${line}\n\n${text}` : `${line}\n`;
+}
+/** Finds `export interface Name {...}` or `export type Name = {...};` (with a doc comment above it). */
+export function findTsBlock(text, name) {
+    const m = new RegExp(`(^|\\n)((?:[ \\t]*(?:/\\*\\*(?:(?!\\*/)[^])*\\*/|//[^\\n]*)\\n)*)[ \\t]*export\\s+(?:interface\\s+${name}\\b[^{]*|type\\s+${name}\\b[^=]*=\\s*)\\{`).exec(text);
+    if (!m)
+        return null;
+    const open = m.index + m[0].length - 1;
+    const close = matchBrace(text, open);
+    if (close === -1)
+        return null;
+    let end = close + 1;
+    if (text[end] === ';')
+        end++;
+    return { start: m.index + m[1].length, end };
+}
+export function appendBlock(text, block) {
+    if (!text.trim())
+        return block + '\n';
+    return text.replace(/\s*$/, '') + '\n\n' + block + '\n';
+}
+export function chooseBase(input, map, root = '.') {
+    const c = map.conventions;
+    const warnings = [];
+    // An endpoint from an API spec goes relative to the project's base URL when there is one: the spec's
+    // server (https://api.example.com/v1) is a stand-in for it, usually another environment.
+    const usesHelper = (c.http === 'axios' && !!c.axiosInstanceFile && /\bbaseURL\s*:/.test(readText(join(root, c.axiosInstanceFile)) ?? '')) || (c.http !== 'axios' && !!c.httpHelper && c.httpHelper !== 'fetch');
+    const projectBase = map.baseUrls.find((b) => b.name === c.baseUrlEnv)?.value ?? map.baseUrls[0]?.value;
+    const fromSpec = specRelativePath(input, projectBase);
+    const spec = fromSpec !== null && (usesHelper || projectBase || c.baseUrlEnv) ? { ...input, origin: '', path: fromSpec } : input;
+    const prefixOf = (value) => {
+        try {
+            return new URL(value).pathname.replace(/\/$/, '');
+        }
+        catch {
+            return '';
+        }
+    };
+    const originOf = (value) => {
+        try {
+            return new URL(value).origin;
+        }
+        catch {
+            return '';
+        }
+    };
+    const candidates = map.baseUrls.filter((b) => !spec.origin || originOf(b.value) === spec.origin);
+    const matched = candidates.find((b) => b.name === c.baseUrlEnv && spec.path.startsWith(prefixOf(b.value))) ?? candidates.find((b) => spec.path.startsWith(prefixOf(b.value)));
+    const path = matched ? spec.path.slice(prefixOf(matched.value).length) || '/' : spec.path;
+    if (spec.origin && !matched) {
+        const known = map.baseUrls.map((b) => `${b.name}=${b.value}`).join(', ');
+        if (known)
+            warnings.push(`The URL host ${spec.origin} does not match any configured base URL (${known}).`);
+    }
+    if (c.http === 'axios' && c.axiosInstanceFile && /\bbaseURL\s*:/.test(readText(join(root, c.axiosInstanceFile)) ?? '')) {
+        if (spec.origin && !matched && warnings.length)
+            warnings[warnings.length - 1] += ` The call goes through the ${c.axiosInstance.replace(/^default:/, '')} axios instance, which uses its own baseURL; check that this endpoint lives on the same server.`;
+        return { kind: 'helper', path, warnings };
+    }
+    if (c.http !== 'axios' && c.httpHelper && c.httpHelper !== 'fetch') {
+        if (spec.origin && !matched)
+            warnings[warnings.length - 1] += ` The call goes through ${c.httpHelper}, which uses its own base URL; check that this endpoint lives on the same server.`;
+        return { kind: 'helper', path, warnings };
+    }
+    if (matched && /^\w+$/.test(matched.name))
+        return { kind: 'env', env: matched.name, path, warnings };
+    if (c.baseUrlEnv && /^\w+$/.test(c.baseUrlEnv))
+        return { kind: 'env', env: c.baseUrlEnv, path, warnings };
+    if (spec.origin) {
+        warnings.push(`No base URL setting was found, so the host ${spec.origin} is written into the code. Consider moving it to an environment variable.`);
+        return { kind: 'literal', origin: spec.origin, path, warnings };
+    }
+    return { kind: 'literal', origin: '', path, warnings };
+}
+export function renderFunction(spec, base, g) {
+    const q = g.q;
+    const params = spec.pathParams.map((p) => `${p.name}: ${p.type === 'int' ? 'number' : 'string'}`);
+    if (spec.request)
+        params.push(`body: ${tsType(spec.request)}`);
+    if (spec.queryParams.length) {
+        params.push(`params?: { ${spec.queryParams.map((p) => `${propKey(p.name, q)}?: ${tsType(p.type)}`).join('; ')} }`);
+    }
+    const hasResponse = !!spec.response && spec.method !== 'DELETE' && spec.method !== 'HEAD';
+    const resultType = hasResponse ? tsType(spec.response) : spec.method === 'DELETE' || spec.method === 'HEAD' ? 'void' : 'unknown';
+    // Literal text is escaped for a template literal; only {param} placeholders become ${param}.
+    const pathExpr = base.path.split(/(\{\w+\})/).map((part) => (/^\{\w+\}$/.test(part) ? `\${${part.slice(1, -1)}}` : jsTemplateText(part))).join('');
+    const lines = [];
+    lines.push(`/** ${spec.method} ${commentText(spec.path)} */`);
+    const needsQuery = spec.queryParams.length > 0;
+    const urlTail = needsQuery ? '${queryString ? `?${queryString}` : \'\'}'.replace(/'/g, q) : '';
+    const queryLines = needsQuery
+        ? [
+            '  const searchParams = new URLSearchParams();',
+            ...spec.queryParams.map((p) => {
+                const check = IDENT.test(p.name) ? `params?.${p.name}` : `params?.[${jsString(p.name, q)}]`;
+                const access = IDENT.test(p.name) ? `params.${p.name}` : `params[${jsString(p.name, q)}]`;
+                return `  if (${check} !== undefined) searchParams.set(${jsString(p.name, q)}, String(${access}));`;
+            }),
+            '  const queryString = searchParams.toString();',
+        ]
+        : [];
+    if (g.c.http === 'axios') {
+        // axios serializes params (skipping undefined) and parses JSON itself.
+        const client = (g.c.axiosInstance || 'axios').replace(/^default:/, '');
+        const prefix = base.kind === 'env' ? `\${process.env.${base.env}}` : base.kind === 'literal' ? jsTemplateText(base.origin ?? '') : '';
+        const genericType = spec.unwrapData ? `{ data: ${resultType} }` : resultType;
+        const verb = spec.method.toLowerCase();
+        const config = needsQuery ? '{ params }' : '';
+        const withBody = ['post', 'put', 'patch'].includes(verb);
+        const args = [`\`${prefix}${pathExpr}\``];
+        if (withBody)
+            args.push(spec.request ? 'body' : config ? 'undefined' : '');
+        if (config)
+            args.push(config);
+        const callArgs = args.filter((a, i) => a !== '' || i === 0).join(', ');
+        lines.push(`export async function ${spec.name}(${params.join(', ')}): Promise<${resultType}> {`);
+        if (resultType === 'void')
+            lines.push(`  await ${client}.${verb}(${callArgs});`);
+        else {
+            lines.push(`  const res = await ${client}.${verb}<${genericType}>(${callArgs});`);
+            lines.push(spec.unwrapData ? '  return res.data.data;' : '  return res.data;');
+        }
+        lines.push('}');
+        return lines.join('\n');
+    }
+    const init = [];
+    if (spec.method !== 'GET')
+        init.push(`method: ${q}${spec.method}${q}`);
+    if (spec.request)
+        init.push('body: JSON.stringify(body)');
+    if (base.kind === 'helper') {
+        const helper = g.c.httpHelper;
+        const genericType = spec.unwrapData ? `{ data: ${resultType} }` : resultType;
+        const call = `${helper}<${genericType}>(\`${pathExpr}${urlTail}\`${init.length ? `, { ${init.join(', ')} }` : ''})`;
+        if (!needsQuery && !spec.unwrapData) {
+            lines.push(`export function ${spec.name}(${params.join(', ')}): Promise<${resultType}> {`);
+            lines.push(`  return ${call};`);
+        }
+        else {
+            lines.push(`export async function ${spec.name}(${params.join(', ')}): Promise<${resultType}> {`);
+            lines.push(...queryLines);
+            if (spec.unwrapData) {
+                lines.push(`  const res = await ${call};`);
+                lines.push('  return res.data;');
+            }
+            else {
+                lines.push(`  return ${call};`);
+            }
+        }
+        lines.push('}');
+        return lines.join('\n');
+    }
+    const prefix = base.kind === 'env' ? `\${process.env.${base.env}}` : jsTemplateText(base.origin ?? '');
+    const headers = spec.request ? [`headers: { ${q}Content-Type${q}: ${q}application/json${q} }`] : [];
+    const fetchInit = [`method: ${q}${spec.method}${q}`, ...headers, ...(spec.request ? ['body: JSON.stringify(body)'] : [])];
+    lines.push(`export async function ${spec.name}(${params.join(', ')}): Promise<${resultType}> {`);
+    lines.push(...queryLines);
+    lines.push(`  const res = await fetch(\`${prefix}${pathExpr}${urlTail}\`, {`);
+    for (const f of fetchInit)
+        lines.push(`    ${f},`);
+    lines.push('  });');
+    lines.push(`  if (!res.ok) throw new Error(\`${spec.name} failed: \${res.status}\`);`);
+    if (resultType === 'void') {
+        // Nothing to parse.
+    }
+    else if (spec.unwrapData) {
+        lines.push(`  const json = (await res.json()) as { data: ${resultType} };`);
+        lines.push('  return json.data;');
+    }
+    else {
+        lines.push(`  return (await res.json()) as ${resultType};`);
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+export const resourceOf = (path) => path
+    .split('/')
+    .filter((s) => s && !s.startsWith('{') && !/^(api|v\d+(\.\d+)?|rest)$/i.test(s))[0] ?? 'root';