datajunction 0.0.1-a30

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.1a30",
+  "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,83 @@
+export default class HttpClient {
+    constructor(options = {}) {
+        this._baseURL = options.baseURL || ''
+        this._headers = options.headers || {}
+    }
+
+    async _fetchJSON(endpoint, options = {}) {
+        const res = await fetch(this._baseURL + endpoint, {
+            ...options,
+            headers: this._headers,
+        })
+
+        if (!res.ok)
+            throw new Error(
+                res.statusText + ` (${endpoint}, ${JSON.stringify(options)})`
+            )
+
+        if (options.parseResponse !== false && res.status !== 204) {
+            return res.json()
+        }
+
+        return undefined
+    }
+
+    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,298 @@
+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
+            },
+        }
+    }
+}

package/src/index.test.js

@@ -0,0 +1,592 @@
+const { DJClient } = require('./index')
+var dockerNames = require('docker-names')
+
+test('should return something', async () => {
+    const randomName = dockerNames.getRandomName(true)
+    const namespace = `integration.javascript.${randomName}`
+    const dj = new DJClient('http://localhost:8000')
+
+    // Create a namespace
+    const namespace_created = await dj.namespaces.create(namespace)
+    expect(namespace_created).toEqual({
+        message: `Node namespace \`${namespace}\` has been successfully created`,
+    })
+
+    // List namespaces
+    const existing_namespaces = await dj.namespaces.list()
+    expect(existing_namespaces).toContainEqual({ namespace: namespace })
+
+    // Create a source
+    await dj.sources.create({
+        name: `${namespace}.repair_orders`,
+        description: 'Repair orders',
+        catalog: 'warehouse',
+        schema_: 'roads',
+        table: 'repair_orders',
+        mode: 'published',
+        columns: [
+            { name: 'repair_order_id', type: 'int' },
+            { name: 'municipality_id', type: 'string' },
+            { name: 'hard_hat_id', type: 'int' },
+            { name: 'order_date', type: 'timestamp' },
+            { name: 'required_date', type: 'timestamp' },
+            { name: 'dispatched_date', type: 'timestamp' },
+            { name: 'dispatcher_id', type: 'int' },
+        ],
+    })
+
+    // Get source
+    const source1 = await dj.nodes.get(`${namespace}.repair_orders`)
+    expect(source1.name).toBe(`${namespace}.repair_orders`)
+    expect(source1.status).toBe('valid')
+    expect(source1.mode).toBe('published')
+
+    // Create a transform
+    await dj.transforms.create({
+        name: `${namespace}.repair_orders_w_dispatchers`,
+        description: 'Repair orders that have a dispatcher',
+        mode: 'published',
+        query: `SELECT
+            repair_order_id,
+            municipality_id,
+            hard_hat_id,
+            dispatcher_id
+            FROM ${namespace}.repair_orders
+            WHERE dispatcher_id IS NOT NULL`,
+    })
+
+    // Get transform
+    const transform1 = await dj.nodes.get(
+        `${namespace}.repair_orders_w_dispatchers`
+    )
+    expect(transform1.name).toBe(`${namespace}.repair_orders_w_dispatchers`)
+    expect(transform1.status).toBe('valid')
+    expect(transform1.mode).toBe('published')
+
+    // Create a source and dimension node
+    const source2 = await dj.sources.create({
+        name: `${namespace}.dispatchers`,
+        description:
+            'Different third party dispatcher companies that coordinate repairs',
+        catalog: 'warehouse',
+        schema_: 'roads',
+        table: 'dispatchers',
+        mode: 'published',
+        columns: [
+            { name: 'dispatcher_id', type: 'int' },
+            { name: 'company_name', type: 'string' },
+            { name: 'phone', type: 'string' },
+        ],
+    })
+    expect(source2.name).toBe(`${namespace}.dispatchers`)
+    expect(source2.status).toBe('valid')
+    expect(source2.mode).toBe('published')
+    await dj.dimensions.create({
+        name: `${namespace}.all_dispatchers`,
+        description: 'All dispatchers',
+        primary_key: ['dispatcher_id'],
+        mode: 'published',
+        query: `SELECT
+        dispatcher_id,
+        company_name,
+        phone
+        FROM ${namespace}.dispatchers`,
+    })
+    const dimension1 = await dj.nodes.get(`${namespace}.all_dispatchers`)
+    expect(dimension1.name).toBe(`${namespace}.all_dispatchers`)
+    expect(dimension1.status).toBe('valid')
+    expect(dimension1.mode).toBe('published')
+
+    // Create metrics
+    await dj.metrics.create({
+        name: `${namespace}.num_repair_orders`,
+        description: 'Number of repair orders',
+        mode: 'published',
+        query: `SELECT
+        count(repair_order_id)
+        FROM ${namespace}.repair_orders`,
+    })
+    const metric1 = await dj.nodes.get(`${namespace}.num_repair_orders`)
+    expect(metric1.name).toBe(`${namespace}.num_repair_orders`)
+    expect(metric1.status).toBe('valid')
+    expect(metric1.mode).toBe('published')
+
+    // List metrics
+    const list_of_metrics = await dj.metrics.all()
+    expect(list_of_metrics).toContain(`${namespace}.num_repair_orders`)
+
+    // Create a dimension link
+    const dimension_linked_message = await dj.dimensions.link(
+        `${namespace}.repair_orders`,
+        'dispatcher_id',
+        `${namespace}.all_dispatchers`,
+        'dispatcher_id'
+    )
+    expect(dimension_linked_message).toEqual({
+        message: `Dimension node ${namespace}.all_dispatchers has been successfully linked to column dispatcher_id on node ${namespace}.repair_orders`,
+    })
+
+    const common_dimensions = await dj.commonDimensions.list([
+        'default.num_repair_orders',
+        'default.avg_repair_price',
+        'default.total_repair_cost',
+    ])
+
+    expect(common_dimensions).toEqual([
+        {
+            name: 'default.dispatcher.company_name',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.dispatcher_id',
+            ],
+        },
+        {
+            name: 'default.dispatcher.dispatcher_id',
+            type: 'int',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.dispatcher_id',
+            ],
+        },
+        {
+            name: 'default.dispatcher.phone',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.dispatcher_id',
+            ],
+        },
+        {
+            name: 'default.hard_hat.address',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+            ],
+        },
+        {
+            name: 'default.hard_hat.birth_date',
+            type: 'date',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+            ],
+        },
+        {
+            name: 'default.hard_hat.city',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+            ],
+        },
+        {
+            name: 'default.hard_hat.contractor_id',
+            type: 'int',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+            ],
+        },
+        {
+            name: 'default.hard_hat.country',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+            ],
+        },
+        {
+            name: 'default.hard_hat.first_name',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+            ],
+        },
+        {
+            name: 'default.hard_hat.hard_hat_id',
+            type: 'int',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+            ],
+        },
+        {
+            name: 'default.hard_hat.hire_date',
+            type: 'date',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+            ],
+        },
+        {
+            name: 'default.hard_hat.last_name',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+            ],
+        },
+        {
+            name: 'default.hard_hat.manager',
+            type: 'int',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+            ],
+        },
+        {
+            name: 'default.hard_hat.postal_code',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+            ],
+        },
+        {
+            name: 'default.hard_hat.state',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+            ],
+        },
+        {
+            name: 'default.hard_hat.title',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+            ],
+        },
+        {
+            name: 'default.municipality_dim.contact_name',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.municipality_id',
+            ],
+        },
+        {
+            name: 'default.municipality_dim.contact_title',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.municipality_id',
+            ],
+        },
+        {
+            name: 'default.municipality_dim.local_region',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.municipality_id',
+            ],
+        },
+        {
+            name: 'default.municipality_dim.municipality_id',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.municipality_id',
+            ],
+        },
+        {
+            name: 'default.municipality_dim.municipality_type_desc',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.municipality_id',
+            ],
+        },
+        {
+            name: 'default.municipality_dim.municipality_type_id',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.municipality_id',
+            ],
+        },
+        {
+            name: 'default.municipality_dim.state_id',
+            type: 'int',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.municipality_id',
+            ],
+        },
+        {
+            name: 'default.repair_orders.repair_order_id',
+            type: 'int',
+            path: [],
+        },
+        {
+            name: 'default.us_state.state_abbr',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+                'default.hard_hat.state',
+            ],
+        },
+        {
+            name: 'default.us_state.state_id',
+            type: 'int',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+                'default.hard_hat.state',
+            ],
+        },
+        {
+            name: 'default.us_state.state_name',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+                'default.hard_hat.state',
+            ],
+        },
+        {
+            name: 'default.us_state.state_region',
+            type: 'int',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+                'default.hard_hat.state',
+            ],
+        },
+        {
+            name: 'default.us_state.state_region_description',
+            type: 'string',
+            path: [
+                'default.repair_orders.repair_order_id',
+                'default.repair_order.hard_hat_id',
+                'default.hard_hat.state',
+            ],
+        },
+    ])
+
+    const query = await dj.sql.get(
+        [
+            'default.num_repair_orders',
+            'default.avg_repair_price',
+            'default.total_repair_cost',
+        ],
+        [
+            'default.us_state.state_abbr',
+            'default.us_state.state_id',
+            'default.us_state.state_name',
+        ],
+        []
+    )
+    const trimmedQuery = query.sql.replace(/\s+/g, '')
+    expect(trimmedQuery).toBe(
+        `WITH
+        m0_default_DOT_num_repair_orders AS (SELECT  default_DOT_us_state.state_abbr,
+                default_DOT_us_state.state_id,
+                default_DOT_us_state.state_name,
+                count(default_DOT_repair_orders.repair_order_id) default_DOT_num_repair_orders 
+         FROM roads.repair_orders AS default_DOT_repair_orders LEFT OUTER JOIN (SELECT  default_DOT_repair_orders.dispatcher_id,
+                default_DOT_repair_orders.hard_hat_id,
+                default_DOT_repair_orders.municipality_id,
+                default_DOT_repair_orders.repair_order_id 
+         FROM roads.repair_orders AS default_DOT_repair_orders)
+         AS default_DOT_repair_order ON default_DOT_repair_orders.repair_order_id = default_DOT_repair_order.repair_order_id
+        LEFT OUTER JOIN (SELECT  default_DOT_hard_hats.birth_date,
+                default_DOT_hard_hats.hard_hat_id,
+                default_DOT_hard_hats.hire_date,
+                default_DOT_hard_hats.state 
+         FROM roads.hard_hats AS default_DOT_hard_hats)
+         AS default_DOT_hard_hat ON default_DOT_repair_order.hard_hat_id = default_DOT_hard_hat.hard_hat_id
+        LEFT OUTER JOIN (SELECT  default_DOT_us_states.state_abbr,
+                default_DOT_us_states.state_id,
+                default_DOT_us_states.state_name 
+         FROM roads.us_states AS default_DOT_us_states LEFT  JOIN roads.us_region AS default_DOT_us_region ON default_DOT_us_states.state_region = default_DOT_us_region.us_region_description)
+         AS default_DOT_us_state ON default_DOT_hard_hat.state = default_DOT_us_state.state_abbr 
+         GROUP BY  default_DOT_us_state.state_abbr, default_DOT_us_state.state_id, default_DOT_us_state.state_name
+        ),
+        m1_default_DOT_avg_repair_price AS (SELECT  default_DOT_us_state.state_abbr,
+                default_DOT_us_state.state_id,
+                default_DOT_us_state.state_name,
+                avg(default_DOT_repair_order_details.price) default_DOT_avg_repair_price 
+         FROM roads.repair_order_details AS default_DOT_repair_order_details LEFT OUTER JOIN (SELECT  default_DOT_repair_orders.dispatcher_id,
+                default_DOT_repair_orders.hard_hat_id,
+                default_DOT_repair_orders.municipality_id,
+                default_DOT_repair_orders.repair_order_id 
+         FROM roads.repair_orders AS default_DOT_repair_orders)
+         AS default_DOT_repair_order ON default_DOT_repair_order_details.repair_order_id = default_DOT_repair_order.repair_order_id
+        LEFT OUTER JOIN (SELECT  default_DOT_hard_hats.birth_date,
+                default_DOT_hard_hats.hard_hat_id,
+                default_DOT_hard_hats.hire_date,
+                default_DOT_hard_hats.state 
+         FROM roads.hard_hats AS default_DOT_hard_hats)
+         AS default_DOT_hard_hat ON default_DOT_repair_order.hard_hat_id = default_DOT_hard_hat.hard_hat_id
+        LEFT OUTER JOIN (SELECT  default_DOT_us_states.state_abbr,
+                default_DOT_us_states.state_id,
+                default_DOT_us_states.state_name 
+         FROM roads.us_states AS default_DOT_us_states LEFT  JOIN roads.us_region AS default_DOT_us_region ON default_DOT_us_states.state_region = default_DOT_us_region.us_region_description)
+         AS default_DOT_us_state ON default_DOT_hard_hat.state = default_DOT_us_state.state_abbr 
+         GROUP BY  default_DOT_us_state.state_abbr, default_DOT_us_state.state_id, default_DOT_us_state.state_name
+        ),
+        m2_default_DOT_total_repair_cost AS (SELECT  default_DOT_us_state.state_abbr,
+                default_DOT_us_state.state_id,
+                default_DOT_us_state.state_name,
+                sum(default_DOT_repair_order_details.price) default_DOT_total_repair_cost 
+         FROM roads.repair_order_details AS default_DOT_repair_order_details LEFT OUTER JOIN (SELECT  default_DOT_repair_orders.dispatcher_id,
+                default_DOT_repair_orders.hard_hat_id,
+                default_DOT_repair_orders.municipality_id,
+                default_DOT_repair_orders.repair_order_id 
+         FROM roads.repair_orders AS default_DOT_repair_orders)
+         AS default_DOT_repair_order ON default_DOT_repair_order_details.repair_order_id = default_DOT_repair_order.repair_order_id
+        LEFT OUTER JOIN (SELECT  default_DOT_hard_hats.birth_date,
+                default_DOT_hard_hats.hard_hat_id,
+                default_DOT_hard_hats.hire_date,
+                default_DOT_hard_hats.state 
+         FROM roads.hard_hats AS default_DOT_hard_hats)
+         AS default_DOT_hard_hat ON default_DOT_repair_order.hard_hat_id = default_DOT_hard_hat.hard_hat_id
+        LEFT OUTER JOIN (SELECT  default_DOT_us_states.state_abbr,
+                default_DOT_us_states.state_id,
+                default_DOT_us_states.state_name 
+         FROM roads.us_states AS default_DOT_us_states LEFT  JOIN roads.us_region AS default_DOT_us_region ON default_DOT_us_states.state_region = default_DOT_us_region.us_region_description)
+         AS default_DOT_us_state ON default_DOT_hard_hat.state = default_DOT_us_state.state_abbr 
+         GROUP BY  default_DOT_us_state.state_abbr, default_DOT_us_state.state_id, default_DOT_us_state.state_name
+        )SELECT  m0_default_DOT_num_repair_orders.default_DOT_num_repair_orders,
+                m1_default_DOT_avg_repair_price.default_DOT_avg_repair_price,
+                m2_default_DOT_total_repair_cost.default_DOT_total_repair_cost,
+                COALESCE(m0_default_DOT_num_repair_orders.state_abbr, m1_default_DOT_avg_repair_price.state_abbr, m2_default_DOT_total_repair_cost.state_abbr) state_abbr,
+                COALESCE(m0_default_DOT_num_repair_orders.state_id, m1_default_DOT_avg_repair_price.state_id, m2_default_DOT_total_repair_cost.state_id) state_id,
+                COALESCE(m0_default_DOT_num_repair_orders.state_name, m1_default_DOT_avg_repair_price.state_name, m2_default_DOT_total_repair_cost.state_name) state_name 
+         FROM m0_default_DOT_num_repair_orders FULL OUTER JOIN m1_default_DOT_avg_repair_price ON m0_default_DOT_num_repair_orders.state_abbr = m1_default_DOT_avg_repair_price.state_abbr AND m0_default_DOT_num_repair_orders.state_id = m1_default_DOT_avg_repair_price.state_id AND m0_default_DOT_num_repair_orders.state_name = m1_default_DOT_avg_repair_price.state_name
+        FULL OUTER JOIN m2_default_DOT_total_repair_cost ON m0_default_DOT_num_repair_orders.state_abbr = m2_default_DOT_total_repair_cost.state_abbr AND m0_default_DOT_num_repair_orders.state_id = m2_default_DOT_total_repair_cost.state_id AND m0_default_DOT_num_repair_orders.state_name = m2_default_DOT_total_repair_cost.state_name
+    `.replace(/\s+/g, '')
+    )
+
+    const data = await dj.data.get(
+        [
+            'default.num_repair_orders',
+            'default.avg_repair_price',
+            'default.total_repair_cost',
+        ],
+        [
+            'default.us_state.state_abbr',
+            'default.us_state.state_id',
+            'default.us_state.state_name',
+        ],
+        []
+    )
+
+    expect(data).toEqual({
+        columns: [
+            {
+                name: 'default_DOT_num_repair_orders',
+                type: 'bigint',
+            },
+            {
+                name: 'default_DOT_avg_repair_price',
+                type: 'double',
+            },
+            {
+                name: 'default_DOT_total_repair_cost',
+                type: 'double',
+            },
+            {
+                name: 'state_abbr',
+                type: 'string',
+            },
+            {
+                name: 'state_id',
+                type: 'int',
+            },
+            {
+                name: 'state_name',
+                type: 'string',
+            },
+        ],
+        data: [
+            [486, 65682.0, 31921452.0, 'AZ', 3, 'Arizona'],
+            [486, 39301.5, 19100529.0, 'CT', 7, 'Connecticut'],
+            [729, 65595.66666666667, 47819241.0, 'GA', 11, 'Georgia'],
+            [729, 76555.33333333333, 55808838.0, 'MA', 22, 'Massachusetts'],
+            [1215, 64190.6, 77991579.0, 'MI', 23, 'Michigan'],
+            [972, 54672.75, 53141913.0, 'NJ', 31, 'New Jersey'],
+            [243, 53374.0, 12969882.0, 'NY', 33, 'New York'],
+            [243, 70418.0, 17111574.0, 'OK', 37, 'Oklahoma'],
+            [972, 54083.5, 52569162.0, 'PA', 39, 'Pennsylvania'],
+        ],
+    })
+
+    // Create a transform 2 downstream from a transform 1
+    await dj.transforms.create({
+        name: `${namespace}.repair_orders_w_hard_hats`,
+        description: 'Repair orders that have a hard hat assigned',
+        mode: 'published',
+        query: `SELECT
+            repair_order_id,
+            municipality_id,
+            hard_hat_id,
+            dispatcher_id
+            FROM ${namespace}.repair_orders_w_dispatchers
+            WHERE hard_hat_id IS NOT NULL`,
+    })
+
+    // Get transform 2 that's downstream from transform 1 and make sure it's valid
+    const transform2 = await dj.nodes.get(
+        `${namespace}.repair_orders_w_hard_hats`
+    )
+    expect(transform2.name).toBe(`${namespace}.repair_orders_w_hard_hats`)
+    expect(transform2.status).toBe('valid')
+    expect(transform2.mode).toBe('published')
+
+    // Create a draft transform 4 that's downstream from a not yet created transform 3
+    await dj.transforms.create({
+        name: `${namespace}.repair_orders_w_repair_order_id`,
+        description: 'Repair orders without a null ID',
+        mode: 'draft',
+        query: `SELECT
+            repair_order_id,
+            municipality_id,
+            hard_hat_id,
+            dispatcher_id
+            FROM ${namespace}.repair_orders_w_municipalities
+            WHERE repair_order_id IS NOT NULL`,
+    })
+    const transform4 = await dj.nodes.get(
+        `${namespace}.repair_orders_w_repair_order_id`
+    )
+    // Check that transform 4 is invalid because transform 3 does not exist
+    expect(transform4.name).toBe(`${namespace}.repair_orders_w_repair_order_id`)
+    expect(transform4.status).toBe('invalid')
+    expect(transform4.mode).toBe('draft')
+
+    // Create a draft transform 3 that's downstream from transform 2
+    await dj.transforms.create({
+        name: `${namespace}.repair_orders_w_municipalities`,
+        description: 'Repair orders that have a municipality listed',
+        mode: 'draft',
+        query: `SELECT
+        repair_order_id,
+        municipality_id,
+        hard_hat_id,
+        dispatcher_id
+        FROM ${namespace}.repair_orders_w_hard_hats
+        WHERE municipality_id IS NOT NULL`,
+    })
+    const transform3 = await dj.nodes.get(
+        `${namespace}.repair_orders_w_municipalities`
+    )
+    expect(transform3.name).toBe(`${namespace}.repair_orders_w_municipalities`)
+    expect(transform3.status).toBe('valid')
+    expect(transform3.mode).toBe('draft')
+
+    // Check that transform 4 is now valid after transform 3 was created
+    const transform4_now_valid = await dj.nodes.get(
+        `${namespace}.repair_orders_w_repair_order_id`
+    )
+    expect(transform4_now_valid.status).toBe('valid')
+
+    // Check that publishing transform 3 works
+    await dj.nodes.publish(transform3.name)
+}, 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',
+    },
+  },
+}