@unito/integration-sdk 0.1.6 → 0.1.8

package/dist/src/index.cjs

@@ -0,0 +1,829 @@
+'use strict';
+
+var integrationApi = require('@unito/integration-api');
+var cachette = require('cachette');
+var uuid = require('uuid');
+var express = require('express');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var integrationApi__namespace = /*#__PURE__*/_interopNamespaceDefault(integrationApi);
+var uuid__namespace = /*#__PURE__*/_interopNamespaceDefault(uuid);
+
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["ERROR"] = "error";
+    LogLevel["WARN"] = "warn";
+    LogLevel["INFO"] = "info";
+    LogLevel["LOG"] = "log";
+    LogLevel["DEBUG"] = "debug";
+})(LogLevel || (LogLevel = {}));
+class Logger {
+    metadata;
+    constructor(metadata = {}) {
+        this.metadata = structuredClone(metadata);
+    }
+    /**
+     * Logs a message with the 'log' log level.
+     * @param message The message to be logged.
+     * @param metadata Optional metadata to be associated with the log message.
+     */
+    log(message, metadata) {
+        this.send(LogLevel.LOG, message, metadata);
+    }
+    /**
+     * Logs an error message with the 'error' log level.
+     * @param message The error message to be logged.
+     * @param metadata Optional metadata to be associated with the log message.
+     */
+    error(message, metadata) {
+        this.send(LogLevel.ERROR, message, metadata);
+    }
+    /**
+     * Logs a warning message with the 'warn' log level.
+     * @param message The warning message to be logged.
+     * @param metadata Optional metadata to be associated with the log message.
+     */
+    warn(message, metadata) {
+        this.send(LogLevel.WARN, message, metadata);
+    }
+    /**
+     * Logs an informational message with the 'info' log level.
+     * @param message The informational message to be logged.
+     * @param metadata Optional metadata to be associated with the log message.
+     */
+    info(message, metadata) {
+        this.send(LogLevel.INFO, message, metadata);
+    }
+    /**
+     * Logs a debug message with the 'debug' log level.
+     * @param message The debug message to be logged.
+     * @param metadata Optional metadata to be associated with the log message.
+     */
+    debug(message, metadata) {
+        this.send(LogLevel.DEBUG, message, metadata);
+    }
+    /**
+     * Decorates the logger with additional metadata.
+     * @param metadata Additional metadata to be added to the logger.
+     */
+    decorate(metadata) {
+        this.metadata = { ...this.metadata, ...metadata };
+    }
+    getMetadata() {
+        return structuredClone(this.metadata);
+    }
+    setMetadata(key, value) {
+        this.metadata[key] = value;
+    }
+    clearMetadata() {
+        this.metadata = {};
+    }
+    send(logLevel, message, metadata) {
+        const processedMessage = this.snakifyKeys({
+            ...this.metadata,
+            ...metadata,
+            message,
+        });
+        if (process.env.NODE_ENV === 'development') {
+            console[logLevel](JSON.stringify(processedMessage, null, 2));
+        }
+        else {
+            console[logLevel](JSON.stringify(processedMessage));
+        }
+    }
+    snakifyKeys(value) {
+        const result = {};
+        for (const key in value) {
+            const deepValue = typeof value[key] === 'object' ? this.snakifyKeys(value[key]) : value[key];
+            const snakifiedKey = key.replace(/[\w](?<!_)([A-Z])/g, k => `${k[0]}_${k[1]}`).toLowerCase();
+            result[snakifiedKey] = deepValue;
+        }
+        return result;
+    }
+}
+
+/**
+ * Array of created caches kept to allow for graceful shutdown on exit signals.
+ */
+const caches = [];
+const shutdownCaches = async () => {
+    return Promise.allSettled(caches.map(cache => cache.quit()));
+};
+class Cache {
+    cacheInstance;
+    constructor(cacheInstance) {
+        this.cacheInstance = cacheInstance;
+    }
+    getOrFetchValue(key, ttl, fetcher, lockTtl, shouldCacheError) {
+        return this.cacheInstance.getOrFetchValue(key, ttl, fetcher, lockTtl, shouldCacheError);
+    }
+    getValue(key) {
+        return this.cacheInstance.getValue(key);
+    }
+    setValue(key, value, ttl) {
+        return this.cacheInstance.setValue(key, value, ttl);
+    }
+    delValue(key) {
+        return this.cacheInstance.delValue(key);
+    }
+    getTtl(key) {
+        return this.cacheInstance.getTtl(key);
+    }
+    /**
+     * Initializes a WriteThroughCache instance with the provided redis url if present, or a LocalCache otherwise.
+     *
+     * @param redisUrl - The redis url to connect to (optional).
+     * @returns A cache instance.
+     */
+    static create(redisUrl) {
+        const cacheInstance = redisUrl ? new cachette.WriteThroughCache(redisUrl) : new cachette.LocalCache();
+        // Push to the array of caches for graceful shutdown on exit signals.
+        caches.push(cacheInstance);
+        // Intended: the correlation id will be the same for all logs of Cachette.
+        const correlationId = uuid__namespace.v4();
+        const logger = new Logger({ correlation_id: correlationId });
+        cacheInstance
+            .on('info', message => {
+            logger.info(message);
+        })
+            .on('warn', message => {
+            logger.warn(message);
+        })
+            .on('error', message => {
+            logger.error(message);
+        });
+        return new Cache(cacheInstance);
+    }
+}
+
+class HttpError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+class BadRequestError extends HttpError {
+    constructor(message) {
+        super(message || 'Bad request', 400);
+    }
+}
+class UnauthorizedError extends HttpError {
+    constructor(message) {
+        super(message || 'Unauthorized', 401);
+    }
+}
+class NotFoundError extends HttpError {
+    constructor(message) {
+        super(message || 'Not found', 404);
+    }
+}
+class TimeoutError extends HttpError {
+    constructor(message) {
+        super(message || 'Not found', 408);
+    }
+}
+class ResourceGoneError extends HttpError {
+    constructor(message) {
+        super(message || 'Resource gone or unavailable', 410);
+    }
+}
+class UnprocessableEntityError extends HttpError {
+    constructor(message) {
+        super(message || 'Unprocessable Entity', 422);
+    }
+}
+class RateLimitExceededError extends HttpError {
+    constructor(message) {
+        super(message || 'Rate Limit Exceeded', 429);
+    }
+}
+
+var httpErrors = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    BadRequestError: BadRequestError,
+    HttpError: HttpError,
+    NotFoundError: NotFoundError,
+    RateLimitExceededError: RateLimitExceededError,
+    ResourceGoneError: ResourceGoneError,
+    TimeoutError: TimeoutError,
+    UnauthorizedError: UnauthorizedError,
+    UnprocessableEntityError: UnprocessableEntityError
+});
+
+class InvalidHandler extends Error {
+}
+/**
+ * Processes provider response codes and returns the corresponding errors to be translated further in our responses
+ *
+ * @param responseStatus the reponseStatus of the request. Any HTTP response code passed here will result in an error!
+ * @param message The message returned by the provider
+ */
+// Keep in errors.ts instead of httpErrors.ts because we do not need to export it outside of the sdk
+function buildHttpError(responseStatus, message) {
+    let httpError;
+    if (responseStatus === 400) {
+        httpError = new BadRequestError(message);
+    }
+    else if (responseStatus === 401 || responseStatus === 403) {
+        httpError = new UnauthorizedError(message);
+    }
+    else if (responseStatus === 404) {
+        httpError = new NotFoundError(message);
+    }
+    else if (responseStatus === 408) {
+        httpError = new TimeoutError(message);
+    }
+    else if (responseStatus === 410) {
+        httpError = new ResourceGoneError(message);
+    }
+    else if (responseStatus === 422) {
+        httpError = new UnprocessableEntityError(message);
+    }
+    else if (responseStatus === 429) {
+        httpError = new RateLimitExceededError(message);
+    }
+    else {
+        httpError = new HttpError(message, responseStatus);
+    }
+    return httpError;
+}
+
+const middleware$6 = (req, res, next) => {
+    res.locals.correlationId = req.header('X-Unito-Correlation-Id') ?? uuid__namespace.v4();
+    next();
+};
+
+const ADDITIONAL_CONTEXT_HEADER = 'X-Unito-Additional-Logging-Context';
+const middleware$5 = (req, res, next) => {
+    const logger = new Logger({ correlation_id: res.locals.correlationId });
+    res.locals.logger = logger;
+    const rawAdditionalContext = req.header(ADDITIONAL_CONTEXT_HEADER);
+    if (typeof rawAdditionalContext === 'string') {
+        try {
+            const additionalContext = JSON.parse(rawAdditionalContext);
+            logger.decorate(additionalContext);
+        }
+        catch (error) {
+            logger.warn(`Failed parsing header ${ADDITIONAL_CONTEXT_HEADER}: ${rawAdditionalContext}`);
+        }
+    }
+    next();
+};
+
+const CREDENTIALS_HEADER = 'X-Unito-Credentials';
+const middleware$4 = (req, res, next) => {
+    const credentialsHeader = req.header(CREDENTIALS_HEADER);
+    if (credentialsHeader) {
+        let credentials;
+        try {
+            credentials = JSON.parse(Buffer.from(credentialsHeader, 'base64').toString('utf8'));
+        }
+        catch {
+            throw new BadRequestError(`Malformed HTTP header ${CREDENTIALS_HEADER}`);
+        }
+        res.locals.credentials = credentials;
+    }
+    next();
+};
+
+const middleware$3 = (req, res, next) => {
+    const rawSelect = req.query.select;
+    if (typeof rawSelect === 'string') {
+        res.locals.selects = rawSelect.split(',');
+    }
+    else {
+        res.locals.selects = [];
+    }
+    next();
+};
+
+const middleware$2 = (err, _req, res, next) => {
+    if (res.headersSent) {
+        return next(err);
+    }
+    let error;
+    if (err instanceof HttpError) {
+        error = {
+            code: err.status.toString(),
+            message: err.message,
+            details: {
+                stack: err.stack,
+            },
+        };
+    }
+    else {
+        error = {
+            code: '500',
+            message: 'Oops! Something went wrong',
+            originalError: {
+                code: err.name,
+                message: err.message,
+                details: {
+                    stack: err.stack,
+                },
+            },
+        };
+    }
+    res.locals.error = structuredClone(error);
+    // Keep the stack details in development for the Debugger
+    if (process.env.NODE_ENV !== 'development') {
+        delete error.details;
+        delete error.originalError?.details;
+    }
+    res.status(Number(error.code)).json(error);
+};
+
+const middleware$1 = (req, res, next) => {
+    if (req.originalUrl !== '/health') {
+        res.on('finish', function () {
+            const error = res.locals.error;
+            const message = `${req.method} ${req.originalUrl} ${res.statusCode}`;
+            const metadata = {
+                // Use reserved and standard attributes of Datadog
+                // https://app.datadoghq.com/logs/pipelines/standard-attributes
+                http: { method: req.method, status_code: res.statusCode, url_details: { path: req.originalUrl } },
+                ...(error
+                    ? {
+                        error: {
+                            kind: error.message,
+                            stack: (error.originalError?.details?.stack ?? error.details?.stack),
+                            message: error.originalError?.message ?? error.message,
+                        },
+                    }
+                    : {}),
+            };
+            if ([404, 429].includes(res.statusCode)) {
+                res.locals.logger.warn(message, metadata);
+            }
+            else if (res.statusCode >= 400) {
+                res.locals.logger.error(message, metadata);
+            }
+            else {
+                res.locals.logger.info(message, metadata);
+            }
+        });
+    }
+    next();
+};
+
+const middleware = (req, res, _next) => {
+    const error = {
+        code: '404',
+        message: `Path ${req.path} not found.`,
+    };
+    res.status(404).json(error);
+};
+
+function assertValidPath(path) {
+    if (!path.startsWith('/')) {
+        throw new InvalidHandler(`The provided path '${path}' is invalid. All paths must start with a '/'.`);
+    }
+    if (path.length > 1 && path.endsWith('/')) {
+        throw new InvalidHandler(`The provided path '${path}' is invalid. Paths must not end with a '/'.`);
+    }
+}
+function assertValidConfiguration(path, pathWithIdentifier, handlers) {
+    if (path === pathWithIdentifier) {
+        const individualHandlers = ['getItem', 'updateItem', 'deleteItem'];
+        const collectionHandlers = ['getCollection', 'createItem'];
+        const hasIndividualHandlers = individualHandlers.some(handler => handler in handlers);
+        const hasCollectionHandlers = collectionHandlers.some(handler => handler in handlers);
+        if (hasIndividualHandlers && hasCollectionHandlers) {
+            throw new InvalidHandler(`The provided path '${path}' doesn't differentiate between individual and collection level operation, so you cannot define both.`);
+        }
+    }
+}
+function parsePath(path) {
+    const pathParts = path.split('/');
+    const lastPart = pathParts.at(-1);
+    if (pathParts.length > 1 && lastPart && lastPart.startsWith(':')) {
+        pathParts.pop();
+    }
+    return { pathWithIdentifier: path, path: pathParts.join('/') };
+}
+function assertCreateItemRequestPayload(body) {
+    if (typeof body !== 'object' || body === null) {
+        throw new BadRequestError('Invalid CreateItemRequestPayload');
+    }
+}
+function assertUpdateItemRequestPayload(body) {
+    if (typeof body !== 'object' || body === null) {
+        throw new BadRequestError('Invalid UpdateItemRequestPayload');
+    }
+}
+function assertWebhookParseRequestPayload(body) {
+    if (typeof body !== 'object' || body === null) {
+        throw new BadRequestError('Invalid WebhookParseRequestPayload');
+    }
+    if (!('payload' in body) || body.payload !== 'string') {
+        throw new BadRequestError("Missing required 'payload' property in WebhookParseRequestPayload");
+    }
+    if (!('url' in body) || body.url !== 'string') {
+        throw new BadRequestError("Missing required 'url' property in WebhookParseRequestPayload");
+    }
+}
+function assertWebhookSubscriptionRequestPayload(body) {
+    if (typeof body !== 'object' || body === null) {
+        throw new BadRequestError('Invalid WebhookSubscriptionRequestPayload');
+    }
+    if (!('itemPath' in body) || body.itemPath !== 'string') {
+        throw new BadRequestError("Missing required 'itemPath' property in WebhookSubscriptionRequestPayload");
+    }
+    if (!('targetUrl' in body) || body.targetUrl !== 'string') {
+        throw new BadRequestError("Missing required 'targetUrl' property in WebhookSubscriptionRequestPayload");
+    }
+    if (!('action' in body) || body.action !== 'string') {
+        throw new BadRequestError("Missing required 'action' property in WebhookSubscriptionRequestPayload");
+    }
+    if (!['start', 'stop'].includes(body.action)) {
+        throw new BadRequestError("Invalid value for 'action' property in WebhookSubscriptionRequestPayload");
+    }
+}
+class Handler {
+    path;
+    pathWithIdentifier;
+    handlers;
+    constructor(inputPath, handlers) {
+        assertValidPath(inputPath);
+        const { pathWithIdentifier, path } = parsePath(inputPath);
+        assertValidConfiguration(path, pathWithIdentifier, handlers);
+        this.pathWithIdentifier = pathWithIdentifier;
+        this.path = path;
+        this.handlers = handlers;
+    }
+    generate() {
+        const router = express.Router({ caseSensitive: true });
+        console.debug(`\x1b[33mMounting handler at path ${this.pathWithIdentifier}`);
+        if (this.handlers.getCollection) {
+            const handler = this.handlers.getCollection;
+            console.debug(`  Enabling getCollection at GET ${this.path}`);
+            router.get(this.path, async (req, res) => {
+                if (!res.locals.credentials) {
+                    throw new UnauthorizedError();
+                }
+                const collection = await handler({
+                    credentials: res.locals.credentials,
+                    selects: res.locals.selects,
+                    filters: res.locals.filters,
+                    logger: res.locals.logger,
+                    params: req.params,
+                    query: req.query,
+                });
+                res.status(200).send(collection);
+            });
+        }
+        if (this.handlers.createItem) {
+            const handler = this.handlers.createItem;
+            console.debug(`  Enabling createItem at POST ${this.path}`);
+            router.post(this.path, async (req, res) => {
+                if (!res.locals.credentials) {
+                    throw new UnauthorizedError();
+                }
+                assertCreateItemRequestPayload(req.body);
+                const createItemSummary = await handler({
+                    credentials: res.locals.credentials,
+                    body: req.body,
+                    logger: res.locals.logger,
+                    params: req.params,
+                    query: req.query,
+                });
+                res.status(201).send(createItemSummary);
+            });
+        }
+        if (this.handlers.getItem) {
+            const handler = this.handlers.getItem;
+            console.debug(`  Enabling getItem at GET ${this.pathWithIdentifier}`);
+            router.get(this.pathWithIdentifier, async (req, res) => {
+                if (!res.locals.credentials) {
+                    throw new UnauthorizedError();
+                }
+                const item = await handler({
+                    credentials: res.locals.credentials,
+                    logger: res.locals.logger,
+                    params: req.params,
+                    query: req.query,
+                });
+                res.status(200).send(item);
+            });
+        }
+        if (this.handlers.updateItem) {
+            const handler = this.handlers.updateItem;
+            console.debug(`  Enabling updateItem at PATCH ${this.pathWithIdentifier}`);
+            router.patch(this.pathWithIdentifier, async (req, res) => {
+                if (!res.locals.credentials) {
+                    throw new UnauthorizedError();
+                }
+                assertUpdateItemRequestPayload(req.body);
+                const item = await handler({
+                    credentials: res.locals.credentials,
+                    body: req.body,
+                    logger: res.locals.logger,
+                    params: req.params,
+                    query: req.query,
+                });
+                res.status(200).send(item);
+            });
+        }
+        if (this.handlers.deleteItem) {
+            const handler = this.handlers.deleteItem;
+            console.debug(`  Enabling deleteItem at DELETE ${this.pathWithIdentifier}`);
+            router.delete(this.pathWithIdentifier, async (req, res) => {
+                if (!res.locals.credentials) {
+                    throw new UnauthorizedError();
+                }
+                await handler({
+                    credentials: res.locals.credentials,
+                    logger: res.locals.logger,
+                    params: req.params,
+                    query: req.query,
+                });
+                res.status(204).send(null);
+            });
+        }
+        if (this.handlers.getCredentialAccount) {
+            const handler = this.handlers.getCredentialAccount;
+            console.debug(`  Enabling getCredentialAccount at GET ${this.pathWithIdentifier}`);
+            router.get(this.pathWithIdentifier, async (req, res) => {
+                if (!res.locals.credentials) {
+                    throw new UnauthorizedError();
+                }
+                const credentialAccount = await handler({
+                    credentials: res.locals.credentials,
+                    logger: res.locals.logger,
+                    params: req.params,
+                    query: req.query,
+                });
+                res.status(200).send(credentialAccount);
+            });
+        }
+        if (this.handlers.acknowledgeWebhooks) {
+            const handler = this.handlers.acknowledgeWebhooks;
+            console.debug(`  Enabling acknowledgeWebhooks at POST ${this.pathWithIdentifier}`);
+            router.post(this.pathWithIdentifier, async (req, res) => {
+                assertWebhookParseRequestPayload(req.body);
+                const response = await handler({
+                    logger: res.locals.logger,
+                    params: req.params,
+                    query: req.query,
+                    body: req.body,
+                });
+                res.status(200).send(response);
+            });
+        }
+        if (this.handlers.parseWebhooks) {
+            const handler = this.handlers.parseWebhooks;
+            console.debug(`  Enabling parseWebhooks at POST ${this.pathWithIdentifier}`);
+            router.post(this.pathWithIdentifier, async (req, res) => {
+                assertWebhookParseRequestPayload(req.body);
+                const response = await handler({
+                    logger: res.locals.logger,
+                    params: req.params,
+                    query: req.query,
+                    body: req.body,
+                });
+                res.status(200).send(response);
+            });
+        }
+        if (this.handlers.updateWebhookSubscriptions) {
+            const handler = this.handlers.updateWebhookSubscriptions;
+            console.debug(`  Enabling updateWebhookSubscriptions at PUT ${this.pathWithIdentifier}`);
+            router.put(this.pathWithIdentifier, async (req, res) => {
+                if (!res.locals.credentials) {
+                    throw new UnauthorizedError();
+                }
+                assertWebhookSubscriptionRequestPayload(req.body);
+                const response = await handler({
+                    credentials: res.locals.credentials,
+                    body: req.body,
+                    logger: res.locals.logger,
+                    params: req.params,
+                    query: req.query,
+                });
+                res.status(204).send(response);
+            });
+        }
+        console.debug(`\x1b[0m`);
+        return router;
+    }
+}
+
+function printErrorMessage(message) {
+    console.error();
+    console.error(`\x1b[31m Oups! Something went wrong! \x1b[0m`);
+    console.error(message);
+}
+class Integration {
+    handlers;
+    instance = undefined;
+    port;
+    constructor(options = {}) {
+        this.port = options.port || 9200;
+        this.handlers = [];
+    }
+    addHandler(path, handlers) {
+        if (this.instance) {
+            printErrorMessage(`
+  It seems like you're trying to add a handler after the server has already started. This is probably
+  a mistake as calling the start() function essentially starts the server and ignore any further change.
+  To fix this error, move all your addHandler() calls before the start() function.
+      `);
+            process.exit(1);
+        }
+        try {
+            this.handlers.push(new Handler(path, handlers));
+        }
+        catch (error) {
+            if (error instanceof InvalidHandler) {
+                printErrorMessage(`
+  It seems like you're trying to add an invalid handler. The exact error message is:
+
+  > ${error.message}
+
+  You must address this issue before trying again.
+        `);
+            }
+            else {
+                printErrorMessage(`
+  An unexpected error happened as we were trying to add your handler. The exact error message is;
+
+  >  ${error.message}
+        `);
+            }
+            process.exit(1);
+        }
+    }
+    start() {
+        // Express Server initialization
+        const app = express();
+        // Parse query strings with https://github.com/ljharb/qs.
+        app.set('query parser', 'extended');
+        app.use(express.json());
+        // Must be one of the first handlers (to catch all the errors).
+        app.use(middleware$1);
+        app.use(middleware$6);
+        app.use(middleware$5);
+        app.use(middleware$4);
+        app.use(middleware$3);
+        // Load handlers as needed.
+        if (this.handlers.length) {
+            for (const handler of this.handlers) {
+                app.use(handler.generate());
+            }
+        }
+        else {
+            printErrorMessage(`
+  It seems like you're trying to start the server without any handler. This is probably a mistake as the
+  server wouldn't expose any route. To fix this error, add at least one handler before calling the start()
+  function.
+      `);
+            process.exit(1);
+        }
+        // Must be the (last - 1) handler.
+        app.use(middleware$2);
+        // Must be the last handler.
+        app.use(middleware);
+        // Start the server.
+        this.instance = app.listen(this.port, () => console.info(`Server started on port ${this.port}.`));
+        // Trap exit signals.
+        ['SIGTERM', 'SIGINT', 'SIGUSR2'].forEach(signalType => {
+            process.once(signalType, async () => {
+                console.info(`Received termination signal ${signalType}. Exiting.`);
+                try {
+                    if (this.instance) {
+                        this.instance.close();
+                    }
+                    await shutdownCaches();
+                }
+                catch (e) {
+                    console.error('Failed to gracefully exit', e);
+                }
+                process.exit();
+            });
+        });
+    }
+}
+
+class Provider {
+    rateLimiter = undefined;
+    prepareRequest;
+    /**
+     * Initialize a Provider with the given options.
+     *
+     * @property prepareRequest - function to define the Provider's base URL and specific headers to add to the request.
+     * @property rateLimiter - function to limit the rate of calls to the provider based on the caller's credentials.
+     */
+    constructor(options) {
+        this.prepareRequest = options.prepareRequest;
+        this.rateLimiter = options.rateLimiter;
+    }
+    async get(endpoint, options) {
+        return this.fetchWrapper(endpoint, null, {
+            ...options,
+            method: 'GET',
+            defaultHeaders: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+        });
+    }
+    async post(endpoint, body, options) {
+        return this.fetchWrapper(endpoint, body, {
+            ...options,
+            method: 'POST',
+            defaultHeaders: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Accept: 'application/json',
+            },
+        });
+    }
+    async put(endpoint, body, options) {
+        return this.fetchWrapper(endpoint, body, {
+            ...options,
+            method: 'PUT',
+            defaultHeaders: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Accept: 'application/json',
+            },
+        });
+    }
+    async patch(endpoint, body, options) {
+        return this.fetchWrapper(endpoint, body, {
+            ...options,
+            method: 'PATCH',
+            defaultHeaders: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Accept: 'application/json',
+            },
+        });
+    }
+    async delete(endpoint, options) {
+        return this.fetchWrapper(endpoint, null, {
+            ...options,
+            method: 'DELETE',
+            defaultHeaders: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Accept: 'application/json',
+            },
+        });
+    }
+    async fetchWrapper(endpoint, body, options) {
+        const { url: providerUrl, headers: providerHeaders } = this.prepareRequest(options);
+        let absoluteUrl = [providerUrl, endpoint.charAt(0) === '/' ? endpoint.substring(1) : endpoint].join('/');
+        if (options.queryParams) {
+            absoluteUrl = `${absoluteUrl}?${new URLSearchParams(options.queryParams)}`;
+        }
+        const headers = { ...options.defaultHeaders, ...providerHeaders, ...options.additionnalheaders };
+        let stringifiedBody = null;
+        if (body) {
+            if (headers['Content-Type'] === 'application/x-www-form-urlencoded') {
+                stringifiedBody = new URLSearchParams(body).toString();
+            }
+            else if (headers['Content-Type'] === 'application/json') {
+                stringifiedBody = JSON.stringify(body);
+            }
+        }
+        const callToProvider = async () => {
+            const response = await fetch(absoluteUrl, {
+                method: options.method,
+                headers,
+                body: stringifiedBody,
+            });
+            if (response.status >= 400) {
+                const textResult = await response.text();
+                throw buildHttpError(response.status, textResult);
+            }
+            try {
+                const body = response.body ? await response.json() : undefined;
+                return { status: response.status, headers: response.headers, body };
+            }
+            catch {
+                throw buildHttpError(400, 'Invalid JSON response');
+            }
+        };
+        return this.rateLimiter ? this.rateLimiter(options, callToProvider) : callToProvider();
+    }
+}
+
+exports.Api = integrationApi__namespace;
+exports.Cache = Cache;
+exports.Handler = Handler;
+exports.HttpErrors = httpErrors;
+exports.Integration = Integration;
+exports.Provider = Provider;