votive 0.0.8 → 0.0.9

package/lib/readAbstracts.js

@@ -1,6 +1,6 @@
 /** @import {VotiveConfig, FlatProcessors, Abstract, AbstractsWithSyntax, Jobs, FlatProcessor, Abstracts} from "./bundle.js" */
 /** @import {Database} from "./createDatabase.js" */
-/** @import {ReadSourceFileResult} from "./readSources.js"
+/** @import {ReadSourceFilesResult} from "./readSources.js"
 
 /**
  * @typedef {object} ReadAbstractsResult
@@ -13,15 +13,17 @@
  */
 
 /**
- * @param {ReadSourceFileResult} abstracts
+ * @param {ReadSourceFilesResult} files
  * @param {VotiveConfig} config
  * @param {Database} database
  * @param {FlatProcessors} processors
  * @returns {{processedAbstracts: Abstracts, abstractsJobs: Jobs}}
  */
-function readAbstracts(abstracts, config, database, processors) {
+function readAbstracts(files, config, database, processors) {
 
-  const processed = abstracts.flatMap(({ abstract: unprocessedAbstract, syntax }) => {
+  const processed = files.flatMap(file => {
+
+    const { abstract: unprocessedAbstract } = file
 
     /**
      * @param {FlatProcessors} processors
@@ -32,13 +34,14 @@ function readAbstracts(abstracts, config, database, processors) {
       const [flatProcessor, ...rest] = processors
       if (!flatProcessor) return { abstract, jobs }
       const { processor, plugin } = flatProcessor
-      if (processor.syntax !== syntax
-        || !processor.read
-        || !processor.read.abstract
+      if (!processor.extensions.includes(file.syntax)
+        || !processor.transformFile
       ) return recursiveProcess(rest, abstract, jobs)
 
-      const processed = processor.read.abstract(abstract, database, config)
-      processed.jobs && processed.jobs.forEach(job => job.syntax = processor.syntax)
+      const settings = database.setting.getByFolder(file.dir)
+      
+      const processed = processor.transformFile(abstract, database, config)
+      processed.jobs && processed.jobs.forEach(job => job.syntax = file.syntax)
       return recursiveProcess(rest, processed.abstract, [...jobs, ...(processed.jobs || [])])
     }
 

package/lib/readBuffers.js

@@ -1,6 +1,6 @@
 /** @import {VotiveConfig, FlatProcessors, Abstract, AbstractsWithSyntax, Jobs, FlatProcessor, Abstracts} from "./bundle.js" */
 /** @import {Database} from "./createDatabase.js" */
-/** @import {ReadSourceFileResult} from "./readSources.js"
+/** @import {ReadSourceFilesResult} from "./readSources.js"
 
 /**
  * @typedef {object} ReadAbstractsResult
@@ -13,7 +13,7 @@
  */
 
 /**
- * @param {ReadSourceFileResult} abstracts
+ * @param {ReadSourceFilesResult} abstracts
  * @param {VotiveConfig} config
  * @param {Database} database
  * @param {FlatProcessors} processors
@@ -21,8 +21,8 @@
  */
 function readBuffers(abstracts, config, database, processors) {
 
-  const processed = abstracts.flatMap(({ abstract: unprocessedAbstract, syntax }) => {
-
+  const processed = abstracts.flatMap(file => {
+    const { abstract: unprocessedAbstract, syntax } = file
     /**
      * @param {FlatProcessors} processors
      * @param {Abstract} abstract
@@ -32,13 +32,13 @@ function readBuffers(abstracts, config, database, processors) {
       const [flatProcessor, ...rest] = processors
       if (!flatProcessor) return { abstract, jobs }
       const { processor, plugin } = flatProcessor
-      if (processor.syntax !== syntax
-        || !processor.read
-        || !processor.read.abstract
+      if (!processor.extensions.includes(syntax)
+        || !processor.readFile
+        || !processor.transformFile
       ) return recursiveProcess(rest, abstract, jobs)
 
-      const processed = processor.read.abstract(abstract, database, config)
-      processed.jobs && processed.jobs.forEach(job => job.syntax = processor.syntax)
+      const processed = processor.transformFile(abstract, database, config)
+      processed.jobs && processed.jobs.forEach(job => job.syntax = file.syntax)
       return recursiveProcess(rest, processed.abstract, [...jobs, ...(processed.jobs || [])])
     }
 
@@ -56,4 +56,4 @@ function readBuffers(abstracts, config, database, processors) {
   return { processedAbstracts, abstractsJobs }
 }
 
-export default readAbstracts
+export default readBuffers

package/lib/readFilePaths.js

@@ -1,28 +1,28 @@
 /** @import {VotiveConfig, FlatProcessors, Abstract, AbstractsWithSyntax, Jobs, FlatProcessor, Abstracts} from "./bundle.js" */
 /** @import {Database} from "./createDatabase.js" */
-/** @import {ReadSourceFileResult} from "./readSources.js"
+/** @import {ReadSourceFilesResult} from "./readSources.js" */
 
 /**
  * @typedef {object} ReadAbstractsResult
  * @property {Jobs} jobs
  * @property {ReadAbstractResult[]} abstracts
  */
-
+ 
 /**
  * @typedef {object} ReadAbstractResult
  */
 
 /**
- * @param {ReadSourceFileResult} abstracts
+ * @param {ReadSourceFilesResult} files
  * @param {VotiveConfig} config
  * @param {Database} database
  * @param {FlatProcessors} processors
  * @returns {{processedAbstracts: Abstracts, abstractsJobs: Jobs}}
  */
-function readFilePaths(abstracts, config, database, processors) {
-
-  const processed = abstracts.flatMap(({ abstract: unprocessedAbstract, syntax }) => {
+function readFilePaths(files, config, database, processors) {
 
+  const processed = files.flatMap(file => {
+    const { abstract: unprocessedAbstract, syntax } = file
     /**
      * @param {FlatProcessors} processors
      * @param {Abstract} abstract
@@ -31,14 +31,14 @@ function readFilePaths(abstracts, config, database, processors) {
     function recursiveProcess(processors, abstract, jobs = []) {
       const [flatProcessor, ...rest] = processors
       if (!flatProcessor) return { abstract, jobs }
-      const { processor, plugin } = flatProcessor
-      if (processor.syntax !== syntax
-        || !processor.read
-        || !processor.read.abstract
+      const { processor } = flatProcessor
+      if (!processor.extensions.includes(syntax)
+        || !processor.readFile
+        || !processor.transformFile
       ) return recursiveProcess(rest, abstract, jobs)
 
-      const processed = processor.read.abstract(abstract, database, config)
-      processed.jobs && processed.jobs.forEach(job => job.syntax = processor.syntax)
+      const processed = processor.transformFile(abstract, database, config)
+      processed.jobs && processed.jobs.forEach(job => job.syntax = file.syntax)
       return recursiveProcess(rest, processed.abstract, [...jobs, ...(processed.jobs || [])])
     }
 

package/lib/readFolders.js

@@ -13,7 +13,7 @@ import path from "node:path"
  */
 function readFolders(folders = [], config, database, processors) {
 
-  const folderProcessors = processors.filter(({ processor }) => processor.read && processor.read.folder)
+  const folderProcessors = processors.filter(({ processor }) => processor.readFolder)
 
   const processed = folderProcessors.flatMap(({ processor, plugin }) => {
 
@@ -21,30 +21,23 @@ function readFolders(folders = [], config, database, processors) {
       let folderPath = path.join(folder.parentPath, folder.name)
       if(folderPath) folderPath += path.sep
 
-
-      /** @ts-ignore `.read` is throwing a warning, but it's guarded above */
-      const { destinations, jobs } = processor.read.folder(folderPath, database, config)
+      const { targets, jobs } = processor.readFolder(folderPath, database, config)
       jobs.forEach(job => job.syntax = processor.syntax)
-      if (destinations) {
-        destinations.forEach(destination => {
-          database.createOrUpdateDestination(destination)
+      if (targets) {
+        targets.forEach(target => {
+          database.target.create(target)
         })
         return jobs
       }
     })
 
     
-    const rootInfo = path.parse(config.sourceFolder)
-    const rootPath = rootInfo.name
-      ? path.format(rootInfo) + path.sep
-      : ""
-
-    // TODO: Add isRoot to type definition
-    const rootFolder = processor.read.folder(rootPath, database, config, true)
+    const rootPath = path.relative(config.sourceFolder, "")
+    const rootFolder = processor.readFolder(rootPath, database, config, true)
 
-    if (rootFolder.destinations) {
-      rootFolder.destinations.forEach(destination => {
-        database.createOrUpdateDestination(destination)
+    if (rootFolder.targets) {
+      rootFolder.targets.forEach(target => {
+        database.target.create(target)
       })
     }
 

package/lib/readSources.js

@@ -1,7 +1,7 @@
 import { decodeBuffer } from "encoding-sniffer"
 import fs from "node:fs/promises"
 import path from "node:path"
-import { visit } from "unist-util-visit"
+import pLimit from "p-limit"
 
 /** @import {VotiveConfig, VotivePlugin, VotiveProcessor, FlatProcessors, Abstracts, Abstract, Jobs, ProcessorSyntax} from "./bundle.js" */
 /** @import {Dirent} from "node:fs" */
@@ -10,7 +10,7 @@ import { visit } from "unist-util-visit"
 /**
  * @typedef {object} ReadSourcesResult
  * @property {Dirent[]} folders
- * @property {ReadSourceFilePlugin[]} sources
+ * @property {ReadSourceFileResult[]} sources
  */
 
 /**
@@ -25,11 +25,28 @@ async function readSources(config, database, processors) {
     recursive: true
   })
 
-  const filteredDirents = (dirents || []).filter(fileFilter(config, database))
+  const filteredDirents = (dirents || []).filter(fileFilter(config))
+
   const { files, folders } = Object.groupBy(filteredDirents, (dirent) => dirent.isFile() ? "files" : "folders")
+  const loadingFiles = files.map(a => path.normalize(path.format({ name: a.name, dir: a.parentPath })))
   if (!files) return { folders, sources: [] }
-  const readingSourceFiles = files.flatMap(readSourceFile(processors, database, config))
+  const limit = pLimit(5)
+  const readingSourceFiles = files.flatMap(readSourceFile(processors, database, config, limit))
+  // const sources = readingSourceFiles && readingSourceFiles.map(async file => {
+  //   try {
+  //     const loaded = await file
+  //     // console.log(loaded)
+  //     // const i = loadingFiles.find(a => a === loaded.sourceFilePath)
+  //     // loadingFiles.splice(i,1)
+  //     // console.log(loadingFiles)
+  //     return loaded
+  //   } catch (e) {
+  //     console.error(e)
+  //   }
+  // })
   const sources = readingSourceFiles && (await Promise.all(readingSourceFiles)).filter(a => a)
+
+
   return {
     folders,
     sources
@@ -38,9 +55,8 @@ async function readSources(config, database, processors) {
 
 /**
  * @param {VotiveConfig} config
- * @param {Database} database
  */
-function fileFilter(config, database) {
+function fileFilter(config) {
   /** @param {Dirent} dirent */
   return (dirent) => {
     const isDestinationFolder = !path.relative(config.destinationFolder, path.join(dirent.parentPath, dirent.name))
@@ -53,9 +69,9 @@ function fileFilter(config, database) {
       return false // Ignore hidden files
     } else if (dirent.parentPath.includes(path.sep + ".")) {
       return false // Ignore hidden folders
-    } else if(dirent.parentPath.match(/^\.\w/)) {
+    } else if (dirent.parentPath.match(/^\.\w/)) {
       return false // Ignore hidden folders
-    } if(isDestinationFolder) {
+    } if (isDestinationFolder) {
       return false
     }
     return true
@@ -63,15 +79,18 @@ function fileFilter(config, database) {
 }
 
 /**
- * @typedef {ReadSourceFilePlugin[]} ReadSourceFileResult
+ * @typedef {ReadSourceFileResult[]} ReadSourceFilesResult
  */
 
 /**
- * @typedef {object} ReadSourceFilePlugin
+ * @typedef {object} ReadSourceFileResult
  * @property {Abstract} abstract
  * @property {ProcessorSyntax} syntax
+ * @property {object} [metadata]
+ * @property {string} [targetFilePath]
+ * @property {string} [dir]
  * @property {Jobs} jobs
- * @property {string} destinationPath
+ * @property {string} sourceFilePath
  */
 
 /**
@@ -79,101 +98,113 @@ function fileFilter(config, database) {
  * @param {Database} database
  * @param {VotiveConfig} config
  */
-function readSourceFile(processors, database, config) {
+function readSourceFile(processors, database, config, limit) {
   /**
    * @param {import("node:fs").Dirent} dirent
-   * @returns {Promise<ReadSourceFilePlugin>[]}
+   * @returns {Promise<ReadSourceFileResult>[]}
    */
   return (dirent) => {
     const { name, parentPath } = dirent
-    const filePath = path.join(parentPath, name)
-    const fileInfo = path.parse(filePath)
+    const sourceFilePath = path.join(parentPath, name)
+    const sourceFileInfo = path.parse(sourceFilePath)
 
-    const processing = processors.flatMap(({ plugin, processor }) => process(plugin, processor, config))
+    const processing = processors.flatMap(({ plugin, processor }) => process(plugin, processor, config, limit))
 
     /**
      * @param {VotivePlugin} plugin
      * @param {VotiveProcessor} processor
      * @param {VotiveConfig} config
      */
-    async function process(plugin, processor, config) {
-      const { read, filter, syntax } = processor
-      if (filter && filter.extensions.includes(fileInfo.ext) && read && (read.text || read.path)) {
+    async function process(plugin, processor, config, limit) {
+      const { readFile: read, extensions: filter, format } = processor
+      if (filter.includes(sourceFileInfo.ext) && read) {
 
         // Check modified time
-        const stat = await fs.stat(filePath)
-        const source = database.getSource(filePath)
-
+        const stat = await fs.stat(sourceFilePath)
+        const source = database.source.get(sourceFilePath)
+        const diff = source && source.lastModified - Number(Math.floor(stat.mtimeMs))
 
-        if (source && source.lastModified === Number(stat.mtimeMs.toFixed())) return null
+        if (source && diff > -1) {
+          return null
+        }
 
-        database.deleteSettings(filePath)
+        database.setting.deleteBySource(sourceFilePath)
 
-        // Get destination route
-        const destinationPath = route(filePath, plugin, config)
+        const targetFilePath = route(sourceFilePath, plugin, config)
+        const targetFileExtension = path.extname(targetFilePath)
 
         // Set URL if exists
         const allJobs = []
-        const destination = {}
 
-        // TODO: Rename "path" to "asset"
-        if (read.path) {
-          const {metadata, abstract, jobs} = await read.path(filePath, database, config)
+        if (format === "buffer") {
+
+          // FIXME update this type
+          const data = read(sourceFilePath, database, config)
+          const { metadata, abstract, jobs } = data
 
-          database.createOrUpdateDestination({
+          const target = database.target.create({
             metadata,
             abstract,
-            path: destinationPath,
-            syntax
+            path: targetFilePath,
           })
 
-          if(Array.isArray(jobs)) {
+
+          if (Array.isArray(jobs)) {
             allJobs.push(...jobs)
           }
         }
 
-        if (read.text) {
-          const buffer = await fs.readFile(path.format(fileInfo))
-          const data = decodeBuffer(buffer)
+        if (format === "text") {
+          const stats = await fs.stat(sourceFilePath)
+          const data = await fs.readFile(sourceFilePath, { encoding: "utf-8" })
 
-          const { jobs, abstract, metadata } = read.text(data, filePath, destinationPath, database, config)
+          const { jobs, abstract, metadata } = read(data, sourceFilePath, targetFilePath, database, config)
 
-          if(Array.isArray(jobs)) {
+
+          if (Array.isArray(jobs)) {
             allJobs.push(...jobs)
           }
 
-          database.createOrUpdateDestination({
+          const target = database.target.create({
             abstract,
-            path: destinationPath,
+            path: targetFilePath,
             metadata,
-            syntax
           })
 
-          // TODO: DRY up
-          allJobs && allJobs.forEach(job => job.syntax = processor.syntax)
+          // FIXME this won't work with the refactor
+          allJobs && allJobs.forEach(job => job.syntax = processor.extensions[0])
           updateSource()
-          return { abstract, destinationPath, syntax, jobs: allJobs }
+          return {
+            abstract,
+            metadata,
+            syntax: targetFileExtension,
+            targetFilePath: target.path,
+            dir: target.dir,
+            sourceFilePath,
+            jobs: allJobs
+          }
         }
 
-        // TODO: DRY up
-        allJobs && allJobs.forEach(job => job.syntax = processor.syntax)
+        // FIXME Job syntax
+        allJobs && allJobs.forEach(job => job.syntax = processor.extensions[0])
         updateSource()
 
         return {
           jobs: allJobs,
           abstract: null,
-          destinationPath: null,
+          targetFilePath: null,
+          sourceFilePath: null,
           metadata: null,
-          syntax
+          syntax: null
         }
 
         function updateSource() {
           const timeStamp = stat.mtimeMs.toFixed()
 
           if (source) {
-            database.updateSource(filePath, Number(timeStamp))
+            database.source.updateTimestamp(sourceFilePath, Number(timeStamp))
           } else {
-            database.createSource(filePath, destinationPath, Number(timeStamp))
+            database.source.create(sourceFilePath, targetFilePath, Number(timeStamp))
           }
         }
 
@@ -192,17 +223,38 @@ function readSourceFile(processors, database, config) {
 function route(filePath, plugin, config) {
   const { dir, ...parsedPath } = path.parse(filePath)
   const rooty = !path.relative(config.sourceFolder, dir)
+  const segments = ["", ...dir.split(path.sep).filter(a => a)]
   const pathInfo = {
     inRootDir: rooty,
-    dir: dir.split(path.sep),
+    dir: segments,
     ...parsedPath
   }
+
   if (!plugin.router) return "0"
+
   const routedPath = plugin.router(pathInfo)
-  if (routedPath && typeof routedPath.dir !== "string") {
-    routedPath.dir = path.join(...routedPath.dir)
+
+  if (!routedPath) return "0"
+
+  if (routedPath.hasOwnProperty("dir") && Array.isArray(routedPath.dir)) {
+    return path.normalize(path.format({
+      dir: path.join(...routedPath.dir),
+      root: routedPath.root || "",
+      base: routedPath.base,
+      name: routedPath.name,
+      ext: routedPath.ext
+    }))
+  }
+
+  const routedInfo = {
+    dir: routedPath.dir || "",
+    root: routedPath.root || "",
+    base: routedPath.base,
+    name: routedPath.name,
+    ext: routedPath.ext
   }
-  return routedPath ? path.format(routedPath) : "0"
+
+  return path.normalize(path.format(routedInfo))
 }
 
 export default readSources

package/lib/runJobs.js

@@ -16,9 +16,6 @@ async function runJobs(jobs, config, database) {
       if (processor.syntax === job.syntax) {
         try {
           const response = await fetch(job.data)
-          // TODO: Change name of "job" to "url"
-          // TODO: Change name of "runner" to "format"
-          // TODO: Probably get rid of syntax filter
           if (response.status >= 200 && response.status < 300) {
             const data = await response[job.runner]()
             const processed = processor.fetcher(data)
@@ -28,6 +25,7 @@ async function runJobs(jobs, config, database) {
             console.warn(`Error fetching URL: ${job.data}`)
           }
         } catch (e) {
+          console.error(e)
           return
         }
       }

package/lib/sqlite.js

@@ -1,5 +1,3 @@
-// TODO: and, or, not, between, not in, order
-
 const operators = {
   glob: "GLOB",
   like: "LIKE",
@@ -9,7 +7,7 @@ const operators = {
   gte: ">=",
   lte: "<=",
   equal: "=",
-  notEqual: "!-"
+  notEqual: "!="
 }
 
 const select = `SELECT * FROM destinations d`
@@ -39,16 +37,16 @@ const join = `LEFT JOIN metadata m ON d.path = m.destination`
  */
 export default function createStatement(query) {
   const segments = [select, join]
-  if(query.limit) segments.push(`LIMIT ${query.limit}`)
-  if(query.offset) segments.push(`OFFSET ${query.offset}`)
-  if(query.orderBy) segments.push(`ORDER BY ${query.orderBy}`)
-  if(query.filter) {
+  if (query.limit) segments.push(`LIMIT ${query.limit}`)
+  if (query.offset) segments.push(`OFFSET ${query.offset}`)
+  if (query.orderBy) segments.push(`ORDER BY ${query.orderBy}`)
+  if (query.filter) {
     const conditions = query.filter.map(condition => {
       const { property, operator, value } = condition
-      
-      if(["dir", "abstract", "path"].includes(property)) {
-        
-      return `d.${property} ${operators[operator]} ${formatValue(value)}`
+
+      if (["dir", "abstract", "path", "syntax"].includes(property)) {
+
+        return `d.${property} ${operators[operator]} ${formatValue(value)}`
       }
       return `m.label = '${property}' AND m.value ${operators[operator]} ${formatValue(value)}`
     })
@@ -60,17 +58,17 @@ export default function createStatement(query) {
 }
 
 function formatProperty(property) {
-  if(property === "abstract") return `d.${property}`
+  if (property === "abstract") return `d.${property}`
   else return `m.${property}`
 }
 
 /** @param {any} value */
 function formatValue(value) {
-  if(Array.isArray(value)) {
+  if (Array.isArray(value)) {
     return `(${value.map(x => `'${x}'`).join(', ')})`
   }
 
-  if(typeof value === "number") return value
+  if (typeof value === "number") return value
 
   return `'${value}'`
 }

package/lib/utils/index.js

@@ -2,14 +2,18 @@ import { styleText } from "node:util"
 import { statSync } from "node:fs"
 import path from "path"
 
-/** @param {string} label */
-export function stopwatch(label) {
+/**
+ * @param {string} label
+ * @param {string} message
+ * @param {boolean} verbose
+ */
+export function stopwatch(label, message, verbose) {
   const start = performance.now()
 
   function stop() {
     const end = performance.now()
     const duration = end - start
-    console.info(`${label}: ${styleText("red", duration.toFixed(2) + "ms")}`)
+    if(verbose) console.info(`${styleText("dim", label + ":")} ${styleText("magenta", message)} ${styleText("magenta", duration.toFixed(2) + "ms")}`)
   }
 
   return stop
@@ -22,7 +26,7 @@ export function splitURL(urlPath) {
   const [urlFileName, ...urlDirSegmentsReversed] = urlPath.split("/").filter(a => a).reverse()
   const segments = urlDirSegmentsReversed.reverse()
   segments.push('')
-  const folder = segments.join(path.sep)
+  const folder = path.relative("", segments.join(path.sep))
   return folder
 }
 

package/lib/writeDestinations.js

@@ -12,41 +12,46 @@ import { checkFile } from "./utils/index.js"
  */
 async function writeDestinations(config, database) {
   const writeProcessors = config && config.plugins && config.plugins.flatMap(plugin => (
-    plugin.processors && plugin.processors.map(({ write, syntax }) => write && { write, syntax }).filter(a => a)
+    plugin.processors && plugin.processors.map(processor => processor.writeFile && processor).filter(a => a)
   )).filter(a => a)
 
   if (!writeProcessors || !writeProcessors.length) throw "No write processor provided"
 
-  const destinations = database.getStaleDestinations()
-  if (!destinations) return
+  const targets = database.target.getStale()
 
-  const writing = destinations.flatMap(destination => {
-    if(!destination.path) database.freshenDependency(destination.path)
+  if (!targets) return
+
+  const writing = targets.filter(({ path }) => path !== "0").flatMap(destination => {
+
+    /* FIXME the following line doesn't make sense */
+    if (!destination.path) database.target.markFresh(destination.path)
+    if (!Object.keys(destination.abstract).length) return
     const destinationPath = path.join(config.destinationFolder, String(destination.path))
     const { dir } = path.parse(destinationPath)
     return writeProcessors.map(async processor => {
-      if (processor.syntax === destination.syntax) {
-        const writeInfo = await processor.write(destination, database, config)
-        if(!writeInfo) return
-        const { data, buffer, encoding = 'utf-8' } = writeInfo
+      if (processor.extensions.includes(destination.syntax)) {
+        const writeInfo = await processor.writeFile(destination, database, config)
+        if (!writeInfo) return
+        const { data, encoding = 'utf-8' } = writeInfo
 
         async function write() {
           const destinationExists = checkFile(dir)
 
-          // TODO: Avoid collisions
-          if(!destinationExists) {
+          if (!destinationExists) {
             await mkdir(dir, { recursive: true })
           }
 
-          if(buffer) {
-            await writeFile(destinationPath, buffer)
-          } else if(data) {
-            await writeFile(destinationPath, data, encoding)
+          if (data) {
+            if (processor.format === "text") {
+              await writeFile(destinationPath, data, "utf-8")
+              database.target.markFresh(destination.path)
+            } else {
+              await writeFile(destinationPath, data)
+              database.target.markFresh(destination.path)
+            }
           }
-
-          database.freshenDependency(destination.path)
         }
-        
+
         return write()
       }
     })