@didcid/gatekeeper 0.1.3

package/dist/cjs/gatekeeper-client.cjs

@@ -0,0 +1,369 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var axiosModule = require('axios');
+
+const VERSION = '/api/v1';
+function throwError(error) {
+    if (error.response) {
+        throw error.response.data;
+    }
+    throw error.message;
+}
+class GatekeeperClient {
+    API;
+    axios;
+    // Factory method
+    static async create(options) {
+        const gatekeeper = new GatekeeperClient();
+        await gatekeeper.connect(options);
+        return gatekeeper;
+    }
+    constructor() {
+        const axios = axiosModule?.default ??
+            axiosModule;
+        this.API = VERSION;
+        this.axios = axios.create();
+    }
+    addCustomHeader(header, value) {
+        this.axios.defaults.headers.common[header] = value;
+    }
+    removeCustomHeader(header) {
+        delete this.axios.defaults.headers.common[header];
+    }
+    async connect(options) {
+        if (options?.url) {
+            this.API = `${options.url}${VERSION}`;
+        }
+        // Only used for unit testing
+        // TBD replace console with a real logging package
+        if (options?.console) {
+            // eslint-disable-next-line
+            console = options.console;
+        }
+        if (options?.waitUntilReady) {
+            await this.waitUntilReady(options);
+        }
+    }
+    async waitUntilReady(options) {
+        let { intervalSeconds = 5, chatty = false, becomeChattyAfter = 0, maxRetries = 0 } = options;
+        let ready = false;
+        let retries = 0;
+        if (chatty) {
+            console.log(`Connecting to gatekeeper at ${this.API}`);
+        }
+        while (!ready) {
+            ready = await this.isReady();
+            if (!ready) {
+                if (chatty) {
+                    console.log('Waiting for Gatekeeper to be ready...');
+                }
+                // wait for 1 second before checking again
+                await new Promise(resolve => setTimeout(resolve, intervalSeconds * 1000));
+            }
+            retries += 1;
+            if (maxRetries > 0 && retries > maxRetries) {
+                return;
+            }
+            if (!chatty && becomeChattyAfter > 0 && retries > becomeChattyAfter) {
+                console.log(`Connecting to gatekeeper at ${this.API}`);
+                chatty = true;
+            }
+        }
+        if (chatty) {
+            console.log('Gatekeeper service is ready!');
+        }
+    }
+    async listRegistries() {
+        try {
+            const response = await this.axios.get(`${this.API}/registries`);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async resetDb() {
+        try {
+            const response = await this.axios.get(`${this.API}/db/reset`);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async verifyDb() {
+        try {
+            const response = await this.axios.get(`${this.API}/db/verify`);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async isReady() {
+        try {
+            const response = await this.axios.get(`${this.API}/ready`);
+            return response.data;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async getVersion() {
+        try {
+            const response = await this.axios.get(`${this.API}/version`);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getStatus() {
+        try {
+            const response = await this.axios.get(`${this.API}/status`);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async createDID(operation) {
+        try {
+            const response = await this.axios.post(`${this.API}/did`, operation);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async resolveDID(did, options) {
+        try {
+            if (options) {
+                const queryParams = new URLSearchParams(options);
+                const response = await this.axios.get(`${this.API}/did/${did}?${queryParams.toString()}`);
+                return response.data;
+            }
+            else {
+                const response = await this.axios.get(`${this.API}/did/${did}`);
+                return response.data;
+            }
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    // eslint-disable-next-line sonarjs/no-identical-functions
+    async updateDID(operation) {
+        try {
+            const response = await this.axios.post(`${this.API}/did`, operation);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    // eslint-disable-next-line sonarjs/no-identical-functions
+    async deleteDID(operation) {
+        try {
+            const response = await this.axios.post(`${this.API}/did`, operation);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getDIDs(options) {
+        try {
+            const response = await this.axios.post(`${this.API}/dids`, options);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async exportDIDs(dids) {
+        try {
+            const response = await this.axios.post(`${this.API}/dids/export`, { dids });
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async importDIDs(dids) {
+        try {
+            const response = await this.axios.post(`${this.API}/dids/import`, dids);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async exportBatch(dids) {
+        try {
+            const response = await this.axios.post(`${this.API}/batch/export`, { dids });
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async importBatch(batch) {
+        try {
+            const response = await this.axios.post(`${this.API}/batch/import`, batch);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async importBatchByCids(cids, metadata) {
+        try {
+            const response = await this.axios.post(`${this.API}/batch/import/cids`, { cids, metadata });
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async removeDIDs(dids) {
+        try {
+            const response = await this.axios.post(`${this.API}/dids/remove`, dids);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getQueue(registry) {
+        try {
+            const response = await this.axios.get(`${this.API}/queue/${registry}`);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async clearQueue(registry, events) {
+        try {
+            const response = await this.axios.post(`${this.API}/queue/${registry}/clear`, events);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async processEvents() {
+        try {
+            const response = await this.axios.post(`${this.API}/events/process`);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async addJSON(data) {
+        try {
+            const response = await this.axios.post(`${this.API}/ipfs/json`, data);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getJSON(cid) {
+        try {
+            const response = await this.axios.get(`${this.API}/ipfs/json/${cid}`);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async addText(data) {
+        try {
+            const response = await this.axios.post(`${this.API}/ipfs/text`, data, {
+                headers: {
+                    'Content-Type': 'text/plain'
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getText(cid) {
+        try {
+            const response = await this.axios.get(`${this.API}/ipfs/text/${cid}`);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async addData(data) {
+        try {
+            const response = await this.axios.post(`${this.API}/ipfs/data`, data, {
+                headers: {
+                    'Content-Type': 'application/octet-stream'
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getData(cid) {
+        try {
+            const response = await this.axios.get(`${this.API}/ipfs/data/${cid}`, {
+                responseType: 'arraybuffer'
+            });
+            return Buffer.from(response.data);
+        }
+        catch (error) {
+            const axiosError = error;
+            if (axiosError.response && axiosError.response.data instanceof Uint8Array) {
+                const textDecoder = new TextDecoder();
+                const errorMessage = textDecoder.decode(axiosError.response.data);
+                axiosError.response.data = JSON.parse(errorMessage);
+            }
+            throwError(axiosError);
+        }
+    }
+    async getBlock(registry, block) {
+        try {
+            const url = block
+                ? `${this.API}/block/${registry}/${block}`
+                : `${this.API}/block/${registry}/latest`;
+            const response = await this.axios.get(url);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async addBlock(registry, block) {
+        try {
+            const response = await this.axios.post(`${this.API}/block/${registry}`, block);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async generateDID(operation) {
+        try {
+            const response = await this.axios.post(`${this.API}/did/generate`, operation);
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+}
+
+exports.default = GatekeeperClient;