@foundatiofx/fetchclient 0.47.0

package/script/src/FetchClientProvider.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultInstance = exports.FetchClientProvider = void 0;
+const FetchClient_js_1 = require("./FetchClient.js");
+const Counter_js_1 = require("./Counter.js");
+const FetchClientCache_js_1 = require("./FetchClientCache.js");
+const ObjectEvent_js_1 = require("./ObjectEvent.js");
+const RateLimitMiddleware_js_1 = require("./RateLimitMiddleware.js");
+const RateLimiter_js_1 = require("./RateLimiter.js");
+/**
+ * Represents a provider for creating instances of the FetchClient class with shared default options and cache.
+ */
+class FetchClientProvider {
+    #options = {};
+    #fetch;
+    #cache;
+    #rateLimitMiddleware;
+    #counter = new Counter_js_1.Counter();
+    #onLoading = new ObjectEvent_js_1.ObjectEvent();
+    /**
+     * Creates a new instance of FetchClientProvider.
+     * @param fetch - The fetch function to use. If not provided, the global fetch function will be used.
+     */
+    constructor(fetch) {
+        this.#cache = new FetchClientCache_js_1.FetchClientCache();
+        if (fetch) {
+            this.#fetch = fetch;
+        }
+        this.#options = {
+            cache: this.#cache,
+            providerCounter: this.#counter,
+            fetch: this.#fetch,
+        };
+        this.#counter.changed.on((e) => {
+            if (!e) {
+                throw new Error("Event data is required.");
+            }
+            if (e.value > 0 && e.previous == 0) {
+                this.#onLoading.trigger(true);
+            }
+            else if (e.value == 0 && e.previous > 0) {
+                this.#onLoading.trigger(false);
+            }
+        });
+    }
+    /**
+     * Gets the fetch function used for making requests.
+     */
+    get fetch() {
+        return this.#fetch;
+    }
+    /**
+     * Sets the fetch function used for making requests.
+     */
+    set fetch(value) {
+        this.#fetch = value;
+    }
+    /**
+     * Gets a value indicating whether there are ongoing requests.
+     */
+    get isLoading() {
+        return this.#counter.count > 0;
+    }
+    /**
+     * Gets an event that is triggered when the loading state changes.
+     */
+    get loading() {
+        return this.#onLoading.expose();
+    }
+    /**
+     * Gets the number of ongoing requests.
+     */
+    get requestCount() {
+        return this.#counter.count;
+    }
+    /**
+     * Gets the counter used for tracking ongoing requests.
+     */
+    get counter() {
+        return this.#counter;
+    }
+    /**
+     * Gets the options used for FetchClient instances.
+     */
+    get options() {
+        return this.#options;
+    }
+    /**
+     * Sets the options used for FetchClient instances.
+     */
+    set options(value) {
+        this.#options = value;
+    }
+    /**
+     * Gets the cache used for storing HTTP responses.
+     */
+    get cache() {
+        return this.#cache;
+    }
+    /**
+     * Creates a new instance of FetchClient using the current provider.
+     * @param options - The options to use for the FetchClient instance.
+     * @returns A new instance of FetchClient.
+     */
+    getFetchClient(options) {
+        if (options) {
+            options = {
+                ...this.#options,
+                ...options,
+            };
+            options.provider = this;
+            return new FetchClient_js_1.FetchClient(options);
+        }
+        return new FetchClient_js_1.FetchClient(this);
+    }
+    /**
+     * Applies the specified options by merging with the current options.
+     */
+    applyOptions(options) {
+        this.#options = {
+            ...this.#options,
+            ...options,
+        };
+    }
+    /**
+     * Sets the function used for retrieving the access token.
+     * @param accessTokenFunc - The function that retrieves the access token.
+     */
+    setAccessTokenFunc(accessTokenFunc) {
+        this.#options = {
+            ...this.#options,
+            accessTokenFunc: accessTokenFunc,
+        };
+    }
+    /**
+     * Sets the default model validator function for all FetchClient instances created by this provider.
+     * @param validate - The function that validates the model.
+     */
+    setModelValidator(validate) {
+        this.#options = {
+            ...this.#options,
+            modelValidator: validate,
+        };
+    }
+    /**
+     * Sets the default base URL for all FetchClient instances created by this provider.
+     * @param url - The URL to set as the default base URL.
+     */
+    setBaseUrl(url) {
+        this.#options = {
+            ...this.#options,
+            baseUrl: url,
+        };
+    }
+    /**
+     * Adds a middleware to all FetchClient instances created by this provider.
+     * @param middleware - The middleware function to be added.
+     */
+    useMiddleware(middleware) {
+        this.#options = {
+            ...this.#options,
+            middleware: [
+                ...(this.#options.middleware ?? []),
+                middleware,
+            ],
+        };
+    }
+    /**
+     * Enables rate limiting for all FetchClient instances created by this provider.
+     * @param options - The rate limiting configuration options.
+     */
+    useRateLimit(options) {
+        this.#rateLimitMiddleware = new RateLimitMiddleware_js_1.RateLimitMiddleware(options);
+        this.useMiddleware(this.#rateLimitMiddleware.middleware());
+    }
+    /**
+     * Enables rate limiting for all FetchClient instances created by this provider.
+     * @param options - The rate limiting configuration options.
+     */
+    usePerDomainRateLimit(options) {
+        this.#rateLimitMiddleware = new RateLimitMiddleware_js_1.RateLimitMiddleware({
+            ...options,
+            getGroupFunc: RateLimiter_js_1.groupByDomain,
+        });
+        this.useMiddleware(this.#rateLimitMiddleware.middleware());
+    }
+    /**
+     * Gets the rate limiter instance used for rate limiting.
+     * @returns The rate limiter instance, or undefined if rate limiting is not enabled.
+     */
+    get rateLimiter() {
+        return this.#rateLimitMiddleware?.rateLimiter;
+    }
+    /**
+     * Removes the rate limiting middleware from all FetchClient instances created by this provider.
+     */
+    removeRateLimit() {
+        this.#rateLimitMiddleware = undefined;
+        this.#options.middleware = this.#options.middleware?.filter((m) => !(m instanceof RateLimitMiddleware_js_1.RateLimitMiddleware));
+    }
+}
+exports.FetchClientProvider = FetchClientProvider;
+const provider = new FetchClientProvider();
+exports.defaultInstance = provider;

