@notifiles/sdk 1.1.17 → 1.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@notifiles/sdk",
   "type": "module",
-  "version": "1.1.17",
+  "version": "1.2.0",
   "description": "",
   "author": {
     "name": "adoucoure",
@@ -50,6 +50,7 @@
   },
   "keywords": [],
   "dependencies": {
+    "@lifeomic/attempt": "^3.1.0",
     "@microflash/remark-figure-caption": "^2.0.2",
     "@stdlib/string-replace": "^0.2.1",
     "axios": "^1.6.1",

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

@@ -49,7 +49,7 @@ export default async ({
           destination,
           filePath,
           err => {
-            console.log(filePath, 'uploaded')
+            console.log('🮱 ', filePath, 'uploaded')
             if (err) {
               console.error(err)
               reject(err)

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

@@ -3,7 +3,7 @@ import fs from 'fs';
 import translate from './translate.js';
 import htmlToHast from '../../../../lib/remark/htmlToHast.js';
 //#TODO: https://github.com/anfragment/react-email-dynamic
-import pRetry, { AbortError } from 'p-retry';
+import { retry } from '@lifeomic/attempt';
 
 export default async (props) => {
   const { entry } = props
@@ -90,27 +90,32 @@ export default async (props) => {
       subject,
       'utf-8'
     )
-    const run = async () => {
-      try {
+
+    try {
+      await retry(async (context) => {
         await fs.promises.cp(
           `${path}/manifest.json`,
           buildPaths.manifestFileNameBuilt
         )
         return true
-      }
-      catch (e) {
-        throw new AbortError(e.message);
-      }
+      }, {
+        delay: 200,
+        maxAttempts: 3,
+        initialDelay: 0,
+        minDelay: 0,
+        maxDelay: 0,
+        factor: 0,
+        timeout: 0,
+        jitter: false,
+        initialJitter: false,
+        handleError: null,
+        handleTimeout: null,
+        beforeAttempt: null,
+        calculateDelay: null
+      });
+    } catch (err) {
+      console.log(`Attempt ${err} failed`);
     }
-    pRetry(run, {
-      retries: 15,
-      onFailedAttempt: error => {
-        console.log(`Attempt ${error.attemptNumber} failed. There are ${error.retriesLeft} retries left.`);
-        // 1st request => Attempt 1 failed. There are 4 retries left.
-        // 2nd request => Attempt 2 failed. There are 3 retries left.
-        // …
-      },
-    })
 
     const child = htmlToHast({ data: body })
     const hast = await perform({

package/src/template/update/lib/cache.js

@@ -0,0 +1,108 @@
+import fs from 'fs'
+import fsPath from 'path'
+import { createHash } from 'crypto'
+import checkFileExists from '../../../lib/fs/checkFileExists.js'
+import importJSONAsync from '../../../lib/fs/importJSONAsync.js'
+
+const CACHE_DIR_NAME = '.cache'
+const CACHE_FILE_NAME = 'template-update.json'
+const IGNORED_DIRECTORIES = new Set([CACHE_DIR_NAME, '.build'])
+const IGNORED_FILES = new Set(['.DS_Store'])
+
+const sortByName = (a, b) => a.name.localeCompare(b.name)
+
+const digestDirectory = async ({
+  rootPath,
+  currentPath,
+  hash
+}) => {
+  const entries = await fs.promises.readdir(currentPath, { withFileTypes: true })
+  entries.sort(sortByName)
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (IGNORED_DIRECTORIES.has(entry.name)) {
+        continue
+      }
+      await digestDirectory({
+        rootPath,
+        currentPath: fsPath.join(currentPath, entry.name),
+        hash
+      })
+      continue
+    }
+
+    if (!entry.isFile() || IGNORED_FILES.has(entry.name)) {
+      continue
+    }
+
+    const filePath = fsPath.join(currentPath, entry.name)
+    const relativePath = fsPath.relative(rootPath, filePath)
+    const content = await fs.promises.readFile(filePath)
+    hash.update(relativePath)
+    hash.update(content)
+  }
+}
+
+export const computeTemplateHash = async ({
+  path
+}) => {
+  try {
+    if (!(await checkFileExists(path))) {
+      return null
+    }
+
+    const hash = createHash('sha256')
+    await digestDirectory({
+      rootPath: path,
+      currentPath: path,
+      hash,
+    })
+    return hash.digest('hex')
+  } catch (e) {
+    console.error(e)
+  }
+  return null
+}
+
+export const getCachedTemplateHash = async ({
+  path
+}) => {
+  try {
+    const cachePath = fsPath.join(path, CACHE_DIR_NAME, CACHE_FILE_NAME)
+    if (!(await checkFileExists(cachePath))) {
+      return null
+    }
+
+    const cacheContent = await importJSONAsync(cachePath)
+    if (!cacheContent || !cacheContent.hash) {
+      return null
+    }
+
+    return cacheContent.hash
+  } catch (e) {
+    console.error(e)
+  }
+  return null
+}
+
+export const updateTemplateHashCache = async ({
+  path,
+  hash,
+}) => {
+  try {
+    const cacheDir = fsPath.join(path, CACHE_DIR_NAME)
+    await fs.promises.mkdir(cacheDir, { recursive: true })
+
+    const cachePath = fsPath.join(cacheDir, CACHE_FILE_NAME)
+    const payload = {
+      hash,
+      updatedAt: (new Date()).toISOString(),
+    }
+    await fs.promises.writeFile(cachePath, JSON.stringify(payload, null, 2))
+    return true
+  } catch (e) {
+    console.error(e)
+  }
+  return false
+}

package/src/template/update/path.js

@@ -7,19 +7,31 @@ import optimize from '../optimize/entry.js'
 import cloudify from '../cloudify/entry.js'
 import adaptSettings from '../../lib/adaptSettings.js'
 import attach from '../attach/entry.js'
+import {
+  computeTemplateHash,
+  getCachedTemplateHash,
+  updateTemplateHashCache
+} from './lib/cache.js'
 
 export default async ({
   path,
-  settings
+  settings = {},
+  force = false
 }) => {
   adaptSettings({ settings })
   let entries = await getEntries({
     path,
     settings
   })
+  if (!entries || !entries.length) {
+    return true
+  }
+
+  const forceUpdate = force || settings.forceUpdate
 
   for (var i in entries) {
     let entry = entries[i]
+
     switch (entry.manifest.status) {
       case 'pause': {
         continue
@@ -27,6 +39,13 @@ export default async ({
       default: break
     }
 
+    const cachedHash = await getCachedTemplateHash({ path: entry.path })
+    const currentHash = await computeTemplateHash({ path: entry.path })
+    if (!forceUpdate && cachedHash && currentHash && cachedHash === currentHash) {
+      console.log(`[notifiles] Skip ${entry.slug || entry.name || entry.path}: no changes detected`)
+      continue
+    }
+
     entry = (await format({ entry, settings })).entry
     entry = (await build({ entry, settings })).entry
     entry = (await consolidate({ entry, settings })).entry
@@ -37,6 +56,11 @@ export default async ({
       continue
     }
     entry = (await sync({ entry, settings })).entry
+
+    const newHash = await computeTemplateHash({ path: entry.path })
+    if (newHash) {
+      await updateTemplateHashCache({ path: entry.path, hash: newHash })
+    }
   }
 
   return true