mirror of https://github.com/Budibase/budibase.git
Michael Drury
5 years ago
committed by
GitHub
GitHub
27 changed files with 949 additions and 255 deletions
@ -0,0 +1,54 @@ |
|||||
|
<script> |
||||
|
import { ActionButton, Modal, notifications } from "@budibase/bbui" |
||||
|
import CreateEditRelationship from "../../Datasources/CreateEditRelationship.svelte" |
||||
|
import { datasources, tables } from "../../../../stores/backend" |
||||
|
import { createEventDispatcher } from "svelte" |
||||
|
|
||||
|
export let table |
||||
|
const dispatch = createEventDispatcher() |
||||
|
|
||||
|
$: plusTables = datasource?.plus |
||||
|
? Object.values(datasource?.entities || {}) |
||||
|
: [] |
||||
|
$: datasource = $datasources.list.find( |
||||
|
source => source._id === table?.sourceId |
||||
|
) |
||||
|
|
||||
|
let modal |
||||
|
|
||||
|
async function saveRelationship() { |
||||
|
try { |
||||
|
// Create datasource |
||||
|
await datasources.save(datasource) |
||||
|
notifications.success(`Relationship information saved.`) |
||||
|
const tableList = await tables.fetch() |
||||
|
await tables.select(tableList.find(tbl => tbl._id === table._id)) |
||||
|
dispatch("updatecolumns") |
||||
|
} catch (err) { |
||||
|
notifications.error(`Error saving relationship info: ${err}`) |
||||
|
} |
||||
|
} |
||||
|
</script> |
||||
|
|
||||
|
{#if table.sourceId} |
||||
|
<div> |
||||
|
<ActionButton |
||||
|
icon="DataCorrelated" |
||||
|
primary |
||||
|
size="S" |
||||
|
quiet |
||||
|
on:click={modal.show} |
||||
|
> |
||||
|
Define existing relationship |
||||
|
</ActionButton> |
||||
|
</div> |
||||
|
<Modal bind:this={modal}> |
||||
|
<CreateEditRelationship |
||||
|
{datasource} |
||||
|
save={saveRelationship} |
||||
|
close={modal.hide} |
||||
|
{plusTables} |
||||
|
selectedFromTable={table} |
||||
|
/> |
||||
|
</Modal> |
||||
|
{/if} |
||||
@ -0,0 +1,45 @@ |
|||||
|
<script> |
||||
|
import { ModalContent, Body, Input } from "@budibase/bbui" |
||||
|
import { tables, datasources } from "stores/backend" |
||||
|
import { goto } from "@roxi/routify" |
||||
|
|
||||
|
export let datasource |
||||
|
|
||||
|
let name = "" |
||||
|
$: valid = name && name.length > 0 && !datasource?.entities[name] |
||||
|
$: error = |
||||
|
name && datasource?.entities[name] ? "Table name already in use." : null |
||||
|
|
||||
|
function buildDefaultTable(tableName, datasourceId) { |
||||
|
return { |
||||
|
name: tableName, |
||||
|
type: "external", |
||||
|
primary: ["id"], |
||||
|
sourceId: datasourceId, |
||||
|
schema: { |
||||
|
id: { |
||||
|
autocolumn: true, |
||||
|
type: "number", |
||||
|
}, |
||||
|
}, |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
async function saveTable() { |
||||
|
const table = await tables.save(buildDefaultTable(name, datasource._id)) |
||||
|
await datasources.fetch() |
||||
|
$goto(`../../table/${table._id}`) |
||||
|
} |
||||
|
</script> |
||||
|
|
||||
|
<ModalContent |
||||
|
title="Create new table" |
||||
|
confirmText="Create" |
||||
|
onConfirm={saveTable} |
||||
|
disabled={!valid} |
||||
|
> |
||||
|
<Body |
||||
|
>Provide a name for your new table; you can add columns once it is created.</Body |
||||
|
> |
||||
|
<Input label="Table Name" bind:error bind:value={name} /> |
||||
|
</ModalContent> |
||||
@ -1,43 +0,0 @@ |
|||||
<script> |
|
||||
import { ModalContent, Select, Body } from "@budibase/bbui" |
|
||||
import { tables } from "stores/backend" |
|
||||
|
|
||||
export let datasource |
|
||||
export let plusTables |
|
||||
export let save |
|
||||
|
|
||||
async function saveDisplayColumns() { |
|
||||
// be explicit about copying over |
|
||||
for (let table of plusTables) { |
|
||||
datasource.entities[table.name].primaryDisplay = table.primaryDisplay |
|
||||
} |
|
||||
save() |
|
||||
await tables.fetch() |
|
||||
} |
|
||||
|
|
||||
function getColumnOptions(table) { |
|
||||
if (!table || !table.schema) { |
|
||||
return [] |
|
||||
} |
|
||||
return Object.entries(table.schema) |
|
||||
.filter(field => field[1].type !== "link") |
|
||||
.map(([fieldName]) => fieldName) |
|
||||
} |
|
||||
</script> |
|
||||
|
|
||||
<ModalContent |
|
||||
title="Edit display columns" |
|
||||
confirmText="Save" |
|
||||
onConfirm={saveDisplayColumns} |
|
||||
> |
|
||||
<Body |
|
||||
>Select the columns that will be shown when displaying relationships.</Body |
|
||||
> |
|
||||
{#each plusTables as table} |
|
||||
<Select |
|
||||
label={table.name} |
|
||||
options={getColumnOptions(table)} |
|
||||
bind:value={table.primaryDisplay} |
|
||||
/> |
|
||||
{/each} |
|
||||
</ModalContent> |
|
||||
@ -0,0 +1,276 @@ |
|||||
|
const CouchDB = require("../../../db") |
||||
|
const { |
||||
|
buildExternalTableId, |
||||
|
breakExternalTableId, |
||||
|
} = require("../../../integrations/utils") |
||||
|
const { |
||||
|
getTable, |
||||
|
generateForeignKey, |
||||
|
generateJunctionTableName, |
||||
|
foreignKeyStructure, |
||||
|
} = require("./utils") |
||||
|
const { |
||||
|
DataSourceOperation, |
||||
|
FieldTypes, |
||||
|
RelationshipTypes, |
||||
|
} = require("../../../constants") |
||||
|
const { makeExternalQuery } = require("../../../integrations/base/utils") |
||||
|
const { cloneDeep } = require("lodash/fp") |
||||
|
|
||||
|
async function makeTableRequest( |
||||
|
datasource, |
||||
|
operation, |
||||
|
table, |
||||
|
tables, |
||||
|
oldTable = null |
||||
|
) { |
||||
|
const json = { |
||||
|
endpoint: { |
||||
|
datasourceId: datasource._id, |
||||
|
entityId: table._id, |
||||
|
operation, |
||||
|
}, |
||||
|
meta: { |
||||
|
tables, |
||||
|
}, |
||||
|
table, |
||||
|
} |
||||
|
if (oldTable) { |
||||
|
json.meta.table = oldTable |
||||
|
} |
||||
|
return makeExternalQuery(datasource, json) |
||||
|
} |
||||
|
|
||||
|
function cleanupRelationships(table, tables, oldTable = null) { |
||||
|
const tableToIterate = oldTable ? oldTable : table |
||||
|
// clean up relationships in couch table schemas
|
||||
|
for (let [key, schema] of Object.entries(tableToIterate.schema)) { |
||||
|
if ( |
||||
|
schema.type === FieldTypes.LINK && |
||||
|
(!oldTable || table.schema[key] == null) |
||||
|
) { |
||||
|
const relatedTable = Object.values(tables).find( |
||||
|
table => table._id === schema.tableId |
||||
|
) |
||||
|
const foreignKey = schema.foreignKey |
||||
|
if (!relatedTable || !foreignKey) { |
||||
|
continue |
||||
|
} |
||||
|
for (let [relatedKey, relatedSchema] of Object.entries( |
||||
|
relatedTable.schema |
||||
|
)) { |
||||
|
if ( |
||||
|
relatedSchema.type === FieldTypes.LINK && |
||||
|
relatedSchema.fieldName === foreignKey |
||||
|
) { |
||||
|
delete relatedTable.schema[relatedKey] |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
function getDatasourceId(table) { |
||||
|
if (!table) { |
||||
|
throw "No table supplied" |
||||
|
} |
||||
|
if (table.sourceId) { |
||||
|
return table.sourceId |
||||
|
} |
||||
|
return breakExternalTableId(table._id).datasourceId |
||||
|
} |
||||
|
|
||||
|
function otherRelationshipType(type) { |
||||
|
if (type === RelationshipTypes.MANY_TO_MANY) { |
||||
|
return RelationshipTypes.MANY_TO_MANY |
||||
|
} |
||||
|
return type === RelationshipTypes.ONE_TO_MANY |
||||
|
? RelationshipTypes.MANY_TO_ONE |
||||
|
: RelationshipTypes.ONE_TO_MANY |
||||
|
} |
||||
|
|
||||
|
function generateManyLinkSchema(datasource, column, table, relatedTable) { |
||||
|
const primary = table.name + table.primary[0] |
||||
|
const relatedPrimary = relatedTable.name + relatedTable.primary[0] |
||||
|
const jcTblName = generateJunctionTableName(column, table, relatedTable) |
||||
|
// first create the new table
|
||||
|
const junctionTable = { |
||||
|
_id: buildExternalTableId(datasource._id, jcTblName), |
||||
|
name: jcTblName, |
||||
|
primary: [primary, relatedPrimary], |
||||
|
constrained: [primary, relatedPrimary], |
||||
|
schema: { |
||||
|
[primary]: foreignKeyStructure(primary, { |
||||
|
toTable: table.name, |
||||
|
toKey: table.primary[0], |
||||
|
}), |
||||
|
[relatedPrimary]: foreignKeyStructure(relatedPrimary, { |
||||
|
toTable: relatedTable.name, |
||||
|
toKey: relatedTable.primary[0], |
||||
|
}), |
||||
|
}, |
||||
|
} |
||||
|
column.through = junctionTable._id |
||||
|
column.throughFrom = primary |
||||
|
column.throughTo = relatedPrimary |
||||
|
column.fieldName = relatedPrimary |
||||
|
return junctionTable |
||||
|
} |
||||
|
|
||||
|
function generateLinkSchema(column, table, relatedTable, type) { |
||||
|
const isOneSide = type === RelationshipTypes.ONE_TO_MANY |
||||
|
const primary = isOneSide ? relatedTable.primary[0] : table.primary[0] |
||||
|
// generate a foreign key
|
||||
|
const foreignKey = generateForeignKey(column, relatedTable) |
||||
|
column.relationshipType = type |
||||
|
column.foreignKey = isOneSide ? foreignKey : primary |
||||
|
column.fieldName = isOneSide ? primary : foreignKey |
||||
|
return foreignKey |
||||
|
} |
||||
|
|
||||
|
function generateRelatedSchema(linkColumn, table, relatedTable, columnName) { |
||||
|
// generate column for other table
|
||||
|
const relatedSchema = cloneDeep(linkColumn) |
||||
|
// swap them from the main link
|
||||
|
if (linkColumn.foreignKey) { |
||||
|
relatedSchema.fieldName = linkColumn.foreignKey |
||||
|
relatedSchema.foreignKey = linkColumn.fieldName |
||||
|
} |
||||
|
// is many to many
|
||||
|
else { |
||||
|
// don't need to copy through, already got it
|
||||
|
relatedSchema.fieldName = linkColumn.throughFrom |
||||
|
relatedSchema.throughTo = linkColumn.throughFrom |
||||
|
relatedSchema.throughFrom = linkColumn.throughTo |
||||
|
} |
||||
|
relatedSchema.relationshipType = otherRelationshipType( |
||||
|
linkColumn.relationshipType |
||||
|
) |
||||
|
relatedSchema.tableId = relatedTable._id |
||||
|
relatedSchema.name = columnName |
||||
|
table.schema[columnName] = relatedSchema |
||||
|
} |
||||
|
|
||||
|
function isRelationshipSetup(column) { |
||||
|
return column.foreignKey || column.through |
||||
|
} |
||||
|
|
||||
|
exports.save = async function (ctx) { |
||||
|
const appId = ctx.appId |
||||
|
const table = ctx.request.body |
||||
|
// can't do this
|
||||
|
delete table.dataImport |
||||
|
const datasourceId = getDatasourceId(ctx.request.body) |
||||
|
let tableToSave = { |
||||
|
type: "table", |
||||
|
_id: buildExternalTableId(datasourceId, table.name), |
||||
|
...table, |
||||
|
} |
||||
|
|
||||
|
let oldTable |
||||
|
if (ctx.request.body && ctx.request.body._id) { |
||||
|
oldTable = await getTable(appId, ctx.request.body._id) |
||||
|
} |
||||
|
|
||||
|
const db = new CouchDB(appId) |
||||
|
const datasource = await db.get(datasourceId) |
||||
|
const oldTables = cloneDeep(datasource.entities) |
||||
|
const tables = datasource.entities |
||||
|
|
||||
|
const extraTablesToUpdate = [] |
||||
|
|
||||
|
// check if relations need setup
|
||||
|
for (let schema of Object.values(tableToSave.schema)) { |
||||
|
if (schema.type !== FieldTypes.LINK || isRelationshipSetup(schema)) { |
||||
|
continue |
||||
|
} |
||||
|
const relatedTable = Object.values(tables).find( |
||||
|
table => table._id === schema.tableId |
||||
|
) |
||||
|
const relatedColumnName = schema.fieldName |
||||
|
const relationType = schema.relationshipType |
||||
|
if (relationType === RelationshipTypes.MANY_TO_MANY) { |
||||
|
const junctionTable = generateManyLinkSchema( |
||||
|
datasource, |
||||
|
schema, |
||||
|
table, |
||||
|
relatedTable |
||||
|
) |
||||
|
if (tables[junctionTable.name]) { |
||||
|
throw "Junction table already exists, cannot create another relationship." |
||||
|
} |
||||
|
tables[junctionTable.name] = junctionTable |
||||
|
extraTablesToUpdate.push(junctionTable) |
||||
|
} else { |
||||
|
const fkTable = |
||||
|
relationType === RelationshipTypes.ONE_TO_MANY ? table : relatedTable |
||||
|
const foreignKey = generateLinkSchema( |
||||
|
schema, |
||||
|
table, |
||||
|
relatedTable, |
||||
|
relationType |
||||
|
) |
||||
|
fkTable.schema[foreignKey] = foreignKeyStructure(foreignKey) |
||||
|
if (fkTable.constrained == null) { |
||||
|
fkTable.constrained = [] |
||||
|
} |
||||
|
if (fkTable.constrained.indexOf(foreignKey) === -1) { |
||||
|
fkTable.constrained.push(foreignKey) |
||||
|
} |
||||
|
// foreign key is in other table, need to save it to external
|
||||
|
if (fkTable._id !== table._id) { |
||||
|
extraTablesToUpdate.push(fkTable) |
||||
|
} |
||||
|
} |
||||
|
generateRelatedSchema(schema, relatedTable, table, relatedColumnName) |
||||
|
schema.main = true |
||||
|
} |
||||
|
|
||||
|
cleanupRelationships(tableToSave, tables, oldTable) |
||||
|
|
||||
|
const operation = oldTable |
||||
|
? DataSourceOperation.UPDATE_TABLE |
||||
|
: DataSourceOperation.CREATE_TABLE |
||||
|
await makeTableRequest(datasource, operation, tableToSave, tables, oldTable) |
||||
|
// update any extra tables (like foreign keys in other tables)
|
||||
|
for (let extraTable of extraTablesToUpdate) { |
||||
|
const oldExtraTable = oldTables[extraTable.name] |
||||
|
let op = oldExtraTable |
||||
|
? DataSourceOperation.UPDATE_TABLE |
||||
|
: DataSourceOperation.CREATE_TABLE |
||||
|
await makeTableRequest(datasource, op, extraTable, tables, oldExtraTable) |
||||
|
} |
||||
|
|
||||
|
// make sure the constrained list, all still exist
|
||||
|
if (Array.isArray(tableToSave.constrained)) { |
||||
|
tableToSave.constrained = tableToSave.constrained.filter(constraint => |
||||
|
Object.keys(tableToSave.schema).includes(constraint) |
||||
|
) |
||||
|
} |
||||
|
|
||||
|
// store it into couch now for budibase reference
|
||||
|
datasource.entities[tableToSave.name] = tableToSave |
||||
|
await db.put(datasource) |
||||
|
|
||||
|
return tableToSave |
||||
|
} |
||||
|
|
||||
|
exports.destroy = async function (ctx) { |
||||
|
const appId = ctx.appId |
||||
|
const tableToDelete = await getTable(appId, ctx.params.tableId) |
||||
|
const datasourceId = getDatasourceId(tableToDelete) |
||||
|
|
||||
|
const db = new CouchDB(appId) |
||||
|
const datasource = await db.get(datasourceId) |
||||
|
const tables = datasource.entities |
||||
|
|
||||
|
const operation = DataSourceOperation.DELETE_TABLE |
||||
|
await makeTableRequest(datasource, operation, tableToDelete, tables) |
||||
|
|
||||
|
cleanupRelationships(tableToDelete, tables) |
||||
|
|
||||
|
delete datasource.entities[tableToDelete.name] |
||||
|
await db.put(datasource) |
||||
|
|
||||
|
return tableToDelete |
||||
|
} |
||||
@ -0,0 +1,138 @@ |
|||||
|
const CouchDB = require("../../../db") |
||||
|
const linkRows = require("../../../db/linkedRows") |
||||
|
const { getRowParams, generateTableID } = require("../../../db/utils") |
||||
|
const { FieldTypes } = require("../../../constants") |
||||
|
const { TableSaveFunctions } = require("./utils") |
||||
|
|
||||
|
exports.save = async function (ctx) { |
||||
|
const appId = ctx.appId |
||||
|
const db = new CouchDB(appId) |
||||
|
const { dataImport, ...rest } = ctx.request.body |
||||
|
let tableToSave = { |
||||
|
type: "table", |
||||
|
_id: generateTableID(), |
||||
|
views: {}, |
||||
|
...rest, |
||||
|
} |
||||
|
|
||||
|
// if the table obj had an _id then it will have been retrieved
|
||||
|
let oldTable |
||||
|
if (ctx.request.body && ctx.request.body._id) { |
||||
|
oldTable = await db.get(ctx.request.body._id) |
||||
|
} |
||||
|
|
||||
|
// saving a table is a complex operation, involving many different steps, this
|
||||
|
// has been broken out into a utility to make it more obvious/easier to manipulate
|
||||
|
const tableSaveFunctions = new TableSaveFunctions({ |
||||
|
db, |
||||
|
ctx, |
||||
|
oldTable, |
||||
|
dataImport, |
||||
|
}) |
||||
|
tableToSave = await tableSaveFunctions.before(tableToSave) |
||||
|
|
||||
|
// make sure that types don't change of a column, have to remove
|
||||
|
// the column if you want to change the type
|
||||
|
if (oldTable && oldTable.schema) { |
||||
|
for (let propKey of Object.keys(tableToSave.schema)) { |
||||
|
let column = tableToSave.schema[propKey] |
||||
|
let oldColumn = oldTable.schema[propKey] |
||||
|
if (oldColumn && oldColumn.type === "internal") { |
||||
|
oldColumn.type = "auto" |
||||
|
} |
||||
|
if (oldColumn && oldColumn.type !== column.type) { |
||||
|
ctx.throw(400, "Cannot change the type of a column") |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Don't rename if the name is the same
|
||||
|
let { _rename } = tableToSave |
||||
|
/* istanbul ignore next */ |
||||
|
if (_rename && _rename.old === _rename.updated) { |
||||
|
_rename = null |
||||
|
delete tableToSave._rename |
||||
|
} |
||||
|
|
||||
|
// rename row fields when table column is renamed
|
||||
|
/* istanbul ignore next */ |
||||
|
if (_rename && tableToSave.schema[_rename.updated].type === FieldTypes.LINK) { |
||||
|
ctx.throw(400, "Cannot rename a linked column.") |
||||
|
} |
||||
|
|
||||
|
tableToSave = await tableSaveFunctions.mid(tableToSave) |
||||
|
|
||||
|
// update schema of non-statistics views when new columns are added
|
||||
|
for (let view in tableToSave.views) { |
||||
|
const tableView = tableToSave.views[view] |
||||
|
if (!tableView) continue |
||||
|
|
||||
|
if (tableView.schema.group || tableView.schema.field) continue |
||||
|
tableView.schema = tableToSave.schema |
||||
|
} |
||||
|
|
||||
|
// update linked rows
|
||||
|
try { |
||||
|
const linkResp = await linkRows.updateLinks({ |
||||
|
appId, |
||||
|
eventType: oldTable |
||||
|
? linkRows.EventType.TABLE_UPDATED |
||||
|
: linkRows.EventType.TABLE_SAVE, |
||||
|
table: tableToSave, |
||||
|
oldTable: oldTable, |
||||
|
}) |
||||
|
if (linkResp != null && linkResp._rev) { |
||||
|
tableToSave._rev = linkResp._rev |
||||
|
} |
||||
|
} catch (err) { |
||||
|
ctx.throw(400, err) |
||||
|
} |
||||
|
|
||||
|
// don't perform any updates until relationships have been
|
||||
|
// checked by the updateLinks function
|
||||
|
const updatedRows = tableSaveFunctions.getUpdatedRows() |
||||
|
if (updatedRows && updatedRows.length !== 0) { |
||||
|
await db.bulkDocs(updatedRows) |
||||
|
} |
||||
|
const result = await db.put(tableToSave) |
||||
|
tableToSave._rev = result.rev |
||||
|
|
||||
|
tableToSave = await tableSaveFunctions.after(tableToSave) |
||||
|
|
||||
|
return tableToSave |
||||
|
} |
||||
|
|
||||
|
exports.destroy = async function (ctx) { |
||||
|
const appId = ctx.appId |
||||
|
const db = new CouchDB(appId) |
||||
|
const tableToDelete = await db.get(ctx.params.tableId) |
||||
|
|
||||
|
// Delete all rows for that table
|
||||
|
const rows = await db.allDocs( |
||||
|
getRowParams(ctx.params.tableId, null, { |
||||
|
include_docs: true, |
||||
|
}) |
||||
|
) |
||||
|
await db.bulkDocs(rows.rows.map(row => ({ ...row.doc, _deleted: true }))) |
||||
|
|
||||
|
// update linked rows
|
||||
|
await linkRows.updateLinks({ |
||||
|
appId, |
||||
|
eventType: linkRows.EventType.TABLE_DELETE, |
||||
|
table: tableToDelete, |
||||
|
}) |
||||
|
|
||||
|
// don't remove the table itself until very end
|
||||
|
await db.remove(tableToDelete) |
||||
|
|
||||
|
// remove table search index
|
||||
|
const currentIndexes = await db.getIndexes() |
||||
|
const existingIndex = currentIndexes.indexes.find( |
||||
|
existing => existing.name === `search:${ctx.params.tableId}` |
||||
|
) |
||||
|
if (existingIndex) { |
||||
|
await db.deleteIndex(existingIndex) |
||||
|
} |
||||
|
|
||||
|
return tableToDelete |
||||
|
} |
||||
@ -0,0 +1,167 @@ |
|||||
|
import { Knex, knex } from "knex" |
||||
|
import { Table } from "../../definitions/common" |
||||
|
import { Operation, QueryJson } from "../../definitions/datasource" |
||||
|
import { breakExternalTableId } from "../utils" |
||||
|
import SchemaBuilder = Knex.SchemaBuilder |
||||
|
import CreateTableBuilder = Knex.CreateTableBuilder |
||||
|
const { FieldTypes, RelationshipTypes } = require("../../constants") |
||||
|
|
||||
|
function generateSchema(schema: CreateTableBuilder, table: Table, tables: Record<string, Table>, oldTable: null | Table = null) { |
||||
|
let primaryKey = table && table.primary ? table.primary[0] : null |
||||
|
const columns = Object.values(table.schema) |
||||
|
// all columns in a junction table will be meta
|
||||
|
let metaCols = columns.filter(col => col.meta) |
||||
|
let isJunction = metaCols.length === columns.length |
||||
|
// can't change primary once its set for now
|
||||
|
if (primaryKey && !oldTable && !isJunction) { |
||||
|
schema.increments(primaryKey).primary() |
||||
|
} else if (!oldTable && isJunction) { |
||||
|
schema.primary(metaCols.map(col => col.name)) |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// check if any columns need added
|
||||
|
const foreignKeys = Object.values(table.schema).map(col => col.foreignKey) |
||||
|
for (let [key, column] of Object.entries(table.schema)) { |
||||
|
// skip things that are already correct
|
||||
|
const oldColumn = oldTable ? oldTable.schema[key] : null |
||||
|
if ((oldColumn && oldColumn.type === column.type) || (primaryKey === key && !isJunction)) { |
||||
|
continue |
||||
|
} |
||||
|
switch (column.type) { |
||||
|
case FieldTypes.STRING: case FieldTypes.OPTIONS: case FieldTypes.LONGFORM: |
||||
|
schema.string(key) |
||||
|
break |
||||
|
case FieldTypes.NUMBER: |
||||
|
// if meta is specified then this is a junction table entry
|
||||
|
if (column.meta && column.meta.toKey && column.meta.toTable) { |
||||
|
const { toKey, toTable } = column.meta |
||||
|
schema.integer(key).unsigned() |
||||
|
schema.foreign(key).references(`${toTable}.${toKey}`) |
||||
|
} else if (foreignKeys.indexOf(key) === -1) { |
||||
|
schema.float(key) |
||||
|
} |
||||
|
break |
||||
|
case FieldTypes.BOOLEAN: |
||||
|
schema.boolean(key) |
||||
|
break |
||||
|
case FieldTypes.DATETIME: |
||||
|
schema.datetime(key) |
||||
|
break |
||||
|
case FieldTypes.ARRAY: |
||||
|
schema.json(key) |
||||
|
break |
||||
|
case FieldTypes.LINK: |
||||
|
// this side of the relationship doesn't need any SQL work
|
||||
|
if ( |
||||
|
column.relationshipType !== RelationshipTypes.MANY_TO_ONE && |
||||
|
column.relationshipType !== RelationshipTypes.MANY_TO_MANY |
||||
|
) { |
||||
|
if (!column.foreignKey || !column.tableId) { |
||||
|
throw "Invalid relationship schema" |
||||
|
} |
||||
|
const { tableName } = breakExternalTableId(column.tableId) |
||||
|
// @ts-ignore
|
||||
|
const relatedTable = tables[tableName] |
||||
|
if (!relatedTable) { |
||||
|
throw "Referenced table doesn't exist" |
||||
|
} |
||||
|
schema.integer(column.foreignKey).unsigned() |
||||
|
schema.foreign(column.foreignKey).references(`${tableName}.${relatedTable.primary[0]}`) |
||||
|
} |
||||
|
break |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// need to check if any columns have been deleted
|
||||
|
if (oldTable) { |
||||
|
const deletedColumns = Object.entries(oldTable.schema) |
||||
|
.filter(([key, schema]) => schema.type !== FieldTypes.LINK && table.schema[key] == null) |
||||
|
.map(([key]) => key) |
||||
|
deletedColumns.forEach(key => { |
||||
|
if (oldTable.constrained && oldTable.constrained.indexOf(key) !== -1) { |
||||
|
schema.dropForeign(key) |
||||
|
} |
||||
|
schema.dropColumn(key) |
||||
|
}) |
||||
|
} |
||||
|
|
||||
|
return schema |
||||
|
} |
||||
|
|
||||
|
function buildCreateTable( |
||||
|
knex: Knex, |
||||
|
table: Table, |
||||
|
tables: Record<string, Table>, |
||||
|
): SchemaBuilder { |
||||
|
return knex.schema.createTable(table.name, schema => { |
||||
|
generateSchema(schema, table, tables) |
||||
|
}) |
||||
|
} |
||||
|
|
||||
|
function buildUpdateTable( |
||||
|
knex: Knex, |
||||
|
table: Table, |
||||
|
tables: Record<string, Table>, |
||||
|
oldTable: Table, |
||||
|
): SchemaBuilder { |
||||
|
return knex.schema.alterTable(table.name, schema => { |
||||
|
generateSchema(schema, table, tables, oldTable) |
||||
|
}) |
||||
|
} |
||||
|
|
||||
|
function buildDeleteTable( |
||||
|
knex: Knex, |
||||
|
table: Table, |
||||
|
): SchemaBuilder { |
||||
|
return knex.schema.dropTable(table.name) |
||||
|
} |
||||
|
|
||||
|
class SqlTableQueryBuilder { |
||||
|
private readonly sqlClient: string |
||||
|
|
||||
|
// pass through client to get flavour of SQL
|
||||
|
constructor(client: string) { |
||||
|
this.sqlClient = client |
||||
|
} |
||||
|
|
||||
|
getSqlClient(): string { |
||||
|
return this.sqlClient |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* @param json the input JSON structure from which an SQL query will be built. |
||||
|
* @return {string} the operation that was found in the JSON. |
||||
|
*/ |
||||
|
_operation(json: QueryJson): Operation { |
||||
|
return json.endpoint.operation |
||||
|
} |
||||
|
|
||||
|
_tableQuery(json: QueryJson): any { |
||||
|
const client = knex({ client: this.sqlClient }) |
||||
|
let query |
||||
|
if (!json.table || !json.meta || !json.meta.tables) { |
||||
|
throw "Cannot execute without table being specified" |
||||
|
} |
||||
|
switch (this._operation(json)) { |
||||
|
case Operation.CREATE_TABLE: |
||||
|
query = buildCreateTable(client, json.table, json.meta.tables) |
||||
|
break |
||||
|
case Operation.UPDATE_TABLE: |
||||
|
if (!json.meta || !json.meta.table) { |
||||
|
throw "Must specify old table for update" |
||||
|
} |
||||
|
query = buildUpdateTable(client, json.table, json.meta.tables, json.meta.table) |
||||
|
break |
||||
|
case Operation.DELETE_TABLE: |
||||
|
query = buildDeleteTable(client, json.table) |
||||
|
break |
||||
|
default: |
||||
|
throw "Table operation is of unknown type" |
||||
|
} |
||||
|
return query.toSQL() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
export default SqlTableQueryBuilder |
||||
|
module.exports = SqlTableQueryBuilder |
||||
@ -0,0 +1,19 @@ |
|||||
|
import { QueryJson } from "../../definitions/datasource" |
||||
|
import { Datasource } from "../../definitions/common" |
||||
|
|
||||
|
module DatasourceUtils { |
||||
|
const { integrations } = require("../index") |
||||
|
|
||||
|
export async function makeExternalQuery(datasource: Datasource, json: QueryJson) { |
||||
|
const Integration = integrations[datasource.source] |
||||
|
// query is the opinionated function
|
||||
|
if (Integration.prototype.query) { |
||||
|
const integration = new Integration(datasource.config) |
||||
|
return integration.query(json) |
||||
|
} else { |
||||
|
throw "Datasource does not support query." |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
module.exports.makeExternalQuery = makeExternalQuery |
||||
|
} |
||||
Loading…
Reference in new issue