@itzworking/devkit 0.0.198-canary.20250707-e7f7621

package/dist-es/generate-api-clients/generate-api-client-class.js

@@ -0,0 +1,156 @@
+import { prepareImports, toClassName, toPropertyName } from "./utils";
+import Handlebars from "handlebars";
+import { loadTemplate } from "./template-loader";
+const pathWithQuotes = (apiPath) => {
+    return `${apiPath.includes("{") ? "`" : '"'}${apiPath}${apiPath.includes("{") ? "`" : '"'}`.replace(/{/g, "${");
+};
+Handlebars.registerHelper("pathWithQuotes", pathWithQuotes);
+const prepareMethods = (apis) => {
+    const methods = [];
+    for (const api of apis) {
+        const pathParams = (api.fullPath.match(/\{[^}]+}/g) || []).map((p) => p.replace(/[{}]/g, ""));
+        let params = "";
+        if (api.method === "GET") {
+            if (pathParams.length > 0) {
+                params += pathParams.map((p) => `${p}: string`).join(", ");
+            }
+            if (api.inputType) {
+                if (params)
+                    params += ", ";
+                params += `body: ${api.inputType}`;
+            }
+        }
+        else {
+            if (pathParams.length > 0 || api.inputType) {
+                params += "{ ";
+                if (pathParams.length > 0) {
+                    params += pathParams.join(", ") + (api.inputType ? ", " : "");
+                }
+                if (api.inputType) {
+                    params += `body`;
+                }
+                params += " }: { ";
+                if (pathParams.length > 0) {
+                    params +=
+                        pathParams.map((p) => `${p}: string`).join(", ") +
+                            (api.inputType ? ", " : "");
+                }
+                if (api.inputType) {
+                    params += `body: ${api.inputType.typeName}`;
+                }
+                params += " }";
+            }
+        }
+        methods.push({
+            name: toPropertyName(api.actionName),
+            params,
+            returnType: api.outputType ? api.outputType.typeName : "void",
+            method: api.method.toLowerCase(),
+            fullPath: api.fullPath,
+            inputType: api.inputType,
+            outputType: api.outputType,
+        });
+    }
+    return methods;
+};
+const prepareTypeImports = (apis) => {
+    const imports = [];
+    for (const api of apis) {
+        const typeSpecs = [api.inputType, api.outputType];
+        for (const typeSpec of typeSpecs) {
+            if (!typeSpec || !typeSpec.importPath)
+                continue;
+            for (const allowedImport of typeSpec.typeDefinition.allowedImports) {
+                let currentImport = imports.find((i) => i.importPath === allowedImport.importPath);
+                if (!currentImport) {
+                    currentImport = {
+                        importPath: allowedImport.importPath,
+                        importNames: new Set(),
+                    };
+                    imports.push(currentImport);
+                }
+                if (allowedImport.namespaceImport) {
+                    const namespaceNames = allowedImport.importNames;
+                    const conflictingNamespaceNames = [];
+                    if (namespaceNames.length > 1) {
+                        conflictingNamespaceNames.push(...namespaceNames);
+                    }
+                    if (currentImport.namespaceImport &&
+                        currentImport.namespaceImport !== namespaceNames[0]) {
+                        conflictingNamespaceNames.push(currentImport.namespaceImport);
+                        conflictingNamespaceNames.push(...namespaceNames);
+                    }
+                    if (conflictingNamespaceNames.length > 0) {
+                        throw new Error(`Conflicting namespace imports found for module "${allowedImport.importPath}": ` +
+                            `[${conflictingNamespaceNames.join(", ")}]. ` +
+                            `All namespace imports from the same module must use the same name. ` +
+                            `Please consolidate to use a single namespace import: import * as [name] from "${allowedImport.importPath}"`);
+                    }
+                    const namespaceName = namespaceNames[0];
+                    const conflictingImport = imports.find((imp) => imp.importPath !== allowedImport.importPath &&
+                        imp.namespaceImport === namespaceName);
+                    if (conflictingImport) {
+                        throw new Error(`Namespace name "${namespaceName}" is used by imports from: ` +
+                            `"${conflictingImport.importPath}" and "${allowedImport.importPath}". ` +
+                            `Cannot use the same namespace name for different modules. ` +
+                            `Please use a different namespace name for one of the imports.`);
+                    }
+                    currentImport.namespaceImport = namespaceName;
+                }
+                else {
+                    for (const importName of allowedImport.importNames) {
+                        currentImport.importNames.add(importName);
+                    }
+                }
+            }
+        }
+    }
+    return imports.map((i) => ({
+        namespaceImport: i.namespaceImport,
+        importPath: i.importPath,
+        importNames: Array.from(i.importNames).sort(),
+    }));
+};
+export const generateApiClientClass = ({ basePath, apis, }, options) => {
+    const className = toClassName(basePath) + "Api";
+    const imports = prepareImports(apis, options);
+    const methods = prepareMethods(apis);
+    const templateSource = loadTemplate("api-client.hbs");
+    const template = Handlebars.compile(templateSource);
+    let apiTypesFile = "";
+    if (options.typeResolutionMode === "inline-types") {
+        const typeImports = prepareTypeImports(apis);
+        for (const typeImport of typeImports) {
+            if (typeImport.namespaceImport) {
+                apiTypesFile += `import * as ${typeImport.namespaceImport} from "${typeImport.importPath}";\n`;
+            }
+            if (typeImport.importNames.length > 0) {
+                apiTypesFile += `import { ${typeImport.importNames.join(", ")} } from "${typeImport.importPath}";\n`;
+            }
+        }
+        const inlinedFilePaths = new Set();
+        for (const api of apis) {
+            const typeSpecs = [api.inputType, api.outputType];
+            for (const typeSpec of typeSpecs) {
+                if (!typeSpec || !typeSpec.importPath)
+                    continue;
+                for (const inlinedFile of typeSpec.typeDefinition.inlinedFiles) {
+                    if (inlinedFilePaths.has(inlinedFile.filePath)) {
+                        continue;
+                    }
+                    inlinedFilePaths.add(inlinedFile.filePath);
+                    apiTypesFile += "\n\n";
+                    apiTypesFile += inlinedFile.text;
+                }
+            }
+        }
+    }
+    return {
+        apiClientClassFile: template({
+            className,
+            imports,
+            methods,
+        }),
+        apiTypesFile,
+    };
+};

