@notifiles/sdk 1.0.0

package/src/lib/remark/mdastToHTML.js

@@ -0,0 +1,8 @@
+import { toHast } from 'mdast-util-to-hast'
+import { toHtml } from 'hast-util-to-html'
+
+export default ({
+  mdast,
+} = {}) => {
+  return toHtml(toHast(mdast))
+}

package/src/lib/remark/mdastToMarkdown.js

@@ -0,0 +1,24 @@
+import { unified } from 'unified'
+import { toHast } from 'mdast-util-to-hast'
+import { toHtml } from 'hast-util-to-html'
+import rehypeParse from 'rehype-parse'
+import rehypeRemark from 'rehype-remark'
+import remarkStringify from 'remark-stringify'
+
+export default async ({
+  mdast,
+} = {}) => {
+
+  const hast = toHast(mdast)
+  const html = toHtml(hast)
+
+  const file = await unified()
+    .use(rehypeParse)
+    .use(rehypeRemark)
+    .use(remarkStringify)
+    .process(html)
+
+  const data = String(file)
+
+  return data
+}

package/src/lib/remark/mdastToString.js

@@ -0,0 +1,12 @@
+import { toString } from 'mdast-util-to-string'
+
+
+export default async ({
+  mdast,
+} = {}) => {
+
+  const v = toString(mdast, {
+
+  })
+  return v
+}

package/src/project/index.js

@@ -0,0 +1,4 @@
+
+export { default as isProject } from './isProject/index.js'
+export { default as isProjectSync } from './isProject/sync.js'
+export * as newProject from './new/index.js'

package/src/project/isProject/index.js

@@ -0,0 +1,26 @@
+import fs from 'fs'
+import fsPath from 'path'
+import checkFileExists from '../../lib/fs/checkFileExists.js'
+
+export default async (props) => {
+  const {
+    path,
+  } = props
+
+  if (!(await checkFileExists(path))) {
+    return false
+  }
+
+  const pathStat = await fs.promises.stat(path)
+  if (!pathStat) {
+    return false
+  }
+
+  const isDir = pathStat.isDirectory()
+  if (!isDir) {
+    return false
+  }
+
+  const manifestPath = fsPath.join(path, 'manifest.yaml')
+  return checkFileExists(manifestPath)
+}

package/src/project/isProject/index.test.js

@@ -0,0 +1,13 @@
+
+
+describe.skip('project', () => {
+  it('ensures a folder is a project', async () => {
+    const fsPath = (await import('path')).default
+    let path = fsPath.resolve(process.env.TEST_MOCK_FOLDER_ROOT)
+    const operation = (await import('./index.js')).default
+    const result = await operation({
+      path,
+    })
+    expect(result).toBeTruthy()
+  })
+})

package/src/project/isProject/sync.js

@@ -0,0 +1,18 @@
+import fs from 'fs'
+
+export default ({ path }) => {
+  try {
+    if (!path || !path.length) {
+      return false
+    }
+    if (!fs.lstatSync(path).isDirectory()) {
+      return false
+    }
+
+    const targetPath = `${path}/manifest.yaml`
+    const exists = fs.existsSync(targetPath)
+    return exists
+  } catch (e) {
+    return false
+  }
+}

package/src/project/lib/activity/createFileIfNeeded.js

@@ -0,0 +1,33 @@
+import fsPath from 'path'
+import fs from 'fs'
+import checkFileExists from '../../../lib/fs/checkFileExists.js'
+import importJSONAsync from '../../../lib/fs/importJSONAsync.js'
+
+export default async ({
+  path,
+  status = "draft",
+}) => {
+
+
+  try {
+
+    const filePath = fsPath.join(path, ".activity.json")
+
+    if ((await checkFileExists(filePath))) {
+      return
+    }
+    const defaultContent = await importJSONAsync('./defaultContent.json')
+
+    let content = {
+      ...defaultContent,
+      createdAt: (new Date()),
+      status,
+    }
+
+    await fs.promises.writeFile(filePath, JSON.stringify(content, null, 2))
+    return true
+  } catch (e) {
+    console.error(e)
+  }
+  return false
+}

package/src/project/lib/activity/defaultContent.json

@@ -0,0 +1,5 @@
+{
+  "createdAt": "",
+  "updatedAt": "",
+  "platforms": []
+}

package/src/project/lib/activity/updateToFile.js

