datajunction 0.0.1-a100

package/.babelrc

@@ -0,0 +1,8 @@
+{
+  "presets": [
+    "@babel/preset-env"
+  ],
+  "test": [
+    "jest"
+  ]
+}

package/.eslintignore

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

package/.eslintrc.js

@@ -0,0 +1,13 @@
+module.exports = {
+  env: {
+    browser: true,
+    es2021: true,
+  },
+  extends: 'standard',
+  overrides: [],
+  parserOptions: {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+  },
+  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

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

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "datajunction",
+  "version": "0.0.1a100",
+  "description": "A Javascript client for interacting with a DataJunction server",
+  "module": "src/index.js",
+  "scripts": {
+    "test": "jest",
+    "test-watch": "jest --watch",
+    "build": "rm -rf dist/* && webpack && babel src -d dist",
+    "lint": "prettier \"src/**/*.{js,jsx}\"",
+    "format": "prettier --write \"src/**/*.{js,jsx}\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DataJunction/dj.git"
+  },
+  "keywords": [
+    "datajunction",
+    "metrics",
+    "metrics-platform",
+    "semantic-layer"
+  ],
+  "author": "DataJunction Authors",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/DataJunction/dj/issues"
+  },
+  "homepage": "https://github.com/DataJunction/dj#readme",
+  "devDependencies": {
+    "@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

@@ -0,0 +1,122 @@
+export default class HttpClient {
+    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,
+                'Cookie': this._cookie,
+            },
+            credentials: 'include',
+        });
+
+        const setCookieHeader = res.headers.get('Set-Cookie');
+        if (setCookieHeader) {
+            this._cookie = setCookieHeader;
+            this._headers['Cookie'] = this._cookie;
+        }
+
+        if (!res.ok) {
+            const errorText = await res.text();
+            throw new Error(`Request failed: ${res.status} ${errorText}`);
+        }
+
+        if (options.parseResponse !== false && res.status !== 204) {
+            return res.json();
+        }
+
+        return undefined;
+    }
+
+    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
+    }
+
+    getHeader(key) {
+        return this._headers[key]
+    }
+
+    setBasicAuth(username, password) {
+        this._headers.Authorization = `Basic ${btoa(`${username}:${password}`)}`
+        return this
+    }
+
+    setBearerAuth(token) {
+        this._headers.Authorization = `Bearer ${token}`
+        return this
+    }
+
+    async get(endpoint, options = {}) {
+        return this._fetchJSON(endpoint, {
+            ...options,
+            method: 'GET',
+        })
+    }
+
+    async post(endpoint, body, options = {}) {
+        return this._fetchJSON(endpoint, {
+            ...options,
+            body: body ? JSON.stringify(body) : undefined,
+            method: 'POST',
+        })
+    }
+
+    async put(endpoint, body, options = {}) {
+        return this._fetchJSON(endpoint, {
+            ...options,
+            body: body ? JSON.stringify(body) : undefined,
+            method: 'PUT',
+        })
+    }
+
+    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

@@ -0,0 +1,314 @@
+import HttpClient from './httpclient.js'
+
+export class DJClient extends HttpClient {
+    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 attributes() {
+        return {
+            list: () => this.get('/attributes/'),
+            create: (attributeData) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    '/attributes/',
+                    attributeData
+                ),
+        }
+    }
+
+    get materializationConfigs() {
+        return {
+            update: (nodeName, materializationDetails) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    `/nodes/${nodeName}/materialization/`,
+                    materializationDetails
+                ),
+        }
+    }
+
+    get columnAttributes() {
+        return {
+            set: (nodeName, columnAttribute) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    `/nodes/${nodeName}/attributes/`,
+                    [columnAttribute]
+                ),
+        }
+    }
+
+    get availabilityState() {
+        return {
+            set: (nodeName, availabilityState) =>
+                this.setHeader('Content-Type', 'application/json').post(
+                    `/data/${nodeName}/availability/`,
+                    availabilityState
+                ),
+        }
+    }
+
+    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 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 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

@@ -0,0 +1,15 @@
+const path = require('path')
+
+module.exports = {
+  entry: './src/index.js',
+  mode: 'production',
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: 'datajunction.js',
+    globalObject: 'this',
+    library: {
+      name: 'datajunction',
+      type: 'umd',
+    },
+  },
+}