package/script/src/FetchClientResponse.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/src/LinkHeader.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLinkHeader = parseLinkHeader;
+const MAX_HEADER_LENGTH = 2000;
+const THROW_ON_MAX_HEADER_LENGTH_EXCEEDED = false;
+function hasRel(x) {
+    return x && x.rel;
+}
+function intoRels(acc, x) {
+    function splitRel(rel) {
+        acc[rel] = Object.assign({}, x, { rel: rel });
+    }
+    x.rel.split(/\s+/).forEach(splitRel);
+    return acc;
+}
+// deno-lint-ignore no-explicit-any
+function createObjects(acc, p) {
+    // rel="next" => 1: rel 2: next
+    const m = p.match(/\s*(.+)\s*=\s*"?([^"]+)"?/);
+    if (m)
+        acc[m[1]] = m[2];
+    return acc;
+}
+function parseLink(link) {
+    try {
+        const m = link.match(/<?([^>]*)>(.*)/);
+        if (!m)
+            return null;
+        const linkUrl = m[1];
+        const parts = m[2].split(";");
+        const qry = {};
+        // The origin is unused but it's required to parse relative URLs
+        const url = new URL(linkUrl, "https://example.com");
+        for (const [key, value] of url.searchParams) {
+            qry[key] = value;
+        }
+        parts.shift();
+        let info = parts.reduce(createObjects, {});
+        info = Object.assign({}, qry, info);
+        info.url = linkUrl;
+        return info;
+    }
+    catch {
+        return null;
+    }
+}
+function checkHeader(linkHeader, options) {
+    if (!linkHeader)
+        return false;
+    options = options || {};
+    const maxHeaderLength = options.maxHeaderLength || MAX_HEADER_LENGTH;
+    const throwOnMaxHeaderLengthExceeded = options.throwOnMaxHeaderLengthExceeded ||
+        THROW_ON_MAX_HEADER_LENGTH_EXCEEDED;
+    if (linkHeader.length > maxHeaderLength) {
+        if (throwOnMaxHeaderLengthExceeded) {
+            throw new Error("Input string too long, it should be under " + maxHeaderLength +
+                " characters.");
+        }
+        else {
+            return false;
+        }
+    }
+    return true;
+}
+function parseLinkHeader(linkHeader, options) {
+    if (!checkHeader(linkHeader, options))
+        return null;
+    return linkHeader.split(/,\s*</)
+        .map(parseLink)
+        .filter(hasRel)
+        .reduce(intoRels, {});
+}

package/script/src/ObjectEvent.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectEvent = void 0;
+class ObjectEvent {
+    handlers = [];
+    on(handler) {
+        this.handlers.push(handler);
+    }
+    off(handler) {
+        this.handlers = this.handlers.filter((h) => h !== handler);
+    }
+    trigger(data) {
+        this.handlers.slice(0).forEach((h) => h(data));
+    }
+    expose() {
+        return this;
+    }
+}
+exports.ObjectEvent = ObjectEvent;

package/script/src/ProblemDetails.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProblemDetails = void 0;
+/**
+ * Represents a problem details object.
+ */
+class ProblemDetails {
+    /**
+     * The type of the problem details.
+     */
+    type;
+    /**
+     * The title of the problem details.
+     */
+    title;
+    /**
+     * The HTTP status code of the problem details.
+     */
+    status;
+    /**
+     * Additional details about the problem.
+     */
+    detail;
+    /**
+     * The URI of the specific occurrence of the problem.
+     */
+    instance;
+    /**
+     * Represents the errors associated with a problem details response.
+     */
+    errors = {};
+    /**
+     * Clears the error with the specified name.
+     * @param name - The name of the error to clear.
+     * @returns The updated ProblemDetails instance.
+     */
+    clear(name) {
+        delete this.errors[name];
+        return this;
+    }
+    /**
+     * Sets the error message for the general error.
+     * @param message - The error message to set.
+     * @returns The updated ProblemDetails instance.
+     */
+    setErrorMessage(message) {
+        this.errors.general = [message];
+        return this;
+    }
+}
+exports.ProblemDetails = ProblemDetails;