package/dist-es/generate-api-clients/generate-api-clients.js

@@ -0,0 +1,65 @@
+import { getITzWorkingResources, toFileName, writeFile } from "./utils";
+import { parseDiscoveredApis } from "./parse-discovered-apis";
+import fs from "fs";
+import path from "path";
+import { generateApiClientClass } from "./generate-api-client-class";
+import { generateHook } from "./generate-hook";
+import { copyApiClient } from "./copy-api-client";
+export const generateApiClients = async (options = {}) => {
+    const { tsConfigPath = "tsconfig.json", targetTypeSystem = "preserve-backend", typeResolutionMode = "source-imports", verbose = false, allowOverwrite = false, cleanOutputDir = false, outputDirectory = "out/apis", resourcesFilePath = "cdk.itzworking.json", } = options;
+    if (targetTypeSystem !== "preserve-backend") {
+        console.error(`Unsupported targetTypeSystem: ${targetTypeSystem}. Only 'preserve-backend' is supported.`);
+        process.exit(1);
+    }
+    const resources = getITzWorkingResources({ resourcesFilePath, verbose });
+    const apisByBasePath = parseDiscoveredApis(resources, {
+        tsConfigPath,
+        typeResolutionMode,
+        verbose,
+    });
+    if (cleanOutputDir) {
+        fs.rmSync(outputDirectory, { recursive: true, force: true });
+    }
+    copyApiClient({ outputDirectory, allowOverwrite, verbose });
+    for (const [basePath, apis] of Object.entries(apisByBasePath)) {
+        writeFile({
+            filePath: path.join(outputDirectory, toFileName(basePath), "index.ts"),
+            content: `export * from "./${toFileName(basePath)}-api";`,
+            allowOverwrite,
+            verbose,
+        });
+        const { apiClientClassFile, apiTypesFile } = generateApiClientClass({ basePath, apis }, {
+            typeResolutionMode,
+            verbose,
+        });
+        writeFile({
+            filePath: path.join(outputDirectory, toFileName(basePath), `${toFileName(basePath)}-api.ts`),
+            content: apiClientClassFile.replace(/^[\s\S]*?(?=import)/m, ""),
+            allowOverwrite,
+            verbose,
+        });
+        if (apiTypesFile) {
+            writeFile({
+                filePath: path.join(outputDirectory, toFileName(basePath), `types.ts`),
+                content: apiTypesFile,
+                allowOverwrite,
+                verbose,
+            });
+            fs.appendFileSync(path.join(outputDirectory, toFileName(basePath), "index.ts"), `\nexport * from "./types";`);
+        }
+    }
+    for (const [basePath, apis] of Object.entries(apisByBasePath)) {
+        for (const api of apis) {
+            const { hookName, hookFile } = generateHook({ basePath, api }, {
+                typeResolutionMode,
+                verbose,
+            });
+            writeFile({
+                filePath: path.join(outputDirectory, toFileName(basePath), "hooks", `${toFileName(hookName)}.ts`),
+                content: hookFile.replace(/^[\s\S]*?(?=import)/m, ""),
+                allowOverwrite,
+                verbose,
+            });
+        }
+    }
+};

