datajunction 0.0.1-rc.0 → 0.0.2

package/.babelrc

@@ -1,8 +1,8 @@
 {
-    "presets": [
-        "es2015"
-    ],
-    "plugins": [
-        "transform-object-rest-spread"
-    ]
-}
+  "presets": [
+    "@babel/preset-env"
+  ],
+  "test": [
+    "jest"
+  ]
+}

package/.eslintrc.js

@@ -1,15 +1,13 @@
 module.exports = {
   env: {
     browser: true,
-    es2021: true
+    es2021: true,
   },
   extends: 'standard',
-  overrides: [
-  ],
+  overrides: [],
   parserOptions: {
     ecmaVersion: 'latest',
-    sourceType: 'module'
+    sourceType: 'module',
   },
-  rules: {
-  }
+  rules: {},
 }

package/.prettierignore

@@ -0,0 +1 @@
+./dist

package/.prettierrc

@@ -0,0 +1,6 @@
+{
+    "trailingComma": "es5",
+    "tabWidth": 4,
+    "semi": false,
+    "singleQuote": true
+}

package/Makefile

@@ -0,0 +1,3 @@
+dev-release:
+	yarn version --prerelease --preid dev --no-git-tag-version
+	npm publish

package/babel.config.js

@@ -0,0 +1 @@
+module.exports = {presets: ['@babel/preset-env']}

package/index.js

@@ -1 +1 @@
-module.exports = require('./dist')
+module.exports = require('./dist')

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "datajunction",
-  "version": "0.0.1-rc.0",
+  "version": "0.0.2",
   "description": "A Javascript client for interacting with a DataJunction server",
   "module": "src/index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest",
+    "test-watch": "jest --watch",
     "build": "rm -rf dist/* && webpack && babel src -d dist",
-    "lint": "eslint src --ext .js",
-    "lint:fix": "npm run lint -- --fix"
+    "lint": "prettier \"src/**/*.{js,jsx}\"",
+    "format": "prettier --write \"src/**/*.{js,jsx}\""
   },
   "repository": {
     "type": "git",
@@ -26,15 +27,24 @@
   },
   "homepage": "https://github.com/DataJunction/dj#readme",
   "devDependencies": {
-    "babel-cli": "^6.26.0",
-    "babel-plugin-transform-object-rest-spread": "^6.26.0",
-    "babel-preset-es2015": "^6.24.1",
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/plugin-proposal-object-rest-spread": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "babel-core": "^7.0.0-bridge.0",
+    "babel-jest": "^23.4.2",
     "eslint": "^8.39.0",
     "eslint-config-standard": "^17.0.0",
     "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-n": "^15.7.0",
     "eslint-plugin-promise": "^6.1.1",
+    "jest": "^29.5.0",
+    "prettier": "^2.8.8",
     "webpack": "^5.81.0",
     "webpack-cli": "^5.0.2"
+  },
+  "dependencies": {
+    "@babel/core": "^7.22.5",
+    "docker-names": "^1.2.1"
   }
 }

package/src/httpclient.js