package/script/src/RateLimitMiddleware.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitMiddleware = exports.RateLimitError = void 0;
+const ProblemDetails_js_1 = require("./ProblemDetails.js");
+const RateLimiter_js_1 = require("./RateLimiter.js");
+/**
+ * Rate limiting error thrown when requests exceed the rate limit.
+ */
+class RateLimitError extends Error {
+    resetTime;
+    remainingRequests;
+    constructor(resetTime, remainingRequests, message) {
+        super(message ||
+            `Rate limit exceeded. Try again after ${new Date(resetTime).toISOString()}`);
+        this.name = "RateLimitError";
+        this.resetTime = resetTime;
+        this.remainingRequests = remainingRequests;
+    }
+}
+exports.RateLimitError = RateLimitError;
+/**
+ * Rate limiting middleware instance that can be shared across requests.
+ */
+class RateLimitMiddleware {
+    #rateLimiter;
+    throwOnRateLimit;
+    errorMessage;
+    autoUpdateFromHeaders;
+    constructor(options) {
+        this.#rateLimiter = new RateLimiter_js_1.RateLimiter(options);
+        this.throwOnRateLimit = options.throwOnRateLimit ?? true;
+        this.errorMessage = options.errorMessage;
+        this.autoUpdateFromHeaders = options.autoUpdateFromHeaders ?? true;
+    }
+    /**
+     * Gets the underlying rate limiter instance.
+     */
+    get rateLimiter() {
+        return this.#rateLimiter;
+    }
+    /**
+     * Creates the middleware function.
+     * @returns The middleware function
+     */
+    middleware() {
+        return async (context, next) => {
+            const url = context.request.url;
+            // Check if request is allowed
+            if (!this.rateLimiter.isAllowed(url)) {
+                const group = this.rateLimiter.getGroup(url);
+                const resetTime = this.rateLimiter.getResetTime(url) ?? Date.now();
+                const remainingRequests = this.rateLimiter.getRemainingRequests(url);
+                if (this.throwOnRateLimit) {
+                    throw new RateLimitError(resetTime, remainingRequests, this.errorMessage);
+                }
+                // Create a 429 Too Many Requests response
+                const groupOptions = this.rateLimiter.getGroupOptions(group);
+                const maxRequests = groupOptions.maxRequests;
+                const windowSeconds = groupOptions.windowSeconds;
+                // Create IETF standard rate limit headers
+                const resetSeconds = Math.ceil((resetTime - Date.now()) / 1000);
+                const rateLimitHeader = (0, RateLimiter_js_1.buildRateLimitHeader)({
+                    policy: group,
+                    remaining: remainingRequests,
+                    resetSeconds: resetSeconds,
+                });
+                const rateLimitPolicyHeader = (0, RateLimiter_js_1.buildRateLimitPolicyHeader)({
+                    policy: group,
+                    limit: maxRequests,
+                    windowSeconds: Math.floor(windowSeconds),
+                });
+                const headers = new Headers({
+                    "Content-Type": "application/problem+json",
+                    "RateLimit": rateLimitHeader,
+                    "RateLimit-Policy": rateLimitPolicyHeader,
+                    // Legacy headers for backward compatibility
+                    "RateLimit-Limit": maxRequests.toString(),
+                    "RateLimit-Remaining": remainingRequests.toString(),
+                    "RateLimit-Reset": Math.ceil(resetTime / 1000).toString(),
+                    "Retry-After": resetSeconds.toString(),
+                });
+                const problem = new ProblemDetails_js_1.ProblemDetails();
+                problem.status = 429;
+                problem.title = "Too Many Requests";
+                problem.detail = this.errorMessage ||
+                    `Rate limit exceeded. Try again after ${new Date(resetTime).toISOString()}`;
+                context.response = {
+                    url: context.request.url,
+                    status: 429,
+                    statusText: "Too Many Requests",
+                    body: null,
+                    bodyUsed: true,
+                    ok: false,
+                    headers: headers,
+                    redirected: false,
+                    type: "basic",
+                    problem: problem,
+                    data: null,
+                    meta: { links: {} },
+                    json: () => Promise.resolve(problem),
+                    text: () => Promise.resolve(JSON.stringify(problem)),
+                    arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
+                    // @ts-ignore: New in Deno 1.44
+                    bytes: () => Promise.resolve(new Uint8Array()),
+                    blob: () => Promise.resolve(new Blob()),
+                    formData: () => Promise.resolve(new FormData()),
+                    clone: () => {
+                        throw new Error("Not implemented");
+                    },
+                };
+                return;
+            }
+            await next();
+            if (this.autoUpdateFromHeaders && context.response) {
+                this.rateLimiter.updateFromHeadersForRequest(url, context.response.headers);
+            }
+        };
+    }
+}
+exports.RateLimitMiddleware = RateLimitMiddleware;