@brickninjaapi/fetch 0.0.19 → 0.0.23

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @brickninjaapi/fetch
 
+## 0.0.23
+
+### Patch Changes
+
+- 06e285a: fix(gha): update publish config
+
+## 0.0.22
+
+### Patch Changes
+
+- f6c3e57: Bump versions
+
+## 0.0.21
+
+### Patch Changes
+
+- Bump versions
+
+## 0.0.20
+
+### Patch Changes
+
+- Migrate to pnpm
+
+## 0.0.20
+
+### Patch Changes
+
+- Update versions
+
 ## 0.0.19
 
 ### Patch Changes

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@brickninjaapi/fetch",
-  "version": "0.0.19",
+  "version": "0.0.23",
   "description": "Tiny wrapper around fetch that returns type-safe responses",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/brickninja-org/brickninjaapi-ts.git",
+    "url": "git+https://github.com/brickninja-org/brickninja-api-ts.git",
     "directory": "packages/fetch"
   },
   "keywords": [
@@ -21,12 +21,13 @@
     "build": "tsc"
   },
   "devDependencies": {
-    "typescript": "5.8.3"
+    "typescript": "5.9.3"
   },
   "peerDependencies": {
-    "@brickninjaapi/types": "~0.0.25"
+    "@brickninjaapi/types": "~0.0.26"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   }
 }

package/dist/index.d.ts

@@ -1,29 +0,0 @@
-import type { EndpointType, KnownEndpoint, OptionsByEndpoint } from '@brickninjaapi/types/endpoints';
-import type { SchemaVersion } from '@brickninjaapi/types/schema';
-type RequiredKeys<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
-}[keyof T];
-type Args<Url extends string, Schema extends SchemaVersion> = RequiredKeys<OptionsByEndpoint<Url>> extends never ? [endpoint: Url, options?: FetchBrickNinjaApiOptions<Schema> & OptionsByEndpoint<Url> & FetchOptions] : [endpoint: Url, options: FetchBrickNinjaApiOptions<Schema> & OptionsByEndpoint<Url> & FetchOptions];
-export declare function fetchBrickNinjaApi<Url extends KnownEndpoint | (string & {}), Schema extends SchemaVersion = undefined>(...[endpoint, options]: Args<Url, Schema>): Promise<EndpointType<Url, Schema>>;
-export type FetchBrickNinjaApiOptions<Schema extends SchemaVersion> = {
-    /** The schema to use when making the API request */
-    schema?: Schema;
-    /** onRequest handler allows to modify the request made to the Brick Ninja API. */
-    onRequest?: (request: Request) => Request | Promise<Request>;
-    /**
-     * onResponse handler. Called for all responses, successful or not.
-     * Make sure to clone the response in case of consuming the body.
-     */
-    onResponse?: (response: Response) => void | Promise<void>;
-};
-export type FetchOptions = {
-    /** @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal */
-    signal?: AbortSignal;
-    /** @see https://developer.mozilla.org/en-US/docs/Web/API/Request/cache */
-    cache?: RequestCache;
-};
-export declare class BrickNinjaApiError extends Error {
-    response: Response;
-    constructor(message: string, response: Response);
-}
-export {};

package/dist/index.js

@@ -1,87 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-export function fetchBrickNinjaApi() {
-    return __awaiter(this, arguments, void 0, function* (...[endpoint, options]) {
-        var _a;
-        const url = new URL(endpoint, 'https://brick-ninja-api.vercel.app/');
-        if (options.schema) {
-            url.searchParams.set('v', options.schema);
-        }
-        if (hasLanguage(options)) {
-            url.searchParams.set('lang', options.language);
-        }
-        if (hasAccessToken(options)) {
-            url.searchParams.set('access_token', options.accessToken);
-        }
-        // build request
-        let request = new Request(url, {
-            // The Brick Ninja API never uses redirects, so we want to error if we encounter one.
-            // We use `manual` instead of `error` here so we can throw our own `BrickNinjaApiError` with the response attached
-            redirect: 'manual',
-            // set signal and cache from options
-            signal: options.signal,
-            cache: options.cache
-        });
-        // if there is a onRequest handler registered, let it modify the request
-        if (options.onRequest) {
-            request = yield options.onRequest(request);
-            if (!(request instanceof Request)) {
-                throw new Error(`onRequest has to return a Request`);
-            }
-        }
-        // call the API
-        const response = yield fetch(request);
-        // call onResponse handler
-        yield ((_a = options.onResponse) === null || _a === void 0 ? void 0 : _a.call(options, response));
-        // check if the response is json (`application/json; charset=utf-8`)
-        const isJson = response.headers.get('content-type').startsWith('application/json');
-        // censor access token in url to not leak it in error messages
-        const erroredUrl = hasAccessToken(options)
-            ? url.toString().replace(options.accessToken, '***')
-            : url.toString();
-        // check if the response is an error
-        if (!response.ok) {
-            // if the response is JSON, it might have more details in the `text` prop
-            if (isJson) {
-                const error = yield response.json();
-                if (typeof error === 'object' && 'text' in error && typeof error.text === 'string') {
-                    throw new BrickNinjaApiError(`The Brick Ninja API call to '${erroredUrl}' returned ${response.status} ${response.statusText}: ${error.text}.`, response);
-                }
-            }
-            // otherwise just throw error with the status code
-            throw new BrickNinjaApiError(`The Brick Ninja API call to '${erroredUrl}' returned ${response.status} ${response.statusText}.`, response);
-        }
-        // if the response is not JSON, throw an error
-        if (!isJson) {
-            throw new BrickNinjaApiError(`The Brick Ninja API call to '${erroredUrl}' did not respond with a JSON response`, response);
-        }
-        // parse json
-        const json = yield response.json();
-        // check that json is not `["v1", "v2"]` which sometimes happens for authenticated endpoints
-        if (url.toString() !== 'https://brick-ninja-api.vercel.app/' && Array.isArray(json) && json.length === 2 && json[0] === 'v1' && json[1] === 'v2') {
-            throw new BrickNinjaApiError(`The Brick Ninja API call to '${erroredUrl}' did returned an invalid response (["v1", "v2"])`, response);
-        }
-        // TODO: catch more errors
-        return json;
-    });
-}
-export class BrickNinjaApiError extends Error {
-    constructor(message, response) {
-        super(message);
-        this.response = response;
-        this.name = 'BrickNinjaApiError';
-    }
-}
-function hasLanguage(options) {
-    return 'language' in options;
-}
-function hasAccessToken(options) {
-    return 'accessToken' in options;
-}