@quantcdn/quant-client 1.0.0 → 2.0.1

package/README.md

@@ -7,24 +7,82 @@ Provides a client to common API interfaces on QuantCDN.
 The preferred method for installation is via npm.
 
 ```
-npm i @quantcdn/quant-cli
+npm i @quantcdn/quant-client
 ```
 
 ## 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
+- Import `types` form '@quantcdn/quant-client' to correctly type parameters
+- All responses are generated using the `PaginatedResponse` object which provides an async iterator
 
-These values can be found from the "Integrations" page of the QuantCDN Dashboard.
+```
+import { QuantClient, types } from '@quantcdn/quant-client'
+
+const config:types.Config = {
+  organization: process.env.QUANT_CUSTOMER,
+  project: process.env.QUANT_PROJECT,
+  token: process.env.QUANT_TOKEN
+}
+
+// If making organization API requests with the client you need to provide bearer
+# config.bearer = process.env.QUANT_BEARER_TOKEN
+
+// Create a new client instance.
+const client = new QuantClient(config)
+
+// Perform requests to the project API.
+const p:types.URLPayload = {"url": "/*"}
+client.project.purge(p).then(async res => {
+   const r = await res.first()
+   console.log(r)
+})
+
+// Ping the API to verify details.
+client.project.ping().then(async res => {
+  const b = await res.first()
+  console.log(b)
+})
 
+// Access project metadata.
+client.project.meta().then(async res => {
+  // res.first() will return the first page of the paginated response.
+  for await (const i of res) {
+    console.log(i)
+  }
+})
 ```
-import { QuantClient } from "@quantcdn/quant-client"
 
-// Purge QuantCDN edge caches for a single route.
-QuantClient().purge('/path/to/content')
+## Available methods
+
+The `QuantClient` class has three properties to access different APIs that are exposed by Quant. These are `project`, `organization`, `search`. Both the project and search clients are project specific.
+
+### `client.project`
+
+| Method    | Description                            | Parameters            |
+| --------- | -------------------------------------- | --------------------- |
+| ping      | Ping the API to validate credentials   |                       |
+| meta      | Access the global meta for the project |                       |
+| markup    | Send a HTML file                       | types.MarkupPayload   |
+| file      | Send a non-HTML file                   | types.FilePayload     |
+| publish   | Publish a URL                          | types.PublishPayload  |
+| unpublish | Unpublish a URL                        | types.PublishPayload  |
+| redirect  | Create a redirect                      | types.RedirectPayload |
+| proxy     | Create an origin proxy                 | types.ProxyPayload    |
+| delete    | Delete a resource                      | types.URLPayload      |
+| revisions | Show revisions for a URL               | types.URLPayload      |
+| purge     | Purge cache for the given URL          | types.URLPayload      |
+
+### `client.organization`
+
+| Method  | Description                          | Parameters           |
+| ------- | ------------------------------------ | -------------------- |
+| wafLogs | Access WAF logs for the organization | types.WafLogsPayload |
+
+### `client.search`
 
-// Purge all QuantCDN edge caches.
-QuantClient().purge('/*')
-``
+| Method | Description                 | Parameters               |
+| ------ | --------------------------- | ------------------------ |
+| index  | Add a new item to the index | types.SearchIndexPayload |
+| remove | Remove a URL form the index | types.URLPayload         |
+| clear  | Clear the projects index    |                          |
+| status | Get the index status        |                          |

package/dist/client.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Quant API client.
+ */
+import type * as types from './types';
+import type * as interfaces from './interfaces';
+export declare class QuantClient {
+    private readonly _project;
+    private readonly _organization;
+    private readonly _search;
+    constructor(config: types.Config, Client?: interfaces.ClientConstructor);
+    getClient(name: string): interfaces.Client;
+    project: interfaces.ProjectApi;
+    organization: interfaces.OrganizationApi;
+    search: interfaces.SearchApi;
+}

package/dist/client.js

