@notifiles/sdk 1.0.0

package/src/template/cloudify/entry.js

@@ -0,0 +1,20 @@
+import adaptSettings from '../../lib/adaptSettings.js'
+import performEmail from './lib/email/index.js'
+import performTextMessage from './lib/textMessage.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, })
+        return res.entry
+      }))
+    }
+  }
+}

package/src/template/cloudify/index.js

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

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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,137 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,26 @@
+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/cloudify/lib/email/image/index.js

@@ -0,0 +1,90 @@
+import isLocal from 'is-local'
+import upload from '../../upload.js'
+import treatRemoteFile from './treatRemoteFile.js'
+import treatLocalFile from './treatLocalFile.js'
+
+import getActivity from '../../../../lib/activity/get.js'
+import updateActivity from '../../../../lib/activity/updateToFile.js'
+
+export default async ({ child,
+  path,
+  settings,
+  buildPaths,
+  entry
+}) => {
+  const { properties: {
+    src: _url,
+  } } = child
+
+
+  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
+          }
+        }
+      }
+    }
+  }
+
+  let result
+  const destination = `${path}/.assets`
+  if (isLocal(_url)) {
+    result = await treatLocalFile({ url: _url, path, destination })
+  }
+  else {
+    result = await treatRemoteFile({ url: _url, destination })
+  }
+  let { sourceUrl, filename } = result
+
+
+  const { clouds } = settings
+  let uploadResult = null
+  for (var i in clouds) {
+    const cloud = clouds[i]
+    uploadResult = await upload({
+      id: cloud.id,
+      sourceUrl,
+      filename: `${buildPaths.email.assetsContainer}/${filename}`,
+      auth: cloud.auth,
+      settings
+    })
+  }
+
+  if (!uploadResult || !uploadResult.url) {
+    return child
+  }
+
+  _activity = await getActivity({ path })
+  _activity[entry.code] = {
+    ...(_activity[entry.code] ? _activity[entry.code] : {}),
+    files: {
+      ...((_activity[entry.code] && _activity[entry.code].files) ? _activity[entry.code].files : {}),
+      [_url]: {
+        url: uploadResult.url
+      }
+    }
+  }
+
+  await updateActivity({
+    path,
+    content: _activity,
+  })
+
+
+  return {
+    ...child,
+    properties: {
+      ...child.properties,
+      src: uploadResult.url
+    }
+  }
+}

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

@@ -0,0 +1,13 @@
+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/image/treatRemoteFile.js

@@ -0,0 +1,26 @@
+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/cloudify/lib/email/index.js

@@ -0,0 +1,77 @@
+import hastToHtml from '../../../../lib/remark/hastToHtml.js'
+import treatAttachments from './attachments/index.js'
+import treatImage from './image/index.js'
+
+
+export default async (props) => {
+  const { entry, settings } = props
+  const { path, email: { hast }, buildPaths } = entry
+
+  const _hast = await perform({
+    entry,
+    child: hast,
+    path,
+    settings,
+    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)
+
+
+  return {
+    entry: {
+      ...entry,
+      email: {
+        ...entry.email,
+        md: null,
+        body,
+        hast: _hast,
+      }
+    }
+  }
+}
+
+const perform = async (props) => {
+  const { child, path, buildPaths, settings, entry } = props
+  let _child = { ...child }
+
+  if (child.properties && child.properties.dataNotifilesDoNotCloudify) {
+    return child
+  }
+
+  switch (_child.tagName) {
+    case 'img': {
+      _child = await treatImage({
+        child: _child,
+        path,
+        settings,
+        buildPaths,
+        entry
+      })
+    } break
+    default:
+      break
+  }
+
+  let _children = []
+  if (_child.children) {
+    _children = await Promise.all(_child.children.map(async child => perform({
+      ...props,
+      child
+    })))
+  }
+
+  return {
+    ..._child,
+    children: _children
+  }
+}

package/src/template/cloudify/lib/remove.js

@@ -0,0 +1,14 @@
+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.remove(props)
+}

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

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

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

@@ -0,0 +1,14 @@
+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)
+}

package/src/template/cloudify/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/cloudify/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/consolidate/entry.js

@@ -0,0 +1,18 @@
+import performEmail from './lib/email.js'
+import performTextMessage from './lib/textMessage.js'
+
+export default async ({
+  entry,
+  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, })
+        return res.entry
+      }))
+    }
+  }
+}

package/src/template/consolidate/index.js

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

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

@@ -0,0 +1,63 @@
+import hastToHtml from '../../../lib/remark/hastToHtml.js';
+import treatImage from './image/index.js';
+import ensureDirectoryExists from '../../../lib/fs/ensureDirectoryExists.js';
+
+export default async (props) => {
+  const { entry } = props
+  const { path, email: { hast } } = entry
+
+  const destination = `${path}/.assets`
+  await ensureDirectoryExists(destination, false)
+
+  const _hast = await perform({
+    child: hast,
+    path,
+
+  })
+
+  let body = hastToHtml({ data: _hast })
+
+  return {
+    entry: {
+      ...entry,
+      email: {
+        ...entry.email,
+        hast: _hast,
+        body
+      }
+    }
+  }
+}
+
+const perform = async (props) => {
+  const { child, path } = props
+  let _child = { ...child }
+
+  if (child.properties && child.properties.dataNotifilesDoNotConsolidate) {
+    return child
+  }
+
+  switch (_child.tagName) {
+    case 'img': {
+      _child = await treatImage({
+        child: _child,
+        path
+      })
+    } break
+    default:
+      break
+  }
+
+  let _children = []
+  if (_child.children) {
+    _children = await Promise.all(_child.children.map(async __child => perform({
+      ...props,
+      child: __child
+    })))
+  }
+
+  return {
+    ..._child,
+    children: _children
+  }
+}

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

@@ -0,0 +1,35 @@
+import isLocal from 'is-local'
+import treatLocalFile from './treatLocalFile.js'
+import treatRemoteFile from './treatRemoteFile.js'
+
+export default async ({ child,
+  path, entry }) => {
+  const { properties: {
+    src: url,
+  } } = child
+
+  let result
+  const destination = `${path}/.assets`
+
+  if (isLocal(url)) {
+    if (url.indexOf(destination) !== 0) {
+      return child
+    }
+
+    result = await treatLocalFile({ url, path, destination })
+  }
+  else {
+    result = await treatRemoteFile({ url, destination })
+  }
+
+  let filename = result.filename
+  const newUrl = `.assets/${filename}`
+  return {
+    ...child,
+    properties: {
+      ...child.properties,
+      src: newUrl
+    }
+  }
+}
+

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

@@ -0,0 +1,14 @@
+import fsPath from 'path'
+import fs from 'fs'
+import isRelative from 'is-relative'
+
+export default async ({
+  url, path, destination }) => {
+  const sourceUrl = isRelative(url) ? fsPath.resolve(path, url) : url
+  const filename = fsPath.basename(sourceUrl)
+  const _destination = `${destination}/${filename}`
+  await fs.promises.cp(sourceUrl, _destination)
+  return {
+    filename,
+  }
+}

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

@@ -0,0 +1,25 @@
+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
+    }
+  }
+  catch (e) {
+    console.error(e)
+  }
+}

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

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