ufkc7e3d
/
budibase
forked from tsai/budibase
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Adding main work to handle creating, deleting and managing the link docs between different linked records.

master
mike12345567 6 years ago
parent
47b512be1c
commit
7f0686380c
6 changed files with 338 additions and 77 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      packages/server/src/api/controllers/client.js
  2. 18
      packages/server/src/api/controllers/instance.js
  3. 3
      packages/server/src/api/controllers/model.js
  4. 73
      packages/server/src/db/linkedRecords.js
  5. 210
      packages/server/src/db/linkedRecords/LinkController.js
  6. 109
      packages/server/src/db/linkedRecords/index.js

2
packages/server/src/api/controllers/client.js
View File

@ -25,7 +25,7 @@ const getClientId = ctx => {
(ctx.body && ctx.body.clientId) ||
env.CLIENT_ID
if (!clientId) {
ctx.throw(400, "ClientId not suplied")
ctx.throw(400, "ClientId not supplied")
}
return clientId
}

18
packages/server/src/api/controllers/instance.js
View File

@ -19,6 +19,8 @@ exports.create = async function(ctx) {
applicationId: appId,
},
views: {
// view collation information, read before writing any complex views:
// https://docs.couchdb.org/en/master/ddocs/views/collation.html#collation-specification
by_username: {
map: function(doc) {
if (doc.type === "user") {
@ -31,6 +33,22 @@ exports.create = async function(ctx) {
emit([doc.type], doc._id)
}.toString(),
},
by_link: {
map: function(doc) {
if (doc.type === "link") {
let doc1 = doc.doc1
let doc2 = doc.doc2
emit([doc1.modelId, 1, doc1.fieldName, doc1.recordId], {
_id: doc2.recordId,
})
emit([doc2.modelId, 1, doc2.fieldName, doc2.recordId], {
_id: doc1.recordId,
})
emit([doc1.modelId, 2, doc1.recordId], { _id: doc2.recordId })
emit([doc2.modelId, 2, doc2.recordId], { _id: doc1.recordId })
}
}.toString(),
},
by_automation_trigger: {
map: function(doc) {
if (doc.type === "automation") {

3
packages/server/src/api/controllers/model.js
View File

@ -63,9 +63,6 @@ exports.save = async function(ctx) {
name: modelToSave.name,
type: "link",
modelId: modelToSave._id,
constraints: {
type: "array",
},
}
await db.put(linkedModel)
}

73
packages/server/src/db/linkedRecords.js
View File

@ -1,73 +0,0 @@
const CouchDB = require("./index")
const emitter = require("../events/index")
const InMemoryQueue = require("../utilities/queue/inMemoryQueue")
/**
* This functionality makes sure that when records with links are created, updated or deleted they are processed
* correctly - making sure that no stale links are left around and that all links have been made successfully.
*/
const EventType = {
RECORD_SAVE: "record:save",
RECORD_UPDATE: "record:update",
RECORD_DELETE: "record:delete",
MODEL_SAVE: "model:save",
MODEL_DELETE: "model:delete",
}
const linkedRecordQueue = new InMemoryQueue("linkedRecordQueue")
function createEmitterCallback(eventName) {
emitter.on(eventName, function(event) {
if (!event || !event.record || !event.record.modelId) {
return
}
linkedRecordQueue.add({
type: eventName,
event,
})
})
}
for (let typeKey of Object.keys(EventType)) {
createEmitterCallback(EventType[typeKey])
}
function doesModelHaveLinkedRecords(model) {
for (let key of Object.keys(model.schema)) {
const { type } = model.schema[key]
if (type === "link") {
return true
}
}
return false
}
linkedRecordQueue.process(async job => {
let event = job.data
// can't operate without these properties
if (event.instanceId == null || event.modelId == null) {
return
}
const db = new CouchDB(event.instanceId)
let model = event.model == null ? await db.get(event.modelId) : event.model
// model doesn't have links, can stop here
if (!doesModelHaveLinkedRecords(model)) {
return
}
// no linked records to operate on
if (model == null) {
return
}
switch (event.type) {
case EventType.RECORD_SAVE:
break
case EventType.RECORD_UPDATE:
break
case EventType.RECORD_DELETE:
break
case EventType.MODEL_SAVE:
break
case EventType.MODEL_DELETE:
break
}
})

210
packages/server/src/db/linkedRecords/LinkController.js
View File

@ -0,0 +1,210 @@
const CouchDB = require("../index")
const linkedRecords = require("./index")
/**
* Creates a new link document structure which can be put to the database. It is important to
* note that while this talks about linker/linked the link is bi-directional and for all intent
* and purposes it does not matter from which direction the link was initiated.
* @param {string} modelId1 The ID of the first model (the linker).
* @param {string} modelId2 The ID of the second model (the linked).
* @param {string} fieldName1 The name of the field in the linker table.
* @param {string} fieldName2 The name of the field in the linked table.
* @param {string} recordId1 The ID of the record which is acting as the linker.
* @param {string} recordId2 The ID of the record which is acting as the linked.
* @constructor
*/
function LinkDocument(
modelId1,
fieldName1,
recordId1,
modelId2,
fieldName2,
recordId2
) {
this.doc1 = {
modelId: modelId1,
fieldName: fieldName1,
recordId: recordId1,
}
this.doc2 = {
modelId: modelId2,
fieldName: fieldName2,
recordId: recordId2,
}
}
class LinkController {
/**
* Create a new link controller which can be used to handle link updates for an event.
* @param {string} instanceId The instance in which updates will be carried out.
* @param {{modelId: string, model: object|undefined, record: object|undefined}} eventData data about
* what has occurred to drive this update - events are emitted when an operation that matters occurs.
*/
constructor(instanceId, eventData) {
this._instanceId = instanceId
this._db = new CouchDB(instanceId)
this._modelId = eventData.modelId
this._record = eventData.record
this._model = eventData.model
}
/**
* Retrieves the model, if it was not already found in the eventData.
* @returns {Promise<object>} This will return a model based on the event data, either
* if it was in the event already, or it uses the specified modelId to get it.
*/
async model() {
if (this._model == null) {
this._model =
this._model == null ? await this._db.get(this._modelId) : this._model
}
return this._model
}
/**
* Checks if the model this was constructed with has any linking columns currently.
* If the model has not been retrieved this will retrieve it based on the eventData.
* @returns {Promise<boolean>} True if there are any linked fields, otherwise it will return
* false.
*/
async doesModelHaveLinkedFields() {
const model = await this.model()
for (const fieldName of Object.keys(model.schema)) {
const { type } = model.schema[fieldName]
if (type === "link") {
return true
}
}
return false
}
/**
* Utility function for main getLinkDocuments function - refer to it for functionality.
*/
getLinkDocs(fieldName, recordId) {
return linkedRecords.getLinkDocuments({
instanceId: this._instanceId,
modelId: this._modelId,
fieldName,
recordId,
})
}
// all operations here will assume that the model
// this operation is related to has linked records
/**
* When a record is saved this will carry out the necessary operations to make sure
* the link has been created/updated.
* @returns {Promise<null>} The operation has been completed and the link documents should now
* be accurate.
*/
async recordSaved() {
const model = await this.model()
const record = this._record
let operations = []
for (let fieldName of Object.keys(model.schema)) {
const field = model.schema[fieldName]
if (field.type === "link") {
// get link docs to compare against
let currentLinkIds = await this.getLinkDocs(fieldName, record._id).map(
doc => doc._id
)
let toLinkIds = record[fieldName]
for (let linkId of toLinkIds) {
if (currentLinkIds.indexOf(linkId) === -1) {
operations.push(
new LinkDocument(
model._id,
fieldName,
record._id,
field.modelId,
field.fieldName,
linkId
)
)
}
const toDeleteIds = currentLinkIds.filter(
id => toLinkIds.indexOf(id) === -1
)
operations.concat(
toDeleteIds.map(id => ({ _id: id, _deleted: true }))
)
}
}
}
await this._db.bulkDocs(operations)
}
/**
* When a record is deleted this will carry out the necessary operations to make sure
* any links that existed have been removed.
* @returns {Promise<null>} The operation has been completed and the link documents should now
* be accurate.
*/
async recordDeleted() {
const record = this._record
// get link docs to compare against
let toDelete = await this.getLinkDocs(null, record._id).map(doc => {
return {
...doc,
_deleted: true,
}
})
await this._db.bulkDocs(toDelete)
}
/**
* When a model is saved this will carry out the necessary operations to make sure
* any linked models are notified and updated correctly.
* @returns {Promise<null>} The operation has been completed and the link documents should now
* be accurate.
*/
async modelSaved() {
const model = await this.model()
const schema = model.schema
for (const fieldName of Object.keys(schema)) {
const field = schema[fieldName]
if (field.type === "link") {
// create the link field in the other model
const linkedModel = await this._db.get(field.modelId)
linkedModel.schema[field.fieldName] = {
name: model.name,
type: "link",
modelId: model._id,
fieldName: fieldName,
}
await this._db.put(linkedModel)
}
}
}
/**
* When a model is deleted this will carry out the necessary operations to make sure
* any linked models have the joining column correctly removed as well as removing any
* now stale linking documents.
* @returns {Promise<null>} The operation has been completed and the link documents should now
* be accurate.
*/
async modelDeleted() {
const model = await this.model()
const schema = model.schema
for (const fieldName of Object.keys(schema)) {
let field = schema[fieldName]
if (field.type === "link") {
const linkedModel = await this._db.get(field.modelId)
delete linkedModel.schema[model.name]
await this._db.put(linkedModel)
}
}
// get link docs for this model and configure for deletion
let toDelete = await this.getLinkDocs().map(doc => {
return {
...doc,
_deleted: true,
}
})
await this._db.bulkDocs(toDelete)
}
}
module.exports = LinkController

109
packages/server/src/db/linkedRecords/index.js
View File

@ -0,0 +1,109 @@
const emitter = require("../../events")
const InMemoryQueue = require("../../utilities/queue/inMemoryQueue")
const LinkController = require("./LinkController")
const CouchDB = require("../index")
/**
* This functionality makes sure that when records with links are created, updated or deleted they are processed
* correctly - making sure that no stale links are left around and that all links have been made successfully.
*/
const EventType = {
RECORD_SAVE: "record:save",
RECORD_UPDATE: "record:update",
RECORD_DELETE: "record:delete",
MODEL_SAVE: "model:save",
MODEL_DELETE: "model:delete",
}
const linkedRecordQueue = new InMemoryQueue("linkedRecordQueue")
function createEmitterCallback(eventName) {
emitter.on(eventName, function(event) {
if (!event || !event.record || !event.record.modelId) {
return
}
linkedRecordQueue.add({
type: eventName,
event,
})
})
}
for (let typeKey of Object.keys(EventType)) {
createEmitterCallback(EventType[typeKey])
}
linkedRecordQueue.process(async job => {
let data = job.data
// can't operate without these properties
if (data.instanceId == null || data.modelId == null) {
return
}
// link controller exists to help manage state, the operation
// of updating links is a particularly stateful task
let linkController = new LinkController(data.instanceId, data)
// model doesn't have links, can stop here
if (!(await linkController.doesModelHaveLinkedFields())) {
return
}
// carry out the logic at a top level so that we can handle
// multiple operations for a single queue entry if desired
switch (data.type) {
case EventType.RECORD_SAVE:
case EventType.RECORD_UPDATE:
await linkController.recordSaved()
break
case EventType.RECORD_DELETE:
await linkController.recordDeleted()
break
case EventType.MODEL_SAVE:
await linkController.modelSaved()
break
case EventType.MODEL_DELETE:
await linkController.modelDeleted()
break
}
})
/**
* Gets the linking documents, not the linked documents themselves.
* @param {string} instanceId The instance in which we are searching for linked records.
* @param {string} modelId The model which we are searching for linked records against.
* @param {string|null} fieldName The name of column/field which is being altered, only looking for
* linking documents that are related to it. If this is not specified then the table level will be assumed.
* @param {string|null} recordId The ID of the record which we want to find linking documents for -
* if this is not specified then it will assume model or field level depending on whether the
* field name has been specified.
* @param {boolean|null} includeDoc whether to include docs in the response call, this is considerably slower so only
* use this if actually interested in the docs themselves.
* @returns {Promise<object[]>} This will return an array of the linking documents that were found
* (if any).
*/
module.exports.getLinkDocuments = async ({
instanceId,
modelId,
fieldName,
recordId,
includeDoc,
}) => {
const db = new CouchDB(instanceId)
let params
if (fieldName != null && recordId != null) {
params = { key: [modelId, 1, fieldName, recordId] }
} else if (fieldName != null && recordId == null) {
params = {
startKey: [modelId, 1, fieldName],
endKey: [modelId, 1, fieldName, {}],
}
} else if (fieldName == null && recordId != null) {
params = { key: [modelId, 2, recordId] }
}
// only model is known
else {
params = { startKey: [modelId, 1], endKey: [modelId, 1, {}] }
}
params.include_docs = !!includeDoc
const response = await db.query("database/by_link", params)
return response.rows.map(row => row.doc)
}
Write Preview
Loading…
Cancel
Save