package/dist-es/generate-api-clients/generate-hook.js

@@ -0,0 +1,66 @@
+import { prepareImports, toClassName, toFileName, toPropertyName, } from "./utils";
+import Handlebars from "handlebars";
+import { loadTemplate } from "./template-loader";
+export const generateHook = ({ basePath, api, }, options) => {
+    const apiClassName = toClassName(basePath) + "Api";
+    const actionName = toPropertyName(api.actionName);
+    const actionClassName = toClassName(api.actionName);
+    const hookName = `use${actionClassName}`;
+    const pathParams = (api.fullPath.match(/\{[^}]+}/g) || []).map((p) => p.replace(/[{}]/g, ""));
+    let mutationParams = "";
+    if (api.method !== "GET") {
+        if (pathParams.length > 0 || api.inputType) {
+            mutationParams += "variables: {\n";
+            if (pathParams.length > 0) {
+                mutationParams +=
+                    pathParams.map((p) => `      ${p}: string`).join(",\n") +
+                        (api.inputType ? ",\n" : "");
+            }
+            if (api.inputType) {
+                mutationParams += `      body: ${api.inputType.typeName}`;
+            }
+            mutationParams += "\n    }";
+        }
+    }
+    let queryKeyParams = "";
+    let queryKeyArray = "";
+    let queryKeyInput = "";
+    if (api.method === "GET") {
+        if (pathParams.length > 0) {
+            queryKeyParams = pathParams.map((p) => `${p}: string`).join(", ");
+            queryKeyInput = pathParams.map((p) => `${p}`).join(", ");
+        }
+        queryKeyArray = api.fullPath
+            .split("/")
+            .filter(Boolean)
+            .map((p) => {
+            if (p.startsWith("{") && p.endsWith("}")) {
+                return "  `$" + `${p}` + "`";
+            }
+            return `  "${p}"`;
+        })
+            .join(",\n");
+    }
+    const imports = [
+        { path: `../${toFileName(apiClassName)}`, names: apiClassName },
+        ...prepareImports(api, options).map((i) => i.path === "./types" ? { path: "../types", names: i.names } : i),
+    ];
+    const data = {
+        imports,
+        hookName,
+        mutationParams,
+        apiClassName,
+        actionName,
+        actionClassName,
+        relatedDataName: toPropertyName(api.relatedDataName),
+        queryKeyParams,
+        queryKeyArray,
+        queryKeyInput,
+        outputType: api.outputType,
+    };
+    const templateFile = api.method === "GET" ? "hook-query.hbs" : "hook-mutation.hbs";
+    const templateSource = loadTemplate(templateFile);
+    const template = Handlebars.compile(templateSource);
+    const hookFile = template(data);
+    return { hookName, hookFile };
+};