@@ -0,0 +1,32 @@
+import fsPath from 'path'
+import fs from 'fs'
+import checkFileExists from '../../../lib/fs/checkFileExists.js'
+import importJSONAsync from '../../../lib/fs/importJSONAsync.js'
+
+export default async ({
+  path,
+  content,
+}) => {
+
+
+  try {
+
+    const filePath = fsPath.join(path, ".activity.json")
+
+    if (!(await checkFileExists(filePath))) {
+      return
+    }
+    const defaultContent = await importJSONAsync('./defaultContent.json')
+
+    let _content = {
+      ...defaultContent,
+      ...content,
+    }
+
+    await fs.promises.writeFile(filePath, JSON.stringify(_content, null, 2))
+    return true
+  } catch (e) {
+    console.error(e)
+  }
+  return false
+}

package/src/project/lib/manifest/createFileIfNeeded.js

@@ -0,0 +1,44 @@
+import fsPath from 'path'
+import fs from 'fs'
+import checkFileExists from '../../../lib/fs/checkFileExists.js'
+import YAML from 'yaml'
+import { nanoid } from 'nanoid'
+
+export default async ({
+  path,
+  data = {}
+}) => {
+
+
+  try {
+
+    const filePath = fsPath.join(path, "manifest.yaml")
+
+    if ((await checkFileExists(filePath))) {
+      return
+    }
+
+    let defaultManifest = YAML.parse(`
+      id: ${nanoid()}
+      createdAt: ""
+      updatedAt: ""
+      nomDePlume: ""
+      description: ""
+      license: all-rights-reserved
+    `)
+
+    let manifest = {
+      ...defaultManifest,
+      createdAt: (new Date()),
+      ...data
+    }
+
+    manifest = YAML.stringify(manifest)
+
+    await fs.promises.writeFile(filePath, manifest)
+    return true
+  } catch (e) {
+    console.error(e)
+  }
+  return false
+}

package/src/project/lib/manifest/read.js

@@ -0,0 +1,21 @@
+import fsPath from 'path'
+import checkFileExists from '../../../lib/fs/checkFileExists.js'
+import importYAMLAsync from '../../../lib/fs/importYAMLAsync.js'
+
+export default async ({
+  path,
+}) => {
+  try {
+    const filePath = fsPath.join(path, "manifest.yaml")
+
+    if (!(await checkFileExists(filePath))) {
+      return null
+    }
+
+    const content = await importYAMLAsync(filePath)
+    return content
+  } catch (e) {
+    console.error(e)
+  }
+  return null
+}

package/src/project/lib/manifest/update.js

@@ -0,0 +1,36 @@
+import read from './read.js'
+import updateToFile from './updateToFile.js'
+import YAML from 'yaml'
+
+export default async ({
+  path,
+  data,
+}) => {
+  try {
+    let existing = await read({ path })
+    if (!existing) {
+      existing = {}
+    }
+    const _data = data ? data : {}
+    let result = {
+      ...existing,
+      platforms: [
+        ...(existing.platforms ? existing.platforms : []),
+        ...(data.platforms ? data.platforms : []),
+      ],
+      clouds: [
+        ...(existing.clouds ? existing.clouds : []),
+        ...(data.clouds ? data.clouds : []),
+      ]
+    }
+
+    const content = YAML.stringify(result)
+    return updateToFile({
+      path,
+      content
+    })
+  } catch (e) {
+    console.error(e)
+  }
+  return false
+}

package/src/project/lib/manifest/updateToFile.js

@@ -0,0 +1,22 @@
+import fsPath from 'path'
+import fs from 'fs'
+import checkFileExists from '../../../lib/fs/checkFileExists.js'
+
+export default async ({
+  path,
+  content,
+}) => {
+
+  try {
+    const filePath = fsPath.join(path, "manifest.yaml")
+    if (!(await checkFileExists(filePath))) {
+      return
+    }
+
+    await fs.promises.writeFile(filePath, content)
+    return true
+  } catch (e) {
+    console.error(e)
+  }
+  return false
+}

package/src/project/new/index.js

@@ -0,0 +1,2 @@
+
+export { default as plain } from './plain.js'

package/src/project/new/plain.js

