mikser-io 6.15.0 → 6.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mikser-io",
-	"version": "6.15.0",
+	"version": "6.17.0",
 	"description": "<p align=\"center\">   <img src=\"mikser-lockup-stacked.svg\" alt=\"mikser\" width=\"198\" /> </p>",
 	"main": "index.js",
 	"scripts": {

package/src/plugins/data.js

@@ -36,9 +36,18 @@ export default ({
             }
         }
         for (let entitiesName in entitiesConfig) {
+            // Per-config namespacing token. When set, this entity-writer's
+            // files land under <dataFolder>/<token>/ instead of straight
+            // in <dataFolder>. Each named entity config can declare its
+            // own token, so they can target different namespaces (useful
+            // for multi-tenant exports into shared storage).
+            const token = entitiesConfig[entitiesName].token
+            const targetFolder = token
+                ? path.join(runtime.options.dataFolder, token)
+                : runtime.options.dataFolder
             const {
                 query,
-                map,
+                map: mapEntity = entity => entity,
                 pick,
                 save: saveEntity = async entity => {
                     if (!entity.name) {
@@ -46,12 +55,12 @@ export default ({
                         return
                     }
                     const dump = JSON.stringify(normalize(entity))
-                    const entityFile = path.join(runtime.options.dataFolder, `${entity.name}.${entitiesName}.json`)
+                    const entityFile = path.join(targetFolder, `${entity.name}.${entitiesName}.json`)
                     await mkdir(path.dirname(entityFile), { recursive: true })
                     await writeFile(entityFile, dump, 'utf8')
                 },
                 delete: deleteEntity = async entity => {
-                    const entityFile = path.join(runtime.options.dataFolder, `${entity.name}.json`)
+                    const entityFile = path.join(targetFolder, `${entity.name}.json`)
                     await unlink(entityFile)
                 }
             } = entitiesConfig[entitiesName]
@@ -62,12 +71,12 @@ export default ({
                         case OPERATION.CREATE:
                         case OPERATION.UPDATE:
                             logger.debug('Data export entity %s %s: %s', entity.collection, operation, entity.id)
-                            await saveEntity(map ? await map(entity) : {
+                            await saveEntity(({
                                 refId: ('/' + entity.name.replaceAll('\\', '/')).replace(/\/index$/g, '/'),
                                 name: entity.name,
                                 date: new Date(entity.time),
-                                data: _.pick(entity, pick || ['collection', 'format', 'type', 'destination', 'stamp', 'meta', 'id',])
-                            })
+                                data: _.pick(await mapEntity(entity), pick || ['collection', 'format', 'type', 'destination', 'stamp', 'meta', 'id',])
+                            }))
                             break
                         case OPERATION.DELETE:
                             await deleteEntity(entity)
@@ -90,14 +99,19 @@ export default ({
             }
         }
         for (let contextName in contextConfig) {
+            // Per-config namespacing token — see the entities loop above.
+            const token = contextConfig[contextName].token
+            const targetFolder = token
+                ? path.join(runtime.options.dataFolder, token)
+                : runtime.options.dataFolder
             const {
                 query,
-                map,
+                map: mapEntityContext = (entity, context) => context,
                 pick,
                 save: saveConext = async (entity, context) => {
                     if (context?.data) {
                         const entityName = entity.name
-                        const contextFile = path.join(runtime.options.dataFolder, `${entityName}.${contextName}.json`)
+                        const contextFile = path.join(targetFolder, `${entityName}.${contextName}.json`)
                         await mkdir(path.dirname(contextFile), { recursive: true })
                         await writeFile(contextFile, JSON.stringify(context), 'utf8')
                     }
@@ -107,7 +121,7 @@ export default ({
             for await (let { entity, context } of useJournal('Data context', [OPERATION.RENDER])) {
                 if (query(entity)) {
                     logger.debug('Data export context: %s', entity.name)
-                    await saveConext(entity, map ? await map(entity, context) : _.pick(context, pick || ['data']))
+                    await saveConext(entity, _.pick(await mapEntityContext(entity, context), pick || ['data']))
                 }
             }
         }
@@ -116,23 +130,29 @@ export default ({
     onFinalize(async () => {
         const logger = useLogger()
         for (let catalogName in runtime.config.data?.catalog || {}) {
+            // Per-config namespacing token — see the entities loop above.
+            const token = runtime.config.data?.catalog[catalogName].token
+            const targetFolder = token
+                ? path.join(runtime.options.dataFolder, token)
+                : runtime.options.dataFolder
             const {
                 query: queryEntities = entity => entity.type == 'document',
-                map,
+                map: mapEntity = entity => entity,
                 pick,
                 save: saveEntities = async entities => {
-                    const entitiesFile = path.join(runtime.options.dataFolder, `${catalogName}.json`)
+                    const entitiesFile = path.join(targetFolder, `${catalogName}.json`)
+                    await mkdir(path.dirname(entitiesFile), { recursive: true })
                     logger.debug('Data export catalog %s %s: %s', catalogName, entities.length, entitiesFile)
                     await writeFile(entitiesFile, JSON.stringify(entities), 'utf8')
                 }
             } = runtime.config.data?.catalog[catalogName]
             const entities = await findEntities(queryEntities)
-            await saveEntities(await pMap(entities, async entity => map ? await map(entity) : {
+            await saveEntities(await pMap(entities, async entity => ({
                 refId: ('/' + entity.name.replaceAll('\\', '/')).replace(/\/index$/g, '/'),
                 name: entity.name,
                 date: new Date(entity.time),
-                data: _.pick(entity, pick || ['collection', 'format', 'type', 'destination', 'stamp', 'meta', 'id',])
-            }))
+                data: _.pick(await mapEntity(entity), pick || ['collection', 'format', 'type', 'destination', 'stamp', 'meta', 'id',])
+            })))
         }
     })
 }

package/src/plugins/resources.js

@@ -24,6 +24,7 @@ export default ({
     trackProgress,
     updateProgress,
     updateEntry,
+    matchEntity,
     constants: { OPERATION },
 }) => {
     const collection = 'resources'
@@ -65,8 +66,7 @@ export default ({
                 _.eachDeep(entity.meta, resource => {
                     if (typeof resource == 'string') {
                         for (let library in resourceLib) {
-                            const match = new RegExp(library)
-                            if (resource.match(match)) {
+                            if (matchEntity(resource, library)) {
                                 resourceMap[entity.id].push({ library, resource, entity })
                             }
                         }

package/src/utils.js

@@ -49,9 +49,9 @@ export function matchEntity(entity, match) {
     if (typeof match == 'function') return match(entity)
     else if (typeof match == 'string') {
         if (match.substring(0, 2) == '@/') {
-            return minimatch(entity.name, match.substring(2))
+            return minimatch(typeof entity == 'string' ? entity : entity.name, match.substring(2))
         } else {
-            return minimatch(entity.id, match)
+            return minimatch(typeof entity == 'string' ? entity : entity.id, match)
         }
     }
     else if (typeof match == 'object') return _.isMatch(entity, match)