@notifiles/sdk 1.1.18 → 1.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@notifiles/sdk",
   "type": "module",
-  "version": "1.1.18",
+  "version": "1.3.0",
   "description": "",
   "author": {
     "name": "adoucoure",

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/lib/fs/importJSONAsync.js

@@ -1,6 +1,28 @@
 import fs from "fs"
 import checkFileExists from "./checkFileExists.js"
 
+const expandEnvPlaceholders = (value) => {
+  if (typeof value === 'string') {
+    return value.replace(/\$\{process\.env\.([A-Z0-9_]+)\}/g, (match, envKey) => {
+      const envValue = process.env[envKey]
+      return envValue !== undefined ? envValue : match
+    })
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(expandEnvPlaceholders)
+  }
+
+  if (value && typeof value === 'object') {
+    return Object.entries(value).reduce((acc, [key, val]) => {
+      acc[key] = expandEnvPlaceholders(val)
+      return acc
+    }, {})
+  }
+
+  return value
+}
+
 export default async _url => {
   // try {
   if (!(await checkFileExists(_url))) {
@@ -8,7 +30,7 @@ export default async _url => {
   }
   const fileUrl = new URL(_url, import.meta.url)
   const parsedPackageJSON = JSON.parse(await fs.promises.readFile(fileUrl, 'utf8'))
-  return parsedPackageJSON
+  return expandEnvPlaceholders(parsedPackageJSON)
   // } catch (e) {
   //   console.log("[notifiles]", `importJSONAsync → `, e)
   //   return null

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