@pikku/fetch 0.6.1

package/CHANGELOG.md

@@ -0,0 +1,61 @@
+# @pikku/fetch
+
+## 0.6.1
+
+### Patch Changes
+
+- 2bc64fd: feat: adding methods to fetch wrapper (and small fixes)
+- a40a508: fix: Fixing some generation bugs and other minors
+
+## 0.6
+
+Marking a major release to include channels and scheduled tasks
+
+## 0.5.8
+
+### Patch Changes
+
+- 886a2fb: refactor: moving singletons (like routes and channels) to global to avoid nodemodule overrides
+
+## 0.5.7
+
+### Patch Changes
+
+- 0f96787: refactor: dropping cjs support
+- c23524a: refactor: bump to versions to ensure correct package usage
+
+## 0.5.6
+
+### Patch Changes
+
+- bba25cc: chore: updating all packages to reflect major changes
+
+## 0.5.5
+
+### Patch Changes
+
+- 35d1a49: fix: server url shouldn't with a /, bug with //
+
+## 0.5.4
+
+### Patch Changes
+
+- 78a17e8: fix: avoid // when concatenating serverUrl and uri
+
+## 0.5.3
+
+### Patch Changes
+
+- effbb4c: doc: adding readme to all packages
+
+## 0.5.2
+
+### Patch Changes
+
+- 725723d: docs: adding typedocs
+
+## 0.5.1
+
+### Patch Changes
+
+- b237ace: fix: fixing bugs in fetch

package/README.md

@@ -0,0 +1,3 @@
+# @pikku/fetch
+
+This package is part of @pikku/mono and is responsible making HTTP calls that are correctly typed and pikku compatible.

package/dist/cjs/abstract-pikku-fetch.d.ts

@@ -0,0 +1,99 @@
+type AuthHeaders = {
+    jwt?: string;
+    apiKey?: string;
+};
+export type HTTPMethod = 'GET' | 'POST' | 'PATCH' | 'DELETE' | 'HEAD' | 'PUT';
+/**
+ * Options for configuring the `CorePikkuFetch` utility.
+ *
+ * @typedef {Object} CorePikkuFetchOptions
+ * @property {boolean} [transformDate] - Whether to transform date-like strings in the response to `Date` objects.
+ * @property {string} [serverUrl] - The base server URL for requests.
+ * @property {AuthHeaders} [authHeaders] - Authorization headers, including JWT or API key.
+ * @property {RequestInit['cache']} [cache] - The cache mode for the request.
+ * @property {RequestInit['credentials']} [credentials] - The credentials mode for the request.
+ * @property {RequestInit['mode']} [mode] - The mode for the request.
+ */
+export type CorePikkuFetchOptions = {
+    transformDate?: boolean;
+    serverUrl?: string;
+    authHeaders?: AuthHeaders;
+} & Pick<RequestInit, 'cache' | 'credentials' | 'mode'>;
+/**
+ * The `CorePikkuFetch` class provides a utility for making HTTP requests, including handling authorization,
+ * transforming dates in responses, and managing server URLs. This class is designed to simplify API interactions
+ * with configurable options and support for JWT and API key-based authentication.
+ */
+export declare class CorePikkuFetch {
+    private options;
+    private authHeaders;
+    /**
+     * Constructs a new instance of the `CorePikkuFetch` class.
+     *
+     * @param {CorePikkuFetchOptions} options - Optional configuration for the fetch utility.
+     */
+    constructor(options?: CorePikkuFetchOptions);
+    /**
+     * Generates the headers for the request, including authorization headers if set.
+     *
+     * @returns {Record<string, string>} - The headers for the request.
+     */
+    private getHeaders;
+    /**
+     * Sets the server URL for subsequent requests.
+     *
+     * @param {string} serverUrl - The server URL to be set.
+     */
+    setServerUrl(serverUrl: string): Promise<void>;
+    /**
+     * Sets the JWT for authorization.
+     *
+     * @param {string} jwt - The JWT to be used for authorization.
+     */
+    setAuthorizationJWT(jwt: string | null): void;
+    /**
+     * Sets the API key for authorization.
+     *
+     * @param {string} [apiKey] - The API key to be used for authorization.
+     */
+    setAPIKey(apiKey: string | null): void;
+    post(uri: string, data: any, options?: RequestInit): Promise<any>;
+    get(uri: string, data: any, options?: RequestInit): Promise<any>;
+    patch(uri: string, data: any, options?: RequestInit): Promise<any>;
+    head(uri: string, data: any, options?: RequestInit): Promise<any>;
+    /**
+     * Makes an API request with the specified URI, method, and data, and optionally transforms dates in the response.
+     *
+     * @param {string} uri - The endpoint URI for the request.
+     * @param {HTTPMethod} method - The HTTP method for the request.
+     * @param {any} data - The data to be sent with the request.
+     * @param {RequestInit} [options] - Additional options for the request.
+     * @returns {Promise<any>} - A promise that resolves to the response data.
+     * @throws {Response} - Throws the response if the status code is greater than 400.
+     */
+    api(uri: string, method: HTTPMethod, data: any, options?: RequestInit): Promise<any>;
+    /**
+     * Makes a raw fetch request with the specified URI, method, and data.
+     *
+     * @param {string} uri - The endpoint URI for the request.
+     * @param {HTTPMethod} method - The HTTP method for the request.
+     * @param {any} data - The data to be sent with the request.
+     * @param {RequestInit} [options] - Additional options for the request.
+     * @returns {Promise<Response>} - A promise that resolves to the fetch response.
+     */
+    fetch(uri: string, method: HTTPMethod, data: any, options?: RequestInit): Promise<Response>;
+    /**
+     * Verifies that the server URL is set before making a request.
+     *
+     * @throws {Error} - Throws an error if the server URL is not set.
+     */
+    private verifyServerUrlSet;
+    /**
+     * Transforms date-like strings in the response data into `Date` objects if the `transformDate` option is set.
+     *
+     * @param {any} data - The data to transform.
+     * @returns {any} - The transformed data.
+     */
+    private transformDates;
+}
+export {};

