@elastic.io/maester-client/dist/src/ObjectStorageWrapper.js

The official object-storage client

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ObjectStorageWrapper = exports.MAESTER_MAX_SUPPORTED_COUNT_OF_QUERY_HEADERS = void 0;
const ObjectStorage_1 = require("./ObjectStorage");
const interfaces_1 = require("./interfaces");
exports.MAESTER_MAX_SUPPORTED_COUNT_OF_QUERY_HEADERS = 5;
const isHeaders = (headers) => headers && headers.length > 0;
class ObjectStorageWrapper {
    constructor(context, userAgent, msgId) {
        this.logger = context.logger;
        if (!process.env.ELASTICIO_OBJECT_STORAGE_TOKEN || !process.env.ELASTICIO_OBJECT_STORAGE_URI) {
            throw new Error('Can not find storage token or storage uri values... Check environment variables');
        }
        this.token = process.env.ELASTICIO_OBJECT_STORAGE_TOKEN;
        this.url = process.env.ELASTICIO_OBJECT_STORAGE_URI;
        this.objectStorage = new ObjectStorage_1.ObjectStorage({ uri: this.url, jwtSecret: this.token, userAgent, msgId });
    }
    /**
     * @param data any data (except 'undefined')
     */
    async createObject(data, queryHeaders, metaHeaders, ttl) {
        this.logger.debug('Going to create an object...');
        if (isHeaders(queryHeaders))
            ObjectStorageWrapper.validateQueryHeaders(queryHeaders);
        if (isHeaders(metaHeaders))
            ObjectStorageWrapper.validateMetaHeaders(metaHeaders);
        const resultHeaders = ObjectStorageWrapper.formHeadersToAdd(queryHeaders, metaHeaders);
        if (ttl)
            resultHeaders[interfaces_1.TTL_HEADER] = ttl.toString();
        return this.objectStorage.add(data, { headers: resultHeaders });
    }
    async deleteObjectById(id) {
        this.logger.debug(`Going to delete an object with id ${id}...`);
        return this.objectStorage.deleteOne(id);
    }
    async deleteObjectsByQueryParameters(headers) {
        this.logger.debug('Going to delete objects by query parameters...');
        ObjectStorageWrapper.validateQueryHeaders(headers);
        const resultParams = ObjectStorageWrapper.getQueryParams(headers);
        return this.objectStorage.deleteAllByParams(resultParams);
    }
    async lookupObjectById(id) {
        this.logger.debug(`Going to find an object by id ${id}...`);
        const { data } = await this.objectStorage.getOne(id);
        return data;
    }
    async getObjectHeaders(id) {
        this.logger.debug(`Going to fetch object headers by id ${id}...`);
        return this.objectStorage.getHeaders(id);
    }
    async lookupObjectsByQueryParameters(headers) {
        this.logger.debug('Going to find an object by query parameters');
        ObjectStorageWrapper.validateQueryHeaders(headers);
        const resultParams = ObjectStorageWrapper.getQueryParams(headers);
        return this.objectStorage.getAllByParams(resultParams);
    }
    /**
     * @param data any data (except 'undefined')
     */
    async updateObjectById(id, data, queryHeaders, metaHeaders) {
        this.logger.debug(`Going to update and object with id ${id}...`);
        if (isHeaders(queryHeaders))
            ObjectStorageWrapper.validateQueryHeaders(queryHeaders);
        if (isHeaders(metaHeaders))
            ObjectStorageWrapper.validateMetaHeaders(metaHeaders);
        const resultHeaders = ObjectStorageWrapper.formHeadersToAdd(queryHeaders, metaHeaders);
        return this.objectStorage.update(id, data, { headers: resultHeaders });
    }
    static validateQueryHeaders(headers) {
        if (headers.length === 0) {
            throw new Error('At least one query header must be present');
        }
        if (headers.length > exports.MAESTER_MAX_SUPPORTED_COUNT_OF_QUERY_HEADERS) {
            throw new Error(`maximum available amount of headers is ${exports.MAESTER_MAX_SUPPORTED_COUNT_OF_QUERY_HEADERS}`);
        }
        ObjectStorageWrapper.validateHeadersFormat(headers);
    }
    static validateMetaHeaders(headers) {
        ObjectStorageWrapper.validateHeadersFormat(headers);
    }
    static validateHeadersFormat(headers) {
        if (!headers)
            return;
        // eslint-disable-next-line no-restricted-syntax
        for (const { key, value } of headers) {
            if (key && !value)
                throw new Error('header "value" is mandatory if header "key" passed');
            if (value && !key)
                throw new Error('header "key" is mandatory if header "value" passed');
        }
    }
    static formHeadersToAdd(queryHeaders, metaHeaders) {
        return {
            ...ObjectStorageWrapper.formHeadersToAddByType(queryHeaders, 'query'),
            ...ObjectStorageWrapper.formHeadersToAddByType(metaHeaders, 'meta'),
        };
    }
    static formHeadersToAddByType(headers, headerName) {
        const resultHeaders = {};
        if (!headers)
            return;
        // eslint-disable-next-line no-restricted-syntax
        for (const { key, value } of headers) {
            const header = `x-${headerName}-${key}`;
            // eslint-disable-next-line no-prototype-builtins
            if (resultHeaders.hasOwnProperty(header))
                throw new Error(`header key "${key}" was already added`);
            resultHeaders[header] = value;
        }
        // eslint-disable-next-line consistent-return
        return resultHeaders;
    }
    static getQueryParams(headers) {
        if (!headers)
            return {};
        const resultParams = {};
        // eslint-disable-next-line no-restricted-syntax
        for (const { key, value } of headers) {
            const queryKey = `query[${key}]`;
            // eslint-disable-next-line no-prototype-builtins
            if (resultParams.hasOwnProperty(queryKey))
                throw new Error(`header key "${key}" was already added`);
            resultParams[queryKey] = value;
        }
        return resultParams;
    }
}
exports.ObjectStorageWrapper = ObjectStorageWrapper;