@blorp-labs/piefed-api-client 0.0.0-7e59b13 → 0.0.0-90bfbe5

package/dist/zod-index.js

@@ -1,13 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 // Re-export generated Zod validation schemas (tags-split)
-export * from './zod/admin/admin';
-export * from './zod/comment/comment';
-export * from './zod/community/community';
-export * from './zod/feed/feed';
-export * from './zod/misc/misc';
-export * from './zod/post/post';
-export * from './zod/private-message/private-message';
-export * from './zod/site/site';
-export * from './zod/topic/topic';
-export * from './zod/upload/upload';
-export * from './zod/user/user';
+__exportStar(require("./zod/admin/admin"), exports);
+__exportStar(require("./zod/comment/comment"), exports);
+__exportStar(require("./zod/community/community"), exports);
+__exportStar(require("./zod/feed/feed"), exports);
+__exportStar(require("./zod/misc/misc"), exports);
+__exportStar(require("./zod/post/post"), exports);
+__exportStar(require("./zod/private-message/private-message"), exports);
+__exportStar(require("./zod/site/site"), exports);
+__exportStar(require("./zod/topic/topic"), exports);
+__exportStar(require("./zod/upload/upload"), exports);
+__exportStar(require("./zod/user/user"), exports);
 //# sourceMappingURL=zod-index.js.map

package/dist/zod-index.js.map