@@ -0,0 +1,342 @@
+"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("@cypress/request");
+const response_1 = require("./response");
+class HttpClient {
+    constructor(baseUrl, headers) {
+        this.baseUrl = baseUrl;
+        this.headers = headers;
+    }
+    do(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield new Promise((resolve, reject) => {
+                request(options, (error, repsonse, body) => {
+                    if (error !== null) {
+                        reject(error);
+                    }
+                    else {
+                        resolve(body);
+                    }
+                });
+            });
+        });
+    }
+    get(path, qs, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = {
+                url: `${this.baseUrl}/${path}`,
+                method: 'GET',
+                headers: Object.assign(Object.assign({}, this.headers), headers),
+                json: true,
+                qs
+            };
+            const res = new response_1.PaginatedResponse(this, options);
+            return yield new Promise((resolve) => { resolve(res); });
+        });
+    }
+    post(path, body, headers, formData, qs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = {
+                url: `${this.baseUrl}/${path}`,
+                method: 'POST',
+                headers: Object.assign(Object.assign({}, this.headers), headers),
+                json: true,
+                body,
+                formData,
+                qs
+            };
+            const res = new response_1.PaginatedResponse(this, options);
+            return yield new Promise((resolve) => { resolve(res); });
+        });
+    }
+    delete(path, body, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = {
+                url: `${this.baseUrl}/${path}`,
+                method: 'DELETE',
+                headers: Object.assign(Object.assign({}, this.headers), headers),
+                json: true,
+                body
+            };
+            const res = new response_1.PaginatedResponse(this, options);
+            return yield new Promise((resolve) => { resolve(res); });
+        });
+    }
+    patch(path, body, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = {
+                url: `${this.baseUrl}/${path}`,
+                method: 'PATCH',
+                headers: Object.assign(Object.assign({}, this.headers), headers),
+                json: true,
+                body
+            };
+            const res = new response_1.PaginatedResponse(this, options);
+            return yield new Promise((resolve) => { resolve(res); });
+        });
+    }
+}
+class QuantClient {
+    constructor(config, Client) {
+        this.project = {
+            /**
+             * Ping and ensure the API credentials are valid.
+             *
+             * @returns Promise<any>
+             *   The response object.
+             */
+            ping: () => __awaiter(this, void 0, void 0, function* () {
+                return yield this._project.get('ping');
+            }),
+            /**
+             * Fetch metadata for all objects stored in Quant.
+             *
+             * @returns Promise<any>
+             *   The repsonse object.
+             */
+            meta: () => __awaiter(this, void 0, void 0, function* () {
+                return yield this._project.get('global-meta');
+            }),
+            /**
+             * Send markup directly to the Quant API.
+             *
+             * @param markup MarkupPayload
+             *   The markup payload data.
+             *
+             * @returns Promise<any>
+             *   The repsonse object.
+             */
+            markup: (payload) => __awaiter(this, void 0, void 0, function* () {
+                const headers = {};
+                const body = {
+                    url: payload.url,
+                    content: payload.data.toString('utf-8'),
+                    published: payload.published,
+                    find_attachments: 'false'
+                };
+                if (typeof payload.skipPurge !== 'undefined') {
+                    headers['Quant-Skip-Purge'] = 'true';
+                }
+                if (typeof payload.findAttachments !== 'undefined') {
+                    body.find_attachments = 'true';
+                }
+                return yield this._project.post('markup', body, headers);
+            }),
+            /**
+             * Upload a file asset to Quant.
+             *
+             * @param payload FilePayload
+             *   The file payload data.
+             *
+             * @returns Promose<any>
+             *   The repsonse object.
+             */
+            file: (payload) => __awaiter(this, void 0, void 0, function* () {
+                const headers = {
+                    'Content-Type': 'multipart/form-data',
+                    'Quant-File-Url': payload.location
+                };
+                const formData = { data: payload.data };
+                if (typeof payload.skipPurge !== 'undefined') {
+                    headers['Quant-Skip-Purge'] = 'true';
+                }
+                return yield this._project.post('file', {}, headers, formData);
+            }),
+            /**
+             * Publish a revision.
+             *
+             * @param payload PublishPayload
+             *   The payload object
+             *
+             * @returns Promise<any>
+             *   The response object.
+             */
+            publish: (payload) => __awaiter(this, void 0, void 0, function* () {
+                return yield this._project.patch(`publish/${payload.revision}`, {}, {
+                    'Quant-Url': payload.location
+                });
+            }),
+            /**
+             * Unpublish a revision.
+             *
+             * @param payload PublishPayload
+             *   The payload object.
+             *
+             * @returns Promise<any>
+             *   The response object.
+             */
+            unpublish: (payload) => __awaiter(this, void 0, void 0, function* () {
+                return yield this._project.patch(`unpublish/${payload.revision}`, {}, {
+                    'Quant-Url': payload.location
+                });
+            }),
+            /**
+             * Redirect a URL.
+             *
+             * @param payload RedirectPayload
+             *   The redirect payload.
+             *
+             * @returns Promise<any>
+             *   The repsonse object.
+             */
+            redirect: (payload) => __awaiter(this, void 0, void 0, function* () {
+                return yield this._project.post('redirect', payload);
+            }),
+            /**
+             * Proxy a URL to a different origin.
+             *
+             * @param payload ProxyPayload
+             *   The proxy API payload.
+             *
+             * @returns Promise<any>
+             *   The repsonse object.
+             */
+            proxy: (payload) => __awaiter(this, void 0, void 0, function* () {
+                return yield this._project.post('proxy', payload);
+            }),
+            /**
+             * Delete a URL from Quant.
+             *
+             * @param payload URLPayload
+             *   The API payload.
+             *
+             * @returns Promise<any>
+             *   The repsonse object.
+             */
+            delete: (payload) => __awaiter(this, void 0, void 0, function* () {
+                return yield this._project.delete('delete/all', {}, {
+                    'Quant-Url': payload.url
+                });
+            }),
+            /**
+             * Get a revision from the API.
+             *
+             * @param payload URLPayload
+             *   The URL payload.
+             *
+             * @returns Promise<any>
+             *   The repsonse object.
+             */
+            revisions: (payload) => __awaiter(this, void 0, void 0, function* () {
+                return yield this._project.get('revisions/latest', {}, {
+                    'Quant-Url': payload.url
+                });
+            }),
+            /**
+             * Purge Varnish for a given URL pattern.
+             *
+             * @param payload URLPayload
+             *   The URL payload.
+             *
+             * @returns Promise<any>
+             *   The repsonse object.
+             */
+            purge: (payload) => __awaiter(this, void 0, void 0, function* () {
+                return yield this._project.post('purge', {}, {
+                    'Quant-Url': payload.url
+                });
+            })
+        };
+        this.organization = {
+            /**
+             * Fetch WAF logs from.
+             *
+             * @param payload types.WafLogsPayload
+             *   The API request payload.
+             *
+             * @returns Promise<any>
+             *   The response object.
+             */
+            wafLogs: (payload) => __awaiter(this, void 0, void 0, function* () {
+                const headers = { 'Quant-Project': payload.project };
+                return yield this._organization.get('waf/logs', {}, headers);
+            })
+        };
+        this.search = {
+            /**
+             * Index search data.
+             *
+             * @param payload types.SearchIndexPayload
+             *   The search index paylod.
+             *
+             * @returns Promose<any>
+             *   The respose.
+             */
+            index: (payload) => __awaiter(this, void 0, void 0, function* () {
+                return yield this._search.post('search', JSON.parse(payload.data.toString()));
+            }),
+            /**
+             * Remove an item from the search index.
+             *
+             * @param payload types.URLPayload
+             *   The URL payload.
+             *
+             * @returns Promise<any>
+             *   The response obejct.
+             */
+            remove: (payload) => __awaiter(this, void 0, void 0, function* () {
+                return yield this._search.delete('search', {}, {
+                    'Quant-Url': payload.url
+                });
+            }),
+            /**
+             * Clear the search index.
+             *
+             * @returns Promise<any>
+             *   The response object.
+             */
+            clear: () => __awaiter(this, void 0, void 0, function* () {
+                return yield this._search.delete('search/all');
+            }),
+            /**
+             * Get the search index status.
+             *
+             * @returns Promise<any>
+             *   The response object.
+             */
+            status: () => __awaiter(this, void 0, void 0, function* () {
+                return yield this._search.get('search');
+            })
+        };
+        if (typeof Client === 'undefined') {
+            Client = HttpClient;
+        }
+        this._project = new Client('https://api.quantcdn.io/v1', {
+            'User-Agent': 'Quant (+http://api.quantcdn.io)',
+            'Quant-Token': config.token,
+            'Quant-Customer': config.organization,
+            'Quant-Project': config.project,
+            'Content-Type': 'application/json'
+        });
+        this._search = new Client('https://api.quantcdn.io/v1', {
+            'User-Agent': 'Quant (+http://api.quantcdn.io)',
+            'Quant-Token': config.token,
+            'Quant-Customer': config.organization,
+            'Quant-Project': config.project,
+            'Content-Type': 'application/json'
+        });
+        this._organization = new Client('https://dashboard.quantcdn.io/api/v1', {
+            'User-Agent': 'Quant (+http://api.quantcdn.io)',
+            // @todo: Americanise.
+            'Quant-Organisation': config.organization,
+            Authorization: `Bearer ${config.bearer}`
+        });
+    }
+    getClient(name) {
+        return this[`_${name}`];
+    }
+}
+exports.QuantClient = QuantClient;

