134 lines
7.6 KiB
JavaScript
134 lines
7.6 KiB
JavaScript
import { grabPrimaryRequiredDbSchema, writeUpdatedDbSchema, } from "../../../shell/createDbFromSchema/grab-required-database-schemas";
|
|
import _ from "lodash";
|
|
import uniqueByKey from "../../unique-by-key";
|
|
export default function ({ currentDbSchema, currentTableSchema, currentTableSchemaIndex, userId, }) {
|
|
var _a, _b, _c, _d, _e, _f, _g;
|
|
if (!currentDbSchema.dbFullName) {
|
|
throw new Error(`Resolve Children tables ERROR => currentDbSchema.dbFullName not found!`);
|
|
}
|
|
const newCurrentDbSchema = _.cloneDeep(currentDbSchema);
|
|
if (newCurrentDbSchema.tables[currentTableSchemaIndex].childrenTables) {
|
|
for (let ch = 0; ch <
|
|
newCurrentDbSchema.tables[currentTableSchemaIndex].childrenTables
|
|
.length; ch++) {
|
|
const childTable = newCurrentDbSchema.tables[currentTableSchemaIndex]
|
|
.childrenTables[ch];
|
|
if (!childTable.dbId || !childTable.tableId) {
|
|
(_a = newCurrentDbSchema.tables[currentTableSchemaIndex].childrenTables) === null || _a === void 0 ? void 0 : _a.splice(ch, 1, {});
|
|
continue;
|
|
}
|
|
const targetChildTableParentDatabase = grabPrimaryRequiredDbSchema({
|
|
dbId: childTable.dbId,
|
|
userId,
|
|
});
|
|
/**
|
|
* Delete child table from array if the parent database
|
|
* of said child table has been deleted or doesn't exist
|
|
*/
|
|
if (!(targetChildTableParentDatabase === null || targetChildTableParentDatabase === void 0 ? void 0 : targetChildTableParentDatabase.dbFullName)) {
|
|
(_b = newCurrentDbSchema.tables[currentTableSchemaIndex].childrenTables) === null || _b === void 0 ? void 0 : _b.splice(ch, 1, {});
|
|
}
|
|
else {
|
|
/**
|
|
* Delete child table from array if the parent database
|
|
* exists but the target tabled has been deleted or doesn't
|
|
* exist
|
|
*/
|
|
const targetChildTableParentDatabaseTableIndex = targetChildTableParentDatabase.tables.findIndex((tbl) => tbl.id == childTable.tableId);
|
|
const targetChildTableParentDatabaseTable = targetChildTableParentDatabase.tables[targetChildTableParentDatabaseTableIndex];
|
|
if (targetChildTableParentDatabaseTable === null || targetChildTableParentDatabaseTable === void 0 ? void 0 : targetChildTableParentDatabaseTable.childTable) {
|
|
targetChildTableParentDatabase.tables[targetChildTableParentDatabaseTableIndex].fields = [...currentTableSchema.fields];
|
|
targetChildTableParentDatabase.tables[targetChildTableParentDatabaseTableIndex].indexes = [...(currentTableSchema.indexes || [])];
|
|
writeUpdatedDbSchema({
|
|
dbSchema: targetChildTableParentDatabase,
|
|
userId,
|
|
});
|
|
}
|
|
else {
|
|
(_c = newCurrentDbSchema.tables[currentTableSchemaIndex].childrenTables) === null || _c === void 0 ? void 0 : _c.splice(ch, 1, {});
|
|
}
|
|
}
|
|
}
|
|
if ((_d = newCurrentDbSchema.tables[currentTableSchemaIndex]
|
|
.childrenTables) === null || _d === void 0 ? void 0 : _d[0]) {
|
|
newCurrentDbSchema.tables[currentTableSchemaIndex].childrenTables =
|
|
uniqueByKey(newCurrentDbSchema.tables[currentTableSchemaIndex].childrenTables.filter((tbl) => Boolean(tbl.dbId) && Boolean(tbl.tableId)), "dbId");
|
|
}
|
|
else {
|
|
delete newCurrentDbSchema.tables[currentTableSchemaIndex]
|
|
.childrenTables;
|
|
}
|
|
}
|
|
/**
|
|
* Handle scenario where this table is a child of another
|
|
*/
|
|
if (currentTableSchema.childTable &&
|
|
currentTableSchema.childTableDbId &&
|
|
currentTableSchema.childTableDbId) {
|
|
const targetParentDatabase = grabPrimaryRequiredDbSchema({
|
|
dbId: currentTableSchema.childTableDbId,
|
|
userId,
|
|
});
|
|
const targetParentDatabaseTableIndex = targetParentDatabase === null || targetParentDatabase === void 0 ? void 0 : targetParentDatabase.tables.findIndex((tbl) => tbl.id == currentTableSchema.childTableId);
|
|
const targetParentDatabaseTable = typeof targetParentDatabaseTableIndex == "number"
|
|
? targetParentDatabaseTableIndex < 0
|
|
? undefined
|
|
: targetParentDatabase === null || targetParentDatabase === void 0 ? void 0 : targetParentDatabase.tables[targetParentDatabaseTableIndex]
|
|
: undefined;
|
|
/**
|
|
* Delete child Table key/values from current database if
|
|
* the parent database doesn't esit
|
|
*/
|
|
if (!(targetParentDatabase === null || targetParentDatabase === void 0 ? void 0 : targetParentDatabase.dbFullName) ||
|
|
!(targetParentDatabaseTable === null || targetParentDatabaseTable === void 0 ? void 0 : targetParentDatabaseTable.tableName)) {
|
|
delete newCurrentDbSchema.tables[currentTableSchemaIndex]
|
|
.childTable;
|
|
delete newCurrentDbSchema.tables[currentTableSchemaIndex]
|
|
.childTableDbId;
|
|
delete newCurrentDbSchema.tables[currentTableSchemaIndex]
|
|
.childTableId;
|
|
delete newCurrentDbSchema.tables[currentTableSchemaIndex]
|
|
.childTableDbId;
|
|
return newCurrentDbSchema;
|
|
}
|
|
/**
|
|
* New Child Database Table Object to be appended
|
|
*/
|
|
const newChildDatabaseTableObject = {
|
|
tableId: currentTableSchema.id,
|
|
dbId: newCurrentDbSchema.id,
|
|
};
|
|
/**
|
|
* Add a new Children array in the target table schema if this is the
|
|
* first child to be added to said table schema. Else append to array
|
|
* if it exists
|
|
*/
|
|
if (typeof targetParentDatabaseTableIndex == "number" &&
|
|
!((_e = targetParentDatabaseTable.childrenTables) === null || _e === void 0 ? void 0 : _e[0])) {
|
|
targetParentDatabase.tables[targetParentDatabaseTableIndex].childrenTables = [newChildDatabaseTableObject];
|
|
}
|
|
else if (typeof targetParentDatabaseTableIndex == "number" &&
|
|
((_f = targetParentDatabaseTable.childrenTables) === null || _f === void 0 ? void 0 : _f[0])) {
|
|
const existingChildDbTable = targetParentDatabaseTable.childrenTables.find((tbl) => tbl.dbId == newCurrentDbSchema.id &&
|
|
tbl.tableId == currentTableSchema.id);
|
|
if (!(existingChildDbTable === null || existingChildDbTable === void 0 ? void 0 : existingChildDbTable.tableId)) {
|
|
(_g = targetParentDatabase.tables[targetParentDatabaseTableIndex].childrenTables) === null || _g === void 0 ? void 0 : _g.push(newChildDatabaseTableObject);
|
|
}
|
|
targetParentDatabase.tables[targetParentDatabaseTableIndex].childrenTables = uniqueByKey(targetParentDatabase.tables[targetParentDatabaseTableIndex]
|
|
.childrenTables || [], ["dbId", "tableId"]);
|
|
}
|
|
/**
|
|
* Update fields and indexes for child table, which is the
|
|
* current table
|
|
*/
|
|
if (targetParentDatabaseTable === null || targetParentDatabaseTable === void 0 ? void 0 : targetParentDatabaseTable.tableName) {
|
|
newCurrentDbSchema.tables[currentTableSchemaIndex].fields =
|
|
targetParentDatabaseTable.fields;
|
|
newCurrentDbSchema.tables[currentTableSchemaIndex].indexes =
|
|
targetParentDatabaseTable.indexes;
|
|
writeUpdatedDbSchema({ dbSchema: targetParentDatabase, userId });
|
|
}
|
|
}
|
|
return newCurrentDbSchema;
|
|
}
|