@@ -1,78 +1,122 @@
 export default class HttpClient {
-  constructor (options = {}) {
-    this._baseURL = options.baseURL || ''
-    this._headers = options.headers || {}
-  }
+    constructor(options = {}) {
+        this._baseURL = options.baseURL || '';
+        this._headers = options.headers || {};
+        this._cookie = '';
+    }
 
-  async _fetchJSON (endpoint, options = {}) {
-    const res = await fetch(this._baseURL + endpoint, {
-      ...options,
-      headers: this._headers
-    })
+    async _fetchJSON(endpoint, options = {}) {
+        const res = await fetch(this._baseURL + endpoint, {
+            ...options,
+            headers: {
+                ...this._headers,
+                'Cookie': this._cookie,
+            },
+            credentials: 'include',
+        });
 
-    if (!res.ok) throw new Error(res.statusText)
+        const setCookieHeader = res.headers.get('Set-Cookie');
+        if (setCookieHeader) {
+            this._cookie = setCookieHeader;
+            this._headers['Cookie'] = this._cookie;
+        }
 
-    if (options.parseResponse !== false && res.status !== 204) { return res.json() }
+        if (!res.ok) {
+            const errorText = await res.text();
+            throw new Error(`Request failed: ${res.status} ${errorText}`);
+        }
 
-    return undefined
-  }
+        if (options.parseResponse !== false && res.status !== 204) {
+            return res.json();
+        }
 
-  setHeader (key, value) {
-    this._headers[key] = value
-    return this
-  }
+        return undefined;
+    }
 
-  getHeader (key) {
-    return this._headers[key]
-  }
+    async login(username, password) {
+        const body = new URLSearchParams({
+            grant_type: 'password',
+            username: username,
+            password: password,
+        });
+    
+        const response = await fetch(this._baseURL + '/basic/login', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                ...this._headers,
+            },
+            body: body.toString(),
+            credentials: 'include',
+        });
+    
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Login failed: ${response.status} ${errorText}`);
+        }
+    
+        const setCookieHeader = response.headers.get('Set-Cookie');
+        if (setCookieHeader) {
+            this._cookie = setCookieHeader;
+            this._headers['Cookie'] = this._cookie;
+        }
+    }
+    setHeader(key, value) {
+        this._headers[key] = value
+        return this
+    }
 
-  setBasicAuth (username, password) {
-    this._headers.Authorization = `Basic ${btoa(`${username}:${password}`)}`
-    return this
-  }
+    getHeader(key) {
+        return this._headers[key]
+    }
 
-  setBearerAuth (token) {
-    this._headers.Authorization = `Bearer ${token}`
-    return this
-  }
+    setBasicAuth(username, password) {
+        this._headers.Authorization = `Basic ${btoa(`${username}:${password}`)}`
+        return this
+    }
 
-  async get (endpoint, options = {}) {
-    return this._fetchJSON(endpoint, {
-      ...options,
-      method: 'GET'
-    })
-  }
+    setBearerAuth(token) {
+        this._headers.Authorization = `Bearer ${token}`
+        return this
+    }
 
-  async post (endpoint, body, options = {}) {
-    return this._fetchJSON(endpoint, {
-      ...options,
-      body: body ? JSON.stringify(body) : undefined,
-      method: 'POST'
-    })
-  }
+    async get(endpoint, options = {}) {
+        return this._fetchJSON(endpoint, {
+            ...options,
+            method: 'GET',
+        })
+    }
 
-  async put (endpoint, body, options = {}) {
-    return this._fetchJSON(endpoint, {
-      ...options,
-      body: body ? JSON.stringify(body) : undefined,
-      method: 'PUT'
-    })
-  }
+    async post(endpoint, body, options = {}) {
+        return this._fetchJSON(endpoint, {
+            ...options,
+            body: body ? JSON.stringify(body) : undefined,
+            method: 'POST',
+        })
+    }
 
-  async patch (endpoint, operations, options = {}) {
-    return this._fetchJSON(endpoint, {
-      parseResponse: false,
-      ...options,
-      body: JSON.stringify(operations),
-      method: 'PATCH'
-    })
-  }
+    async put(endpoint, body, options = {}) {
+        return this._fetchJSON(endpoint, {
+            ...options,
+            body: body ? JSON.stringify(body) : undefined,
+            method: 'PUT',
+        })
+    }
 
-  async delete (endpoint, options = {}) {
-    return this._fetchJSON(endpoint, {
-      parseResponse: false,
-      ...options,
-      method: 'DELETE'
-    })
-  }
+    async patch(endpoint, operations, options = {}) {
+        return this._fetchJSON(endpoint, {
+            parseResponse: false,
+            ...options,
+            body: JSON.stringify(operations),
+            method: 'PATCH',
+        })
+    }
+
+    async delete(endpoint, options = {}) {
+        return this._fetchJSON(endpoint, {
+            parseResponse: false,
+            ...options,
+            method: 'DELETE',
+        })
+    }
 }

package/src/index.js

@@ -1,51 +1,314 @@
 import HttpClient from './httpclient.js'
 
 export class DJClient extends HttpClient {
-  constructor (baseURL) {
-    super({
-      baseURL
-    })
-  }
+    constructor(
+        baseURL,
+        namespace,
+        engineName = null,
+        engineVersion = null,
+        httpAgent = null,
+    ) {
+        super(
+            {
+                baseURL,
+            },
+            httpAgent
+        )
+        this.namespace = namespace
+        this.engineName = engineName
+        this.engineVersion = engineVersion
+    }
+
+    get healthcheck() {
+        return {
+            get: () => this.get('/health/'),
+        }
+    }
+
+    get catalogs() {
+        return {
+            list: () => this.get('/catalogs/'),
+            get: (catalog) => this.get(`/catalogs/${catalog}/`),
+            create: (catalog) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    `/catalogs/`,
+                    catalog
+                ),
+            addEngine: (catalog, engineName, engineVersion) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    `/catalogs/${catalog}/engines/`,
+                    [
+                        {
+                            name: engineName,
+                            version: engineVersion,
+                        },
+                    ]
+                ),
+        }
+    }
+
+    get engines() {
+        return {
+            list: () => this.get('/engines/'),
+            get: (engineName, engineVersion) =>
+                this.get(`/engines/${engineName}/${engineVersion}/`),
+            create: (engine) => this.post('/engines/', engine),
+        }
+    }
+
+    get addEngineToCatalog() {
+        return {
+            set: (catalogName, engine) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    `/catalogs/${catalogName}/engines/`,
+                    [engine]
+                ),
+        }
+    }
+
+    get namespaces() {
+        return {
+            list: () => this.get('/namespaces/'),
+            nodes: (namespace) => this.get(`/namespaces/${namespace}/`),
+            create: (namespace) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    `/namespaces/${namespace}/`
+                ),
+        }
+    }
+
+    get commonDimensions() {
+        return {
+            list: (metrics) => {
+                const metricsQuery =
+                    '?' + metrics.map((m) => `metric=${m}`).join('&')
+                return this.get('/metrics/common/dimensions/' + metricsQuery)
+            },
+        }
+    }
+
+    get nodes() {
+        return {
+            get: (nodeName) => this.get(`/nodes/${nodeName}/`),
+            validate: (nodeDetails) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    '/nodes/validate/',
+                    nodeDetails
+                ),
+            update: (nodeName, nodeDetails) =>
+                this.setHeader('Content-Type', 'application/json').patch(
+                    `/nodes/${nodeName}/`,
+                    nodeDetails
+                ),
+            revisions: (nodeName) => this.get(`/nodes/${nodeName}/revisions/`),
+            downstream: (nodeName) =>
+                this.get(`/nodes/${nodeName}/downstream/`),
+            upstream: (nodeName) => this.get(`/nodes/${nodeName}/upstream/`),
+            publish: (nodeName) => this.patch(`/nodes/${nodeName}/`, {'mode': 'published'})
+        }
+    }
+
+    get sources() {
+        return {
+            create: (sourceDetails) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    '/nodes/source/',
+                    sourceDetails
+                ),
+            list: () => this.get(`/namespaces/${this.namespace}/?type_=source`),
+        }
+    }
+
+    get transforms() {
+        return {
+            create: (transformDetails) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    '/nodes/transform/',
+                    transformDetails
+                ),
+            list: () =>
+                this.get(`/namespaces/${this.namespace}/?type_=transform`),
+        }
+    }
+
+    get dimensions() {
+        return {
+            create: (dimensionDetails) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    '/nodes/dimension/',
+                    dimensionDetails
+                ),
+            list: () =>
+                this.get(`/namespaces/${this.namespace}/?type_=dimension`),
+            link: (nodeName, nodeColumn, dimension, dimensionColumn) =>
+                this.post(
+                    `/nodes/${nodeName}/columns/${nodeColumn}/?dimension=${dimension}&dimension_column=${dimensionColumn}`
+                ),
+        }
+    }
+
+    get metrics() {
+        return {
+            get: (metricName) => this.get(`/metrics/${metricName}/`),
+            create: (metricDetails) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    '/nodes/metric/',
+                    metricDetails
+                ),
+            list: () => this.get(`/namespaces/${this.namespace}/?type_=metric`),
+            all: () => this.get(`/metrics/`),
+        }
+    }
+
+    get cubes() {
+        return {
+            get: (cubeName) => this.get(`/cubes/${cubeName}/`),
+            create: (cubeDetails) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    '/nodes/cube/',
+                    cubeDetails
+                ),
+        }
+    }
+
+    get tags() {
+        return {
+            list: () => this.get('/tags/'),
+            get: (tagName) => this.get(`/tags/${tagName}/`),
+            create: (tagData) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    '/tags/',
+                    tagData
+                ),
+            update: (tagName, tagData) =>
+                this.setHeader('Content-Type', 'application/json').patch(
+                    `/tags/${tagName}/`,
+                    tagData
+                ),
+            set: (nodeName, tagName) =>
+                this.post(`/nodes/${nodeName}/tag/?tag_name=${tagName}`),
+            listNodes: (tagName) => this.get(`/tags/${tagName}/nodes/`),
+        }
+    }
 
-  get catalogs () {
-    return {
-      get: () => this.get('/catalogs/')
+    get attributes() {
+        return {
+            list: () => this.get('/attributes/'),
+            create: (attributeData) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    '/attributes/',
+                    attributeData
+                ),
+        }
     }
-  }
 
-  get engines () {
-    return {
-      get: () => this.get('/engines/')
+    get materializationConfigs() {
+        return {
+            update: (nodeName, materializationDetails) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    `/nodes/${nodeName}/materialization/`,
+                    materializationDetails
+                ),
+        }
     }
-  }
 
-  get namespaces () {
-    return {
-      get: () => this.get('/namespaces/')
+    get columnAttributes() {
+        return {
+            set: (nodeName, columnAttribute) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    `/nodes/${nodeName}/attributes/`,
+                    [columnAttribute]
+                ),
+        }
     }
-  }
 
-  get metrics () {
-    return {
-      get: () => this.get('/metrics/')
+    get availabilityState() {
+        return {
+            set: (nodeName, availabilityState) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    `/data/${nodeName}/availability/`,
+                    availabilityState
+                ),
+        }
     }
-  }
 
-  get nodes () {
-    return {
-      get: () => this.get('/nodes/')
+    get sql() {
+        return {
+            get: (
+                metrics,
+                dimensions,
+                filters,
+                engineName = null,
+                engineVersion = null
+            ) => {
+                const metricsQuery =
+                    '?' + metrics.map((m) => `metrics=${m}`).join('&')
+                const dimensionsQuery = dimensions
+                    .map((d) => `dimensions=${d}`)
+                    .join('&')
+                const filtersQuery = filters
+                    .map((f) => `filters=${f}`)
+                    .join('&')
+                const engineNameP = engineName ? `&engine=${engineName}` : ''
+                const engineVersionP = engineVersion
+                    ? `&engine_version=${engineVersion}`
+                    : ''
+                return this.get(
+                    `/sql/${metricsQuery}&${dimensionsQuery}${filtersQuery}${engineNameP}${engineVersionP}`
+                )
+            },
+        }
     }
-  }
 
-  get tags () {
-    return {
-      get: () => this.get('/tags/')
+    get data() {
+        return {
+            get: (
+                metrics,
+                dimensions,
+                filters,
+                async_ = false,
+                engineName = null,
+                engineVersion = null
+            ) => {
+                const metricsQuery =
+                    '?' + metrics.map((m) => `metrics=${m}`).join('&')
+                const dimensionsQuery = dimensions
+                    .map((d) => `dimensions=${d}`)
+                    .join('&')
+                const filtersQuery = filters
+                    .map((f) => `filters=${f}`)
+                    .join('&')
+                const asyncP = async_ ? `&async_=${async_}` : ''
+                const engineNameP = engineName ? `&engine=${engineName}` : ''
+                const engineVersionP = engineVersion
+                    ? `&engine_version=${engineVersion}`
+                    : ''
+                const data = this.get(
+                    `/data/${metricsQuery}&${dimensionsQuery}${filtersQuery}${asyncP}${engineNameP}${engineVersionP}`
+                ).then((data) => {
+                    return {
+                        columns: data.results[0].columns,
+                        data: data.results[0].rows,
+                    }
+                })
+                return data
+            },
+        }
     }
-  }
 
-  get attributes () {
-    return {
-      get: () => this.get('/attributes/')
+    get register() {
+      return {
+          table: (catalog, schema, table) =>
+              this.setHeader('Content-Type', 'application/json').post(
+                  `/register/table/${catalog}/${schema}/${table}`
+              ),
+          view: (catalog, schema, view, query, replace = false) => {
+              const replaceQuery = replace ? `?replace=${replace}` : '';
+              return this.setHeader('Content-Type', 'application/json').post(
+                  `/register/view/${catalog}/${schema}/${view}${replaceQuery}`,
+                  { query }
+              );
+          }
+      }
     }
-  }
 }

package/src/index.test.js

@@ -0,0 +1,80 @@
+const { DJClient } = require('./index')
+var dockerNames = require('docker-names')
+
+test('should return something', async () => {
+    const dj = new DJClient('http://localhost:8000', 'integration.tests', 'dj', 'dj');
+    await dj.login("dj", "dj")
+
+    await dj.catalogs.create({ name: 'tpch' });
+    await dj.engines.create({ name: 'trino', version: '451' });
+    await dj.catalogs.addEngine('tpch', 'trino', '451');
+
+    await dj.namespaces.create('integration.tests');
+    await dj.namespaces.create('integration.tests.trino');
+
+    const source = await dj.sources.create({
+        name: 'integration.tests.source1',
+        catalog: 'unknown',
+        schema_: 'db',
+        table: 'tbl',
+        display_name: 'Test Source with Columns',
+        description: 'A test source node with columns',
+        columns: [
+            { name: 'id', type: 'int' },
+            { name: 'name', type: 'string' },
+            { name: 'price', type: 'double' },
+            { name: 'created_at', type: 'timestamp' },
+        ],
+        primary_key: ['id'],
+        mode: 'published',
+        update_if_exists: true,
+    });
+
+    await dj.register.table('tpch', 'sf1', 'orders');
+
+    const transform = await dj.transforms.create({
+        name: 'integration.tests.trino.transform1',
+        display_name: 'Filter to last 1000 records',
+        description: 'The last 1000 purchases',
+        mode: 'published',
+        query: 'select custkey, totalprice, orderdate from source.tpch.sf1.orders order by orderdate desc limit 1000',
+        update_if_exists: true,
+    });
+
+    const dimension = await dj.dimensions.create({
+        name: 'integration.tests.trino.dimension1',
+        display_name: 'Customer keys',
+        description: 'All custkey values in the source table',
+        mode: 'published',
+        primary_key: ['id'],
+        tags: [],
+        query: "select custkey as id, 'attribute' as foo from source.tpch.sf1.orders",
+        update_if_exists: true,
+    });
+
+    await dj.dimensions.link(
+        'integration.tests.trino.transform1',
+        'custkey',
+        'integration.tests.trino.dimension1',
+        'id',
+    );
+
+    const metric = await dj.metrics.create({
+        name: 'integration.tests.trino.metric1',
+        display_name: 'Total of last 1000 purchases',
+        description: 'This is the total amount from the last 1000 purchases',
+        mode: 'published',
+        query: 'select sum(totalprice) from integration.tests.trino.transform1',
+        update_if_exists: true,
+    });
+
+    await dj.commonDimensions.list(['integration.tests.trino.metric1']);
+
+    const query = await dj.sql.get(
+        ['integration.tests.trino.metric1'],
+        ['integration.tests.trino.dimension1.id'],
+        []
+    );
+
+    expect(query.sql).toContain('SELECT');
+}, 60000)

package/webpack.config.js

@@ -1,8 +1,8 @@
-const path = require('path');
+const path = require('path')
 
 module.exports = {
   entry: './src/index.js',
-  mode: "production",
+  mode: 'production',
   output: {
     path: path.resolve(__dirname, 'dist'),
     filename: 'datajunction.js',
@@ -12,4 +12,4 @@ module.exports = {
       type: 'umd',
     },
   },
-};
+}

package/dist/datajunction.js

@@ -1 +0,0 @@
-!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.datajunction=t():e.datajunction=t()}(this,(()=>(()=>{"use strict";var e={d:(t,s)=>{for(var r in s)e.o(s,r)&&!e.o(t,r)&&Object.defineProperty(t,r,{enumerable:!0,get:s[r]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t),r:e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})}},t={};e.r(t),e.d(t,{DJClient:()=>r});class s{constructor(e={}){this._baseURL=e.baseURL||"",this._headers=e.headers||{}}async _fetchJSON(e,t={}){const s=await fetch(this._baseURL+e,{...t,headers:this._headers});if(!s.ok)throw new Error(s.statusText);if(!1!==t.parseResponse&&204!==s.status)return s.json()}setHeader(e,t){return this._headers[e]=t,this}getHeader(e){return this._headers[e]}setBasicAuth(e,t){return this._headers.Authorization=`Basic ${btoa(`${e}:${t}`)}`,this}setBearerAuth(e){return this._headers.Authorization=`Bearer ${e}`,this}async get(e,t={}){return this._fetchJSON(e,{...t,method:"GET"})}async post(e,t,s={}){return this._fetchJSON(e,{...s,body:t?JSON.stringify(t):void 0,method:"POST"})}async put(e,t,s={}){return this._fetchJSON(e,{...s,body:t?JSON.stringify(t):void 0,method:"PUT"})}async patch(e,t,s={}){return this._fetchJSON(e,{parseResponse:!1,...s,body:JSON.stringify(t),method:"PATCH"})}async delete(e,t={}){return this._fetchJSON(e,{parseResponse:!1,...t,method:"DELETE"})}}class r extends s{constructor(e){super({baseURL:e})}get catalogs(){return{get:()=>this.get("/catalogs/")}}get engines(){return{get:()=>this.get("/engines/")}}get namespaces(){return{get:()=>this.get("/namespaces/")}}get metrics(){return{get:()=>this.get("/metrics/")}}get nodes(){return{get:()=>this.get("/nodes/")}}get tags(){return{get:()=>this.get("/tags/")}}get attributes(){return{get:()=>this.get("/attributes/")}}}return t})()));

package/dist/httpclient.js

@@ -1,120 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var HttpClient = function () {
-  function HttpClient() {
-    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
-    _classCallCheck(this, HttpClient);
-
-    this._baseURL = options.baseURL || '';
-    this._headers = options.headers || {};
-  }
-
-  _createClass(HttpClient, [{
-    key: '_fetchJSON',
-    value: async function _fetchJSON(endpoint) {
-      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
-      var res = await fetch(this._baseURL + endpoint, _extends({}, options, {
-        headers: this._headers
-      }));
-
-      if (!res.ok) throw new Error(res.statusText);
-
-      if (options.parseResponse !== false && res.status !== 204) {
-        return res.json();
-      }
-
-      return undefined;
-    }
-  }, {
-    key: 'setHeader',
-    value: function setHeader(key, value) {
-      this._headers[key] = value;
-      return this;
-    }
-  }, {
-    key: 'getHeader',
-    value: function getHeader(key) {
-      return this._headers[key];
-    }
-  }, {
-    key: 'setBasicAuth',
-    value: function setBasicAuth(username, password) {
-      this._headers.Authorization = 'Basic ' + btoa(username + ':' + password);
-      return this;
-    }
-  }, {
-    key: 'setBearerAuth',
-    value: function setBearerAuth(token) {
-      this._headers.Authorization = 'Bearer ' + token;
-      return this;
-    }
-  }, {
-    key: 'get',
-    value: async function get(endpoint) {
-      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
-      return this._fetchJSON(endpoint, _extends({}, options, {
-        method: 'GET'
-      }));
-    }
-  }, {
-    key: 'post',
-    value: async function post(endpoint, body) {
-      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
-      return this._fetchJSON(endpoint, _extends({}, options, {
-        body: body ? JSON.stringify(body) : undefined,
-        method: 'POST'
-      }));
-    }
-  }, {
-    key: 'put',
-    value: async function put(endpoint, body) {
-      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
-      return this._fetchJSON(endpoint, _extends({}, options, {
-        body: body ? JSON.stringify(body) : undefined,
-        method: 'PUT'
-      }));
-    }
-  }, {
-    key: 'patch',
-    value: async function patch(endpoint, operations) {
-      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
-      return this._fetchJSON(endpoint, _extends({
-        parseResponse: false
-      }, options, {
-        body: JSON.stringify(operations),
-        method: 'PATCH'
-      }));
-    }
-  }, {
-    key: 'delete',
-    value: async function _delete(endpoint) {
-      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
-      return this._fetchJSON(endpoint, _extends({
-        parseResponse: false
-      }, options, {
-        method: 'DELETE'
-      }));
-    }
-  }]);
-
-  return HttpClient;
-}();
-
-exports.default = HttpClient;

package/dist/index.js

@@ -1,113 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.DJClient = undefined;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _httpclient = require('./httpclient.js');
-
-var _httpclient2 = _interopRequireDefault(_httpclient);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var DJClient = exports.DJClient = function (_HttpClient) {
-  _inherits(DJClient, _HttpClient);
-
-  function DJClient(baseURL) {
-    _classCallCheck(this, DJClient);
-
-    return _possibleConstructorReturn(this, (DJClient.__proto__ || Object.getPrototypeOf(DJClient)).call(this, {
-      baseURL: baseURL
-    }));
-  }
-
-  _createClass(DJClient, [{
-    key: 'catalogs',
-    get: function get() {
-      var _this2 = this;
-
-      return {
-        get: function get() {
-          return _this2.get('/catalogs/');
-        }
-      };
-    }
-  }, {
-    key: 'engines',
-    get: function get() {
-      var _this3 = this;
-
-      return {
-        get: function get() {
-          return _this3.get('/engines/');
-        }
-      };
-    }
-  }, {
-    key: 'namespaces',
-    get: function get() {
-      var _this4 = this;
-
-      return {
-        get: function get() {
-          return _this4.get('/namespaces/');
-        }
-      };
-    }
-  }, {
-    key: 'metrics',
-    get: function get() {
-      var _this5 = this;
-
-      return {
-        get: function get() {
-          return _this5.get('/metrics/');
-        }
-      };
-    }
-  }, {
-    key: 'nodes',
-    get: function get() {
-      var _this6 = this;
-
-      return {
-        get: function get() {
-          return _this6.get('/nodes/');
-        }
-      };
-    }
-  }, {
-    key: 'tags',
-    get: function get() {
-      var _this7 = this;
-
-      return {
-        get: function get() {
-          return _this7.get('/tags/');
-        }
-      };
-    }
-  }, {
-    key: 'attributes',
-    get: function get() {
-      var _this8 = this;
-
-      return {
-        get: function get() {
-          return _this8.get('/attributes/');
-        }
-      };
-    }
-  }]);
-
-  return DJClient;
-}(_httpclient2.default);