package/dist-es/generate-api-clients/handlebars-helpers.js

@@ -0,0 +1,9 @@
+import Handlebars from "handlebars";
+export const handlebarsHelpers = () => {
+    Handlebars.registerHelper("eq", function (a, b) {
+        return a === b;
+    });
+    Handlebars.registerHelper("lowercase", function (str) {
+        return typeof str === "string" ? str.toLowerCase() : str;
+    });
+};

package/dist-es/generate-api-clients/index.js

@@ -0,0 +1 @@
+export * from "./generate-api-clients";

package/dist-es/generate-api-clients/parse-discovered-apis.js

@@ -0,0 +1,120 @@
+import { Project, SyntaxKind } from "ts-morph";
+import * as path from "path";
+import { extractTypeDefinition, setTypeKind } from "./api-type-spec-utils";
+const INPUT_DECORATOR_NAME = "LambdaInput";
+const OUTPUT_DECORATOR_NAME = "LambdaOutput";
+export const parseDiscoveredApis = (resources, options) => {
+    const parsedApis = {};
+    const project = new Project({
+        tsConfigFilePath: options.tsConfigPath,
+        skipAddingFilesFromTsConfig: true,
+    });
+    for (const stackResources of Object.values(resources.discoveredResources)) {
+        for (const api of stackResources.apis) {
+            const method = api.id.split("--")[0];
+            const fullPath = "/" + api.id.split("--").slice(1).join("/");
+            const basePath = fullPath.split("/")[1];
+            const handlerPath = path.join(api.folderPath, "handler.ts");
+            const sourceFile = project.addSourceFileAtPathIfExists(handlerPath);
+            if (!sourceFile)
+                continue;
+            const handlerVar = sourceFile.getVariableDeclaration("handler");
+            if (!handlerVar)
+                continue;
+            const initializer = handlerVar.getInitializer();
+            let className = null;
+            if (initializer && initializer.getKind() === SyntaxKind.CallExpression) {
+                const callExpr = initializer.asKind(SyntaxKind.CallExpression);
+                if (callExpr) {
+                    const expr = callExpr.getExpression();
+                    const exprText = expr.getText();
+                    className = exprText.split(".")[0];
+                }
+            }
+            if (!className)
+                continue;
+            const actionName = className.replace(/Lambda|lambda|Handler|handler/g, "");
+            const relatedDataName = actionName.replace(/^[A-Z][a-z]*/, "");
+            const classDecl = sourceFile.getClass(className);
+            if (!classDecl)
+                continue;
+            let inputTypeName = null;
+            let outputTypeName = null;
+            for (const decorator of classDecl.getDecorators()) {
+                const name = decorator.getName();
+                const args = decorator.getArguments();
+                if (name === INPUT_DECORATOR_NAME && args.length > 0) {
+                    inputTypeName = args[0].getText().replace(/\W/g, "");
+                }
+                if (name === OUTPUT_DECORATOR_NAME && args.length > 0) {
+                    outputTypeName = args[0].getText().replace(/\W/g, "");
+                }
+            }
+            const imports = {};
+            let inputImportPath = null;
+            let outputImportPath = null;
+            for (const importDecl of sourceFile.getImportDeclarations()) {
+                const namedImports = importDecl.getNamedImports();
+                for (const namedImport of namedImports) {
+                    const importName = namedImport.getName();
+                    const importPath = importDecl.getModuleSpecifierValue();
+                    if (inputTypeName && importName === inputTypeName) {
+                        inputImportPath = importPath;
+                        if (!imports[importPath])
+                            imports[importPath] = [];
+                        imports[importPath].push(importName);
+                    }
+                    if (outputTypeName && importName === outputTypeName) {
+                        outputImportPath = importPath;
+                        if (!imports[importPath])
+                            imports[importPath] = [];
+                        imports[importPath].push(importName);
+                    }
+                }
+            }
+            const inputType = inputTypeName
+                ? {
+                    typeName: inputTypeName,
+                    importPath: inputImportPath,
+                    typeDefinition: {
+                        allowedImports: [],
+                        inlinedFiles: [],
+                    },
+                    structure: null,
+                    kind: "unknown",
+                }
+                : null;
+            const outputType = outputTypeName
+                ? {
+                    typeName: outputTypeName,
+                    importPath: outputImportPath,
+                    typeDefinition: {
+                        allowedImports: [],
+                        inlinedFiles: [],
+                    },
+                    structure: null,
+                    kind: "unknown",
+                }
+                : null;
+            setTypeKind(inputType, sourceFile);
+            setTypeKind(outputType, sourceFile);
+            if (options.typeResolutionMode === "inline-types") {
+                extractTypeDefinition(inputType, sourceFile);
+                extractTypeDefinition(outputType, sourceFile);
+            }
+            if (!parsedApis[basePath]) {
+                parsedApis[basePath] = [];
+            }
+            parsedApis[basePath].push({
+                fullPath,
+                method,
+                actionName,
+                relatedDataName,
+                inputType,
+                outputType,
+                imports,
+            });
+        }
+    }
+    return parsedApis;
+};