package/dist/index.d.ts

@@ -1 +1,2 @@
-export { QuantClient } from './quant-client';
+export * from './client';
+export * as types from './types';

package/dist/index.js

@@ -1,5 +1,20 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 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; } });
+exports.types = void 0;
+// export { QuantClient } from './quant-client'
+__exportStar(require("./client"), exports);
+exports.types = require("./types");

package/dist/interfaces.d.ts

@@ -0,0 +1,34 @@
+import type * as types from './types';
+import type * as request from '@cypress/request';
+export type ClientConstructor = new (baseUrl: string, headers: object) => Client;
+export interface Client {
+    baseUrl: string;
+    headers: object;
+    do: (options: request.Options) => Promise<any>;
+    get: (path: string, qs?: object, headers?: object) => Promise<any>;
+    post: (path: string, body?: any, headers?: object, formData?: object, qs?: object) => Promise<any>;
+    delete: (path: string, body?: any, headers?: object) => Promise<any>;
+    patch: (path: string, body?: any, headers?: object) => Promise<any>;
+}
+export interface ProjectApi {
+    ping: () => Promise<any>;
+    meta: () => Promise<any>;
+    markup: (payload: types.MarkupPayload) => Promise<any>;
+    file: (payload: types.FilePayload) => Promise<any>;
+    publish: (payload: types.PublishPayload) => Promise<any>;
+    unpublish: (payload: types.PublishPayload) => Promise<any>;
+    redirect: (payload: types.RedirectPayload) => Promise<any>;
+    proxy: (payload: types.ProxyPayload) => Promise<any>;
+    delete: (payload: types.URLPayload) => Promise<any>;
+    revisions: (payload: types.URLPayload) => Promise<any>;
+    purge: (payload: types.URLPayload) => Promise<any>;
+}
+export interface OrganizationApi {
+    wafLogs: (payload: types.WafLogsPayload) => Promise<any>;
+}
+export interface SearchApi {
+    index: (payload: types.SearchIndexPayload) => Promise<any>;
+    remove: (payload: types.URLPayload) => Promise<any>;
+    clear: () => Promise<any>;
+    status: () => Promise<any>;
+}