package/dist/cjs/abstract-pikku-fetch.js

@@ -0,0 +1,178 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorePikkuFetch = void 0;
+const transform_date_js_1 = require("./transform-date.js");
+const pikku_fetch_js_1 = require("./pikku-fetch.js");
+/**
+ * The `CorePikkuFetch` class provides a utility for making HTTP requests, including handling authorization,
+ * transforming dates in responses, and managing server URLs. This class is designed to simplify API interactions
+ * with configurable options and support for JWT and API key-based authentication.
+ */
+class CorePikkuFetch {
+    /**
+     * Constructs a new instance of the `CorePikkuFetch` class.
+     *
+     * @param {CorePikkuFetchOptions} options - Optional configuration for the fetch utility.
+     */
+    constructor(options = {}) {
+        this.options = options;
+        this.authHeaders = {};
+        this.authHeaders = options.authHeaders || {};
+    }
+    /**
+     * Generates the headers for the request, including authorization headers if set.
+     *
+     * @returns {Record<string, string>} - The headers for the request.
+     */
+    getHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.authHeaders.jwt) {
+            headers.Authorization = `Bearer ${this.authHeaders.jwt}`;
+        }
+        else if (this.authHeaders.apiKey) {
+            headers['X-API-KEY'] = this.authHeaders.apiKey;
+        }
+        return headers;
+    }
+    /**
+     * Sets the server URL for subsequent requests.
+     *
+     * @param {string} serverUrl - The server URL to be set.
+     */
+    setServerUrl(serverUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (serverUrl.endsWith('/')) {
+                console.warn('Server URL should not end with a slash, removing.');
+                serverUrl = serverUrl.slice(0, -1);
+            }
+            this.options.serverUrl = serverUrl;
+        });
+    }
+    /**
+     * Sets the JWT for authorization.
+     *
+     * @param {string} jwt - The JWT to be used for authorization.
+     */
+    setAuthorizationJWT(jwt) {
+        if (jwt) {
+            this.authHeaders.jwt = jwt;
+        }
+        else {
+            delete this.authHeaders.jwt;
+        }
+    }
+    /**
+     * Sets the API key for authorization.
+     *
+     * @param {string} [apiKey] - The API key to be used for authorization.
+     */
+    setAPIKey(apiKey) {
+        if (apiKey) {
+            this.authHeaders.apiKey = apiKey;
+        }
+        else {
+            delete this.authHeaders.apiKey;
+        }
+    }
+    post(uri, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.api(uri, 'POST', data, options);
+        });
+    }
+    get(uri, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.api(uri, 'GET', data, options);
+        });
+    }
+    patch(uri, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.api(uri, 'PATCH', data, options);
+        });
+    }
+    head(uri, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.api(uri, 'HEAD', data, options);
+        });
+    }
+    /**
+     * Makes an API request with the specified URI, method, and data, and optionally transforms dates in the response.
+     *
+     * @param {string} uri - The endpoint URI for the request.
+     * @param {HTTPMethod} method - The HTTP method for the request.
+     * @param {any} data - The data to be sent with the request.
+     * @param {RequestInit} [options] - Additional options for the request.
+     * @returns {Promise<any>} - A promise that resolves to the response data.
+     * @throws {Response} - Throws the response if the status code is greater than 400.
+     */
+    api(uri, method, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.fetch(uri, method, data, options);
+            if (response.status >= 400) {
+                throw response;
+            }
+            try {
+                const result = yield response.json();
+                return this.transformDates(result);
+            }
+            catch (_a) {
+                // TODO: If it doesn't return anything..
+                return;
+            }
+        });
+    }
+    /**
+     * Makes a raw fetch request with the specified URI, method, and data.
+     *
+     * @param {string} uri - The endpoint URI for the request.
+     * @param {HTTPMethod} method - The HTTP method for the request.
+     * @param {any} data - The data to be sent with the request.
+     * @param {RequestInit} [options] - Additional options for the request.
+     * @returns {Promise<Response>} - A promise that resolves to the fetch response.
+     */
+    fetch(uri, method, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.verifyServerUrlSet();
+            if (uri.startsWith('/')) {
+                uri = `${this.options.serverUrl}${uri}`;
+            }
+            else {
+                uri = `${this.options.serverUrl}/${uri}`;
+            }
+            return yield (0, pikku_fetch_js_1.corePikkuFetch)(uri, data, Object.assign(Object.assign({}, options), { method, mode: this.options.mode, credentials: this.options.credentials, headers: Object.assign(Object.assign({}, this.getHeaders()), options === null || options === void 0 ? void 0 : options.headers) }));
+        });
+    }
+    /**
+     * Verifies that the server URL is set before making a request.
+     *
+     * @throws {Error} - Throws an error if the server URL is not set.
+     */
+    verifyServerUrlSet() {
+        if (!this.options.serverUrl) {
+            throw new Error('Server url is not set');
+        }
+    }
+    /**
+     * Transforms date-like strings in the response data into `Date` objects if the `transformDate` option is set.
+     *
+     * @param {any} data - The data to transform.
+     * @returns {any} - The transformed data.
+     */
+    transformDates(data) {
+        if (!this.options.transformDate) {
+            return data;
+        }
+        return (0, transform_date_js_1.transformDates)(data);
+    }
+}
+exports.CorePikkuFetch = CorePikkuFetch;