package/dist-es/generate-api-clients/sync-api-clients.js

@@ -0,0 +1,79 @@
+import * as fs from "fs";
+import * as path from "path";
+export const syncApiClients = (webappDataPath) => {
+    const sourceDir = path.join(__dirname, "out", "apis");
+    const targetDir = path.join(webappDataPath, "apis");
+    if (!fs.existsSync(sourceDir)) {
+        throw new Error(`Source directory not found: ${sourceDir}`);
+    }
+    if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+    }
+    const getHooks = (dir) => {
+        const hooks = [];
+        const services = fs
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((dirent) => dirent.isDirectory() && dirent.name !== "node_modules");
+        for (const service of services) {
+            const hooksPath = path.join(dir, service.name, "hooks");
+            if (fs.existsSync(hooksPath)) {
+                const hookFiles = fs
+                    .readdirSync(hooksPath)
+                    .filter((file) => file.endsWith(".ts") && file !== "index.ts");
+                for (const hookFile of hookFiles) {
+                    hooks.push({
+                        service: service.name,
+                        name: hookFile.replace(".ts", ""),
+                        fullPath: path.join(hooksPath, hookFile),
+                    });
+                }
+            }
+        }
+        return hooks;
+    };
+    const existingHooks = getHooks(targetDir);
+    const newHooks = getHooks(sourceDir);
+    const addedHooks = newHooks.filter((newHook) => !existingHooks.some((existingHook) => existingHook.service === newHook.service &&
+        existingHook.name === newHook.name));
+    const removedHooks = existingHooks.filter((existingHook) => !newHooks.some((newHook) => newHook.service === existingHook.service &&
+        newHook.name === existingHook.name));
+    console.log("Hook changes:");
+    if (addedHooks.length === 0 && removedHooks.length === 0) {
+        console.log("No changes detected.");
+    }
+    addedHooks.forEach((hook) => console.log(`+ ${hook.service}/${hook.name}`));
+    removedHooks.forEach((hook) => console.log(`- ${hook.service}/${hook.name}`));
+    fs.copyFileSync(path.join(sourceDir, "api-client.ts"), path.join(targetDir, "api-client.ts"));
+    const services = fs
+        .readdirSync(sourceDir, { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory());
+    const mainIndexContent = services
+        .map((service) => `export * from "./${service.name}";`)
+        .join("\n");
+    fs.writeFileSync(path.join(targetDir, "index.ts"), mainIndexContent);
+    for (const service of services) {
+        const sourceServiceDir = path.join(sourceDir, service.name);
+        const targetServiceDir = path.join(targetDir, service.name);
+        if (!fs.existsSync(targetServiceDir)) {
+            fs.mkdirSync(targetServiceDir, { recursive: true });
+        }
+        fs.copyFileSync(path.join(sourceServiceDir, `${service.name}-api.ts`), path.join(targetServiceDir, `${service.name}-api.ts`));
+        fs.copyFileSync(path.join(sourceServiceDir, "index.ts"), path.join(targetServiceDir, "index.ts"));
+        const targetHooksDir = path.join(targetServiceDir, "hooks");
+        if (!fs.existsSync(targetHooksDir)) {
+            fs.mkdirSync(targetHooksDir, { recursive: true });
+        }
+        const serviceHooks = [...addedHooks, ...existingHooks].filter((hook) => hook.service === service.name);
+        for (const hook of serviceHooks) {
+            const targetHookPath = path.join(targetHooksDir, `${hook.name}.ts`);
+            if (!fs.existsSync(targetHookPath)) {
+                fs.copyFileSync(hook.fullPath, targetHookPath);
+            }
+        }
+        const hooksIndexContent = serviceHooks
+            .map((hook) => `export * from "./${hook.name}";`)
+            .sort()
+            .join("\n") + "\n";
+        fs.writeFileSync(path.join(targetHooksDir, "index.ts"), hooksIndexContent);
+    }
+};

