@zapier/zapier-sdk-cli 0.1.1 → 0.2.1

package/dist/utils/pager.js

@@ -1,19 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pager = void 0;
-exports.createPager = createPager;
-exports.fetchAllPages = fetchAllPages;
-exports.showPaginationStatus = showPaginationStatus;
-const inquirer_1 = __importDefault(require("inquirer"));
-const chalk_1 = __importDefault(require("chalk"));
+import inquirer from "inquirer";
+import chalk from "chalk";
 /**
  * Generic pager that handles pagination for any data source
  * Supports interactive "load more" functionality
  */
-class Pager {
+export class Pager {
     constructor(options = {}) {
         this.allItems = [];
         this.currentOffset = 0;
@@ -67,7 +58,7 @@ class Pager {
                     : "";
                 const message = `Load more ${this.itemName}? (${this.allItems.length}${totalInfo} shown so far)`;
                 // Ask user if they want to load more
-                const { loadMore } = await inquirer_1.default.prompt([
+                const { loadMore } = await inquirer.prompt([
                     {
                         type: "confirm",
                         name: "loadMore",
@@ -98,17 +89,16 @@ class Pager {
         this.currentOffset = 0;
     }
 }
-exports.Pager = Pager;
 /**
  * Convenience function to create a pager for a specific use case
  */
-function createPager(options = {}) {
+export function createPager(options = {}) {
     return new Pager(options);
 }
 /**
  * Simple pagination without interactivity - just fetches all results up to a limit
  */
-async function fetchAllPages(fetchFunction, baseParams, maxResults = 100) {
+export async function fetchAllPages(fetchFunction, baseParams, maxResults = 100) {
     const pageSize = Math.min(maxResults, 50); // Reasonable page size
     const allItems = [];
     let offset = 0;
@@ -136,12 +126,12 @@ async function fetchAllPages(fetchFunction, baseParams, maxResults = 100) {
 /**
  * Display helper for showing pagination status
  */
-function showPaginationStatus(currentCount, requestedLimit, itemName = "items") {
+export function showPaginationStatus(currentCount, requestedLimit, itemName = "items") {
     if (currentCount >= requestedLimit) {
-        console.log(chalk_1.default.yellow(`\n📄 Showing first ${currentCount} ${itemName} (limit: ${requestedLimit})`));
-        console.log(chalk_1.default.gray(`Use --limit to increase the limit, or add paging with --page`));
+        console.log(chalk.yellow(`\n📄 Showing first ${currentCount} ${itemName} (limit: ${requestedLimit})`));
+        console.log(chalk.gray(`Use --limit to increase the limit, or add paging with --page`));
     }
     else {
-        console.log(chalk_1.default.gray(`\n📄 Showing all ${currentCount} ${itemName}`));
+        console.log(chalk.gray(`\n📄 Showing all ${currentCount} ${itemName}`));
     }
 }

package/dist/utils/parameter-resolver.js

@@ -1,23 +1,17 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaParameterResolver = void 0;
-const inquirer_1 = __importDefault(require("inquirer"));
-const chalk_1 = __importDefault(require("chalk"));
-const zod_1 = require("zod");
-const zapier_sdk_1 = require("@zapier/zapier-sdk");
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { z } from "zod";
+import { getResolver, hasResolver, getResolutionOrderForParams, } from "@zapier/zapier-sdk";
 // ============================================================================
 // Schema Parameter Resolver
 // ============================================================================
-class SchemaParameterResolver {
+export class SchemaParameterResolver {
     async resolveParameters(schema, providedParams, sdk) {
         // 1. Try to parse with current parameters
         const parseResult = schema.safeParse(providedParams);
         // Get all schema parameters to check which ones have resolvers
         const allParams = this.extractParametersFromSchema(schema);
-        const resolvableParams = allParams.filter((param) => (0, zapier_sdk_1.hasResolver)(param.name));
+        const resolvableParams = allParams.filter((param) => hasResolver(param.name));
         // Get all missing parameters that have resolvers
         const missingResolvable = resolvableParams.filter((param) => {
             const hasValue = this.getNestedValue(providedParams, param.path) !== undefined;
@@ -57,7 +51,7 @@ class SchemaParameterResolver {
         };
         if (functionallyRequired.length > 0) {
             const requiredParamNames = functionallyRequired.map((p) => p.name);
-            const requiredResolutionOrder = (0, zapier_sdk_1.getResolutionOrderForParams)(requiredParamNames);
+            const requiredResolutionOrder = getResolutionOrderForParams(requiredParamNames);
             const orderedRequiredParams = requiredResolutionOrder
                 .map((paramName) => functionallyRequired.find((p) => p.name === paramName))
                 .filter((param) => param !== undefined);
@@ -70,10 +64,10 @@ class SchemaParameterResolver {
                 }
                 catch (error) {
                     if (this.isUserCancellation(error)) {
-                        console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                        console.log(chalk.yellow("\n\nOperation cancelled by user"));
                         process.exit(0);
                     }
-                    console.error(chalk_1.default.red(`Failed to resolve ${param.name}:`), error);
+                    console.error(chalk.red(`Failed to resolve ${param.name}:`), error);
                     throw error;
                 }
             }
@@ -81,7 +75,7 @@ class SchemaParameterResolver {
         // 3. Ask user if they want to resolve truly optional parameters
         if (trulyOptional.length > 0) {
             const optionalNames = trulyOptional.map((p) => p.name).join(", ");
-            const shouldResolveOptional = await inquirer_1.default.prompt([
+            const shouldResolveOptional = await inquirer.prompt([
                 {
                     type: "confirm",
                     name: "resolveOptional",
@@ -92,7 +86,7 @@ class SchemaParameterResolver {
             if (shouldResolveOptional.resolveOptional) {
                 // Resolve optional parameters using their resolvers
                 const optionalParamNames = trulyOptional.map((p) => p.name);
-                const optionalResolutionOrder = (0, zapier_sdk_1.getResolutionOrderForParams)(optionalParamNames);
+                const optionalResolutionOrder = getResolutionOrderForParams(optionalParamNames);
                 const orderedOptionalParams = optionalResolutionOrder
                     .map((paramName) => trulyOptional.find((p) => p.name === paramName))
                     .filter((param) => param !== undefined);
@@ -105,10 +99,10 @@ class SchemaParameterResolver {
                     }
                     catch (error) {
                         if (this.isUserCancellation(error)) {
-                            console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                            console.log(chalk.yellow("\n\nOperation cancelled by user"));
                             process.exit(0);
                         }
-                        console.error(chalk_1.default.red(`Failed to resolve ${param.name}:`), error);
+                        console.error(chalk.red(`Failed to resolve ${param.name}:`), error);
                         throw error;
                     }
                 }
@@ -117,7 +111,7 @@ class SchemaParameterResolver {
         // 3. Validate final parameters
         const finalResult = schema.safeParse(resolvedParams);
         if (!finalResult.success) {
-            console.error(chalk_1.default.red("❌ Parameter validation failed after resolution:"));
+            console.error(chalk.red("❌ Parameter validation failed after resolution:"));
             throw finalResult.error;
         }
         return finalResult.data;
@@ -125,7 +119,7 @@ class SchemaParameterResolver {
     extractParametersFromSchema(schema) {
         const parameters = [];
         // Only handle ZodObject at the top level
-        if (schema instanceof zod_1.z.ZodObject) {
+        if (schema instanceof z.ZodObject) {
             const shape = schema.shape;
             for (const [key, fieldSchema] of Object.entries(shape)) {
                 const param = this.analyzeFieldSchema(key, fieldSchema);
@@ -140,11 +134,11 @@ class SchemaParameterResolver {
         let baseSchema = fieldSchema;
         let isRequired = true;
         // Check if field is optional or has default
-        if (baseSchema instanceof zod_1.z.ZodOptional) {
+        if (baseSchema instanceof z.ZodOptional) {
             isRequired = false;
             baseSchema = baseSchema._def.innerType;
         }
-        if (baseSchema instanceof zod_1.z.ZodDefault) {
+        if (baseSchema instanceof z.ZodDefault) {
             isRequired = false;
             baseSchema = baseSchema._def.innerType;
         }
@@ -163,11 +157,11 @@ class SchemaParameterResolver {
         };
     }
     async resolveParameter(param, context) {
-        const resolver = (0, zapier_sdk_1.getResolver)(param.name);
+        const resolver = getResolver(param.name);
         if (!resolver) {
             throw new Error(`No resolver found for parameter: ${param.name}`);
         }
-        console.log(chalk_1.default.blue(`\n🔍 Resolving ${param.name}...`));
+        console.log(chalk.blue(`\n🔍 Resolving ${param.name}...`));
         if (resolver.type === "static") {
             // Static resolver - just prompt for input
             const promptConfig = {
@@ -176,33 +170,33 @@ class SchemaParameterResolver {
                 message: `Enter ${param.name}:`,
                 ...(resolver.placeholder && { default: resolver.placeholder }),
             };
-            const answers = await inquirer_1.default.prompt([promptConfig]);
+            const answers = await inquirer.prompt([promptConfig]);
             return answers[param.name];
         }
         else if (resolver.type === "dynamic") {
             // Dynamic resolver - fetch options and prompt for selection
             try {
-                console.log(chalk_1.default.gray(`Fetching options for ${param.name}...`));
+                console.log(chalk.gray(`Fetching options for ${param.name}...`));
                 const items = await resolver.fetch(context.sdk, context.resolvedParams);
                 if (!items || items.length === 0) {
                     throw new Error(`No options available for ${param.name}`);
                 }
                 const promptConfig = resolver.prompt(items, context.resolvedParams);
-                const answers = await inquirer_1.default.prompt([promptConfig]);
+                const answers = await inquirer.prompt([promptConfig]);
                 return answers[param.name];
             }
             catch (error) {
-                console.error(chalk_1.default.red(`Failed to fetch options for ${param.name}:`), error instanceof Error ? error.message : error);
+                console.error(chalk.red(`Failed to fetch options for ${param.name}:`), error instanceof Error ? error.message : error);
                 throw error;
             }
         }
         else if (resolver.type === "fields") {
             // Fields resolver - fetch field definitions and prompt for each input
             try {
-                console.log(chalk_1.default.gray(`Fetching input fields for ${param.name}...`));
+                console.log(chalk.gray(`Fetching input fields for ${param.name}...`));
                 const fields = await resolver.fetch(context.sdk, context.resolvedParams);
                 if (!fields || fields.length === 0) {
-                    console.log(chalk_1.default.yellow(`No input fields required for this action.`));
+                    console.log(chalk.yellow(`No input fields required for this action.`));
                     return {};
                 }
                 const inputs = {};
@@ -211,17 +205,17 @@ class SchemaParameterResolver {
                 const optionalFields = fields.filter((field) => !field.required);
                 // First, prompt for all required fields
                 if (requiredFields.length > 0) {
-                    console.log(chalk_1.default.blue(`\n📝 Please provide values for the following input fields:`));
+                    console.log(chalk.blue(`\n📝 Please provide values for the following input fields:`));
                     for (const field of requiredFields) {
                         await this.promptForField(field, inputs);
                     }
                 }
                 // Then ask if user wants to configure optional fields
                 if (optionalFields.length > 0) {
-                    console.log(chalk_1.default.gray(`\nThere are ${optionalFields.length} optional field(s) available.`));
+                    console.log(chalk.gray(`\nThere are ${optionalFields.length} optional field(s) available.`));
                     let shouldConfigureOptional;
                     try {
-                        shouldConfigureOptional = await inquirer_1.default.prompt([
+                        shouldConfigureOptional = await inquirer.prompt([
                             {
                                 type: "confirm",
                                 name: "configure",
@@ -232,13 +226,13 @@ class SchemaParameterResolver {
                     }
                     catch (error) {
                         if (this.isUserCancellation(error)) {
-                            console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                            console.log(chalk.yellow("\n\nOperation cancelled by user"));
                             process.exit(0);
                         }
                         throw error;
                     }
                     if (shouldConfigureOptional.configure) {
-                        console.log(chalk_1.default.cyan(`\nOptional fields:`));
+                        console.log(chalk.cyan(`\nOptional fields:`));
                         for (const field of optionalFields) {
                             await this.promptForField(field, inputs);
                         }
@@ -247,7 +241,7 @@ class SchemaParameterResolver {
                 return inputs;
             }
             catch (error) {
-                console.error(chalk_1.default.red(`Failed to fetch fields for ${param.name}:`), error instanceof Error ? error.message : error);
+                console.error(chalk.red(`Failed to fetch fields for ${param.name}:`), error instanceof Error ? error.message : error);
                 throw error;
             }
         }
@@ -271,7 +265,7 @@ class SchemaParameterResolver {
             type: field.type === "boolean" ? "confirm" : "input",
             name: field.key,
             message: `${field.label || field.key}${field.required ? " (required)" : " (optional)"}:`,
-            ...(field.helpText && { prefix: chalk_1.default.gray(`ℹ ${field.helpText}\n`) }),
+            ...(field.helpText && { prefix: chalk.gray(`ℹ ${field.helpText}\n`) }),
             ...(field.default && { default: field.default }),
         };
         if (field.choices && field.choices.length > 0) {
@@ -282,7 +276,7 @@ class SchemaParameterResolver {
             }));
         }
         try {
-            const answer = await inquirer_1.default.prompt([fieldPrompt]);
+            const answer = await inquirer.prompt([fieldPrompt]);
             if (answer[field.key] !== undefined && answer[field.key] !== "") {
                 inputs[field.key] = answer[field.key];
             }
@@ -292,7 +286,7 @@ class SchemaParameterResolver {
         }
         catch (error) {
             if (this.isUserCancellation(error)) {
-                console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                console.log(chalk.yellow("\n\nOperation cancelled by user"));
                 process.exit(0);
             }
             throw error;
@@ -304,4 +298,3 @@ class SchemaParameterResolver {
             error?.isTTYError);
     }
 }
-exports.SchemaParameterResolver = SchemaParameterResolver;

package/dist/utils/schema-formatter.js

@@ -1,10 +1,4 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatItemsFromSchema = formatItemsFromSchema;
-const chalk_1 = __importDefault(require("chalk"));
+import chalk from "chalk";
 function getFormatMetadata(schema) {
     return schema?._def?.formatMeta;
 }
@@ -14,7 +8,7 @@ function getOutputSchema(schema) {
 // ============================================================================
 // Generic Schema-Driven Formatter
 // ============================================================================
-function formatItemsFromSchema(inputSchema, items) {
+export function formatItemsFromSchema(inputSchema, items) {
     // Get the output schema and its format metadata
     const outputSchema = getOutputSchema(inputSchema);
     if (!outputSchema) {
@@ -37,9 +31,9 @@ function formatSingleItem(item, index, formatMeta) {
     // Get the formatted item from the format function
     const formatted = formatMeta.format(item);
     // Build the main title line
-    let titleLine = `${chalk_1.default.gray(`${index + 1}.`)} ${chalk_1.default.cyan(formatted.title)}`;
+    let titleLine = `${chalk.gray(`${index + 1}.`)} ${chalk.cyan(formatted.title)}`;
     if (formatted.subtitle) {
-        titleLine += ` ${chalk_1.default.gray(formatted.subtitle)}`;
+        titleLine += ` ${chalk.gray(formatted.subtitle)}`;
     }
     console.log(titleLine);
     // Format detail lines
@@ -52,25 +46,25 @@ function formatSingleItem(item, index, formatMeta) {
 function applyStyle(value, style) {
     switch (style) {
         case "dim":
-            return chalk_1.default.dim(value);
+            return chalk.dim(value);
         case "accent":
-            return chalk_1.default.magenta(value);
+            return chalk.magenta(value);
         case "warning":
-            return chalk_1.default.red(value);
+            return chalk.red(value);
         case "success":
-            return chalk_1.default.green(value);
+            return chalk.green(value);
         case "normal":
         default:
-            return chalk_1.default.blue(value);
+            return chalk.blue(value);
     }
 }
 function formatItemsGeneric(items) {
     // Fallback formatting for items without schema metadata
     items.forEach((item, index) => {
         const name = item.name || item.key || item.id || "Item";
-        console.log(`${chalk_1.default.gray(`${index + 1}.`)} ${chalk_1.default.cyan(name)}`);
+        console.log(`${chalk.gray(`${index + 1}.`)} ${chalk.cyan(name)}`);
         if (item.description) {
-            console.log(`   ${chalk_1.default.dim(item.description)}`);
+            console.log(`   ${chalk.dim(item.description)}`);
         }
         console.log();
     });

package/dist/utils/serializeAsync.d.ts

@@ -0,0 +1,2 @@
+declare const serializeAsync: <R, A extends []>(fn: (...args: A) => Promise<R>) => ((...args: A) => Promise<R>);
+export default serializeAsync;

package/dist/utils/serializeAsync.js

@@ -0,0 +1,16 @@
+import { createHash } from "node:crypto";
+const promises = {};
+const serializeAsync = (fn) => async (...args) => {
+    const hash = createHash("sha256")
+        .update(fn.toString(), "utf8")
+        .digest()
+        .toString("hex");
+    const promise = promises[hash];
+    if (!promise) {
+        promises[hash] = fn(...args).finally(() => {
+            delete promises[hash];
+        });
+    }
+    return promises[hash];
+};
+export default serializeAsync;

package/dist/utils/spinner.d.ts

@@ -0,0 +1 @@
+export declare const spinPromise: <T>(promise: Promise<T>, text: string) => Promise<T>;

package/dist/utils/spinner.js

@@ -0,0 +1,13 @@
+import ora from "ora";
+export const spinPromise = async (promise, text) => {
+    const spinner = ora(text).start();
+    try {
+        const result = await promise;
+        spinner.succeed();
+        return result;
+    }
+    catch (error) {
+        spinner.fail();
+        throw error;
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Command line interface for Zapier SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,13 +22,19 @@
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.5",
     "commander": "^12.0.0",
+    "express": "^5.1.0",
     "inquirer": "^12.6.3",
+    "jsonwebtoken": "^9.0.2",
+    "open": "^10.2.0",
     "ora": "^8.2.0",
+    "pkce-challenge": "^5.0.0",
     "zod": "^3.25.67",
-    "@zapier/zapier-sdk": "0.1.1"
+    "@zapier/zapier-sdk": "0.2.1"
   },
   "devDependencies": {
+    "@types/express": "^5.0.3",
     "@types/inquirer": "^9.0.8",
+    "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^24.0.1",
     "typescript": "^5.8.3",
     "vitest": "^3.2.3"

package/src/cli.ts

@@ -3,6 +3,12 @@
 import { Command } from "commander";
 import { createZapierSdk } from "@zapier/zapier-sdk";
 import { generateCliCommands } from "./utils/cli-generator";
+import {
+  createLoginCommand,
+  createLogoutCommand,
+  createWhoamiCommand,
+  createConfigPathCommand,
+} from "./commands";
 
 const program = new Command();
 
@@ -16,13 +22,17 @@ program
 const isDebugMode =
   process.env.DEBUG === "true" || process.argv.includes("--debug");
 
-// Create SDK instance for CLI operations
-// Auth will be resolved from environment variables or command options
+// Create SDK instance - automatically handles token resolution
 const sdk = createZapierSdk({
-  // Token will be picked up from ZAPIER_TOKEN env var or provided via options
   debug: isDebugMode,
 });
 
+// Add auth commands before generating SDK commands
+program.addCommand(createLoginCommand());
+program.addCommand(createLogoutCommand());
+program.addCommand(createWhoamiCommand());
+program.addCommand(createConfigPathCommand());
+
 // Generate CLI commands from SDK schemas
 generateCliCommands(program, sdk);
 

package/src/commands/configPath.ts

@@ -0,0 +1,10 @@
+import { Command } from "commander";
+import { getConfigPath } from "@zapier/zapier-sdk";
+
+export function createConfigPathCommand(): Command {
+  return new Command("get-config-path")
+    .description("Show the path to the configuration file")
+    .action(async () => {
+      console.log(`Configuration file: ${getConfigPath()}`);
+    });
+}

package/src/commands/index.ts

@@ -0,0 +1,4 @@
+export { createLoginCommand } from "./login";
+export { createLogoutCommand } from "./logout";
+export { createWhoamiCommand } from "./whoami";
+export { createConfigPathCommand } from "./configPath";

package/src/commands/login.ts

@@ -0,0 +1,34 @@
+import { Command } from "commander";
+import login from "../utils/auth/login";
+import { getLoggedInUser } from "@zapier/zapier-sdk";
+
+export function createLoginCommand(): Command {
+  return new Command("login")
+    .description("Log in to Zapier to access your account")
+    .option(
+      "--timeout <seconds>",
+      "Login timeout in seconds (default: 300)",
+      "300",
+    )
+    .action(async (options) => {
+      try {
+        const timeoutSeconds = parseInt(options.timeout, 10);
+        if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
+          throw new Error("Timeout must be a positive number");
+        }
+        await login(timeoutSeconds * 1000); // Convert to milliseconds
+        const user = await getLoggedInUser();
+
+        console.log(`✅ Successfully logged in as ${user.email}`);
+
+        // Force immediate exit to prevent hanging (especially in development with tsx)
+        setTimeout(() => process.exit(0), 100);
+      } catch (error) {
+        console.error(
+          "❌ Login failed:",
+          error instanceof Error ? error.message : "Unknown error",
+        );
+        process.exit(1);
+      }
+    });
+}

package/src/commands/logout.ts

@@ -0,0 +1,19 @@
+import { Command } from "commander";
+import { logout } from "@zapier/zapier-sdk";
+
+export function createLogoutCommand(): Command {
+  return new Command("logout")
+    .description("Log out of your Zapier account")
+    .action(async () => {
+      try {
+        logout();
+        console.log("✅ Successfully logged out");
+      } catch (error) {
+        console.error(
+          "❌ Logout failed:",
+          error instanceof Error ? error.message : "Unknown error",
+        );
+        process.exit(1);
+      }
+    });
+}

package/src/commands/whoami.ts

@@ -0,0 +1,25 @@
+import { Command } from "commander";
+import { getLoggedInUser } from "@zapier/zapier-sdk";
+import { spinPromise } from "../utils/spinner";
+
+export function createWhoamiCommand(): Command {
+  return new Command("whoami")
+    .description("Show current login status and user information")
+    .action(async () => {
+      try {
+        const user = await spinPromise(
+          getLoggedInUser(),
+          "Checking login status...",
+        );
+
+        console.log(
+          `✅ Logged in as ${user.email} (Account ID: ${user.accountId})`,
+        );
+      } catch {
+        console.log(
+          "❌ Not logged in. Use 'zapier-sdk login' to authenticate.",
+        );
+        process.exit(1);
+      }
+    });
+}

package/src/utils/api/client.ts

@@ -0,0 +1,44 @@
+// Simple HTTP client for OAuth authentication
+export interface ApiResponse<T = any> {
+  data: T;
+  status: number;
+}
+
+export const createApiClient = () => {
+  const post = async <T = any>(
+    url: string,
+    data: any,
+    options: {
+      headers?: Record<string, string>;
+    } = {},
+  ): Promise<ApiResponse<T>> => {
+    const { headers = {} } = options;
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Connection: "close",
+        ...headers,
+      },
+      body: new URLSearchParams(data),
+    });
+
+    if (!response.ok) {
+      throw new Error(`${response.status} ${response.statusText}`);
+    }
+
+    const responseData = await response.json();
+    return {
+      data: responseData,
+      status: response.status,
+    };
+  };
+
+  return {
+    post,
+  };
+};
+
+const api = createApiClient();
+export default api;