package/dist/cjs/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This module provides a wrapper around the Fetch API that integrates with the Pikku framework.
+ * It includes utilities for making HTTP requests, such as options for authorization, server URL management,
+ * and transforming dates in responses, while ensuring requests are validated against Pikku routes.
+ * The module exports the `CorePikkuFetch` class, as well as other supporting types and functions.
+ *
+ * @module @pikku/fetch
+ */
+export { CorePikkuFetch, CorePikkuFetchOptions, HTTPMethod, } from './abstract-pikku-fetch.js';
+export { corePikkuFetch } from './pikku-fetch.js';

package/dist/cjs/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * This module provides a wrapper around the Fetch API that integrates with the Pikku framework.
+ * It includes utilities for making HTTP requests, such as options for authorization, server URL management,
+ * and transforming dates in responses, while ensuring requests are validated against Pikku routes.
+ * The module exports the `CorePikkuFetch` class, as well as other supporting types and functions.
+ *
+ * @module @pikku/fetch
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.corePikkuFetch = exports.CorePikkuFetch = void 0;
+var abstract_pikku_fetch_js_1 = require("./abstract-pikku-fetch.js");
+Object.defineProperty(exports, "CorePikkuFetch", { enumerable: true, get: function () { return abstract_pikku_fetch_js_1.CorePikkuFetch; } });
+var pikku_fetch_js_1 = require("./pikku-fetch.js");
+Object.defineProperty(exports, "corePikkuFetch", { enumerable: true, get: function () { return pikku_fetch_js_1.corePikkuFetch; } });

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/cjs/pikku-fetch.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `corePikkuFetch` function is a utility for making HTTP requests with dynamic URI and data handling.
+ * It can automatically replace URI parameters, append query strings for GET requests, and set the request body for POST, PATCH, or PUT requests.
+ *
+ * @param {string} uri - The endpoint URI for the request. URI parameters can be specified using `:param` syntax.
+ * @param {any} data - The data to be included in the request, either as query parameters or as the request body.
+ * @param {Omit<RequestInit, 'body'>} [options] - Optional configuration options for the fetch request, excluding the body.
+ * @returns {Promise<Response>} - A promise that resolves to the response of the fetch request.
+ */
+export declare const corePikkuFetch: (uri: string, data: any, options?: Omit<RequestInit, "body">) => Promise<Response>;

package/dist/cjs/pikku-fetch.js

@@ -0,0 +1,45 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.corePikkuFetch = void 0;
+/**
+ * The `corePikkuFetch` function is a utility for making HTTP requests with dynamic URI and data handling.
+ * It can automatically replace URI parameters, append query strings for GET requests, and set the request body for POST, PATCH, or PUT requests.
+ *
+ * @param {string} uri - The endpoint URI for the request. URI parameters can be specified using `:param` syntax.
+ * @param {any} data - The data to be included in the request, either as query parameters or as the request body.
+ * @param {Omit<RequestInit, 'body'>} [options] - Optional configuration options for the fetch request, excluding the body.
+ * @returns {Promise<Response>} - A promise that resolves to the response of the fetch request.
+ */
+const corePikkuFetch = (uri, data, options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const method = ((_a = options === null || options === void 0 ? void 0 : options.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'GET';
+    let body;
+    if (data) {
+        data = JSON.parse(JSON.stringify(data));
+        const keys = Object.keys(data);
+        for (const key of keys) {
+            if (uri.includes(`:${key}`)) {
+                uri = uri.replace(`:${key}`, data[key]);
+                delete data[key];
+            }
+        }
+        if (method === 'POST' || method === 'PATCH' || method === 'PUT') {
+            body = data;
+        }
+        else {
+            const queryString = new URLSearchParams(JSON.parse(JSON.stringify(data)));
+            uri = `${uri}?${queryString}`;
+        }
+    }
+    return yield fetch(uri, Object.assign(Object.assign({ method: method.toUpperCase() }, options), { body: body ? JSON.stringify(body) : undefined }));
+});
+exports.corePikkuFetch = corePikkuFetch;

package/dist/cjs/transform-date.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `transformDates` function recursively traverses an object or array and converts any date-like strings
+ * into JavaScript `Date` objects. This helps in ensuring that date fields are properly handled as `Date` instances
+ * rather than strings.
+ *
+ * @private
+ * @param {any} data - The input data that may contain date strings. It can be an object, array, or primitive value.
+ * @returns {any} - The transformed data with date strings converted to `Date` objects.
+ */
+export declare const transformDates: (data: any) => any;

package/dist/cjs/transform-date.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformDates = void 0;
+/**
+ * The `transformDates` function recursively traverses an object or array and converts any date-like strings
+ * into JavaScript `Date` objects. This helps in ensuring that date fields are properly handled as `Date` instances
+ * rather than strings.
+ *
+ * @private
+ * @param {any} data - The input data that may contain date strings. It can be an object, array, or primitive value.
+ * @returns {any} - The transformed data with date strings converted to `Date` objects.
+ */
+const transformDates = (data) => {
+    if (data === null)
+        return null;
+    if (Array.isArray(data))
+        return data.map(exports.transformDates.bind(this));
+    if (typeof data === 'object') {
+        return Object.entries(data).reduce((result, [key, value]) => {
+            result[key] = (0, exports.transformDates)(value);
+            return result;
+        }, {});
+    }
+    if (typeof data === 'string' &&
+        /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}\.\d{3}Z?)?/.test(data)) {
+        return new Date(data);
+    }
+    return data;
+};
+exports.transformDates = transformDates;