package/dist-es/generate-api-clients/template-loader.js

@@ -0,0 +1,20 @@
+import * as fs from "fs";
+import * as path from "path";
+export function loadTemplate(templateName) {
+    const possiblePaths = [
+        path.join(__dirname, "templates", templateName),
+        path.join(__dirname, "templates", templateName),
+        path.join(process.cwd(), "node_modules", "@itzworking", "devkit", "dist-cjs", "generate-api-clients", "templates", templateName),
+        path.join(process.cwd(), "node_modules", "@itzworking", "devkit", "dist-es", "generate-api-clients", "templates", templateName),
+    ];
+    for (const templatePath of possiblePaths) {
+        try {
+            if (fs.existsSync(templatePath)) {
+                return fs.readFileSync(templatePath, "utf8");
+            }
+        }
+        catch (error) {
+        }
+    }
+    throw new Error(`Template not found: ${templateName}. Tried paths: ${possiblePaths.join(", ")}`);
+}

package/dist-es/generate-api-clients/templates/api-client.hbs

@@ -0,0 +1,25 @@
+// prettier-ignore
+/* eslint-disable */
+
+import { ApiClientClass } from "../api-client";
+{{#each imports}}
+import { {{names}} } from "{{path}}";
+{{/each}}
+
+class {{className}}Class extends ApiClientClass {
+{{#each methods}}
+  async {{name}}({{params}}): Promise<{{returnType}}> {
+    {{#if outputType}}
+    const responseBody = await this.{{method}}({ path: {{{pathWithQuotes fullPath}}}{{#if inputType}}, options: { body }{{/if}} });
+    return new {{outputType.typeName}}(responseBody);
+    {{else}}
+    await this.{{method}}({ path: {{{pathWithQuotes fullPath}}}{{#if inputType}}, options: { body }{{/if}} });
+    {{/if}}
+  }
+{{#unless @last}}
+
+{{/unless}}
+{{/each}}
+}
+
+export const {{className}} = new {{className}}Class();

package/dist-es/generate-api-clients/templates/api-client.ts.template

@@ -0,0 +1,131 @@
+import {
+  del,
+  get,
+  head,
+  isCancelError,
+  patch,
+  post,
+  put,
+} from "aws-amplify/api";
+import type {
+  ApiInput as AmplifyApiInput,
+  RestApiOptionsBase as AmplifyRestApiOptionsBase,
+  RestApiResponse as AmplifyRestApiResponse,
+} from "@aws-amplify/api-rest/src/types";
+import { fetchAuthSession } from "aws-amplify/auth";
+
+type ApiClientInputOption = {
+  headers?: Record<string, string>;
+  queryParams?: Record<string, string>;
+  body?: any;
+};
+
+type ApiClientInput = {
+  path: string;
+  options?: Omit<ApiClientInputOption, "body">;
+};
+
+type ApiClientInputWithBody = {
+  path: string;
+  options?: ApiClientInputOption;
+};
+
+export type GetInput = ApiClientInputWithBody;
+export type PostInput = ApiClientInputWithBody;
+export type PutInput = ApiClientInputWithBody;
+export type PatchInput = ApiClientInputWithBody;
+export type DeleteInput = ApiClientInput;
+export type HeadInput = ApiClientInput;
+
+export class ApiClientClass {
+  private readonly apiName = "default";
+
+  private async formatInput(
+    input: ApiClientInput
+  ): Promise<AmplifyApiInput<AmplifyRestApiOptionsBase>> {
+    const { idToken, accessToken } = (await fetchAuthSession()).tokens ?? {};
+    return {
+      ...input,
+      apiName: this.apiName,
+      options: {
+        ...input.options,
+        headers: {
+          ...input.options?.headers,
+          Authorization: `Bearer ${idToken}`,
+        },
+      },
+    };
+  }
+
+  private async formatResponseBody(
+    response:
+      | Promise<AmplifyRestApiResponse>
+      | Promise<Omit<AmplifyRestApiResponse, "body">>
+  ): Promise<any> {
+    try {
+      const res = await response;
+      // Handle 204 No Content or empty body
+      if (res.statusCode === 204 || !("body" in res) || !res.body) {
+        return undefined;
+      }
+      // Try to parse JSON, but handle empty string
+      const text = await res.body.text();
+      if (!text) return undefined;
+      try {
+        const json = JSON.parse(text);
+        return json;
+      } catch (e) {
+        throw new Error("Response must be a JSON object or array");
+      }
+    } catch (e: any) {
+      if (e?._response?.body) {
+        let parsed: any;
+        try {
+          parsed = JSON.parse(e._response.body);
+        } catch (parseError) {
+          // If JSON parsing fails, continue to throw original error
+        }
+        if (parsed) {
+          throw parsed;
+        }
+      }
+      throw e;
+    }
+  }
+
+  async get(input: GetInput) {
+    const formattedInput = await this.formatInput(input);
+    return this.formatResponseBody(get(formattedInput).response);
+  }
+
+  async put(input: PutInput) {
+    const formattedInput = await this.formatInput(input);
+    return this.formatResponseBody(put(formattedInput).response);
+  }
+
+  async post(input: PostInput) {
+    const formattedInput = await this.formatInput(input);
+    return this.formatResponseBody(post(formattedInput).response);
+  }
+
+  async delete(input: DeleteInput) {
+    const formattedInput = await this.formatInput(input);
+    return this.formatResponseBody(del(formattedInput).response);
+  }
+
+  async head(input: HeadInput) {
+    const formattedInput = await this.formatInput(input);
+    return this.formatResponseBody(head(formattedInput).response);
+  }
+
+  async patch(input: PatchInput) {
+    const formattedInput = await this.formatInput(input);
+    return this.formatResponseBody(patch(formattedInput).response);
+  }
+
+  isCancelError(error: unknown) {
+    return isCancelError(error);
+  }
+}
+
+export const ApiClient = new ApiClientClass();