@outseta/api-client 0.2.0 → 0.2.1

package/dist/index.js

@@ -1,35 +1,33 @@
 // src/client.ts
-import ky, { HTTPError } from "ky";
 function getAuthorization(creds) {
   if ("accessToken" in creds) {
     return `Bearer ${creds.accessToken}`;
   }
   return `Outseta ${creds.apiKey}:${creds.apiSecret}`;
 }
+function getRequestUrl(subdomain, path) {
+  if (/^https?:\/\//.test(path)) {
+    return path;
+  }
+  const normalizedPath = path.startsWith("/api/v1/") ? path : `/api/v1/${path.replace(/^\/+/, "")}`;
+  return new URL(normalizedPath, `https://${subdomain}.outseta.com`).toString();
+}
 function createClient(creds) {
-  return ky.create({
-    prefixUrl: `https://${creds.subdomain}.outseta.com/api/v1/`,
-    headers: {
-      Authorization: getAuthorization(creds)
-    },
-    retry: { limit: 3, statusCodes: [408, 429, 500, 502, 503, 504] }
-  });
+  return (path, init = {}) => {
+    const headers = new Headers(init.headers);
+    headers.set("Authorization", getAuthorization(creds));
+    return fetch(getRequestUrl(creds.subdomain, path), {
+      ...init,
+      headers
+    });
+  };
 }
 var customFetch = async (url, options) => {
   const { client, ...init } = options;
   if (!client) {
-    throw new Error("@outseta/api-client: No client provided. Pass a ky instance from createClient() via the `client` option.");
-  }
-  let response;
-  try {
-    response = await client(url.replace(/^\/api\/v1\//, ""), init);
-  } catch (error) {
-    if (error instanceof HTTPError) {
-      response = error.response;
-    } else {
-      throw error;
-    }
+    throw new Error("@outseta/api-client: No client provided. Pass a client from createClient() via the `client` option.");
   }
+  const response = await client(url, init);
   const data = response.headers.get("content-type")?.includes("application/json") ? await response.json() : undefined;
   return { data, status: response.status, headers: response.headers };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outseta/api-client",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Generated API client for the Outseta REST API",
   "license": "MIT",
   "repository": {
@@ -18,15 +18,12 @@
     }
   },
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target node --format esm --packages external",
+    "build": "rimraf dist && bun build src/index.ts --outdir dist --target node --format esm --packages external",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src --ignore-pattern generated",
     "test": "bun test --env-file ../../.env.test"
   },
-  "dependencies": {
-    "ky": "^1.7.0",
-    "zod": "^3.24.0"
-  },
+  "dependencies": {},
   "devDependencies": {
     "@types/bun": "^1.3.10",
     "typescript": "^5.7.0"

package/src/__tests__/accounts-crud.integration.test.ts

@@ -1,5 +1,14 @@
 import { describe, expect, test, afterAll } from "bun:test";
-import { hasCredentials, getTestClient } from "./setup.js";
+import { hasCredentials, getTestClient, opts, type PaginatedResponse } from "./setup.js";
+import type { Account, AccountAddAccountBody, AccountUpdateAccountBody, Person } from "../generated/models/index.js";
+import {
+  accountAddAccount,
+  accountGetAccount,
+  accountUpdateAccount,
+  accountDeleteAccount,
+  personGetAllPeople,
+  personDeletePerson,
+} from "../generated/crm/crm.js";
 
 const emailsToCleanup: string[] = [];
 const accountUidsToCleanup: string[] = [];
@@ -10,17 +19,17 @@ describe.skipIf(!hasCredentials)("Accounts CRUD (live)", () => {
 
     // Delete any accounts that weren't cleaned up by the test
     for (const uid of accountUidsToCleanup) {
-      await client(`crm/accounts/${uid}`, { method: "DELETE", throwHttpErrors: false });
+      await accountDeleteAccount(uid, opts(client));
     }
 
-    // Delete orphaned people by email (API doesn't embed Person in account responses)
+    // Delete orphaned people by email
     if (emailsToCleanup.length > 0) {
-      const res = await client("crm/people", { throwHttpErrors: false });
-      if (res.ok) {
-        const body = await res.json<{ items: Array<{ Uid: string; Email: string }> }>();
+      const res = await personGetAllPeople(undefined, opts(client));
+      if (res.status === 200) {
+        const body = res.data as unknown as PaginatedResponse<Person>;
         for (const person of body.items) {
-          if (emailsToCleanup.includes(person.Email)) {
-            await client(`crm/people/${person.Uid}`, { method: "DELETE", throwHttpErrors: false });
+          if (person.Email && emailsToCleanup.includes(person.Email)) {
+            await personDeletePerson(person.Uid!, opts(client));
           }
         }
       }
@@ -33,9 +42,8 @@ describe.skipIf(!hasCredentials)("Accounts CRUD (live)", () => {
     emailsToCleanup.push(email);
 
     // CREATE
-    const createRes = await client("crm/accounts", {
-      method: "POST",
-      json: {
+    const createRes = await accountAddAccount(
+      {
         Name: "Lifecycle Test Corp",
         PersonAccount: [
           {
@@ -43,55 +51,49 @@ describe.skipIf(!hasCredentials)("Accounts CRUD (live)", () => {
             IsPrimary: true,
           },
         ],
-      },
-      throwHttpErrors: false,
-    });
+      } as AccountAddAccountBody,
+      undefined,
+      opts(client),
+    );
     expect(createRes.status).toBe(200);
-    const created = await createRes.json<{ Uid: string; Name: string }>();
+    const created = createRes.data as unknown as Account;
     expect(created.Uid).toBeDefined();
     expect(created.Name).toBe("Lifecycle Test Corp");
-    accountUidsToCleanup.push(created.Uid);
+    accountUidsToCleanup.push(created.Uid!);
 
     // READ
-    const getRes = await client(`crm/accounts/${created.Uid}`, {
-      throwHttpErrors: false,
-    });
+    const getRes = await accountGetAccount(created.Uid!, opts(client));
     expect(getRes.status).toBe(200);
-    const fetched = await getRes.json<{ Uid: string; Name: string }>();
+    const fetched = getRes.data as unknown as Account;
     expect(fetched.Uid).toBe(created.Uid);
 
     // UPDATE
-    const updateRes = await client(`crm/accounts/${created.Uid}`, {
-      method: "PUT",
-      json: { Name: "Lifecycle Test Corp (Updated)" },
-      throwHttpErrors: false,
-    });
+    const updateRes = await accountUpdateAccount(
+      created.Uid!,
+      { Name: "Lifecycle Test Corp (Updated)" } as AccountUpdateAccountBody,
+      opts(client),
+    );
     expect(updateRes.status).toBe(200);
-    const updated = await updateRes.json<{ Uid: string; Name: string }>();
+    const updated = updateRes.data as unknown as Account;
     expect(updated.Name).toBe("Lifecycle Test Corp (Updated)");
 
     // DELETE account
-    const deleteRes = await client(`crm/accounts/${created.Uid}`, {
-      method: "DELETE",
-      throwHttpErrors: false,
-    });
+    const deleteRes = await accountDeleteAccount(created.Uid!, opts(client));
     expect(deleteRes.status).toBe(200);
 
     // Verify deleted — should 404
-    const verifyRes = await client(`crm/accounts/${created.Uid}`, {
-      throwHttpErrors: false,
-    });
+    const verifyRes = await accountGetAccount(created.Uid!, opts(client));
     expect(verifyRes.status).toBe(404);
   });
 
   test("create account without required person returns error", async () => {
     const client = getTestClient();
 
-    const res = await client("crm/accounts", {
-      method: "POST",
-      json: { Name: "No Person Corp" },
-      throwHttpErrors: false,
-    });
-    expect(res.ok).toBe(false);
+    const res = await accountAddAccount(
+      { Name: "No Person Corp" } as AccountAddAccountBody,
+      undefined,
+      opts(client),
+    );
+    expect(res.status).not.toBe(200);
   });
 });

package/src/__tests__/client.test.ts

@@ -3,7 +3,7 @@ import { createClient, customFetch } from "../client.js";
 import { hasCredentials, getTestClient } from "./setup.js";
 
 describe("createClient", () => {
-  test("returns a ky instance (callable function)", () => {
+  test("returns a callable fetch client", () => {
     const client = createClient({
       subdomain: "test",
       apiKey: "key",
@@ -43,7 +43,7 @@ describe("customFetch", () => {
 describe.skipIf(!hasCredentials)("Auth (live)", () => {
   test("valid credentials return 200", async () => {
     const client = getTestClient();
-    const res = await client("crm/accounts", { throwHttpErrors: false });
+    const res = await client("crm/accounts");
     expect(res.status).toBe(200);
   });
 
@@ -53,7 +53,7 @@ describe.skipIf(!hasCredentials)("Auth (live)", () => {
       apiKey: "bad-key",
       apiSecret: "bad-secret",
     });
-    const res = await badClient("crm/accounts", { throwHttpErrors: false });
+    const res = await badClient("crm/accounts");
     expect(res.status).toBe(401);
   });
 });

package/src/__tests__/people.integration.test.ts

@@ -1,5 +1,13 @@
 import { describe, expect, test, afterAll } from "bun:test";
-import { hasCredentials, getTestClient } from "./setup.js";
+import { hasCredentials, getTestClient, opts, type PaginatedResponse } from "./setup.js";
+import type { Person, PersonAddPersonBody, PersonUpdatePersonBody } from "../generated/models/index.js";
+import {
+  personGetAllPeople,
+  personAddPerson,
+  personGetPerson,
+  personUpdatePerson,
+  personDeletePerson,
+} from "../generated/crm/crm.js";
 
 const peopleToCleanup: string[] = [];
 
@@ -7,16 +15,16 @@ describe.skipIf(!hasCredentials)("People (live)", () => {
   afterAll(async () => {
     const client = getTestClient();
     for (const uid of peopleToCleanup) {
-      await client(`crm/people/${uid}`, { method: "DELETE", throwHttpErrors: false });
+      await personDeletePerson(uid, opts(client));
     }
   });
 
   test("list all people", async () => {
     const client = getTestClient();
-    const res = await client("crm/people", { throwHttpErrors: false });
+    const res = await personGetAllPeople(undefined, opts(client));
 
     expect(res.status).toBe(200);
-    const body = await res.json<{ metadata: { total: number }; items: unknown[] }>();
+    const body = res.data as unknown as PaginatedResponse<Person>;
     expect(body.metadata).toBeDefined();
     expect(body.items).toBeInstanceOf(Array);
     expect(body.metadata.total).toBeGreaterThan(0);
@@ -27,52 +35,40 @@ describe.skipIf(!hasCredentials)("People (live)", () => {
     const email = `person-crud-${Date.now()}@test.com`;
 
     // CREATE
-    const createRes = await client("crm/people", {
-      method: "POST",
-      json: {
-        Email: email,
-        FirstName: "CrudTest",
-        LastName: "Person",
-      },
-      throwHttpErrors: false,
-    });
+    const createRes = await personAddPerson(
+      { Email: email, FirstName: "CrudTest", LastName: "Person" } as PersonAddPersonBody,
+      opts(client),
+    );
     expect(createRes.status).toBe(200);
-    const created = await createRes.json<{ Uid: string; Email: string; FirstName: string }>();
+    const created = createRes.data as unknown as Person;
     expect(created.Uid).toBeDefined();
     expect(created.Email).toBe(email);
-    peopleToCleanup.push(created.Uid);
+    peopleToCleanup.push(created.Uid!);
 
     // READ
-    const getRes = await client(`crm/people/${created.Uid}`, {
-      throwHttpErrors: false,
-    });
+    const getRes = await personGetPerson(created.Uid!, opts(client));
     expect(getRes.status).toBe(200);
-    const fetched = await getRes.json<{ Uid: string; Email: string }>();
+    const fetched = getRes.data as unknown as Person;
     expect(fetched.Uid).toBe(created.Uid);
 
     // UPDATE
-    const updateRes = await client(`crm/people/${created.Uid}`, {
-      method: "PUT",
-      json: { FirstName: "UpdatedFirst" },
-      throwHttpErrors: false,
-    });
+    const updateRes = await personUpdatePerson(
+      created.Uid!,
+      { FirstName: "UpdatedFirst" } as PersonUpdatePersonBody,
+      opts(client),
+    );
     expect(updateRes.status).toBe(200);
-    const updated = await updateRes.json<{ FirstName: string }>();
+    const updated = updateRes.data as unknown as Person;
     expect(updated.FirstName).toBe("UpdatedFirst");
 
     // DELETE
-    const deleteRes = await client(`crm/people/${created.Uid}`, {
-      method: "DELETE",
-      throwHttpErrors: false,
-    });
+    const deleteRes = await personDeletePerson(created.Uid!, opts(client));
     expect(deleteRes.status).toBe(200);
   });
 
   test("get non-existent person returns 404", async () => {
     const client = getTestClient();
-    const res = await client("crm/people/nonexistent-uid-000", {
-      throwHttpErrors: false,
-    });
+    const res = await personGetPerson("nonexistent-uid-000", opts(client));
     expect(res.status).toBe(404);
   });
 });

package/src/__tests__/setup.ts

@@ -1,5 +1,4 @@
-import { createClient } from "../client.js";
-import type { KyInstance } from "ky";
+import { createClient, type OutsetaClient } from "../client.js";
 
 const subdomain = process.env.OUTSETA_SUBDOMAIN;
 const apiKey = process.env.OUTSETA_API_KEY;
@@ -7,13 +6,13 @@ const apiSecret = process.env.OUTSETA_API_SECRET;
 
 export const hasCredentials = !!(subdomain && apiKey && apiSecret);
 
-let _client: KyInstance | undefined;
+let _client: OutsetaClient | undefined;
 
 /**
  * Generated functions type options as RequestInit, but the customFetch mutator
- * expects { client: KyInstance } at runtime. This bridges the gap.
+ * expects { client: OutsetaClient } at runtime. This bridges the gap.
  */
-export const opts = (client: KyInstance) =>
+export const opts = (client: OutsetaClient) =>
   ({ client }) as unknown as RequestInit;
 
 /** Outseta list endpoints return this paginated wrapper, not a flat array. */
@@ -22,7 +21,7 @@ export interface PaginatedResponse<T> {
   items: T[];
 }
 
-export function getTestClient(): KyInstance {
+export function getTestClient(): OutsetaClient {
   if (!hasCredentials) {
     throw new Error("Missing OUTSETA_SUBDOMAIN, OUTSETA_API_KEY, or OUTSETA_API_SECRET env vars");
   }

package/src/__tests__/support.integration.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, test, afterAll } from "bun:test";
 import { hasCredentials, getTestClient, opts, type PaginatedResponse } from "./setup.js";
-import type { Case } from "../generated/models/index.js";
-import { caseGetAllCases } from "../generated/support/support.js";
+import type { Case, CaseAddCaseBody, Person } from "../generated/models/index.js";
+import { caseGetAllCases, caseAddCase, caseGetCase } from "../generated/support/support.js";
+import { personGetAllPeople } from "../generated/crm/crm.js";
 
 describe.skipIf(!hasCredentials)("Support Cases — generated endpoints (live)", () => {
   test("caseGetAllCases returns a paginated response", async () => {
@@ -18,67 +19,59 @@ describe.skipIf(!hasCredentials)("Support Cases — generated endpoints (live)",
 });
 
 // Cases cannot be deleted via API (405), so we close them after the test
-// to keep the test account tidy.
+// to keep the test account tidy. No generated caseUpdateCase exists,
+// so cleanup uses the low-level client.
 const caseUidsToClose: string[] = [];
 
 describe.skipIf(!hasCredentials)("Support Cases — CRUD (live)", () => {
   afterAll(async () => {
     const client = getTestClient();
     for (const uid of caseUidsToClose) {
-      const getRes = await client(`support/cases/${uid}`, { throwHttpErrors: false });
-      if (getRes.ok) {
-        const full = await getRes.json<Record<string, unknown>>();
+      const getRes = await caseGetCase(uid, opts(client));
+      if (getRes.status === 200) {
+        const full = getRes.data as unknown as Case;
+        // No generated update function — fall back to the low-level client
         await client(`support/cases/${uid}`, {
           method: "PUT",
-          json: { ...full, Status: 2 },
-          throwHttpErrors: false,
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ ...full, Status: 2 }),
         });
       }
     }
   });
 
-  test("create → read → update case", async () => {
+  test("create → read case", async () => {
     const client = getTestClient();
 
     // Get a person to be the case author
-    const peopleRes = await client("crm/people", { throwHttpErrors: false });
-    const people = await peopleRes.json<{ items: Array<{ Uid: string }> }>();
+    const peopleRes = await personGetAllPeople(undefined, opts(client));
+    expect(peopleRes.status).toBe(200);
+    const people = peopleRes.data as unknown as PaginatedResponse<Person>;
     expect(people.items.length).toBeGreaterThan(0);
-    const personUid = people.items[0].Uid;
+    const person = people.items[0];
 
     // CREATE
-    const createRes = await client("support/cases?sendAutoResponder=false", {
-      method: "POST",
-      json: {
-        FromPerson: { Uid: personUid },
+    const createRes = await caseAddCase(
+      {
+        FromPerson: { Uid: person.Uid! },
         Subject: `CRUD test case ${Date.now()}`,
         Body: "Created by integration test",
         Source: 2,
-      },
-      throwHttpErrors: false,
-    });
+        Status: 1,
+      } as CaseAddCaseBody,
+      { sendautoresponder: "false" },
+      opts(client),
+    );
     expect(createRes.status).toBe(200);
-    const created = await createRes.json<Record<string, unknown>>();
+    const created = createRes.data as unknown as Case;
     expect(created.Uid).toBeDefined();
     expect(created.Subject).toContain("CRUD test case");
-    caseUidsToClose.push(created.Uid as string);
+    caseUidsToClose.push(created.Uid!);
 
     // READ
-    const getRes = await client(`support/cases/${created.Uid}`, {
-      throwHttpErrors: false,
-    });
+    const getRes = await caseGetCase(created.Uid!, opts(client));
     expect(getRes.status).toBe(200);
-    const fetched = await getRes.json<Record<string, unknown>>();
+    const fetched = getRes.data as unknown as Case;
     expect(fetched.Uid).toBe(created.Uid);
-
-    // UPDATE (close case: Status 2 = Closed)
-    const closeRes = await client(`support/cases/${created.Uid}`, {
-      method: "PUT",
-      json: { ...fetched, Status: 2 },
-      throwHttpErrors: false,
-    });
-    expect(closeRes.status).toBe(200);
-    const closed = await closeRes.json<Record<string, unknown>>();
-    expect(closed.Status).toBe(2);
   });
 });

package/src/client.ts

@@ -1,5 +1,3 @@
-import ky, { HTTPError, type KyInstance } from "ky";
-
 export type OutsetaApiKeyCredentials = {
   subdomain: string;
   apiKey: string;
@@ -15,6 +13,15 @@ export type OutsetaCredentials =
   | OutsetaApiKeyCredentials
   | OutsetaBearerCredentials;
 
+export type OutsetaClient = (
+  path: string,
+  init?: RequestInit,
+) => Promise<Response>;
+
+export type OutsetaRequestInit = RequestInit & {
+  client?: OutsetaClient;
+};
+
 function getAuthorization(creds: OutsetaCredentials): string {
   if ("accessToken" in creds) {
     return `Bearer ${creds.accessToken}`;
@@ -22,44 +29,52 @@ function getAuthorization(creds: OutsetaCredentials): string {
   return `Outseta ${creds.apiKey}:${creds.apiSecret}`;
 }
 
-export function createClient(creds: OutsetaCredentials): KyInstance {
-  return ky.create({
-    prefixUrl: `https://${creds.subdomain}.outseta.com/api/v1/`,
-    headers: {
-      Authorization: getAuthorization(creds),
-    },
-    retry: { limit: 3, statusCodes: [408, 429, 500, 502, 503, 504] },
-  });
+function getRequestUrl(subdomain: string, path: string): string {
+  if (/^https?:\/\//.test(path)) {
+    return path;
+  }
+
+  const normalizedPath = path.startsWith("/api/v1/")
+    ? path
+    : `/api/v1/${path.replace(/^\/+/, "")}`;
+
+  return new URL(normalizedPath, `https://${subdomain}.outseta.com`).toString();
+}
+
+export function createClient(creds: OutsetaCredentials): OutsetaClient {
+  return (path, init = {}) => {
+    const headers = new Headers(init.headers);
+    headers.set("Authorization", getAuthorization(creds));
+
+    return fetch(getRequestUrl(creds.subdomain, path), {
+      ...init,
+      headers,
+    });
+  };
 }
 
 /**
  * Custom Orval mutator for the fetch client.
  *
  * Generated functions call `customFetch(url, { ...options, method })`.
- * Consumers pass `{ client }` in the options to inject their ky instance.
+ * Consumers pass `{ client }` in the options to inject a client from
+ * `createClient()`.
  */
 export const customFetch = async <T>(
   url: string,
-  options: RequestInit & { client?: KyInstance },
+  options: OutsetaRequestInit,
 ): Promise<T> => {
   const { client, ...init } = options;
   if (!client) {
     throw new Error(
-      "@outseta/api-client: No client provided. Pass a ky instance from createClient() via the `client` option.",
+      "@outseta/api-client: No client provided. Pass a client from createClient() via the `client` option.",
     );
   }
-  let response: Response;
-  try {
-    response = await client(url.replace(/^\/api\/v1\//, ""), init);
-  } catch (error) {
-    if (error instanceof HTTPError) {
-      response = error.response;
-    } else {
-      throw error;
-    }
-  }
+
+  const response = await client(url, init);
   const data = response.headers.get("content-type")?.includes("application/json")
     ? await response.json()
     : undefined;
+
   return { data, status: response.status, headers: response.headers } as T;
 };