package/dist/esm/abstract-pikku-fetch.d.ts

@@ -0,0 +1,99 @@
+type AuthHeaders = {
+    jwt?: string;
+    apiKey?: string;
+};
+export type HTTPMethod = 'GET' | 'POST' | 'PATCH' | 'DELETE' | 'HEAD' | 'PUT';
+/**
+ * Options for configuring the `CorePikkuFetch` utility.
+ *
+ * @typedef {Object} CorePikkuFetchOptions
+ * @property {boolean} [transformDate] - Whether to transform date-like strings in the response to `Date` objects.
+ * @property {string} [serverUrl] - The base server URL for requests.
+ * @property {AuthHeaders} [authHeaders] - Authorization headers, including JWT or API key.
+ * @property {RequestInit['cache']} [cache] - The cache mode for the request.
+ * @property {RequestInit['credentials']} [credentials] - The credentials mode for the request.
+ * @property {RequestInit['mode']} [mode] - The mode for the request.
+ */
+export type CorePikkuFetchOptions = {
+    transformDate?: boolean;
+    serverUrl?: string;
+    authHeaders?: AuthHeaders;
+} & Pick<RequestInit, 'cache' | 'credentials' | 'mode'>;
+/**
+ * The `CorePikkuFetch` class provides a utility for making HTTP requests, including handling authorization,
+ * transforming dates in responses, and managing server URLs. This class is designed to simplify API interactions
+ * with configurable options and support for JWT and API key-based authentication.
+ */
+export declare class CorePikkuFetch {
+    private options;
+    private authHeaders;
+    /**
+     * Constructs a new instance of the `CorePikkuFetch` class.
+     *
+     * @param {CorePikkuFetchOptions} options - Optional configuration for the fetch utility.
+     */
+    constructor(options?: CorePikkuFetchOptions);
+    /**
+     * Generates the headers for the request, including authorization headers if set.
+     *
+     * @returns {Record<string, string>} - The headers for the request.
+     */
+    private getHeaders;
+    /**
+     * Sets the server URL for subsequent requests.
+     *
+     * @param {string} serverUrl - The server URL to be set.
+     */
+    setServerUrl(serverUrl: string): Promise<void>;
+    /**
+     * Sets the JWT for authorization.
+     *
+     * @param {string} jwt - The JWT to be used for authorization.
+     */
+    setAuthorizationJWT(jwt: string | null): void;
+    /**
+     * Sets the API key for authorization.
+     *
+     * @param {string} [apiKey] - The API key to be used for authorization.
+     */
+    setAPIKey(apiKey: string | null): void;
+    post(uri: string, data: any, options?: RequestInit): Promise<any>;
+    get(uri: string, data: any, options?: RequestInit): Promise<any>;
+    patch(uri: string, data: any, options?: RequestInit): Promise<any>;
+    head(uri: string, data: any, options?: RequestInit): Promise<any>;
+    /**
+     * Makes an API request with the specified URI, method, and data, and optionally transforms dates in the response.
+     *
+     * @param {string} uri - The endpoint URI for the request.
+     * @param {HTTPMethod} method - The HTTP method for the request.
+     * @param {any} data - The data to be sent with the request.
+     * @param {RequestInit} [options] - Additional options for the request.
+     * @returns {Promise<any>} - A promise that resolves to the response data.
+     * @throws {Response} - Throws the response if the status code is greater than 400.
+     */
+    api(uri: string, method: HTTPMethod, data: any, options?: RequestInit): Promise<any>;
+    /**
+     * Makes a raw fetch request with the specified URI, method, and data.
+     *
+     * @param {string} uri - The endpoint URI for the request.
+     * @param {HTTPMethod} method - The HTTP method for the request.
+     * @param {any} data - The data to be sent with the request.
+     * @param {RequestInit} [options] - Additional options for the request.
+     * @returns {Promise<Response>} - A promise that resolves to the fetch response.
+     */
+    fetch(uri: string, method: HTTPMethod, data: any, options?: RequestInit): Promise<Response>;
+    /**
+     * Verifies that the server URL is set before making a request.
+     *
+     * @throws {Error} - Throws an error if the server URL is not set.
+     */
+    private verifyServerUrlSet;
+    /**
+     * Transforms date-like strings in the response data into `Date` objects if the `transformDate` option is set.
+     *
+     * @param {any} data - The data to transform.
+     * @returns {any} - The transformed data.
+     */
+    private transformDates;
+}
+export {};

package/dist/esm/abstract-pikku-fetch.js