@@ -1 +1 @@
-{"version":3,"file":"zod-index.js","sourceRoot":"","sources":["../src/zod-index.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uCAAuC,CAAC;AACtD,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"zod-index.js","sourceRoot":"","sources":["../src/zod-index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0DAA0D;AAC1D,oDAAkC;AAClC,wDAAsC;AACtC,4DAA0C;AAC1C,kDAAgC;AAChC,kDAAgC;AAChC,kDAAgC;AAChC,wEAAsD;AACtD,kDAAgC;AAChC,oDAAkC;AAClC,sDAAoC;AACpC,kDAAgC"}

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@blorp-labs/piefed-api-client",
-  "version": "0.0.0-7e59b13",
+  "version": "0.0.0-90bfbe5",
   "description": "Typed TypeScript client for the PieFed API, generated from the OpenAPI spec",
-  "type": "module",
   "packageManager": "pnpm@10.6.5",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,14 +22,18 @@
   "scripts": {
     "generate": "orval --config orval.config.ts",
     "build": "tsc",
-    "prepublishOnly": "pnpm build"
+    "prepublishOnly": "pnpm build",
+    "test": "vitest run",
+    "prepare": "husky"
   },
   "dependencies": {
     "zod": "^3.23.8"
   },
   "devDependencies": {
+    "husky": "^9.1.7",
     "orval": "^7.3.0",
-    "typescript": "^5.7.3"
+    "typescript": "^5.7.3",
+    "vitest": "^2.0.0"
   },
   "repository": {
     "type": "git",

package/src/__tests__/create-client.test.ts

@@ -0,0 +1,317 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { createClient } from '../create-client';
+import { ApiError } from '../mutator/custom-fetch';
+
+const BASE_URL = 'https://test.example.com';
+
+function makeResponse(body: unknown, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
+let fetchSpy: ReturnType<typeof vi.fn>;
+
+beforeEach(() => {
+  fetchSpy = vi.fn().mockImplementation(() => Promise.resolve(makeResponse({ ok: true })));
+  vi.stubGlobal('fetch', fetchSpy);
+});
+
+afterEach(() => vi.unstubAllGlobals());
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function lastCall() {
+  return fetchSpy.mock.calls[fetchSpy.mock.calls.length - 1] as [string, RequestInit];
+}
+
+function lastUrl() {
+  return lastCall()[0];
+}
+
+function lastOptions() {
+  return lastCall()[1];
+}
+
+function lastHeaders(): Record<string, string> {
+  return (lastOptions().headers ?? {}) as Record<string, string>;
+}
+
+// ---------------------------------------------------------------------------
+// GET no-params  (fn.length = 1): getApiAlphaSite(options?)
+// ---------------------------------------------------------------------------
+
+describe('getApiAlphaSite — GET, no params', () => {
+  it('forwards default headers', async () => {
+    const client = createClient(BASE_URL, {
+      headers: { Authorization: 'Bearer tok' },
+    });
+    await client.getApiAlphaSite();
+    expect(lastHeaders()['Authorization']).toBe('Bearer tok');
+  });
+
+  it('merges per-call headers on top of defaults (per-call wins)', async () => {
+    const client = createClient(BASE_URL, {
+      headers: { Authorization: 'Bearer default', 'X-Custom': 'base' },
+    });
+    await client.getApiAlphaSite({ headers: { Authorization: 'Bearer override' } });
+    expect(lastHeaders()['Authorization']).toBe('Bearer override');
+    expect(lastHeaders()['X-Custom']).toBe('base');
+  });
+
+  it('forwards default RequestInit options (e.g. cache)', async () => {
+    const client = createClient(BASE_URL, { cache: 'no-store' });
+    await client.getApiAlphaSite();
+    expect(lastOptions().cache).toBe('no-store');
+  });
+
+  it('per-call RequestInit options override defaults', async () => {
+    const client = createClient(BASE_URL, { cache: 'no-store' });
+    await client.getApiAlphaSite({ cache: 'force-cache' });
+    expect(lastOptions().cache).toBe('force-cache');
+  });
+
+  it('prepends baseUrl to the path', async () => {
+    const client = createClient(BASE_URL);
+    await client.getApiAlphaSite();
+    expect(lastUrl()).toBe(`${BASE_URL}/api/alpha/site`);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// GET optional-params  (fn.length = 2): getApiAlphaPostList(params?, options?)
+// ---------------------------------------------------------------------------
+
+describe('getApiAlphaPostList — GET, optional params', () => {
+  it('forwards default headers when params are provided', async () => {
+    const client = createClient(BASE_URL, {
+      headers: { Authorization: 'Bearer tok' },
+    });
+    await client.getApiAlphaPostList({ page: 1 });
+    expect(lastHeaders()['Authorization']).toBe('Bearer tok');
+  });
+
+  it('forwards default headers when params are omitted', async () => {
+    const client = createClient(BASE_URL, {
+      headers: { Authorization: 'Bearer tok' },
+    });
+    await client.getApiAlphaPostList();
+    expect(lastHeaders()['Authorization']).toBe('Bearer tok');
+  });
+
+  it('merges per-call headers (options as second arg)', async () => {
+    const client = createClient(BASE_URL, {
+      headers: { Authorization: 'Bearer default' },
+    });
+    await client.getApiAlphaPostList(
+      { page: 1 },
+      { headers: { Authorization: 'Bearer override' } },
+    );
+    expect(lastHeaders()['Authorization']).toBe('Bearer override');
+  });
+
+  it('constructs correct URL with query params', async () => {
+    const client = createClient(BASE_URL);
+    await client.getApiAlphaPostList({ page: 2 });
+    expect(lastUrl()).toContain(`${BASE_URL}/api/alpha/post/list`);
+    expect(lastUrl()).toContain('page=2');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// GET required-params  (fn.length = 2): getApiAlphaPost(params, options?)
+// ---------------------------------------------------------------------------
+
+describe('getApiAlphaPost — GET, required params', () => {
+  const params = { id: 42 };
+
+  it('forwards default headers', async () => {
+    const client = createClient(BASE_URL, {
+      headers: { Authorization: 'Bearer tok' },
+    });
+    await client.getApiAlphaPost(params);
+    expect(lastHeaders()['Authorization']).toBe('Bearer tok');
+  });
+
+  it('merges per-call headers', async () => {
+    const client = createClient(BASE_URL, {
+      headers: { Authorization: 'Bearer default' },
+    });
+    await client.getApiAlphaPost(params, { headers: { Authorization: 'Bearer override' } });
+    expect(lastHeaders()['Authorization']).toBe('Bearer override');
+  });
+
+  it('forwards default cache option', async () => {
+    const client = createClient(BASE_URL, { cache: 'no-store' });
+    await client.getApiAlphaPost(params);
+    expect(lastOptions().cache).toBe('no-store');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// POST required-body  (fn.length = 2): postApiAlphaSiteBlock(body, options?)
+// ---------------------------------------------------------------------------
+
+describe('postApiAlphaSiteBlock — POST, required body', () => {
+  const body = { instance: 'spam.example.com', block: true };
+
+  it('sends the body correctly (not corrupted)', async () => {
+    const client = createClient(BASE_URL);
+    await client.postApiAlphaSiteBlock(body);
+    expect(lastOptions().body).toBe(JSON.stringify(body));
+  });
+
+  it('forwards default headers alongside Content-Type', async () => {
+    const client = createClient(BASE_URL, {
+      headers: { Authorization: 'Bearer tok' },
+    });
+    await client.postApiAlphaSiteBlock(body);
+    expect(lastHeaders()['Authorization']).toBe('Bearer tok');
+    expect(lastHeaders()['Content-Type']).toBe('application/json');
+  });
+
+  it('merges per-call headers without losing body', async () => {
+    const client = createClient(BASE_URL, {
+      headers: { Authorization: 'Bearer default' },
+    });
+    await client.postApiAlphaSiteBlock(body, {
+      headers: { Authorization: 'Bearer override' },
+    });
+    expect(lastHeaders()['Authorization']).toBe('Bearer override');
+    expect(lastOptions().body).toBe(JSON.stringify(body));
+  });
+
+  it('uses POST method', async () => {
+    const client = createClient(BASE_URL);
+    await client.postApiAlphaSiteBlock(body);
+    expect(lastOptions().method).toBe('POST');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Error handling
+// ---------------------------------------------------------------------------
+
+describe('ApiError', () => {
+  it('throws ApiError with correct status and data on 4xx', async () => {
+    fetchSpy.mockImplementation(() => Promise.resolve(makeResponse({ error: 'not found' }, 404)));
+    const client = createClient(BASE_URL);
+
+    await expect(client.getApiAlphaSite()).rejects.toMatchObject({
+      name: 'ApiError',
+      status: 404,
+      data: { error: 'not found' },
+    });
+  });
+
+  it('throws ApiError on 5xx', async () => {
+    fetchSpy.mockImplementation(() => Promise.resolve(makeResponse({ error: 'server error' }, 500)));
+    const client = createClient(BASE_URL);
+
+    const err = await client.getApiAlphaSite().catch((e) => e);
+    expect(err).toBeInstanceOf(ApiError);
+    expect(err.status).toBe(500);
+  });
+
+  it('throws ApiError (not SyntaxError) when response body is non-JSON', async () => {
+    fetchSpy.mockImplementation(() =>
+      Promise.resolve(new Response('<html>Gateway Timeout</html>', { status: 504 })),
+    );
+    const client = createClient(BASE_URL);
+
+    const err = await client.getApiAlphaSite().catch((e) => e);
+    expect(err).toBeInstanceOf(ApiError);
+    expect(err.status).toBe(504);
+    expect(err.data).toBe('<html>Gateway Timeout</html>');
+  });
+
+  it('returns parsed JSON on success', async () => {
+    fetchSpy.mockImplementation(() =>
+      Promise.resolve(new Response('not json', { status: 200 })),
+    );
+    const client = createClient(BASE_URL);
+
+    const result = await client.getApiAlphaSite();
+    expect(result).toBe('not json');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// No-body responses (204 / 205 / 304)
+// ---------------------------------------------------------------------------
+
+describe('no-body responses', () => {
+  // customFetch returns {} for no-body statuses regardless of the expected return type.
+  // This is a known type hole: TypeScript promises GetSiteResponse but {} is returned at runtime.
+  // Endpoints that legitimately return 204 (some POSTs/DELETEs) are fine; for GET endpoints
+  // this would indicate a server bug that currently passes through silently.
+  it.each([204, 205])('status %i resolves to empty object', async (status) => {
+    fetchSpy.mockImplementation(() => Promise.resolve(new Response(null, { status })));
+    const client = createClient(BASE_URL);
+    const result = await client.getApiAlphaSite();
+    expect(result).toEqual({});
+  });
+
+  it('status 304 throws ApiError with empty data (not a body-read error)', async () => {
+    fetchSpy.mockImplementation(() => Promise.resolve(new Response(null, { status: 304 })));
+    const client = createClient(BASE_URL);
+    const err = await client.getApiAlphaSite().catch((e) => e);
+    expect(err).toBeInstanceOf(ApiError);
+    expect(err.status).toBe(304);
+    expect(err.data).toEqual({});
+  });
+});
+
+// ---------------------------------------------------------------------------
+// AbortController
+// ---------------------------------------------------------------------------
+
+describe('AbortController', () => {
+  it('forwards signal to fetch', async () => {
+    const controller = new AbortController();
+    const client = createClient(BASE_URL);
+    await client.getApiAlphaSite({ signal: controller.signal });
+    expect(lastOptions().signal).toBe(controller.signal);
+  });
+
+  it('propagates abort error when signal is already aborted', async () => {
+    const controller = new AbortController();
+    controller.abort();
+    fetchSpy.mockImplementation((_url: string, opts: RequestInit) => {
+      if (opts.signal?.aborted) return Promise.reject(new DOMException('Aborted', 'AbortError'));
+      return Promise.resolve(makeResponse({ ok: true }));
+    });
+    const client = createClient(BASE_URL);
+    const err = await client.getApiAlphaSite({ signal: controller.signal }).catch((e) => e);
+    expect(err.name).toBe('AbortError');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// baseUrl
+// ---------------------------------------------------------------------------
+
+describe('baseUrl construction', () => {
+  it('trims trailing slash from baseUrl', async () => {
+    const client = createClient('https://test.example.com/');
+    await client.getApiAlphaSite();
+    expect(lastUrl()).toBe('https://test.example.com/api/alpha/site');
+  });
+
+  it('different clients use their own baseUrl', async () => {
+    const a = createClient('https://instance-a.com');
+    const b = createClient('https://instance-b.com');
+
+    await a.getApiAlphaSite();
+    const urlA = lastUrl();
+
+    await b.getApiAlphaSite();
+    const urlB = lastUrl();
+
+    expect(urlA).toBe('https://instance-a.com/api/alpha/site');
+    expect(urlB).toBe('https://instance-b.com/api/alpha/site');
+  });
+});

package/src/client/admin/admin.ts

@@ -5,11 +5,9 @@
  * OpenAPI spec version: alpha 1.6
  */
 import type {
-  DefaultError,
   GetApiAlphaAdminRegistrationApplicationListParams,
   GetRegistrationListResponse,
-  RegistrationApproveRequest,
-  UnprocessableEntityResponse
+  RegistrationApproveRequest
 } from '../../schemas';
 
 import { customFetch } from '../../mutator/custom-fetch';
@@ -17,30 +15,6 @@ import { customFetch } from '../../mutator/custom-fetch';
 /**
  * @summary Get the list of applications ready for admin review
  */
-export type getApiAlphaAdminRegistrationApplicationListResponse200 = {
-  data: GetRegistrationListResponse
-  status: 200
-}
-
-export type getApiAlphaAdminRegistrationApplicationListResponse400 = {
-  data: DefaultError
-  status: 400
-}
-
-export type getApiAlphaAdminRegistrationApplicationListResponse422 = {
-  data: UnprocessableEntityResponse
-  status: 422
-}
-    
-export type getApiAlphaAdminRegistrationApplicationListResponseSuccess = (getApiAlphaAdminRegistrationApplicationListResponse200) & {
-  headers: Headers;
-};
-export type getApiAlphaAdminRegistrationApplicationListResponseError = (getApiAlphaAdminRegistrationApplicationListResponse400 | getApiAlphaAdminRegistrationApplicationListResponse422) & {
-  headers: Headers;
-};
-
-export type getApiAlphaAdminRegistrationApplicationListResponse = (getApiAlphaAdminRegistrationApplicationListResponseSuccess | getApiAlphaAdminRegistrationApplicationListResponseError)
-
 export const getGetApiAlphaAdminRegistrationApplicationListUrl = (params?: GetApiAlphaAdminRegistrationApplicationListParams,) => {
   const normalizedParams = new URLSearchParams();
 
@@ -56,9 +30,9 @@ export const getGetApiAlphaAdminRegistrationApplicationListUrl = (params?: GetAp
   return stringifiedParams.length > 0 ? `/api/alpha/admin/registration_application/list?${stringifiedParams}` : `/api/alpha/admin/registration_application/list`
 }
 
-export const getApiAlphaAdminRegistrationApplicationList = async (params?: GetApiAlphaAdminRegistrationApplicationListParams, options?: RequestInit): Promise<getApiAlphaAdminRegistrationApplicationListResponse> => {
+export const getApiAlphaAdminRegistrationApplicationList = async (params?: GetApiAlphaAdminRegistrationApplicationListParams, options?: RequestInit): Promise<GetRegistrationListResponse> => {
   
-  return customFetch<getApiAlphaAdminRegistrationApplicationListResponse>(getGetApiAlphaAdminRegistrationApplicationListUrl(params),
+  return customFetch<GetRegistrationListResponse>(getGetApiAlphaAdminRegistrationApplicationListUrl(params),
   {      
     ...options,
     method: 'GET'
@@ -71,30 +45,6 @@ export const getApiAlphaAdminRegistrationApplicationList = async (params?: GetAp
 /**
  * @summary Approve or deny a registration
  */
-export type putApiAlphaAdminRegistrationApplicationApproveResponse200 = {
-  data: void
-  status: 200
-}
-
-export type putApiAlphaAdminRegistrationApplicationApproveResponse400 = {
-  data: DefaultError
-  status: 400
-}
-
-export type putApiAlphaAdminRegistrationApplicationApproveResponse422 = {
-  data: UnprocessableEntityResponse
-  status: 422
-}
-    
-export type putApiAlphaAdminRegistrationApplicationApproveResponseSuccess = (putApiAlphaAdminRegistrationApplicationApproveResponse200) & {
-  headers: Headers;
-};
-export type putApiAlphaAdminRegistrationApplicationApproveResponseError = (putApiAlphaAdminRegistrationApplicationApproveResponse400 | putApiAlphaAdminRegistrationApplicationApproveResponse422) & {
-  headers: Headers;
-};
-
-export type putApiAlphaAdminRegistrationApplicationApproveResponse = (putApiAlphaAdminRegistrationApplicationApproveResponseSuccess | putApiAlphaAdminRegistrationApplicationApproveResponseError)
-
 export const getPutApiAlphaAdminRegistrationApplicationApproveUrl = () => {
 
 
@@ -103,9 +53,9 @@ export const getPutApiAlphaAdminRegistrationApplicationApproveUrl = () => {
   return `/api/alpha/admin/registration_application/approve`
 }
 
-export const putApiAlphaAdminRegistrationApplicationApprove = async (registrationApproveRequest: RegistrationApproveRequest, options?: RequestInit): Promise<putApiAlphaAdminRegistrationApplicationApproveResponse> => {
+export const putApiAlphaAdminRegistrationApplicationApprove = async (registrationApproveRequest: RegistrationApproveRequest, options?: RequestInit): Promise<void> => {
   
-  return customFetch<putApiAlphaAdminRegistrationApplicationApproveResponse>(getPutApiAlphaAdminRegistrationApplicationApproveUrl(),
+  return customFetch<void>(getPutApiAlphaAdminRegistrationApplicationApproveUrl(),
   {      
     ...options,
     method: 'PUT',