|
|
|
const _ = require('lodash')
|
|
|
|
const graphHelper = require('../../helpers/graph')
|
|
|
|
const { v4: uuid } = require('uuid')
|
|
|
|
|
|
|
|
module.exports = {
|
|
|
|
Query: {
|
|
|
|
async storageTargets (obj, args, context, info) {
|
|
|
|
const dbTargets = await WIKI.db.storage.getTargets({ siteId: args.siteId })
|
|
|
|
// targets = _.sortBy(targets.map(tgt => {
|
|
|
|
// const targetInfo = _.find(WIKI.data.storage, ['module', tgt.key]) || {}
|
|
|
|
// return {
|
|
|
|
// ...targetInfo,
|
|
|
|
// ...tgt,
|
|
|
|
// hasSchedule: (targetInfo.schedule !== false),
|
|
|
|
// syncInterval: targetInfo.syncInterval || targetInfo.schedule || 'P0D',
|
|
|
|
// syncIntervalDefault: targetInfo.schedule,
|
|
|
|
// config: _.sortBy(_.transform(tgt.config, (res, value, key) => {
|
|
|
|
// const configData = _.get(targetInfo.props, key, false)
|
|
|
|
// if (configData) {
|
|
|
|
// res.push({
|
|
|
|
// key,
|
|
|
|
// value: JSON.stringify({
|
|
|
|
// ...configData,
|
|
|
|
// value: (configData.sensitive && value.length > 0) ? '********' : value
|
|
|
|
// })
|
|
|
|
// })
|
|
|
|
// }
|
|
|
|
// }, []), 'key')
|
|
|
|
// }
|
|
|
|
// }), ['title', 'key'])
|
|
|
|
return _.sortBy(WIKI.storage.defs.map(md => {
|
|
|
|
const dbTarget = dbTargets.find(tg => tg.module === md.key)
|
|
|
|
return {
|
|
|
|
id: dbTarget?.id ?? uuid(),
|
|
|
|
isEnabled: dbTarget?.isEnabled ?? false,
|
|
|
|
module: md.key,
|
|
|
|
title: md.title,
|
|
|
|
description: md.description,
|
|
|
|
icon: md.icon,
|
|
|
|
banner: md.banner,
|
|
|
|
vendor: md.vendor,
|
|
|
|
website: md.website,
|
|
|
|
contentTypes: {
|
|
|
|
activeTypes: dbTarget?.contentTypes?.activeTypes ?? md.contentTypes.defaultTypesEnabled,
|
|
|
|
largeThreshold: dbTarget?.contentTypes?.largeThreshold ?? md.contentTypes.defaultLargeThreshold
|
|
|
|
},
|
|
|
|
assetDelivery: {
|
|
|
|
isStreamingSupported: md?.assetDelivery?.isStreamingSupported ?? false,
|
|
|
|
isDirectAccessSupported: md?.assetDelivery?.isDirectAccessSupported ?? false,
|
|
|
|
streaming: dbTarget?.assetDelivery?.streaming ?? md?.assetDelivery?.defaultStreamingEnabled ?? false,
|
|
|
|
directAccess: dbTarget?.assetDelivery?.directAccess ?? md?.assetDelivery?.defaultDirectAccessEnabled ?? false
|
|
|
|
},
|
|
|
|
versioning: {
|
|
|
|
isSupported: md?.versioning?.isSupported ?? false,
|
|
|
|
isForceEnabled: md?.versioning?.isForceEnabled ?? false,
|
|
|
|
enabled: dbTarget?.versioning?.enabled ?? md?.versioning?.defaultEnabled ?? false
|
|
|
|
},
|
|
|
|
sync: {},
|
|
|
|
status: {},
|
|
|
|
setup: {
|
|
|
|
handler: md?.setup?.handler,
|
|
|
|
state: dbTarget?.state?.setup ?? 'notconfigured',
|
|
|
|
values: md.setup?.handler ?
|
|
|
|
_.transform(md.setup.defaultValues,
|
|
|
|
(r, v, k) => {
|
|
|
|
r[k] = dbTarget?.config?.[k] ?? v
|
|
|
|
}, {}) :
|
|
|
|
{}
|
|
|
|
},
|
|
|
|
config: _.transform(md.props, (r, v, k) => {
|
|
|
|
const cfValue = dbTarget?.config?.[k] ?? v.default
|
|
|
|
r[k] = {
|
|
|
|
...v,
|
|
|
|
value: v.sensitive && cfValue ? '********' : cfValue,
|
|
|
|
...v.enum && {
|
|
|
|
enum: v.enum.map(o => {
|
|
|
|
if (o.indexOf('|') > 0) {
|
|
|
|
const oParsed = o.split('|')
|
|
|
|
return {
|
|
|
|
value: oParsed[0],
|
|
|
|
label: oParsed[1]
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return {
|
|
|
|
value: o,
|
|
|
|
label: o
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {}),
|
|
|
|
actions: md.actions
|
|
|
|
}
|
|
|
|
}), ['title'])
|
|
|
|
}
|
|
|
|
},
|
|
|
|
Mutation: {
|
|
|
|
async updateStorageTargets (obj, args, context) {
|
|
|
|
WIKI.logger.debug(`Updating storage targets for site ${args.siteId}...`)
|
|
|
|
try {
|
|
|
|
const dbTargets = await WIKI.db.storage.getTargets({ siteId: args.siteId })
|
|
|
|
for (const tgt of args.targets) {
|
|
|
|
const md = _.find(WIKI.storage.defs, ['key', tgt.module])
|
|
|
|
if (!md) {
|
|
|
|
throw new Error('Invalid module key for non-existent storage target.')
|
|
|
|
}
|
|
|
|
|
|
|
|
const dbTarget = _.find(dbTargets, ['id', tgt.id])
|
|
|
|
|
|
|
|
// -> Build update config object
|
|
|
|
const updatedConfig = dbTarget?.config ?? {}
|
|
|
|
if (tgt.config) {
|
|
|
|
for (const [key, prop] of Object.entries(md.props)) {
|
|
|
|
if (prop.readOnly) { continue }
|
|
|
|
if (!Object.prototype.hasOwnProperty.call(tgt.config, key)) { continue }
|
|
|
|
if (prop.sensitive && tgt.config[key] === '********') { continue }
|
|
|
|
updatedConfig[key] = tgt.config[key]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// -> Target doesn't exist yet in the DB, let's create it
|
|
|
|
if (!dbTarget) {
|
|
|
|
WIKI.logger.debug(`No existing DB configuration for module ${tgt.module}. Creating a new one...`)
|
|
|
|
await WIKI.db.storage.query().insert({
|
|
|
|
id: tgt.id,
|
|
|
|
module: tgt.module,
|
|
|
|
siteId: args.siteId,
|
|
|
|
isEnabled: tgt.isEnabled ?? false,
|
|
|
|
contentTypes: {
|
|
|
|
activeTypes: tgt.contentTypes ?? md.contentTypes.defaultTypesEnabled ?? [],
|
|
|
|
largeThreshold: tgt.largeThreshold ?? md.contentTypes.defaultLargeThreshold ?? '5MB'
|
|
|
|
},
|
|
|
|
assetDelivery: {
|
|
|
|
streaming: tgt.assetDeliveryFileStreaming ?? md?.assetDelivery?.defaultStreamingEnabled ?? false,
|
|
|
|
directAccess: tgt.assetDeliveryDirectAccess ?? md?.assetDelivery?.defaultDirectAccessEnabled ?? false
|
|
|
|
},
|
|
|
|
versioning: {
|
|
|
|
enabled: tgt.useVersioning ?? md?.versioning?.defaultEnabled ?? false
|
|
|
|
},
|
|
|
|
state: {
|
|
|
|
current: 'ok'
|
|
|
|
},
|
|
|
|
config: updatedConfig
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
WIKI.logger.debug(`Updating DB configuration for module ${tgt.module}...`)
|
|
|
|
await WIKI.db.storage.query().patch({
|
|
|
|
isEnabled: tgt.isEnabled ?? dbTarget.isEnabled ?? false,
|
|
|
|
contentTypes: {
|
|
|
|
activeTypes: tgt.contentTypes ?? dbTarget?.contentTypes?.activeTypes ?? [],
|
|
|
|
largeThreshold: tgt.largeThreshold ?? dbTarget?.contentTypes?.largeThreshold ?? '5MB'
|
|
|
|
},
|
|
|
|
assetDelivery: {
|
|
|
|
streaming: tgt.assetDeliveryFileStreaming ?? dbTarget?.assetDelivery?.streaming ?? false,
|
|
|
|
directAccess: tgt.assetDeliveryDirectAccess ?? dbTarget?.assetDelivery?.directAccess ?? false
|
|
|
|
},
|
|
|
|
versioning: {
|
|
|
|
enabled: tgt.useVersioning ?? dbTarget?.versioning?.enabled ?? false
|
|
|
|
},
|
|
|
|
config: updatedConfig
|
|
|
|
}).where('id', tgt.id)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// await WIKI.db.storage.initTargets()
|
|
|
|
return {
|
|
|
|
status: graphHelper.generateSuccess('Storage targets updated successfully')
|
|
|
|
}
|
|
|
|
} catch (err) {
|
|
|
|
return graphHelper.generateError(err)
|
|
|
|
}
|
|
|
|
},
|
|
|
|
async setupStorageTarget (obj, args, context) {
|
|
|
|
try {
|
|
|
|
const tgt = await WIKI.db.storage.query().findById(args.targetId)
|
|
|
|
if (!tgt) {
|
|
|
|
throw new Error('Not storage target matching this ID')
|
|
|
|
}
|
|
|
|
const md = _.find(WIKI.storage.defs, ['key', tgt.module])
|
|
|
|
if (!md) {
|
|
|
|
throw new Error('No matching storage module installed.')
|
|
|
|
}
|
|
|
|
if (!await WIKI.db.storage.ensureModule(md.key)) {
|
|
|
|
throw new Error('Failed to load storage module. Check logs for details.')
|
|
|
|
}
|
|
|
|
const result = await WIKI.storage.modules[md.key].setup(args.targetId, args.state)
|
|
|
|
|
|
|
|
return {
|
|
|
|
status: graphHelper.generateSuccess('Storage target setup step succeeded'),
|
|
|
|
state: result
|
|
|
|
}
|
|
|
|
} catch (err) {
|
|
|
|
return graphHelper.generateError(err)
|
|
|
|
}
|
|
|
|
},
|
|
|
|
async destroyStorageTargetSetup (obj, args, context) {
|
|
|
|
try {
|
|
|
|
const tgt = await WIKI.db.storage.query().findById(args.targetId)
|
|
|
|
if (!tgt) {
|
|
|
|
throw new Error('Not storage target matching this ID')
|
|
|
|
}
|
|
|
|
const md = _.find(WIKI.storage.defs, ['key', tgt.module])
|
|
|
|
if (!md) {
|
|
|
|
throw new Error('No matching storage module installed.')
|
|
|
|
}
|
|
|
|
if (!await WIKI.db.storage.ensureModule(md.key)) {
|
|
|
|
throw new Error('Failed to load storage module. Check logs for details.')
|
|
|
|
}
|
|
|
|
await WIKI.storage.modules[md.key].setupDestroy(args.targetId)
|
|
|
|
|
|
|
|
return {
|
|
|
|
status: graphHelper.generateSuccess('Storage target setup configuration destroyed succesfully.')
|
|
|
|
}
|
|
|
|
} catch (err) {
|
|
|
|
return graphHelper.generateError(err)
|
|
|
|
}
|
|
|
|
},
|
|
|
|
async executeStorageAction (obj, args, context) {
|
|
|
|
try {
|
|
|
|
await WIKI.db.storage.executeAction(args.targetKey, args.handler)
|
|
|
|
return {
|
|
|
|
status: graphHelper.generateSuccess('Action completed.')
|
|
|
|
}
|
|
|
|
} catch (err) {
|
|
|
|
return graphHelper.generateError(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|