@@ -0,0 +1,158 @@
+import { transformDates } from './transform-date.js';
+import { corePikkuFetch } from './pikku-fetch.js';
+/**
+ * The `CorePikkuFetch` class provides a utility for making HTTP requests, including handling authorization,
+ * transforming dates in responses, and managing server URLs. This class is designed to simplify API interactions
+ * with configurable options and support for JWT and API key-based authentication.
+ */
+export class CorePikkuFetch {
+    options;
+    authHeaders = {};
+    /**
+     * Constructs a new instance of the `CorePikkuFetch` class.
+     *
+     * @param {CorePikkuFetchOptions} options - Optional configuration for the fetch utility.
+     */
+    constructor(options = {}) {
+        this.options = options;
+        this.authHeaders = options.authHeaders || {};
+    }
+    /**
+     * Generates the headers for the request, including authorization headers if set.
+     *
+     * @returns {Record<string, string>} - The headers for the request.
+     */
+    getHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.authHeaders.jwt) {
+            headers.Authorization = `Bearer ${this.authHeaders.jwt}`;
+        }
+        else if (this.authHeaders.apiKey) {
+            headers['X-API-KEY'] = this.authHeaders.apiKey;
+        }
+        return headers;
+    }
+    /**
+     * Sets the server URL for subsequent requests.
+     *
+     * @param {string} serverUrl - The server URL to be set.
+     */
+    async setServerUrl(serverUrl) {
+        if (serverUrl.endsWith('/')) {
+            console.warn('Server URL should not end with a slash, removing.');
+            serverUrl = serverUrl.slice(0, -1);
+        }
+        this.options.serverUrl = serverUrl;
+    }
+    /**
+     * Sets the JWT for authorization.
+     *
+     * @param {string} jwt - The JWT to be used for authorization.
+     */
+    setAuthorizationJWT(jwt) {
+        if (jwt) {
+            this.authHeaders.jwt = jwt;
+        }
+        else {
+            delete this.authHeaders.jwt;
+        }
+    }
+    /**
+     * Sets the API key for authorization.
+     *
+     * @param {string} [apiKey] - The API key to be used for authorization.
+     */
+    setAPIKey(apiKey) {
+        if (apiKey) {
+            this.authHeaders.apiKey = apiKey;
+        }
+        else {
+            delete this.authHeaders.apiKey;
+        }
+    }
+    async post(uri, data, options) {
+        return await this.api(uri, 'POST', data, options);
+    }
+    async get(uri, data, options) {
+        return await this.api(uri, 'GET', data, options);
+    }
+    async patch(uri, data, options) {
+        return await this.api(uri, 'PATCH', data, options);
+    }
+    async head(uri, data, options) {
+        return await this.api(uri, 'HEAD', data, options);
+    }
+    /**
+     * Makes an API request with the specified URI, method, and data, and optionally transforms dates in the response.
+     *
+     * @param {string} uri - The endpoint URI for the request.
+     * @param {HTTPMethod} method - The HTTP method for the request.
+     * @param {any} data - The data to be sent with the request.
+     * @param {RequestInit} [options] - Additional options for the request.
+     * @returns {Promise<any>} - A promise that resolves to the response data.
+     * @throws {Response} - Throws the response if the status code is greater than 400.
+     */
+    async api(uri, method, data, options) {
+        const response = await this.fetch(uri, method, data, options);
+        if (response.status >= 400) {
+            throw response;
+        }
+        try {
+            const result = await response.json();
+            return this.transformDates(result);
+        }
+        catch {
+            // TODO: If it doesn't return anything..
+            return;
+        }
+    }
+    /**
+     * Makes a raw fetch request with the specified URI, method, and data.
+     *
+     * @param {string} uri - The endpoint URI for the request.
+     * @param {HTTPMethod} method - The HTTP method for the request.
+     * @param {any} data - The data to be sent with the request.
+     * @param {RequestInit} [options] - Additional options for the request.
+     * @returns {Promise<Response>} - A promise that resolves to the fetch response.
+     */
+    async fetch(uri, method, data, options) {
+        this.verifyServerUrlSet();
+        if (uri.startsWith('/')) {
+            uri = `${this.options.serverUrl}${uri}`;
+        }
+        else {
+            uri = `${this.options.serverUrl}/${uri}`;
+        }
+        return await corePikkuFetch(uri, data, {
+            ...options,
+            method,
+            mode: this.options.mode,
+            credentials: this.options.credentials,
+            headers: { ...this.getHeaders(), ...options?.headers },
+        });
+    }
+    /**
+     * Verifies that the server URL is set before making a request.
+     *
+     * @throws {Error} - Throws an error if the server URL is not set.
+     */
+    verifyServerUrlSet() {
+        if (!this.options.serverUrl) {
+            throw new Error('Server url is not set');
+        }
+    }
+    /**
+     * Transforms date-like strings in the response data into `Date` objects if the `transformDate` option is set.
+     *
+     * @param {any} data - The data to transform.
+     * @returns {any} - The transformed data.
+     */
+    transformDates(data) {
+        if (!this.options.transformDate) {
+            return data;
+        }
+        return transformDates(data);
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This module provides a wrapper around the Fetch API that integrates with the Pikku framework.
+ * It includes utilities for making HTTP requests, such as options for authorization, server URL management,
+ * and transforming dates in responses, while ensuring requests are validated against Pikku routes.
+ * The module exports the `CorePikkuFetch` class, as well as other supporting types and functions.
+ *
+ * @module @pikku/fetch
+ */
+export { CorePikkuFetch, CorePikkuFetchOptions, HTTPMethod, } from './abstract-pikku-fetch.js';
+export { corePikkuFetch } from './pikku-fetch.js';

package/dist/esm/index.js

@@ -0,0 +1,10 @@
+/**
+ * This module provides a wrapper around the Fetch API that integrates with the Pikku framework.
+ * It includes utilities for making HTTP requests, such as options for authorization, server URL management,
+ * and transforming dates in responses, while ensuring requests are validated against Pikku routes.
+ * The module exports the `CorePikkuFetch` class, as well as other supporting types and functions.
+ *
+ * @module @pikku/fetch
+ */
+export { CorePikkuFetch, } from './abstract-pikku-fetch.js';
+export { corePikkuFetch } from './pikku-fetch.js';

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type": "module"}

package/dist/esm/pikku-fetch.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `corePikkuFetch` function is a utility for making HTTP requests with dynamic URI and data handling.
+ * It can automatically replace URI parameters, append query strings for GET requests, and set the request body for POST, PATCH, or PUT requests.
+ *
+ * @param {string} uri - The endpoint URI for the request. URI parameters can be specified using `:param` syntax.
+ * @param {any} data - The data to be included in the request, either as query parameters or as the request body.
+ * @param {Omit<RequestInit, 'body'>} [options] - Optional configuration options for the fetch request, excluding the body.
+ * @returns {Promise<Response>} - A promise that resolves to the response of the fetch request.
+ */
+export declare const corePikkuFetch: (uri: string, data: any, options?: Omit<RequestInit, "body">) => Promise<Response>;

package/dist/esm/pikku-fetch.js

@@ -0,0 +1,35 @@
+/**
+ * The `corePikkuFetch` function is a utility for making HTTP requests with dynamic URI and data handling.
+ * It can automatically replace URI parameters, append query strings for GET requests, and set the request body for POST, PATCH, or PUT requests.
+ *
+ * @param {string} uri - The endpoint URI for the request. URI parameters can be specified using `:param` syntax.
+ * @param {any} data - The data to be included in the request, either as query parameters or as the request body.
+ * @param {Omit<RequestInit, 'body'>} [options] - Optional configuration options for the fetch request, excluding the body.
+ * @returns {Promise<Response>} - A promise that resolves to the response of the fetch request.
+ */
+export const corePikkuFetch = async (uri, data, options) => {
+    const method = options?.method?.toUpperCase() || 'GET';
+    let body;
+    if (data) {
+        data = JSON.parse(JSON.stringify(data));
+        const keys = Object.keys(data);
+        for (const key of keys) {
+            if (uri.includes(`:${key}`)) {
+                uri = uri.replace(`:${key}`, data[key]);
+                delete data[key];
+            }
+        }
+        if (method === 'POST' || method === 'PATCH' || method === 'PUT') {
+            body = data;
+        }
+        else {
+            const queryString = new URLSearchParams(JSON.parse(JSON.stringify(data)));
+            uri = `${uri}?${queryString}`;
+        }
+    }
+    return await fetch(uri, {
+        method: method.toUpperCase(),
+        ...options,
+        body: body ? JSON.stringify(body) : undefined,
+    });
+};

package/dist/esm/transform-date.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `transformDates` function recursively traverses an object or array and converts any date-like strings
+ * into JavaScript `Date` objects. This helps in ensuring that date fields are properly handled as `Date` instances
+ * rather than strings.
+ *
+ * @private
+ * @param {any} data - The input data that may contain date strings. It can be an object, array, or primitive value.
+ * @returns {any} - The transformed data with date strings converted to `Date` objects.
+ */
+export declare const transformDates: (data: any) => any;

package/dist/esm/transform-date.js

@@ -0,0 +1,26 @@
+/**
+ * The `transformDates` function recursively traverses an object or array and converts any date-like strings
+ * into JavaScript `Date` objects. This helps in ensuring that date fields are properly handled as `Date` instances
+ * rather than strings.
+ *
+ * @private
+ * @param {any} data - The input data that may contain date strings. It can be an object, array, or primitive value.
+ * @returns {any} - The transformed data with date strings converted to `Date` objects.
+ */
+export const transformDates = (data) => {
+    if (data === null)
+        return null;
+    if (Array.isArray(data))
+        return data.map(transformDates.bind(this));
+    if (typeof data === 'object') {
+        return Object.entries(data).reduce((result, [key, value]) => {
+            result[key] = transformDates(value);
+            return result;
+        }, {});
+    }
+    if (typeof data === 'string' &&
+        /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}\.\d{3}Z?)?/.test(data)) {
+        return new Date(data);
+    }
+    return data;
+};