package/dist/{config.js → interfaces.js}

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

package/dist/response.d.ts

@@ -0,0 +1,15 @@
+import { type Client } from './interfaces';
+import type * as request from '@cypress/request';
+export declare class PaginatedResponse implements AsyncIterator<any> {
+    private readonly client;
+    private readonly request;
+    private readonly per_page;
+    private page;
+    private total;
+    private hasNext;
+    constructor(client: Client, options: request.Options);
+    first(): Promise<any>;
+    do(): Promise<any>;
+    next(): Promise<IteratorResult<any>>;
+    [Symbol.asyncIterator](): AsyncIterator<any>;
+}

package/dist/response.js

@@ -0,0 +1,101 @@
+"use strict";
+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());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginatedResponse = void 0;
+class PaginatedResponse {
+    constructor(client, options) {
+        this.per_page = 10;
+        this.page = 0;
+        this.total = 0;
+        this.hasNext = true;
+        this.client = client;
+        this.request = options;
+        this.per_page = 10;
+        this.page = 1;
+        if (typeof this.request.qs !== 'object') {
+            this.request.qs = {};
+        }
+    }
+    first() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let body = { data: {} };
+            try {
+                body = yield this.client.do(this.request);
+            }
+            catch (err) {
+                return yield new Promise((resolve, reject) => { reject(err); });
+            }
+            return yield new Promise(resolve => { resolve(body); });
+        });
+    }
+    do() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.first();
+        });
+    }
+    next() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let body = { data: {} };
+            if (this.page > this.total && this.total !== 0) {
+                this.hasNext = false;
+                return body;
+            }
+            this.request.qs.page = this.page;
+            this.request.qs.per_page = this.per_page;
+            try {
+                body = yield this.client.do(this.request);
+            }
+            catch (err) {
+                this.hasNext = false;
+                return body;
+            }
+            this.page += 1;
+            if ('global_meta' in body) {
+                // Handle meta responses.
+                this.total = body.global_meta.total_pages;
+                this.hasNext = this.page <= body.global_meta.total_pages;
+                return body.global_meta.records;
+            }
+            else if ('total_records' in body) {
+                // WAFlog responses.
+                this.total = Math.ceil(body.total_reccords % this.per_page);
+                this.hasNext = body.next !== '';
+                return body.data;
+            }
+            else {
+                this.total = body.pagination.total_pages;
+                this.hasNext = this.page <= body.pagination.total_pages;
+                return body.data;
+            }
+        });
+    }
+    [Symbol.asyncIterator]() {
+        return __asyncGenerator(this, arguments, function* _a() {
+            while (this.hasNext) {
+                const data = yield __await(this.next());
+                yield yield __await(data);
+            }
+        });
+    }
+}
+exports.PaginatedResponse = PaginatedResponse;