@quantcdn/quant-client 1.0.0

package/README.md

@@ -0,0 +1,30 @@
+# QuantCDN client API
+
+Provides a client to common API interfaces on QuantCDN.
+
+## Install
+
+The preferred method for installation is via npm.
+
+```
+npm i @quantcdn/quant-cli
+```
+
+## Usage
+
+The API client expects the following environment variables are present in order to make a successful API connection:
+* `QUANT_CUSTOMER`: The organization/customer identifier
+* `QUANT_PROJECT`: The project identifier
+* `QUANT_TOKEN`: The project token
+
+These values can be found from the "Integrations" page of the QuantCDN Dashboard.
+
+```
+import { QuantClient } from "@quantcdn/quant-client"
+
+// Purge QuantCDN edge caches for a single route.
+QuantClient().purge('/path/to/content')
+
+// Purge all QuantCDN edge caches.
+QuantClient().purge('/*')
+``

package/dist/config.d.ts

@@ -0,0 +1,7 @@
+export interface QuantConfig {
+    dir: string;
+    endpoint: "https://api.quantcdn.io/v1";
+    clientid: string;
+    project: string;
+    token: string;
+}

package/dist/config.js

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

package/dist/helper/quant-url.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Prepare URLs for quant.
+ */
+export declare class QuantURL {
+    /**
+     * Prepare a URI to work with Quant.
+     *
+     * @param {string} uri
+     *   The URI to prepare.
+     *
+     * @return {string}
+     *   The prepared URI
+     */
+    static prepare(uri: any): any;
+}

package/dist/helper/quant-url.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Prepare URLs for quant.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuantURL = void 0;
+class QuantURL {
+    /**
+     * Prepare a URI to work with Quant.
+     *
+     * @param {string} uri
+     *   The URI to prepare.
+     *
+     * @return {string}
+     *   The prepared URI
+     */
+    static prepare(uri) {
+        uri = uri.startsWith('/') ? uri : `/${uri}`;
+        uri = uri.toLowerCase();
+        uri = uri.replace(/^\/\//, '/');
+        uri = uri.replace(/(\/)index\.html/, '$1');
+        if (uri.length > 1) {
+            return uri.endsWith('/') ? uri.slice(0, -1) : uri;
+        }
+        return uri;
+    }
+}
+exports.QuantURL = QuantURL;
+;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { QuantClient } from './quant-client';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuantClient = void 0;
+var quant_client_1 = require("./quant-client");
+Object.defineProperty(exports, "QuantClient", { enumerable: true, get: function () { return quant_client_1.QuantClient; } });

package/dist/quant-client.d.ts

@@ -0,0 +1,230 @@
+/**
+ * Quant API client.
+ */
+export declare function QuantClient(): {
+    /**
+     * Initialize the client
+     */
+    init: () => void;
+    /**
+     * Ping the quant API.
+     *
+     * @return {object}
+     *   The response object.
+     *
+     * @throws Error.
+     */
+    ping: () => Promise<any>;
+    /**
+     * Access the global meta for the project.
+     *
+     * @param {bool} unfold
+     *   Unfold the record set.
+     * @param {bool} exclude
+     *   Exclude delete objects from the meta result.
+     * @param {object} extend
+     *   Additional query parameters to send.
+     *
+     * @return {object}
+     *   The global meta response object.
+     *
+     * @throws Error.
+     *
+     * @TODO
+     *   - Async iterator for memory 21k items ~ 40mb.
+     */
+    meta: (unfold?: boolean, exclude?: boolean, extend?: {}) => Promise<{
+        total_pages: any;
+        total_records: any;
+        records: any[];
+    }>;
+    /**
+     * Send a file to the server.
+     *
+     * @param {string} file
+     *   The path to the file.
+     * @param {string} location
+     *   The path the location.
+     * @param {bool} published
+     *   The status.
+     * @param {bool} attachments
+     *   Should quant find attachments.
+     * @param {bool} skipPurge
+     *   Skip CDN cache purge.
+     * @param {bool} includeIndex
+     *   Include index.html suffix on HTML assets.
+     * @param {object} extraHeaders
+     *   Additional HTTP headers.
+     * @param {string} encoding
+     *   The encoding type.
+     *
+     * @return {object}
+     *   The API response.
+     */
+    send: (file: any, location: any, published?: boolean, attachments?: boolean, skipPurge?: boolean, includeIndex?: boolean, extraHeaders?: {}, encoding?: string) => Promise<any>;
+    /**
+     * Upload markup.
+     *
+     * @param {string} file
+     *   Filepath on disk.
+     * @param {string} location
+     *   The web accessible destination.
+     * @param {bool} published
+     *   The status.
+     * @param {bool} attachments
+     *   Quant looking for attachments.
+     * @param {object} extraHeaders
+     *   Additional HTTP headers.
+     * @param {string} encoding
+     *   The encoding type.
+     * @param {bool} skipPurge
+     *   Skip CDN cache purge.
+     *
+     * @return {object}
+     *   The API response.
+     */
+    markup: (file: any, location: any, published?: boolean, attachments?: boolean, extraHeaders?: {}, encoding?: string, skipPurge?: boolean) => Promise<any>;
+    /**
+     * Send a file to the Quant API.
+     *
+     * @param {string} local
+     *   File path on disk.
+     * @param {string} location
+     *   Accessible location.
+     * @param {bool} absolute
+     *   If the location is an absolute path.
+     * @param {object} extraHeaders
+     *   Additional HTTP headers.
+     * @param {bool} skipPurge
+     *   Skip CDN cache purge.
+     *
+     * @return {object}
+     *   The successful payload.
+     *
+     * @throws Error
+     */
+    file: (local: any, location: any, absolute?: boolean, extraHeaders?: {}, skipPurge?: boolean) => Promise<any>;
+    /**
+     * Change the status of an asset.
+     *
+     * @param {string} location
+     *   The URL location of the content.
+     * @param {string} revision
+     *   The revision to publish.
+     *
+     * @return {object}
+     *   API payload.
+     *
+     * @throws Error.
+     */
+    publish: (location: any, revision: any) => Promise<any>;
+    /**
+     * Unpublish a URL.
+     *
+     * @param {string} url
+     *   The URL to unpublish.
+     *
+     * @return {object}
+     *
+     * @throws Error.
+     */
+    unpublish: (url: any) => Promise<any>;
+    /**
+     *
+     * @param {string} from
+     *   The URL to redirect form.
+     * @param {string} to
+     *   The URL to redirect to.
+     * @param {string} author
+     *   (Optional) Author.
+     * @param {int} status
+     *   HTTP status code.
+     *
+     * @return {object}
+     *   API payload.
+     *
+     * @throws Error.
+     */
+    redirect: (from: any, to: any, author: any, status?: number) => Promise<any>;
+    /**
+     * Create a proxy with the Quant API.
+     *
+     * @param {string} url
+     *   The relative URL to proxy.
+     * @param {string} destination
+     *   The absolute FQDN/path to proxy to.
+     * @param {bool} published
+     *   If the proxy is published
+     * @param {string} username
+     *   Basic auth user.
+     * @param {string} password
+     *   Basic auth password.
+     *
+     * @return {object}
+     *   The response.
+     *
+     * @throws Error.
+     */
+    proxy: (url: any, destination: any, published: boolean, username: any, password: any) => Promise<any>;
+    /**
+     * Delete a path from Quant.
+     *
+     * @param {string} path
+     *
+     * @return {object}
+     *   The response object.
+     *
+     * @throw Error.
+     */
+    delete: (path: any) => Promise<any>;
+    /**
+     * Get the revision history from Quant.
+     *
+     * @param {string} url
+     *   The URL path to get revisions for.
+     * @param {string|bool} revision
+     *   Retrieve a specific revision.
+     *
+     * @return {object}
+     *   The response.
+     *
+     * @throws Error.
+     */
+    revisions: (url: any, revision?: boolean) => Promise<any>;
+    /**
+     * Purge URL patterns from Quants Varnish.
+     *
+     * @param {string} urlPattern
+     *
+     * @throws Error
+     */
+    purge: (urlPattern: any) => Promise<any>;
+    /**
+      * Add/update items in search index.
+      *
+      * @param {string} filePath
+      *
+      * @throws Error
+      */
+    searchIndex: (filePath: any) => Promise<any>;
+    /**
+      * Remove item from search index.
+      *
+      * @param {string} url
+      *
+      * @throws Error
+      */
+    searchRemove: (url: any) => Promise<any>;
+    /**
+      * Clear search index.
+      *
+      * @throws Error
+      */
+    searchClearIndex: () => Promise<any>;
+    /**
+      * Retrieve search index status.
+      *
+      * @throws Error
+      */
+    searchStatus: () => Promise<any>;
+};

package/dist/quant-client.js

@@ -0,0 +1,696 @@
+"use strict";
+/**
+ * Quant API client.
+ */
+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.QuantClient = void 0;
+const request = require('request');
+const util = require('util');
+const fs = require('fs');
+const path = require('path');
+const mime = require('mime-types');
+const querystring = require('querystring');
+const quant_url_1 = require("./helper/quant-url");
+function QuantClient() {
+    const req = util.promisify(request); // eslint-disable-line
+    const get = util.promisify(request.get);
+    const post = util.promisify(request.post);
+    const patch = util.promisify(request.patch);
+    const del = util.promisify(request.delete);
+    let headers = {};
+    let config;
+    /**
+     * Handle the response.
+     *
+     * @param {string} response
+     *   Response body from the Quant API.
+     *
+     * @return {object}
+     *   The API response.
+     */
+    const handleResponse = function (response) {
+        const body = typeof response.body == 'string' ? JSON.parse(response.body) : response.body; // eslint-disable-line max-len
+        if (typeof body.errors != 'undefined') {
+            let msg = '';
+            for (const i in body.errors) { // eslint-disable-line
+                msg += body.errors[i].errorMsg + '\n';
+            }
+            throw new Error(msg);
+        }
+        if (response.statusCode == 400) {
+            // @TODO: this is generally if the content is
+            // streamed to the endpoint 4xx and 5xx are thrown
+            // similarly, the API should respond with errors
+            // otherwise.
+            if (typeof body.errorMsg != 'undefined') {
+                throw new Error(body.errorMsg);
+            }
+            throw new Error('Critical error...');
+        }
+        if (body.error || (typeof body.errorMsg != 'undefined' && body.errorMsg.length > 0)) { // eslint-disable-line max-len
+            const msg = typeof body.errorMsg != 'undefined' ? body.errorMsg : body.msg;
+            throw new Error(msg);
+        }
+        return body;
+    };
+    return {
+        /**
+         * Initialize the client
+         */
+        init: function () {
+            this.config = {
+                clientid: process.env.QUANT_CUSTOMER,
+                project: process.env.QUANT_PROJECT,
+                token: process.env.QUANT_TOKEN,
+                endpoint: 'https://api.quantcdn.io/v1'
+            };
+            this.headers = {
+                'User-Agent': 'Quant (+http://api.quantcdn.io)',
+                'Quant-Token': this.config.token,
+                'Quant-Customer': this.config.clientid,
+                'Quant-Project': this.config.project,
+                'Content-Type': 'application/json',
+            };
+        },
+        /**
+         * Ping the quant API.
+         *
+         * @return {object}
+         *   The response object.
+         *
+         * @throws Error.
+         */
+        ping: function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    const options = {
+                        url: `${this.config.endpoint}/ping`,
+                        json: true,
+                        headers,
+                    };
+                    const res = yield get(options);
+                    return handleResponse(res);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+        /**
+         * Access the global meta for the project.
+         *
+         * @param {bool} unfold
+         *   Unfold the record set.
+         * @param {bool} exclude
+         *   Exclude delete objects from the meta result.
+         * @param {object} extend
+         *   Additional query parameters to send.
+         *
+         * @return {object}
+         *   The global meta response object.
+         *
+         * @throws Error.
+         *
+         * @TODO
+         *   - Async iterator for memory 21k items ~ 40mb.
+         */
+        meta: function (unfold = false, exclude = true, extend = {}) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    const records = [];
+                    const query = Object.assign({
+                        page_size: 500,
+                        published: true,
+                        deleted: false,
+                        sort_field: 'last_modified',
+                        sort_direction: 'desc',
+                    }, extend);
+                    const url = `${this.config.endpoint}/global-meta?${querystring.stringify(query)}`;
+                    const doUnfold = function (i) {
+                        return __awaiter(this, void 0, void 0, function* () {
+                            const res = yield get({
+                                url: `${url}&page=${i}`,
+                                json: true,
+                                headers,
+                            });
+                            if (res.body.global_meta && res.body.global_meta.records) {
+                                res.body.global_meta.records.map((item) => records.push({ url: item.meta.url, md5: item.meta.md5 }));
+                            }
+                        });
+                    };
+                    let page = 1;
+                    const options = {
+                        url: `${url}&page=${page}`,
+                        json: true,
+                        headers,
+                    };
+                    // Seed the record set.
+                    const res = yield get(options);
+                    if (!res.body.global_meta) {
+                        // If no records have been published then global_meta is not
+                        // present in the response.
+                        return;
+                    }
+                    if (res.body.global_meta.records) {
+                        res.body.global_meta.records.map((item) => records.push({ url: item.meta.url, md5: item.meta.md5 }));
+                    }
+                    if (unfold) {
+                        page++;
+                        while (res.body.global_meta.total_pages >= page) {
+                            yield doUnfold(page);
+                            page++;
+                        }
+                    }
+                    return {
+                        total_pages: res.body.global_meta.total_pages,
+                        total_records: res.body.global_meta.total_records,
+                        records,
+                    };
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+        /**
+         * Send a file to the server.
+         *
+         * @param {string} file
+         *   The path to the file.
+         * @param {string} location
+         *   The path the location.
+         * @param {bool} published
+         *   The status.
+         * @param {bool} attachments
+         *   Should quant find attachments.
+         * @param {bool} skipPurge
+         *   Skip CDN cache purge.
+         * @param {bool} includeIndex
+         *   Include index.html suffix on HTML assets.
+         * @param {object} extraHeaders
+         *   Additional HTTP headers.
+         * @param {string} encoding
+         *   The encoding type.
+         *
+         * @return {object}
+         *   The API response.
+         */
+        send: function (file, location, published = true, attachments = false, skipPurge = false, includeIndex = false, extraHeaders = {}, encoding = 'utf-8') {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    const mimeType = mime.lookup(file);
+                    if (mimeType == 'text/html') {
+                        if (!location) {
+                            const p = path.resolve(process.cwd(), this.config.dir);
+                            // If a location isn't given, calculate it.
+                            location = path.relative(p, file);
+                        }
+                        location = quant_url_1.QuantURL.prepare(location);
+                        if (!location.endsWith('.html') && includeIndex) {
+                            location = `${location}/index.html`;
+                            location = location.replace(/^\/\//, '/');
+                        }
+                        return yield this.markup(file, location, published, attachments, extraHeaders, encoding, skipPurge);
+                    }
+                    else {
+                        return yield this.file(file, location, false, extraHeaders, skipPurge);
+                    }
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+        /**
+         * Upload markup.
+         *
+         * @param {string} file
+         *   Filepath on disk.
+         * @param {string} location
+         *   The web accessible destination.
+         * @param {bool} published
+         *   The status.
+         * @param {bool} attachments
+         *   Quant looking for attachments.
+         * @param {object} extraHeaders
+         *   Additional HTTP headers.
+         * @param {string} encoding
+         *   The encoding type.
+         * @param {bool} skipPurge
+         *   Skip CDN cache purge.
+         *
+         * @return {object}
+         *   The API response.
+         */
+        markup: function (file, location, published = true, attachments = false, extraHeaders = {}, encoding = 'utf-8', skipPurge = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    if (!Buffer.isBuffer(file)) {
+                        if (!location) {
+                            const p = path.resolve(process.cwd(), this.config.dir);
+                            // If a location isn't given, calculate it.
+                            location = path.relative(p, file);
+                        }
+                        file = fs.readFileSync(file, [encoding]);
+                    }
+                    const content = file.toString('utf8');
+                    location = location.startsWith('/') ? location : `/${location}`;
+                    if (skipPurge) {
+                        headers['Quant-Skip-Purge'] = 'true';
+                    }
+                    const options = {
+                        url: `${this.config.endpoint}`,
+                        json: true,
+                        body: {
+                            url: location,
+                            find_attachments: attachments,
+                            content,
+                            published,
+                        },
+                        headers: Object.assign({}, headers),
+                    };
+                    //   if (Object.entries(extraHeaders).length > 0) {
+                    //     options.body.headers = extraHeaders;
+                    //   }
+                    const res = yield post(options);
+                    return handleResponse(res);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+        /**
+         * Send a file to the Quant API.
+         *
+         * @param {string} local
+         *   File path on disk.
+         * @param {string} location
+         *   Accessible location.
+         * @param {bool} absolute
+         *   If the location is an absolute path.
+         * @param {object} extraHeaders
+         *   Additional HTTP headers.
+         * @param {bool} skipPurge
+         *   Skip CDN cache purge.
+         *
+         * @return {object}
+         *   The successful payload.
+         *
+         * @throws Error
+         */
+        file: function (local, location, absolute = false, extraHeaders = {}, skipPurge = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    if (!Buffer.isBuffer(local)) {
+                        if (!location) {
+                            const p = path.resolve(process.cwd(), this.config.dir);
+                            // If a location isn't given, calculate it.
+                            location = path.relative(p, local);
+                            location.replace(path.basename(location), '');
+                        }
+                        if (!fs.existsSync(local)) {
+                            throw new Error('File is not accessible.');
+                        }
+                        local = fs.createReadStream(local);
+                    }
+                    const formData = {
+                        data: local,
+                    };
+                    location = location.startsWith('/') ? location : `/${location}`;
+                    if (skipPurge) {
+                        headers['Quant-Skip-Purge'] = 'true';
+                    }
+                    const options = {
+                        url: this.config.endpoint,
+                        json: true,
+                        headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'multipart/form-data', 'Quant-File-Url': location }),
+                        formData,
+                    };
+                    if (Object.entries(extraHeaders).length > 0) {
+                        options.headers['Quant-File-Headers'] = JSON.stringify(extraHeaders);
+                    }
+                    const res = yield post(options);
+                    return handleResponse(res);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+        /**
+         * Change the status of an asset.
+         *
+         * @param {string} location
+         *   The URL location of the content.
+         * @param {string} revision
+         *   The revision to publish.
+         *
+         * @return {object}
+         *   API payload.
+         *
+         * @throws Error.
+         */
+        publish: function (location, revision) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    const url = quant_url_1.QuantURL.prepare(location);
+                    if (!revision) {
+                        throw Error('Invalid revision ID provided.');
+                    }
+                    const options = {
+                        url: `${this.config.endpoint}/publish/${revision}`,
+                        headers: Object.assign(Object.assign({}, headers), { 'Quant-Url': url }),
+                        json: true,
+                    };
+                    const res = yield patch(options);
+                    return handleResponse(res);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+        /**
+         * Unpublish a URL.
+         *
+         * @param {string} url
+         *   The URL to unpublish.
+         *
+         * @return {object}
+         *
+         * @throws Error.
+         */
+        unpublish: function (url) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    url = quant_url_1.QuantURL.prepare(url);
+                    const options = {
+                        url: `${this.config.endpoint}/unpublish`,
+                        headers: Object.assign(Object.assign({}, headers), { 'Quant-Url': url }),
+                        json: true,
+                    };
+                    const res = yield patch(options);
+                    return handleResponse(res);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+        /**
+         *
+         * @param {string} from
+         *   The URL to redirect form.
+         * @param {string} to
+         *   The URL to redirect to.
+         * @param {string} author
+         *   (Optional) Author.
+         * @param {int} status
+         *   HTTP status code.
+         *
+         * @return {object}
+         *   API payload.
+         *
+         * @throws Error.
+         */
+        redirect: function (from, to, author, status = 302) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    const options = {
+                        url: `${this.config.endpoint}/redirect`,
+                        headers: Object.assign({}, headers),
+                        json: true,
+                        body: {
+                            url: from,
+                            redirect_url: to,
+                            redirect_http_code: status,
+                            published: true,
+                        },
+                    };
+                    if (status < 300 || status > 400) {
+                        throw new Error('A valid redirect status code is required');
+                    }
+                    //   if (author) {
+                    //     options.body.info = {author_user: author};
+                    //   }
+                    const res = yield post(options);
+                    return handleResponse(res);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+        /**
+         * Create a proxy with the Quant API.
+         *
+         * @param {string} url
+         *   The relative URL to proxy.
+         * @param {string} destination
+         *   The absolute FQDN/path to proxy to.
+         * @param {bool} published
+         *   If the proxy is published
+         * @param {string} username
+         *   Basic auth user.
+         * @param {string} password
+         *   Basic auth password.
+         *
+         * @return {object}
+         *   The response.
+         *
+         * @throws Error.
+         */
+        proxy: function (url, destination, published = true, username, password) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    const options = {
+                        url: `${this.config.endpoint}/proxy`,
+                        headers: Object.assign({}, headers),
+                        json: true,
+                        body: {
+                            url,
+                            destination,
+                            published,
+                        },
+                    };
+                    //   if (username) {
+                    //     options.body.basic_auth_user = username;
+                    //     options.body.basic_auth_pass = password;
+                    //   }
+                    const res = yield post(options);
+                    return handleResponse(res);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+        /**
+         * Delete a path from Quant.
+         *
+         * @param {string} path
+         *
+         * @return {object}
+         *   The response object.
+         *
+         * @throw Error.
+         */
+        delete: function (path) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    path = path.replace('index.html', '');
+                    const options = {
+                        url: `${this.config.endpoint}/delete/all`,
+                        headers: Object.assign(Object.assign({}, headers), { 'Quant-Url': path }),
+                    };
+                    const res = yield del(options);
+                    return handleResponse(res);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+        /**
+         * Get the revision history from Quant.
+         *
+         * @param {string} url
+         *   The URL path to get revisions for.
+         * @param {string|bool} revision
+         *   Retrieve a specific revision.
+         *
+         * @return {object}
+         *   The response.
+         *
+         * @throws Error.
+         */
+        revisions: function (url, revision = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    const path = revision ? revision : 'published';
+                    url = url.indexOf('/') == 0 ? url : `/${url}`;
+                    url = url.toLowerCase();
+                    url = url.replace(/\/?index\.html/, '');
+                    const options = {
+                        url: `${this.config.endpoint}/revisions/${path}`,
+                        headers: Object.assign(Object.assign({}, headers), { 'Quant-Url': url }),
+                        json: true,
+                    };
+                    const res = yield get(options);
+                    return handleResponse(res);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+        /**
+         * Purge URL patterns from Quants Varnish.
+         *
+         * @param {string} urlPattern
+         *
+         * @throws Error
+         */
+        purge: function (urlPattern) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    const options = {
+                        url: `${this.config.endpoint}/purge`,
+                        headers: Object.assign(Object.assign({}, this.headers), { 'Quant-Url': urlPattern }),
+                    };
+                    const res = yield post(options);
+                    return handleResponse(res);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+        /**
+          * Add/update items in search index.
+          *
+          * @param {string} filePath
+          *
+          * @throws Error
+          */
+        searchIndex: function (filePath) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    let data = '';
+                    // filePath is a JSON file we send the raw content of.
+                    try {
+                        data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+                    }
+                    catch (err) {
+                        console.error(err);
+                        return;
+                    }
+                    const options = {
+                        url: `${this.config.endpoint}/search`,
+                        headers: Object.assign({}, this.headers),
+                        json: true,
+                        body: data,
+                    };
+                    const res = yield post(options);
+                    return handleResponse(res);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+        /**
+          * Remove item from search index.
+          *
+          * @param {string} url
+          *
+          * @throws Error
+          */
+        searchRemove: function (url) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    const options = {
+                        url: `${this.config.endpoint}/search`,
+                        headers: Object.assign(Object.assign({}, this.headers), { 'Quant-Url': url }),
+                        json: true,
+                    };
+                    const res = yield del(options);
+                    return handleResponse(res);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+        /**
+          * Clear search index.
+          *
+          * @throws Error
+          */
+        searchClearIndex: function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    const options = {
+                        url: `${this.config.endpoint}/search/all`,
+                        headers: Object.assign({}, this.headers),
+                        json: true,
+                    };
+                    const res = yield del(options);
+                    return handleResponse(res);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+        /**
+          * Retrieve search index status.
+          *
+          * @throws Error
+          */
+        searchStatus: function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.init();
+                    const options = {
+                        url: `${this.config.endpoint}/search`,
+                        headers: Object.assign({}, this.headers),
+                        json: true,
+                    };
+                    const res = yield get(options);
+                    return handleResponse(res);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        },
+    };
+}
+exports.QuantClient = QuantClient;
+;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@quantcdn/quant-client",
+  "version": "1.0.0",
+  "description": "Client library for API connectivity",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "/dist"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/quantcdn/quant-client.git"
+  },
+  "author": "Stuart Rowlands <stuart.rowlands@quantcdn.io>",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/quantcdn/quant-client/issues"
+  },
+  "homepage": "https://github.com/quantcdn/quant-client#readme",
+  "dependencies": {
+    "mime-types": "^2.1.27",
+    "request": "^2.88.2"
+  },
+  "devDependencies": {
+    "@types/node": "^18.16.3"
+  }
+}