package/dist/tsconfig.cjs.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/abstract-pikku-fetch.ts","../src/index.ts","../src/pikku-fetch.ts","../src/transform-date.ts"],"version":"5.7.3"}

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/abstract-pikku-fetch.ts","../src/index.ts","../src/pikku-fetch.ts","../src/transform-date.ts"],"version":"5.7.3"}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@pikku/fetch",
+  "version": "0.6.1",
+  "author": "yasser.fadl@gmail.com",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "scripts": {
+    "tsc": "tsc",
+    "build:esm": "tsc -b && echo '{\"type\": \"module\"}' > dist/esm/package.json",
+    "build:cjs": "tsc -b tsconfig.cjs.json && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json",
+    "build": "yarn build:esm && yarn build:cjs",
+    "ncu": "ncu -x '/.*glob.*/'",
+    "release": "yarn build && npm test",
+    "test": "bash run-tests.sh",
+    "test:watch": "bash run-tests.sh --watch",
+    "test:coverage": "bash run-tests.sh --coverage"
+  },
+  "devDependencies": {
+    "typescript": "^5.6"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/run-tests.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+
+# Enable nullglob to handle cases where no files match the pattern
+shopt -s nullglob
+
+# Initialize variables for options
+watch_mode=false
+coverage_mode=false
+
+# Parse command-line options
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --watch)
+      watch_mode=true
+      shift
+      ;;
+    --coverage)
+      coverage_mode=true
+      shift
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+      ;;
+  esac
+done
+
+# Define the pattern to match your test files
+pattern="src/*.test.ts"
+
+# Expand the pattern into an array of files
+files=($(find src -type f -name "*.test.ts"))
+
+# Check if any files matched the pattern
+if [ ${#files[@]} -eq 0 ]; then
+  echo "No test files found matching pattern: $pattern"
+  exit 0
+fi
+
+# Construct the node command
+node_cmd="node --import tsx --test"
+
+# Append options based on flags
+if [ "$watch_mode" = true ]; then
+  node_cmd="$node_cmd --watch"
+fi
+
+if [ "$coverage_mode" = true ]; then
+  node_cmd="$node_cmd --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info"
+fi
+
+# Execute the node command with the expanded list of files
+$node_cmd "${files[@]}"

package/src/abstract-pikku-fetch.ts

@@ -0,0 +1,200 @@
+import { transformDates } from './transform-date.js'
+import { corePikkuFetch } from './pikku-fetch.js'
+
+type AuthHeaders = {
+  jwt?: string
+  apiKey?: string
+}
+
+export type HTTPMethod = 'GET' | 'POST' | 'PATCH' | 'DELETE' | 'HEAD' | 'PUT'
+
+/**
+ * Options for configuring the `CorePikkuFetch` utility.
+ *
+ * @typedef {Object} CorePikkuFetchOptions
+ * @property {boolean} [transformDate] - Whether to transform date-like strings in the response to `Date` objects.
+ * @property {string} [serverUrl] - The base server URL for requests.
+ * @property {AuthHeaders} [authHeaders] - Authorization headers, including JWT or API key.
+ * @property {RequestInit['cache']} [cache] - The cache mode for the request.
+ * @property {RequestInit['credentials']} [credentials] - The credentials mode for the request.
+ * @property {RequestInit['mode']} [mode] - The mode for the request.
+ */
+export type CorePikkuFetchOptions = {
+  transformDate?: boolean
+  serverUrl?: string
+  authHeaders?: AuthHeaders
+} & Pick<RequestInit, 'cache' | 'credentials' | 'mode'>
+
+/**
+ * The `CorePikkuFetch` class provides a utility for making HTTP requests, including handling authorization,
+ * transforming dates in responses, and managing server URLs. This class is designed to simplify API interactions
+ * with configurable options and support for JWT and API key-based authentication.
+ */
+export class CorePikkuFetch {
+  private authHeaders: AuthHeaders = {}
+
+  /**
+   * Constructs a new instance of the `CorePikkuFetch` class.
+   *
+   * @param {CorePikkuFetchOptions} options - Optional configuration for the fetch utility.
+   */
+  constructor(private options: CorePikkuFetchOptions = {}) {
+    this.authHeaders = options.authHeaders || {}
+  }
+
+  /**
+   * Generates the headers for the request, including authorization headers if set.
+   *
+   * @returns {Record<string, string>} - The headers for the request.
+   */
+  private getHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    }
+    if (this.authHeaders.jwt) {
+      headers.Authorization = `Bearer ${this.authHeaders.jwt}`
+    } else if (this.authHeaders.apiKey) {
+      headers['X-API-KEY'] = this.authHeaders.apiKey
+    }
+    return headers
+  }
+
+  /**
+   * Sets the server URL for subsequent requests.
+   *
+   * @param {string} serverUrl - The server URL to be set.
+   */
+  public async setServerUrl(serverUrl: string): Promise<void> {
+    if (serverUrl.endsWith('/')) {
+      console.warn('Server URL should not end with a slash, removing.')
+      serverUrl = serverUrl.slice(0, -1)
+    }
+    this.options.serverUrl = serverUrl
+  }
+
+  /**
+   * Sets the JWT for authorization.
+   *
+   * @param {string} jwt - The JWT to be used for authorization.
+   */
+  public setAuthorizationJWT(jwt: string | null): void {
+    if (jwt) {
+      this.authHeaders.jwt = jwt
+    } else {
+      delete this.authHeaders.jwt
+    }
+  }
+
+  /**
+   * Sets the API key for authorization.
+   *
+   * @param {string} [apiKey] - The API key to be used for authorization.
+   */
+  public setAPIKey(apiKey: string | null): void {
+    if (apiKey) {
+      this.authHeaders.apiKey = apiKey
+    } else {
+      delete this.authHeaders.apiKey
+    }
+  }
+
+  public async post(uri: string, data: any, options?: RequestInit) {
+    return await this.api(uri, 'POST', data, options)
+  }
+
+  public async get(uri: string, data: any, options?: RequestInit) {
+    return await this.api(uri, 'GET', data, options)
+  }
+
+  public async patch(uri: string, data: any, options?: RequestInit) {
+    return await this.api(uri, 'PATCH', data, options)
+  }
+
+  public async head(uri: string, data: any, options?: RequestInit) {
+    return await this.api(uri, 'HEAD', data, options)
+  }
+
+  /**
+   * Makes an API request with the specified URI, method, and data, and optionally transforms dates in the response.
+   *
+   * @param {string} uri - The endpoint URI for the request.
+   * @param {HTTPMethod} method - The HTTP method for the request.
+   * @param {any} data - The data to be sent with the request.
+   * @param {RequestInit} [options] - Additional options for the request.
+   * @returns {Promise<any>} - A promise that resolves to the response data.
+   * @throws {Response} - Throws the response if the status code is greater than 400.
+   */
+  public async api(
+    uri: string,
+    method: HTTPMethod,
+    data: any,
+    options?: RequestInit
+  ) {
+    const response = await this.fetch(uri, method, data, options)
+    if (response.status >= 400) {
+      throw response
+    }
+    try {
+      const result = await response.json()
+      return this.transformDates(result)
+    } catch {
+      // TODO: If it doesn't return anything..
+      return
+    }
+  }
+
+  /**
+   * Makes a raw fetch request with the specified URI, method, and data.
+   *
+   * @param {string} uri - The endpoint URI for the request.
+   * @param {HTTPMethod} method - The HTTP method for the request.
+   * @param {any} data - The data to be sent with the request.
+   * @param {RequestInit} [options] - Additional options for the request.
+   * @returns {Promise<Response>} - A promise that resolves to the fetch response.
+   */
+  public async fetch(
+    uri: string,
+    method: HTTPMethod,
+    data: any,
+    options?: RequestInit
+  ) {
+    this.verifyServerUrlSet()
+    if (uri.startsWith('/')) {
+      uri = `${this.options.serverUrl}${uri}`
+    } else {
+      uri = `${this.options.serverUrl}/${uri}`
+    }
+
+    return await corePikkuFetch(uri, data, {
+      ...options,
+      method,
+      mode: this.options.mode,
+      credentials: this.options.credentials,
+      headers: { ...this.getHeaders(), ...options?.headers },
+    })
+  }
+
+  /**
+   * Verifies that the server URL is set before making a request.
+   *
+   * @throws {Error} - Throws an error if the server URL is not set.
+   */
+  private verifyServerUrlSet() {
+    if (!this.options.serverUrl) {
+      throw new Error('Server url is not set')
+    }
+  }
+
+  /**
+   * Transforms date-like strings in the response data into `Date` objects if the `transformDate` option is set.
+   *
+   * @param {any} data - The data to transform.
+   * @returns {any} - The transformed data.
+   */
+  private transformDates(data: any): any {
+    if (!this.options.transformDate) {
+      return data
+    }
+    return transformDates(data)
+  }
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+/**
+ * This module provides a wrapper around the Fetch API that integrates with the Pikku framework.
+ * It includes utilities for making HTTP requests, such as options for authorization, server URL management,
+ * and transforming dates in responses, while ensuring requests are validated against Pikku routes.
+ * The module exports the `CorePikkuFetch` class, as well as other supporting types and functions.
+ *
+ * @module @pikku/fetch
+ */
+
+export {
+  CorePikkuFetch,
+  CorePikkuFetchOptions,
+  HTTPMethod,
+} from './abstract-pikku-fetch.js'
+export { corePikkuFetch } from './pikku-fetch.js'

package/src/pikku-fetch.ts

@@ -0,0 +1,41 @@
+/**
+ * The `corePikkuFetch` function is a utility for making HTTP requests with dynamic URI and data handling.
+ * It can automatically replace URI parameters, append query strings for GET requests, and set the request body for POST, PATCH, or PUT requests.
+ *
+ * @param {string} uri - The endpoint URI for the request. URI parameters can be specified using `:param` syntax.
+ * @param {any} data - The data to be included in the request, either as query parameters or as the request body.
+ * @param {Omit<RequestInit, 'body'>} [options] - Optional configuration options for the fetch request, excluding the body.
+ * @returns {Promise<Response>} - A promise that resolves to the response of the fetch request.
+ */
+export const corePikkuFetch = async (
+  uri: string,
+  data: any,
+  options?: Omit<RequestInit, 'body'>
+) => {
+  const method = options?.method?.toUpperCase() || 'GET'
+  let body: any | undefined
+
+  if (data) {
+    data = JSON.parse(JSON.stringify(data))
+
+    const keys = Object.keys(data)
+    for (const key of keys) {
+      if (uri.includes(`:${key}`)) {
+        uri = uri.replace(`:${key}`, data[key])
+        delete data[key]
+      }
+    }
+    if (method === 'POST' || method === 'PATCH' || method === 'PUT') {
+      body = data
+    } else {
+      const queryString = new URLSearchParams(JSON.parse(JSON.stringify(data)))
+      uri = `${uri}?${queryString}`
+    }
+  }
+
+  return await fetch(uri, {
+    method: method.toUpperCase(),
+    ...options,
+    body: body ? JSON.stringify(body) : undefined,
+  })
+}

package/src/transform-date.ts

@@ -0,0 +1,26 @@
+/**
+ * The `transformDates` function recursively traverses an object or array and converts any date-like strings
+ * into JavaScript `Date` objects. This helps in ensuring that date fields are properly handled as `Date` instances
+ * rather than strings.
+ *
+ * @private
+ * @param {any} data - The input data that may contain date strings. It can be an object, array, or primitive value.
+ * @returns {any} - The transformed data with date strings converted to `Date` objects.
+ */
+export const transformDates = (data: any) => {
+  if (data === null) return null
+  if (Array.isArray(data)) return data.map(transformDates.bind(this))
+  if (typeof data === 'object') {
+    return Object.entries(data).reduce((result, [key, value]) => {
+      result[key] = transformDates(value)
+      return result
+    }, {} as any)
+  }
+  if (
+    typeof data === 'string' &&
+    /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}\.\d{3}Z?)?/.test(data)
+  ) {
+    return new Date(data)
+  }
+  return data
+}

package/tsconfig.cjs.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "module": "commonjs",
+    "outDir": "dist/cjs",
+    "target": "es2015",
+    "moduleResolution": "node"
+  },
+  "exclude": ["**/*.test.ts", "node_modules", "dist"]
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "module": "Node16",
+    "outDir": "dist/esm",
+    "target": "esnext",
+    "declaration": true,
+    "resolveJsonModule": true,
+    "lib": ["DOM"]
+  },
+  "include": ["src/*.ts"],
+  "exclude": ["**/*.test.ts", "node_modules"]
+}