@notifiles/sdk 1.1.0 → 1.1.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@notifiles/sdk",
   "type": "module",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "",
   "author": {
     "name": "adoucoure",
@@ -116,6 +116,7 @@
     "twitter": "^1.7.1",
     "underscore": "^1.13.6",
     "unified": "^11.0.4",
+    "walk": "^2.3.15",
     "yaml": "^2.4.2"
   },
   "devDependencies": {

package/src/lib/cloudLibrary/minio/index.js

@@ -1,4 +1,6 @@
 export { default as isValid } from './isValid.js'
 export { default as upload } from './upload.js'
+export { default as syncFolder } from './syncFolder.js'
 export { default as remove } from './remove.js'
+export { default as previewRemoteUrl } from './previewRemoteUrl.js'
 // export { default as uploadFolder } from './uploadFolder.js'

package/src/lib/cloudLibrary/minio/previewRemoteUrl.js

@@ -0,0 +1,20 @@
+export default async ({
+  filename,
+  auth,
+  // contentType = 'image/png'
+}) => {
+
+  try {
+    const {
+      endPoint,
+      bucketName
+    } = auth
+
+    const url = `https://${endPoint}/${bucketName}/${filename}`
+    return { url }
+
+  } catch (e) {
+    console.error(e)
+  }
+  return null
+}

package/src/lib/cloudLibrary/minio/syncFolder.js

@@ -0,0 +1,72 @@
+import * as Minio from 'minio'
+import { walk } from 'walk'
+
+export default async ({
+  sourceUrl,
+  destinationPath,
+  auth,
+  // contentType = 'image/png'
+}) => {
+
+  try {
+    const {
+      endPoint,
+      accessKey,
+      secretKey,
+      bucketName
+    } = auth
+
+    const minioClient = new Minio.Client({
+      endPoint,
+      // port,
+      // useSSL,
+      accessKey,
+      secretKey,
+    })
+
+    const exists = await minioClient.bucketExists(bucketName)
+    if (!exists) {
+      return null
+      // await minioClient.makeBucket(bucketName, 'us-east-1')
+      // console.log('Bucket ' + bucketName + ' created in "us-east-1".')
+    }
+
+    const metaData = {
+      // 'Content-Type': contentType,
+    }
+
+    const walker = walk(sourceUrl)
+    const result = await new Promise((resolve, reject) => {
+      walker.on('file', (root, fileStats, next) => {
+        const filePath = `${root}/${fileStats.name}`
+        const postSourceURl = root.split(sourceUrl)[1]
+        let destination = `${destinationPath}/${postSourceURl}/${fileStats.name}`
+        destination = destination.replaceAll('//', '/')
+        console.log('Upload', filePath)
+
+        minioClient.fPutObject(
+          bucketName,
+          destination,
+          filePath,
+          err => {
+            console.log(filePath, 'uploaded')
+            if (err) {
+              console.error(err)
+              reject(err)
+            }
+            next()
+          })
+      })
+
+      walker.on('end', function () {
+        console.log('End upload')
+        resolve()
+      })
+    })
+
+    return {}
+  } catch (e) {
+    console.error(e)
+  }
+  return null
+}

package/src/lib/fs/dirFilesRescursivePure.js

@@ -0,0 +1,21 @@
+import fs from 'fs';
+import path from 'path';
+
+const walk = async (dir, filelist = []) => {
+  const files = await fs.promises.readdir(dir);
+
+  for (file of files) {
+    const filepath = path.join(dir, file)
+    const stat = await fs.promises.stat(filepath)
+
+    if (stat.isDirectory()) {
+      filelist = await walk(filepath, filelist)
+    } else {
+      filelist.push(file)
+    }
+  }
+
+  return filelist;
+}
+
+export default walk

package/src/template/attach/entry.js

@@ -0,0 +1,22 @@
+import adaptSettings from '../../lib/adaptSettings.js'
+import performEmail from './lib/email.js'
+import performTextMessage from './lib/textMessage.js'
+import performPushNotification from './lib/pushNotification.js'
+
+export default async ({
+  entry,
+  settings,
+}) => {
+  adaptSettings({ settings })
+  return {
+    entry: {
+      ...entry,
+      versions: await Promise.all(entry.versions.map(async _entry => {
+        let res = await performEmail({ entry: _entry, settings, })
+        res = await performTextMessage({ entry: res.entry, settings, })
+        res = await performPushNotification({ entry: res.entry, settings, })
+        return res.entry
+      }))
+    }
+  }
+}

package/src/template/attach/index.js

@@ -0,0 +1,2 @@
+export { default as processEntry } from './entry.js'
+export { default as processPath } from './path.js'

package/src/template/attach/lib/email.js

@@ -0,0 +1,59 @@
+import fs from 'fs'
+import checkFileExists from '../../../lib/fs/checkFileExists.js'
+import fsPath from 'path'
+
+export default async (props) => {
+  const { entry, settings } = props
+  const {
+    path,
+    buildPaths,
+    code,
+  } = entry
+
+  const sharedItemsPath = `${path}/attachments`
+  let sharedItems = await fs.promises.readdir(sharedItemsPath)
+  let items = (await Promise.all(sharedItems.map(async item => {
+    const folderPath = fsPath.join(sharedItemsPath, item)
+    const folderPathStat = await fs.promises.stat(folderPath)
+    if (!folderPathStat) {
+      return null
+    }
+
+    const isDir = folderPathStat.isDirectory()
+    if (isDir) {
+      return null
+    }
+    return {
+      fileName: item,
+      path: `${sharedItemsPath}/${item}`
+    }
+  }))).filter(a => a)
+
+  const codeOwnItemsPath = `${path}/attachments/${entry.code}`
+
+  if ((await checkFileExists(codeOwnItemsPath))) {
+    let codeOwnItems = await fs.promises.readdir(codeOwnItemsPath)
+    items = [
+      ...items,
+      ...(codeOwnItems.map(fileName => ({
+        fileName,
+        path: `${codeOwnItemsPath}/${fileName}`
+      })))
+    ]
+  }
+
+  if (!items) {
+    return { entry }
+  }
+
+  await Promise.all(items.map(async ({ fileName, path: filePath }) => {
+    return fs.promises.cp(
+      filePath,
+      `${path}/.build/email/${code}/attachments/${fileName}`,
+    )
+  }))
+
+  return {
+    entry
+  }
+}

package/src/template/attach/lib/pushNotification.js

@@ -0,0 +1,9 @@
+
+export default async (props) => {
+
+  const { entry } = props
+
+  return {
+    entry
+  }
+}

package/src/template/attach/lib/textMessage.js

@@ -0,0 +1,9 @@
+
+export default async (props) => {
+
+  const { entry } = props
+
+  return {
+    entry
+  }
+}

package/src/template/attach/path.js

@@ -0,0 +1,20 @@
+import perform from './lib/perform.js'
+import getEntries from '../../lib/entries/getAtPath.js'
+import adaptSettings from '../../lib/adaptSettings.js'
+
+export default async ({
+  path,
+  settings
+}) => {
+  adaptSettings({ settings })
+  let entries = await getEntries({
+    path,
+  })
+
+  for (var i in entries) {
+    const entry = entries[i]
+    await perform({ entry, settings })
+  }
+
+  return true
+}

package/src/template/attach/path.test.js

@@ -0,0 +1,24 @@
+
+describe.skip('cloudify', () => {
+  it('cloudifies to minio', async () => {
+    const fsPath = (await import('path')).default
+    let path = fsPath.resolve(process.env.TEST_MOCK_FOLDER)
+    const operation = (await import('./path.js')).default
+
+    const result = await operation({
+      settings: {
+        clouds: [{
+          id: "minio",
+          auth: {
+            endPoint: process.env.TEST_MINIO_ENDPOINT,
+            accessKey: process.env.TEST_MINIO_ACCESS_KEY,
+            secretKey: process.env.TEST_MINIO_SECRET,
+            bucketName: process.env.TEST_MINIO_BUCKET_NAME
+          }
+        }]
+      },
+      path,
+    })
+    expect(result).toBeTruthy()
+  })
+})

package/src/template/cloudify/lib/email/image/index.js

@@ -16,27 +16,28 @@ export default async ({ child,
     src: _url,
   } } = child
 
-
+  //#region CACHE
   let _activity = await getActivity({ path })
-  if (!settings.forceUploadAssets) {
-    const codeActivity = _activity[entry.code]
-    if (codeActivity) {
-      const files = codeActivity.files
-      if (files && files[_url]) {
-        const cache = files[_url]
-        return {
-          ...child,
-          properties: {
-            ...child.properties,
-            src: cache.url
-          }
-        }
-      }
-    }
-  }
+  // if (!settings.forceUploadAssets) {
+  //   const codeActivity = _activity[entry.code]
+  //   if (codeActivity) {
+  //     const files = codeActivity.files
+  //     if (files && files[_url]) {
+  //       const cache = files[_url]
+  //       return {
+  //         ...child,
+  //         properties: {
+  //           ...child.properties,
+  //           src: cache.url
+  //         }
+  //       }
+  //     }
+  //   }
+  // }
+  //#endregion
 
   let result
-  const destination = `${path}/.assets`
+  const destination = buildPaths.email.assetsContainer
   if (isLocal(_url)) {
     result = await treatLocalFile({ url: _url, path, destination })
   }
@@ -53,7 +54,7 @@ export default async ({ child,
     uploadResult = await upload({
       id: cloud.id,
       sourceUrl,
-      filename: `${buildPaths.email.assetsContainer}/${filename}`,
+      filename: `${buildPaths.email.assetsContainerRemote}/${filename}`,
       auth: cloud.auth,
       settings
     })

package/src/template/cloudify/lib/email/index.js

@@ -1,7 +1,6 @@
 import hastToHtml from '../../../../lib/remark/hastToHtml.js'
-import treatAttachments from './attachments/index.js'
 import treatImage from './image/index.js'
-
+import fs from 'fs'
 
 export default async (props) => {
   const { entry, settings } = props
@@ -15,17 +14,12 @@ export default async (props) => {
     buildPaths
   })
 
-  await treatAttachments({
-    path,
-    settings,
-    buildPaths,
-    entry
-  })
-
-  // let md = await mdastToMarkdown({ mdast })
   let body = hastToHtml({ data: _hast })
-  // await fs.promises.writeFile(`${path}/.build/html/email.cloud.html`, html)
 
+  await fs.promises.writeFile(
+    buildPaths.email.body,
+    body
+  )
 
   return {
     entry: {

package/src/template/consolidate/lib/email.js

@@ -1,22 +1,27 @@
 import hastToHtml from '../../../lib/remark/hastToHtml.js';
 import treatImage from './image/index.js';
 import ensureDirectoryExists from '../../../lib/fs/ensureDirectoryExists.js';
+import fs from 'fs';
 
 export default async (props) => {
   const { entry } = props
-  const { path, email: { hast } } = entry
+  const { path, email: { hast }, buildPaths } = entry
 
-  const destination = `${path}/.assets`
-  await ensureDirectoryExists(destination, false)
 
   const _hast = await perform({
     child: hast,
     path,
+    buildPaths
 
   })
 
   let body = hastToHtml({ data: _hast })
 
+  await fs.promises.writeFile(
+    buildPaths.email.body,
+    body
+  )
+
   return {
     entry: {
       ...entry,
@@ -30,7 +35,7 @@ export default async (props) => {
 }
 
 const perform = async (props) => {
-  const { child, path } = props
+  const { child, path, buildPaths } = props
   let _child = { ...child }
 
   if (child.properties && child.properties.dataNotifilesDoNotConsolidate) {
@@ -41,7 +46,8 @@ const perform = async (props) => {
     case 'img': {
       _child = await treatImage({
         child: _child,
-        path
+        path,
+        buildPaths
       })
     } break
     default:

package/src/template/consolidate/lib/image/index.js

@@ -1,15 +1,17 @@
 import isLocal from 'is-local'
 import treatLocalFile from './treatLocalFile.js'
 import treatRemoteFile from './treatRemoteFile.js'
+import ensureDirectoryExists from '../../../../lib/fs/ensureDirectoryExists.js'
 
 export default async ({ child,
-  path, entry }) => {
+  path, buildPaths }) => {
   const { properties: {
     src: url,
   } } = child
 
   let result
-  const destination = `${path}/.assets`
+  const destination = buildPaths.email.assetsContainer
+  await ensureDirectoryExists(destination)
 
   if (isLocal(url)) {
     if (url.indexOf(destination) !== 0) {
@@ -23,7 +25,8 @@ export default async ({ child,
   }
 
   let filename = result.filename
-  const newUrl = `.assets/${filename}`
+  // const newUrl = `.assets/${filename}`
+  const newUrl = result.path
   return {
     ...child,
     properties: {

package/src/template/consolidate/lib/image/treatLocalFile.js

@@ -10,5 +10,6 @@ export default async ({
   await fs.promises.cp(sourceUrl, _destination)
   return {
     filename,
+    path: _destination
   }
 }

package/src/template/consolidate/lib/image/treatRemoteFile.js

@@ -16,7 +16,8 @@ export default async ({ url,
     const filename = fsPath.basename(item.filename)
 
     return {
-      filename
+      filename,
+      path: `${destination}/${filename}`
     }
   }
   catch (e) {

package/src/template/format/entry.js

@@ -22,30 +22,36 @@ export default async ({
       buildPaths: {
         email: {
           container: `${path}/.build/email/${code}`,
+          containerRemote: `${entry.slug}/email/${code}`,
           body: `${path}/.build/email/${code}/body.html`,
           bodyFileName: `${entry.slug}/email/${code}/body.html`,
           text: `${path}/.build/email/${code}/text.txt`,
           textFileName: `${entry.slug}/email/${code}/text.txt`,
           subject: `${path}/.build/email/${code}/subject.txt`,
           subjectFileName: `${entry.slug}/email/${code}/subject.txt`,
-          assetsContainer: `${entry.slug}/email/${code}/assets`,
+          assetsContainer: `${path}/.build/email/${code}/assets`,
+          assetsContainerRemote: `${entry.slug}/email/${code}/assets`,
           attachmentsContainer: `${entry.slug}/email/${code}/attachments`,
           manifestFileNameBuilt: `${path}/.build/email/${code}/manifest.json`,
           manifestFileName: `${entry.slug}/email/${code}/manifest.json`,
         },
         textMessage: {
           container: `${path}/.build/textmessage/${code}`,
+          containerRemote: `${entry.slug}/textmessage/${code}`,
           text: `${path}/.build/textmessage/${code}/textmessage.txt`,
           textFileName: `${entry.slug}/textmessage/${code}/textmessage.txt`,
-          assetsContainer: `${entry.slug}/textmessage/${code}/assets`,
+          assetsContainer: `${path}/.build/textmessage/${code}/assets`,
+          assetsContainerRemote: `${entry.slug}/textmessage/${code}/assets`,
           manifestFileNameBuilt: `${path}/.build/textmessage/${code}/manifest.json`,
           manifestFileName: `${entry.slug}/textmessage/${code}/manifest.json`,
         },
         pushNotification: {
           container: `${path}/.build/pushnotification/${code}`,
+          containerRemote: `${entry.slug}/pushnotification/${code}`,
           text: `${path}/.build/pushnotification/${code}/pushnotification.txt`,
           textFileName: `${entry.slug}/pushnotification/${code}/pushnotification.txt`,
-          assetsContainer: `${entry.slug}/pushnotification/${code}/assets`,
+          assetsContainer: `${path}/.build/pushnotification/${code}/assets`,
+          assetsContainerRemote: `${entry.slug}/pushnotification/${code}/assets`,
           manifestFileNameBuilt: `${path}/.build/pushnotification/${code}/manifest.json`,
           manifestFileName: `${entry.slug}/pushnotification/${code}/manifest.json`,
         },

package/src/template/optimize/lib/email.js

@@ -1,17 +1,24 @@
 import hastToHtml from '../../../lib/remark/hastToHtml.js'
 import treatImage from './image/index.js'
+import fs from 'fs'
 
 export default async (props) => {
   const { entry } = props
-  const { path, email: { hast } } = entry
+  const { path, email: { hast }, buildPaths } = entry
 
   let _hast = await perform({
     child: hast,
-    path
+    path,
+    buildPaths
   })
 
   let body = hastToHtml({ data: _hast })
 
+  await fs.promises.writeFile(
+    buildPaths.email.body,
+    body
+  )
+
   return {
     entry: {
       ...entry,
@@ -25,7 +32,7 @@ export default async (props) => {
 }
 
 const perform = async (props) => {
-  const { child, path } = props
+  const { child, path, buildPaths } = props
   let _child = { ...child }
 
   if (child.properties && _child.properties.dataNotifilesDoNotOptimize) {
@@ -36,7 +43,8 @@ const perform = async (props) => {
     case 'img': {
       _child = await treatImage({
         child: _child,
-        path
+        path,
+        buildPaths
       })
     } break
     default:

package/src/template/optimize/lib/image/index.js

@@ -2,9 +2,10 @@ import fsPath from 'path'
 import isLocal from 'is-local'
 import isRelative from 'is-relative'
 import sharp from 'sharp'
+import fs from 'fs'
 
 export default async ({ child,
-  path, }) => {
+  path, buildPaths }) => {
   const { properties: {
     src: url,
   } } = child
@@ -22,14 +23,17 @@ export default async ({ child,
     default: break
   }
 
-  const filename = `_${fsPath.parse(sourceUrl).name}.webp`
-  const destination = `${path}/.assets/${filename}`
+  const filename = `${fsPath.parse(sourceUrl).name}_optimized.webp`
+  const destination = `${buildPaths.email.assetsContainer}/${filename}`
 
   await sharp(sourceUrl)
     .webp({ quality: 90 })
     .toFile(destination)
 
-  const newUrl = `.assets/${filename}`
+  await fs.promises.rm(sourceUrl)
+
+  // const newUrl = `assets/${filename}`
+  const newUrl = destination
   return {
     ...child,
     properties: {

package/src/template/sync/lib/email.js

@@ -1,4 +1,4 @@
-import upload from './upload.js'
+import syncFolder from './syncFolder.js'
 import fs from 'fs'
 import updateActivity from '../../lib/activity/updateToFile.js'
 import getActivity from '../../lib/activity/get.js'
@@ -10,10 +10,10 @@ export default async (props) => {
   const { path, email, buildPaths, } = entry
   const { body, } = email
 
-  await fs.promises.writeFile(
-    buildPaths.email.body,
-    body
-  )
+  // await fs.promises.writeFile(
+  //   buildPaths.email.body,
+  //   body
+  // )
 
   let manifest = await importJSONAsync(
     buildPaths.manifestFileNameBuilt,
@@ -38,31 +38,10 @@ export default async (props) => {
   let uploadResult = null
   for (var i in clouds) {
     const cloud = clouds[i]
-    uploadResult = await upload({
-      id: cloud.id,
-      sourceUrl: buildPaths.email.body,
-      filename: buildPaths.email.bodyFileName,
-      auth: cloud.auth,
-      settings
-    })
-    uploadResult = await upload({
-      id: cloud.id,
-      sourceUrl: buildPaths.email.text,
-      filename: buildPaths.email.textFileName,
-      auth: cloud.auth,
-      settings
-    })
-    uploadResult = await upload({
-      id: cloud.id,
-      sourceUrl: buildPaths.email.subject,
-      filename: buildPaths.email.subjectFileName,
-      auth: cloud.auth,
-      settings
-    })
-    uploadResult = await upload({
+    uploadResult = await syncFolder({
       id: cloud.id,
-      sourceUrl: buildPaths.email.manifestFileNameBuilt,
-      filename: buildPaths.email.manifestFileName,
+      sourceUrl: buildPaths.email.container,
+      destinationPath: buildPaths.email.containerRemote,
       auth: cloud.auth,
       settings
     })

package/src/template/sync/lib/pushNotification.js

@@ -1,9 +1,9 @@
-import upload from './upload.js'
 import fs from 'fs'
 import updateActivity from '../../lib/activity/updateToFile.js'
 import getActivity from '../../lib/activity/get.js'
 import importJSONAsync from '../../../lib/fs/importJSONAsync.js'
 import checkFileExists from '../../../lib/fs/checkFileExists.js'
+import syncFolder from './syncFolder.js'
 
 export default async (props) => {
 
@@ -46,17 +46,10 @@ export default async (props) => {
   let uploadResult = null
   for (var i in clouds) {
     const cloud = clouds[i]
-    uploadResult = await upload({
+    uploadResult = await syncFolder({
       id: cloud.id,
-      sourceUrl: buildPaths.pushNotification.text,
-      filename: buildPaths.pushNotification.textFileName,
-      auth: cloud.auth,
-      settings
-    })
-    uploadResult = await upload({
-      id: cloud.id,
-      sourceUrl: buildPaths.pushNotification.manifestFileNameBuilt,
-      filename: buildPaths.pushNotification.manifestFileName,
+      sourceUrl: buildPaths.pushNotification.container,
+      destinationPath: buildPaths.pushNotification.containerRemote,
       auth: cloud.auth,
       settings
     })

package/src/template/{cloudify/lib/remove.js → sync/lib/syncFolder.js}

@@ -10,5 +10,5 @@ export default async (props) => {
     }
   }
 
-  return cloudLibrary.remove(props)
+  return cloudLibrary.syncFolder(props)
 }

package/src/template/sync/lib/textMessage.js

@@ -1,9 +1,9 @@
-import upload from './upload.js'
 import fs from 'fs'
 import updateActivity from '../../lib/activity/updateToFile.js'
 import getActivity from '../../lib/activity/get.js'
 import importJSONAsync from '../../../lib/fs/importJSONAsync.js'
 import checkFileExists from '../../../lib/fs/checkFileExists.js'
+import syncFolder from './syncFolder.js'
 
 export default async (props) => {
 
@@ -46,17 +46,10 @@ export default async (props) => {
   let uploadResult = null
   for (var i in clouds) {
     const cloud = clouds[i]
-    uploadResult = await upload({
+    uploadResult = await syncFolder({
       id: cloud.id,
-      sourceUrl: buildPaths.textMessage.text,
-      filename: buildPaths.textMessage.textFileName,
-      auth: cloud.auth,
-      settings
-    })
-    uploadResult = await upload({
-      id: cloud.id,
-      sourceUrl: buildPaths.textMessage.manifestFileNameBuilt,
-      filename: buildPaths.textMessage.manifestFileName,
+      sourceUrl: buildPaths.textMessage.container,
+      destinationPath: buildPaths.textMessage.containerRemote,
       auth: cloud.auth,
       settings
     })

package/src/template/update/path.js

@@ -7,6 +7,7 @@ import optimize from '../optimize/entry.js'
 import version from '../version/entry.js'
 import cloudify from '../cloudify/entry.js'
 import adaptSettings from '../../lib/adaptSettings.js'
+import attach from '../attach/entry.js'
 
 export default async ({
   path,
@@ -32,7 +33,11 @@ export default async ({
     entry = (await consolidate({ entry, settings })).entry
     entry = (await optimize({ entry, settings })).entry
     entry = (await cloudify({ entry, settings })).entry
-    entry = (await sync({ entry, settings })).entry
+    entry = (await attach({ entry, settings })).entry
+    if (!settings.dryRun) {
+      entry = (await sync({ entry, settings })).entry
+    }
+
 
     await version({})
   }

package/src/template/cloudify/lib/email/attachments/addAttachment.js

@@ -1,24 +0,0 @@
-import getActivity from '../../../../lib/activity/get.js'
-import updateActivity from '../../../../lib/activity/updateToFile.js'
-
-export default async ({ path, entry, fileName, attachment }) => {
-  let activity = await getActivity({ path })
-  let attachments = [
-    ...((activity[entry.code] && activity[entry.code].attachments)
-      ? activity[entry.code].attachments
-      : []),
-  ]
-
-  attachments = attachments.filter(a => a.id !== fileName)
-  attachments.push(attachment)
-
-  activity[entry.code] = {
-    ...(activity[entry.code] ? activity[entry.code] : {}),
-    attachments
-  }
-
-  await updateActivity({
-    path,
-    content: activity,
-  })
-}

package/src/template/cloudify/lib/email/attachments/index.js

@@ -1,137 +0,0 @@
-import upload from '../../upload.js'
-
-import getActivity from '../../../../lib/activity/get.js'
-import updateActivity from '../../../../lib/activity/updateToFile.js'
-import fs from 'fs'
-import checkFileExists from '../../../../../lib/fs/checkFileExists.js'
-import _mimetype from 'mimetype'
-import remove from '../../remove.js'
-import addAttachment from './addAttachment.js'
-
-export default async ({ child,
-  path,
-  settings,
-  buildPaths,
-  entry
-}) => {
-
-  let entries = await fs.promises.readdir(`${path}/attachments`)
-  let items = entries.map(fileName => ({
-    fileName,
-    path: `${path}/attachments/${fileName}`
-  }))
-
-  let codeDestination = `${path}/attachments/${entry.code}`
-  if ((await checkFileExists(codeDestination))) {
-    entries = await fs.promises.readdir(codeDestination)
-    items = [
-      ...items,
-      ...(entries.map(fileName => ({
-        fileName,
-        path: `${codeDestination}/${fileName}`
-      })))
-    ]
-  }
-
-  if (!items) {
-    return {}
-  }
-
-  const { clouds } = settings
-
-  let __activity = await getActivity({ path })
-  let previousActivity = __activity[entry.code]
-  __activity[entry.code] = {}
-  await updateActivity({
-    path,
-    content: __activity,
-  })
-
-  const uploaded = []
-  for (var i in items) {
-    const { fileName, path: folderPath } = items[i]
-    const fileNameRemote = encodeURI(fileName)
-
-    const folderPathStat = await fs.promises.stat(folderPath)
-    if (!folderPathStat) {
-      continue
-    }
-
-    const isDir = folderPathStat.isDirectory()
-    if (isDir) {
-      continue
-    }
-
-    if (!settings.forceUploadAttachments) {
-      if (previousActivity) {
-        if (previousActivity.attachments) {
-          const attachment = previousActivity.attachments.find(a => a.id === fileName)
-          if (attachment) {
-            uploaded.push(attachment)
-            await addAttachment({ path, entry, fileName, attachment })
-            continue
-          }
-        }
-      }
-    }
-
-    const mimeType = _mimetype.lookup(folderPath)
-    let uploadResult = null
-
-    for (var i in clouds) {
-      const cloud = clouds[i]
-      uploadResult = await upload({
-        id: cloud.id,
-        sourceUrl: folderPath,
-        filename: `${buildPaths.email.attachmentsContainer}/${fileNameRemote}`,
-        auth: cloud.auth,
-        settings
-      })
-    }
-
-    if (!uploadResult || !uploadResult.url) {
-      continue
-    }
-
-    const attachment = {
-      id: fileName,
-      fileName,
-      url: uploadResult.url,
-      mimeType,
-      disposition: "attachment",
-      relativeFileName: `${buildPaths.email.attachmentsContainer}/${fileNameRemote}`,
-    }
-    uploaded.push(attachment
-    )
-    await addAttachment({
-      path, entry, fileName, attachment
-    })
-  }
-
-
-  const removed = []
-  for (var i in previousActivity.attachments) {
-    const item = previousActivity.attachments[i]
-    const eq = uploaded.find(a => a.id === item.id)
-    if (!eq) {
-      removed.push(item)
-    }
-  }
-
-  for (var i in removed) {
-    const item = removed[i]
-    for (var i in clouds) {
-      const cloud = clouds[i]
-      await remove({
-        id: cloud.id,
-        filename: item.relativeFileName,
-        auth: cloud.auth,
-        settings
-      })
-    }
-  }
-  return {
-
-  }
-}
-

package/src/template/cloudify/lib/email/attachments/treatLocalFile.js

@@ -1,13 +0,0 @@
-import fsPath from 'path'
-import isRelative from 'is-relative'
-
-export default async ({
-  url, path, }) => {
-  const sourceUrl = isRelative(url) ? fsPath.resolve(path, url) : url
-  const filename = fsPath.basename(sourceUrl)
-
-  return {
-    filename,
-    sourceUrl
-  }
-}

package/src/template/cloudify/lib/email/attachments/treatRemoteFile.js

@@ -1,26 +0,0 @@
-import fsPath from 'path'
-import downloadImage from 'image-downloader'
-
-export default async ({ url,
-  destination
-}) => {
-  try {
-    const options = {
-      url,
-      dest: destination,         // will be saved to /path/to/dest/photo
-      extractFilename: true,
-    }
-
-    const item = await downloadImage.image(options)
-    // const { filename } = item
-    const filename = fsPath.basename(item.filename)
-
-    return {
-      filename,
-      sourceUrl: destination
-    }
-  }
-  catch (e) {
-    console.error(e)
-  }
-}

package/src/template/sync/lib/upload.js

@@ -1,14 +0,0 @@
-export default async (props) => {
-
-  const { id, settings } = props
-
-  const cloudLibrary = settings.cloudLibrary({ id })
-  if (!cloudLibrary) {
-    return {
-      isValid: false,
-      error: new Error('Cloud not supported.')
-    }
-  }
-
-  return cloudLibrary.upload(props)
-}