@@ -0,0 +1,49 @@
+import fsPath from 'path'
+import fs from 'fs'
+import checkFileExists from '../../lib/fs/checkFileExists.js'
+import createStatusIfNeeded from '../lib/activity/createFileIfNeeded.js'
+import createManifestIfNeeded from '../lib/manifest/createFileIfNeeded.js'
+
+export default async ({
+  path,
+  name = "My new project",
+  description = "An authoring project for my personal usage.",
+  settings = {
+  },
+  force = false,
+  author = {
+    id: "",
+    name: ""
+  },
+}) => {
+  try {
+    const folderPath = fsPath.join(path, name)
+
+    if ((await checkFileExists(folderPath))) {
+      if (!force) {
+        return false
+      }
+      await fs.promises.rmdir(folderPath, { recursive: true })
+    }
+
+    await fs.promises.mkdir(folderPath)
+
+    await createStatusIfNeeded({
+      path: folderPath
+    })
+
+    await createManifestIfNeeded({
+      path: folderPath,
+      data: {
+        name,
+        author,
+        description
+      }
+    })
+
+    return true
+  } catch (e) {
+    console.error(e)
+  }
+  return false
+}

package/src/project/new/plain.test.js

@@ -0,0 +1,38 @@
+
+
+describe.skip('project', () => {
+  it('creates new to medium and dev.to platforms', async () => {
+    const fsPath = (await import('path')).default
+    let path = fsPath.resolve(process.env.TEST_MOCK_FOLDER_ROOT)
+    const operation = (await import('./plain.js')).default
+    const result = await operation({
+      settings: {
+        platforms: [{
+          id: 'medium',
+          auth: {
+            token: process.env.TEST_MEDIUM_TOKEN,
+          }
+        },
+        {
+          id: 'devto',
+          auth: {
+            token: process.env.TEST_DEVTO_TOKEN,
+          }
+        }],
+        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
+          }
+        }
+      },
+      name: process.env.TEST_MOCK_FOLDER_NEW_NAME,
+      path,
+      force: true
+    })
+    expect(result).toBeTruthy()
+  })
+})

package/src/template/build/entry.js

@@ -0,0 +1,37 @@
+import checkFileExists from '../../lib/fs/checkFileExists.js'
+import performEmail from './lib/email/index.js'
+import performTextMessage from './lib/textmessage/index.js'
+import fs from 'fs'
+
+export default async ({
+  entry,
+  settings,
+}) => {
+  const buildPath = `${entry.path}/.build`
+  if ((await checkFileExists(buildPath))) {
+    await fs.promises.rmdir(
+      buildPath,
+      { recursive: true }
+    )
+  }
+
+  const 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
+  }))
+
+  if ((await checkFileExists(`${entry.path}/.build/temp`))) {
+    await fs.promises.rmdir(
+      `${entry.path}/.build/temp`,
+      { recursive: true }
+    )
+  }
+
+  return {
+    entry: {
+      ...entry,
+      versions
+    }
+  }
+}

package/src/template/build/index.js

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

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

@@ -0,0 +1,100 @@
+import { execa } from 'execa'
+import fs from 'fs'
+import translate from './translate.js'
+import htmlToHast from '../../../../lib/remark/htmlToHast.js'
+
+export default async (props) => {
+
+  const { entry } = props
+  const { path,
+    buildPaths,
+    code,
+    language } = entry
+
+  const { stdout } = await execa`npx react-email@2.1.4 export --pretty --plainText --dir ${path} --outDir ${path}/.build/temp/email/${code}/text`;
+  const { stdoutB } = await execa`npx react-email@2.1.4 export --pretty --dir ${path} --outDir ${path}/.build/temp/email/${code}/html`;
+
+  await fs.promises.cp(
+    `${path}/.build/temp/email/${code}/html/email.html`,
+    buildPaths.email.body
+  )
+
+  let body = await fs.promises.readFile(buildPaths.email.body, 'utf8')
+  body = translate({ text: body, strings: language.data })
+  body = body
+    .replaceAll('|%', '{{')
+    .replaceAll('%|', '}}')
+    .replaceAll(']]', '')
+    .replaceAll('[[', '')
+
+  await fs.promises.writeFile(
+    buildPaths.email.body,
+    body
+  )
+
+  await fs.promises.cp(
+    `${path}/.build/temp/email/${code}/text/email.txt`,
+    buildPaths.email.text
+  )
+
+  let text = await fs.promises.readFile(buildPaths.email.text, 'utf8')
+  text = translate({ text: text, strings: language.data })
+  text = text
+    .replaceAll('|%', '{{')
+    .replaceAll('%|', '}}')
+    .replaceAll(']]', '')
+    .replaceAll('[[', '')
+
+  await fs.promises.writeFile(
+    buildPaths.email.text,
+    text
+  )
+
+  await fs.promises.cp(
+    `${path}/email.subject.txt`,
+    buildPaths.email.subject
+  )
+
+  let subject = await fs.promises.readFile(buildPaths.email.subject, 'utf8')
+  subject = translate({ text: subject, strings: language.data })
+  subject = subject
+    .trim()
+    .replaceAll('|%', '{{')
+    .replaceAll('%|', '}}')
+    .replaceAll(']]', '')
+    .replaceAll('[[', '')
+
+  await fs.promises.writeFile(
+    buildPaths.email.subject,
+    subject,
+    'utf-8'
+  )
+
+  await fs.promises.cp(
+    `${path}/manifest.json`,
+    buildPaths.manifestFileNameBuilt
+  )
+
+  const child = htmlToHast({ data: body })
+  const hast = await perform({
+    child,
+    path
+  })
+
+  return {
+    entry: {
+      ...entry,
+      email: {
+        text,
+        body,
+        subject,
+        hast,
+      }
+    },
+  }
+}
+
+const perform = async (props) => {
+  const { child, path } = props
+  return child
+}

package/src/template/build/lib/email/translate.js

@@ -0,0 +1,16 @@
+export default ({ text, strings }) => {
+  const replacer = (match, p1) => {
+    const str = match.trim().replace('[[', '').replace(']]', '')
+
+    if (!strings[str]) {
+      return match
+    }
+
+    const prefix = match[0] === " " ? " " : ""
+    const suffix = match[match.length - 1] === " " ? " " : ""
+    return prefix + strings[str] + suffix
+  }
+
+  const reg = new RegExp(/ *\[\[[^)]*\]\] */g)
+  return text.replaceAll(reg, replacer)
+}

package/src/template/build/lib/textmessage/index.js

@@ -0,0 +1,44 @@
+import fs from 'fs'
+import translate from './translate.js'
+import checkFileExists from '../../../../lib/fs/checkFileExists.js'
+
+export default async (props) => {
+
+  const { entry } = props
+  const { path,
+    buildPaths,
+    code,
+    language } = entry
+
+  const textPath = `${path}/textmessage.txt`
+  if (!(await checkFileExists(textPath))) {
+    return {
+      entry
+    }
+  }
+
+  await fs.promises.cp(
+    textPath,
+    buildPaths.textMessage.text
+  )
+
+  let text = await fs.promises.readFile(buildPaths.textMessage.text, 'utf8')
+  text = translate({ text: text, strings: language.data })
+  text = text
+    .replaceAll('|%', '{{')
+    .replaceAll('%|', '}}')
+
+  await fs.promises.writeFile(
+    buildPaths.textMessage.text,
+    text
+  )
+
+  return {
+    entry: {
+      ...entry,
+      textMessage: {
+        text,
+      }
+    },
+  }
+}

package/src/template/build/lib/textmessage/translate.js

@@ -0,0 +1,25 @@
+export default ({ text, strings }) => {
+  let _text = text
+
+  const firsts = _text.split('[[')
+  let matched = firsts.map(element => {
+    if (element.indexOf(']]') === -1) {
+      return element
+    }
+
+    let seconds = element.split(']]')
+    const key = seconds[0]
+    const value = strings[key]
+    if (!value) {
+      return seconds.join('')
+    }
+    seconds = seconds.length > 1
+      ? seconds.slice(1, seconds.length)
+      : seconds
+    return [value, seconds].join('')
+  })
+
+  matched = matched.join('')
+  return matched
+
+}

package/src/template/build/path.js

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

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

@@ -0,0 +1,29 @@
+
+test.skip('build posts', 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: {
+      platforms: [{
+        id: 'medium',
+        auth: {
+          token: process.env.TEST_MEDIUM_TOKEN,
+        }
+      }],
+      storage: {
+        type: "cdn",
+        auth: {
+          key: '',
+          secret: '',
+          bucketName: ''
+        }
+      }
+    },
+    path,
+  })
+  expect(result).toBeTruthy()
+})
+
+