votive 0.2.0 → 0.3.0

package/lib/createDatabase.js

@@ -1,52 +1,13 @@
 import { DatabaseSync, backup } from "node:sqlite"
 import { splitURL, checkFile } from "./utils/index.js"
+import { statSync } from "node:fs"
 import path from "node:path"
 
-/** @typedef {ReturnType<createDatabase>} Database */
-
-/**
- * @typedef {object | array} Abstract
- */
-
-/**
- * @typedef {any} MetadataProperty
- */
-
-/**
- * @typedef {Record<string, MetadataProperty>} Metadata 
- */
-
-/**
- * @typedef {object} TargetOutput
- * @property {number} key
- * @property {string} path
- * @property {string} dir
- * @property {string} syntax
- * @property {number} stale
- * @property {Abstract} abstract
- * @property {Metadata} metadata
- */
-
 /**
- * @typedef {object} TargetInput
- * @property {string} path
- * @property {Abstract} abstract
- * @property {Metadata} metadata
+ * @typedef {ReturnType<createDatabase>} Database
  */
 
 
-/**
- * @param {string} json
- * @returns {object | array}
- */
-function coerceJSON(json) {
-  const parsed = JSON.parse(json)
-  if (!json) return {}
-  if (Array.isArray(json)) return parsed
-  if (typeof parsed === "object") return parsed
-  else return {}
-}
-
 /** @param {string} dbPath */
 function loadDB(dbPath) {
   if (checkFile(dbPath)) return new DatabaseSync(dbPath)
@@ -54,952 +15,433 @@ function loadDB(dbPath) {
 }
 
 
-/** @param {DatabaseSync} database */
-function prepareStatements(database) {
+/** @param {string} dbPath */
+function createDatabase(dbPath = ".votive.db") {
+  const databaseSync = loadDB(dbPath)
 
-  const { prepare } = database
+  const store = databaseSync.createTagStore()
 
-  /**
-   * @typedef {string} JSONString - A string that is actually JSON.
-   */
+  databaseSync.exec(sqlCreateTables)
 
-  /**
-   * @typedef {object} SQLiteSource
-   * @property {number} id
-   * @property {string} destination
-   * @property {string} filePath
-   * @property {number} lastModified
-   */
+  const database = {}
 
-  /**
-   * @typedef {object} SQLiteTarget
-   * @property {number} key
-   * @property {string} path
-   * @property {string} dir
-   * @property {string} syntax
-   * @property {number} stale
-   * @property {JSONString} abstract
-   * @property {JSONString} metadata
-   */
+  database.saveDB = async () => {
+    if (databaseSync.location()) return // Only save if running in memory
+    await backup(databaseSync, dbPath)
+  }
 
   /**
-   * @typedef {object} SQLiteDependency
-   * @property {number} key
-   * @property {string} destination
-   * @property {string} property
-   * @property {string} dependent
+   * @param {string} folderPath 
+   * @param {string} urlPath
    */
+  database.createFolder = (folderPath, urlPath) => {
+    return store.get`INSERT INTO folders (folderPath, urlPath) VALUES :${folderPath} :${urlPath} RETURNING *`
+  }
+
+  const createSource = databaseSync.prepare(`INSERT INTO sources (path, destination, lastModified) VALUES (?, ?, ?)`)
 
   /**
-   * @typedef {object} SQLiteMetadata
-   * @property {number} id
-   * @property {string} destination
-   * @property {string} label
-   * @property {string} value
-   * @property {string} type
+   * @param {string} source - Source file path.
+   * @param {string} destination - Destination file path.
+   * @param {number} lastModified - Source file date last modified.
    */
+  database.createSource = (source, destination, lastModified) => {
+    databaseSync.prepare(``) // SQLite bug. Query fails without this.
+    createSource.get(source, destination, lastModified)
+  }
+
+  const updateSource = databaseSync.prepare(`UPDATE sources SET lastModified = ? WHERE path = ?`)
 
   /**
-   * @typedef {object} SQLiteSetting
-   * @typedef {number} id
-   * @typedef {string} destination
-   * @typedef {string} source
-   * @typedef {string} label
-   * @typedef {string} value
+   * @param {string} source
+   * @param {number} lastModified
    */
+  database.updateSource = (source, lastModified) => {
+    updateSource.get(lastModified, source)
+  }
+
+  const getSettingsBySource = databaseSync.prepare(`SELECT * FROM settings WHERE source = ?`)
+
+
+  // These statements are cached, no need to refactor
+  const createDest = databaseSync.prepare(`INSERT INTO destinations (path, dir, syntax, stale, abstract) VALUES (?, ?, ?, 1, ?)`)
+  const updateDest = databaseSync.prepare(`UPDATE destinations SET abstract = ? WHERE path = ?`)
+  const createMeta = databaseSync.prepare(`INSERT INTO metadata (destination, label, value, type) VALUES (?, ?, ?, ?)`)
+  const updateMeta = databaseSync.prepare(`UPDATE metadata SET value = ? WHERE destination = ? AND label = ?`)
+  const getDepends = databaseSync.prepare(`SELECT * FROM dependencies WHERE destination = ? AND property = ?`)
+  const getDependenciesByDestination = databaseSync.prepare(`SELECT * FROM dependencies WHERE destination = ?`)
+  const getAllDeps = databaseSync.prepare(`SELECT * FROM dependencies`)
+  const staleDepen = databaseSync.prepare(`UPDATE destinations SET stale = 1 WHERE path = ?`)
+  const freshDepen = databaseSync.prepare(`UPDATE destinations SET stale = 0 WHERE path = ? RETURNING *`)
+  const staleDescendents = databaseSync.prepare(`UPDATE destinations SET stale = 1 WHERE path LIKE ? RETURNING *`)
+  const getAllSettings = databaseSync.prepare(`SELECT * FROM settings`)
+
+  database.getAllSettings = () => {
+    return getAllSettings.all()
+  }
+
+  /** @param {string} path */
+  database.freshenDependency = (path) => {
+    freshDepen.get(path)
+  }
+
+  database.getDependencies = () => {
+    return getAllDeps.all()
+  }
 
   /**
-   * @typedef {object} SQLiteURL
-   * @typedef {string} url
-   * @typedef {string} data
+   * @param {object} params
+   * @param {string} params.path - Destination file path
+   * @param {object} params.abstract
+   * @param {object} params.metadata
+   * @param {string} params.syntax - Destination abstract syntax
    */
-
-  return {
-
-    /* SOURCES */
-    source: {
-
-      /**
-       * @callback SQLiteSourcesCreate
-       * @param {string} path
-       * @param {string} destination
-       * @param {number} timestamp
-       * @returns {SQLiteSource}
-       */
-
-      create: /** @type {{get: SQLiteSourcesCreate}} */ (/** @type {unknown} */ (database.prepare(`
-        INSERT INTO sources (path, destination, lastModified) VALUES (?, ?, ?)
-        RETURNING *
-      `))),
-
-      /**
-       * @callback SQLiteSourcesDelete
-       * @param {string} filePath
-       * @returns {SQLiteSource}
-       */
-
-      delete: /** @type {{get: SQLiteSourcesDelete}} */ (/** @type {unknown} */ (database.prepare(`
-        DELETE FROM sources WHERE path = ? RETURNING *
-      `))),
-
-      /**
-       * @callback SQLiteSourcesGet
-       * @param {string} path
-       * @returns {SQLiteSource}
-       */
-
-      get: /** @type {{get: SQLiteSourcesGet}} */ (/** @type {unknown} */ (database.prepare(`
-        SELECT * FROM sources WHERE path = ?
-      `))),
-
-      /**
-       * @callback SQLiteSourcesGetAll
-       * @returns {SQLiteSource[]}
-       */
-
-      getAll: /** @type {{all: SQLiteSourcesGetAll}} */ (/** @type {unknown} */ (database.prepare(`
-        SELECT * FROM sources
-      `))),
-
-
-      /**
-       * @callback SQLiteSourcesUpdate
-       * @param {number} timestamp
-       * @param {string} filePath
-       * @returns {void}
-       */
-
-      update: /** @type {{get: SQLiteSourcesUpdate}} */ (/** @type {unknown} */ (database.prepare(`
-        UPDATE sources SET lastModified = ? WHERE path = ?
-      `))),
-    },
-
-    /* TARGETS */
-    target: {
-
-      /**
-       * @callback SQLiteTargetCreate
-       * @param {string} path
-       * @param {string} dir
-       * @param {string} syntax
-       * @param {string} abstract
-       * @returns {SQLiteTarget}
-       */
-
-      create: /** @type {{get: SQLiteTargetCreate}} */ (/** @type {unknown} */ (database.prepare(`
-        INSERT OR IGNORE INTO destinations (path, dir, syntax, stale, abstract)
-        VALUES (?, ?, ?, 1, ?)
-        RETURNING *
-      `))),
-
-
-      /**
-       * @callback SQLiteTargetDelete
-       * @param {string} targetFilePath
-       * @returns {void}
-       */
-
-      delete: /** @type {{get: SQLiteTargetDelete}} */ (/** @type {unknown} */ (database.prepare(`
-        DELETE FROM destinations WHERE path = ?
-      `))),
-
-      /**
-       * @callback SQLiteTargetGet
-       * @param {string} targetFilePath
-       * @returns {SQLiteTarget}
-       */
-
-      get: /** @type {{get: SQLiteTargetGet}} */ (/** @type {unknown} */ (database.prepare(`
-        WITH destination AS (
-          SELECT * FROM destinations
-          LEFT JOIN metadata ON destinations.path = metadata.destination
-          WHERE path = ?
-        )
-        SELECT destination.path, destination.dir, destination.syntax, destination.abstract, json_group_object(destination.label, destination.value) AS metadata
-        FROM destination
-        GROUP BY destination.path
-      `))),
-
-      /**
-       * @callback SQLiteTargetGetMany
-       * @param {{ filter: JSONString, folder: string, recursivePath: string }} params
-       * @returns {SQLiteTarget[]}
-       */
-
-      getMany: /** @type {{all: SQLiteTargetGetMany}} */ (/** @type {unknown} */ (database.prepare(`
-        WITH matches AS (
-          SELECT m.destination, COUNT(*) AS match_count
-          FROM metadata m
-          INNER JOIN json_each(:filter) j ON j.key = m.label AND j.value = m.value
-          GROUP BY m.destination
-        ),
-        filter_count AS (
-          SELECT COUNT(*) AS total FROM json_each(:filter)
-        )
-        SELECT d.*, json_group_object(i.label, i.value) AS metadata
-        FROM destinations d
-        INNER JOIN metadata i ON d.path = i.destination
-        LEFT JOIN matches ON matches.destination = d.path
-        CROSS JOIN filter_count f
-        WHERE (
-          f.total = 0
-          OR matches.match_count = f.total
-        )
-        AND (
-          d.dir = :folder
-          OR d.dir LIKE :recursivePath
-        )
-        GROUP BY d.path
-        ORDER BY d.path ASC
-      `))),
-
-
-      /**
-       * @callback SQLiteTargetGetAll
-       * @returns {SQLiteTarget[]}
-       */
-
-      getAll: /** @type {{all: SQLiteTargetGetAll}} */ (/** @type {unknown} */ (database.prepare(`
-        SELECT destinations.*, json_group_object(i.label, i.value) AS metadata
-        FROM destinations
-        LEFT JOIN metadata i ON destinations.path = i.destination
-        GROUP BY destinations.path
-      `))),
-
-      /**
-       * @callback SQLiteTargetGetAllStale
-       * @returns {SQLiteTarget[]}
-       */
-
-      getAllStale: /** @type {{all: SQLiteTargetGetAllStale}} */ (/** @type {unknown} */ (database.prepare(`
-        WITH destination AS (
-          SELECT * FROM destinations
-          LEFT JOIN metadata ON destinations.path = metadata.destination
-        ) 
-        SELECT destination.path, destination.dir, destination.syntax, destination.abstract, json_group_object(destination.label, destination.value) AS metadata
-        FROM destination
-        WHERE stale = 1
-        GROUP BY destination.path
-      `))),
-
-      /**
-       * @callback SQLiteTargetMarkDescendentsStale
-       * @param {string} targetFilePathPattern
-       * @returns {SQLiteTarget[]}
-       */
-
-      markDescendentsStale: /** @type {{all: SQLiteTargetMarkDescendentsStale}} */ (/** @type {unknown} */ (database.prepare(`
-        UPDATE destinations SET stale = 1 WHERE path LIKE ? RETURNING *
-      `))),
-
-      /**
-       * @callback SQLiteTargetMarkFresh
-       * @param {string} targetFilePath
-       * @returns {SQLiteTarget[]}
-       */
-
-      markFresh: /** @type {{get: SQLiteTargetMarkFresh}} */ (/** @type {unknown} */ (database.prepare(`
-        UPDATE destinations SET stale = 0 WHERE path = ? RETURNING *
-      `))),
-
-      /**
-       * @callback SQLiteTargetMarkStale
-       * @param {string} targetFilePath
-       * @returns {SQLiteTarget}
-       */
-
-      markStale: /** @type {{get: SQLiteTargetMarkStale}} */ (/** @type {unknown} */ (database.prepare(`
-        UPDATE destinations SET stale = 1 WHERE path = ? RETURNING *
-      `))),
-
-      /**
-       * @callback SQLiteTargetUpdate
-       * @param {string} abstract
-       * @param {string} targetFilePath
-       * @returns {SQLiteTarget}
-       */
-      update: /** @type {{get: SQLiteTargetUpdate}} */ (/** @type {unknown} */ (database.prepare(`
-        UPDATE destinations
-        SET abstract = ?
-        WHERE path = ?
-      `))),
-    },
-
-    /* DEPENDENCIES */
-    dependency: {
-
-      /**
-       * @callback SQLiteDependencyCreate
-       * @param {string} destination
-       * @param {string} property
-       * @param {string} dependent
-       * @returns {void}
-       */
-
-      create: /** @type {{get: SQLiteDependencyCreate}} */ (/** @type {unknown} */ (database.prepare(`
-        INSERT OR IGNORE INTO dependencies (destination, property, dependent)
-        VALUES (?, ?, ?)
-      `))),
-
-      /**
-       * @callback SQLiteDependencyDeleteByTarget
-       * @param {string} targetFilePath
-       * @returns {SQLiteDependency[]}
-       */
-
-      deleteByTarget: /** @type {{all: SQLiteDependencyDeleteByTarget}} */ (/** @type {unknown} */ (database.prepare(`
-        DELETE FROM dependencies WHERE destination = ? RETURNING dependent
-      `))),
-
-      /**
-       * @callback SQLiteDependencyGetAll
-       * @returns {SQLiteDependency[]}
-       */
-
-      getAll: /** @type {{all: SQLiteDependencyGetAll}} */ (/** @type {unknown} */ (database.prepare(`
-        SELECT * FROM dependencies
-      `))),
-
-      /**
-       * @callback SQLiteDependencyGetByTarget
-       * @param {string} targetFilePath
-       * @returns {SQLiteDependency[]}
-       */
-
-      getAllByTarget: /** @type {{all: SQLiteDependencyGetByTarget}} */ (/** @type {unknown} */ (database.prepare(`
-        SELECT * FROM dependencies WHERE destination = ?
-      `))),
-
-      /**
-       * @callback SQLiteDependencyGetByTargetAndProperty
-       * @param {string} targetFilePath
-       * @param {string} property
-       * @returns {SQLiteDependency[]}
-       */
-
-      getByTargetAndProperty: /** @type {{all: SQLiteDependencyGetByTargetAndProperty}} */ (/** @type {unknown} */ (database.prepare(`
-        SELECT * FROM dependencies WHERE destination = ? AND property = ?
-      `))),
-
-    },
-
-    /* METADATA */
-    metadata: {
-
-      /**
-       * @callback SQLiteMetadataCreate
-       * @param {JSONString} metadataJSON
-       * @param {string} targetPath
-       * @returns {void}
-       */
-
-      create: /** @type {{get: SQLiteMetadataCreate}} */ (/** @type {unknown} */ (database.prepare(`
-        INSERT OR REPLACE INTO metadata (label, value, type, destination)
-        SELECT
-          json_each.key,
-          json_each.value,
-          json_each.type,
-          ?
-        FROM json_each(?);
-      `))),
-
-      /**
-       * @callback SQLiteMetadataDelete
-       * @param {string} targetFilePath
-       * @param {string} label
-       * @returns {void}
-       */
-
-      delete: /** @type {{get: SQLiteMetadataDelete}} */ (/** @type {unknown} */ (database.prepare(`
-        DELETE FROM metadata WHERE destination = ? AND label = ?
-      `))),
-
-      /**
-       * @callback SQLiteMetadataDeleteByTarget
-       * @param {string} targetFilePath
-       * @returns {void}
-       */
-
-      deleteByTarget: /** @type {{all: SQLiteMetadataDeleteByTarget}} */ (/** @type {unknown} */ (database.prepare(`
-        DELETE FROM metadata WHERE destination = ?
-      `)))
-    },
-
-    /* SETTINGS */
-    settings: {
-
-      /**
-       * @callback SQLiteSettingsCreate
-       * @param {string} targetFilePath
-       * @param {string} label
-       * @param {string} value
-       * @param {string} sourceFilePath
-       * @returns {SQLiteSetting[]}
-       */
-
-      create: /** @type {{get: SQLiteSettingsCreate}} */ (/** @type {unknown} */ (database.prepare(`
-        INSERT OR IGNORE INTO settings (destination, label, value, source) VALUES (?, ?, ?, ?) RETURNING *
-      `))),
-
-      /**
-       * @callback SQLiteSettingsDelete
-       * @param {string} sourceFilePath
-       * @returns {SQLiteSetting[]}
-       */
-
-      delete: /** @type {{all: SQLiteSettingsDelete}} */ (/** @type {unknown} */ (database.prepare(`
-        DELETE FROM settings WHERE source = ?
-        RETURNING *
-      `))),
-
-      /**
-       * @callback SQLiteSettingsGet
-       * @param {string} label
-       * @param {string} targetFilePath
-       * @returns {SQLiteSettings[]}
-       */
-
-      get: /** @type {{all: SQLiteSettingsGet}} */ (/** @type {unknown} */ (database.prepare(`
-        SELECT * FROM settings WHERE label = ? AND destination = ?
-      `))),
-
-      /**
-       * @callback SQLiteSettingsGetAll
-       * @returns {SQLiteSetting[]}
-       */
-
-      getAll: /** @type {{all: SQLiteSettingsGetAll}} */ (/** @type {unknown} */ (database.prepare(`
-        SELECT * FROM settings
-      `))),
-
-      /**
-       * @callback SQLiteSettingsGetByFolder
-       * @param {JSONString} JSONarray - JSON string of an array of target file paths
-       * @returns {SQLiteSetting[]}
-       */
-
-      getByFolder: /** @type {{all: SQLiteSettingsGetByFolder}} */ (/** @type {unknown} */ (database.prepare(`
-        SELECT label, json_group_array(json_object('destination', destination, 'value', value)) AS settings
-        FROM settings
-        WHERE destination IN (SELECT value FROM json_each(?))
-        GROUP BY label
-      `))),
-
-      /**
-       * @callback SQLiteSettingsUpdate
-       * @param {string} value
-       * @param {string} targetFilePath
-       * @param {string} label
-       * @returns {SQLiteSettings}
-       */
-
-      update: /** @type {{get: SQLiteSettingsUpdate}} */ (/** @type {unknown} */ (database.prepare(`
-        UPDATE settings SET value = ? WHERE destination = ? AND label = ? RETURNING *
-      `)))
-    },
-
-    /* URLS */
-    url: {
-
-      /**
-       * @callback SQLiteURLCreate
-       * @param {string} url
-       * @param {string} data
-       * @returns {SQLiteURL}
-       */
-
-      create: /** @type {{get: SQLiteURLCreate}} */ (/** @type {unknown} */ (database.prepare(`
-        INSERT OR IGNORE INTO urls (url, data) VALUES (?, ?) RETURNING *
-      `))),
-
-      /**
-       * @callback SQLiteURLGet
-       * @param {string} url
-       * @returns {SQLiteURL}
-       */
-
-      get: /** @type {{get: SQLiteURLGet}} */ (/** @type {unknown} */ (database.prepare(`
-        SELECT data FROM urls WHERE url = ?
-      `)))
+  database.createOrUpdateDestination = ({ metadata, ...dest }) => {
+    const [dir] = dest.path ? splitURL(dest.path) : []
+    const params = Object.keys(metadata)
+    if (dest.abstract) params.push("abstract")
+    const extant = database.getDestinationIndependently(dest.path, params)
+
+    if (!extant) {
+      createDest.get(dest.path, dir, dest.syntax, JSON.stringify(dest.abstract))
+      Object.entries(metadata).map(([k, v]) => createMeta.get(dest.path, k, v, typeof v))
+      return
     }
-  }
-}
 
-/**
- * @param {string} databasePath
- */
-function createDatabase(databasePath = ".votive.db") {
-
-  const database = loadDB(databasePath)
-  createTables(database)
-  const prepared = prepareStatements(database)
-
-  const queries = {
-    begin: () => database.exec("BEGIN TRANSACTION"),
-    commit: () => database.exec("COMMIT"),
-    restore: () => database.exec("RESTORE"),
-    raw: database,
-
-    /** @param {object[]} sources */
-    async saveDB(sources) {
-      /*
-        FIXME This seems to throw an error sometimes if the backup
-        runs too quickly after writing, which maybe happens when
-        Votive runs with no changes. To guard against this, I check
-        to see if any sources have changed. With no source changes,
-        the backup should theoretically be unnecessary.
-      */
-      if (database.location() || !sources.length) return // Only save if running in memory
-      await backup(database, databasePath)
-    },
-
-    source: {
-
-      /**
-       * @param {string} source - Source file path.
-       * @param {string} target - Destination file path.
-       * @param {number} lastModified - Source file date last modified.
-       */
-      create(source, target, lastModified) {
-        const created = prepared.source.create.get(source, target, lastModified)
-        prepared.target.markDescendentsStale.all("%")
-        return created
-      },
-
-      /** @param {string} filePath */
-      delete(filePath) {
-        const deletedSource = prepared.source.delete.get(filePath)
-        prepared.settings.delete.all(filePath)
-        prepared.dependency.deleteByTarget.all(deletedSource.destination)
-          .forEach(({ dependent }) => {
-            prepared.target.markStale.get(dependent)
-          })
-        prepared.metadata.deleteByTarget.all(deletedSource.destination)
-        prepared.target.delete.get(deletedSource.destination)
-        return deletedSource
-      },
-
-      getAll() {
-        return prepared.source.getAll.all()
-      },
-
-      /**
-       * @param {string} filePath
-       */
-      get(filePath) {
-        return prepared.source.get.get(filePath)
-      },
-
-      /**
-       * @param {string} source
-       * @param {number} timestamp
-       */
-      updateTimestamp(source, timestamp) {
-        return prepared.source.update.get(timestamp, source)
-      },
-    },
-
-    setting: {
-
-      /**
-       * @param {string} folder
-       * @param {string} key
-       * @param {string} value
-       * @param {string} [source]
-       */
-      create(folder, key, value, source = "") {
-        const type = typeof value
-        const safeValue = type === "object"
-          ? JSON.stringify(value)
-          : value
-
-        const descendents = folder === ""
-          ? "%"
-          : `${folder}/%`
-
-        prepared.target.markDescendentsStale.all(descendents)
-
-        return prepared.settings.create.get(folder, key, safeValue, source)
-      },
-
-
-      /** @param {string} source */
-      deleteBySource(source) {
-        const deletedSettings = prepared.settings.delete.all(source)
-
-        deletedSettings.forEach(setting => {
-          prepared.dependency.markStale.get(setting.destination)
-          prepared.dependency.markDescendentTargetsStale.all(setting.destination + "/%")
-        })
-      },
-
-      getAll() {
-        return prepared.settings.getAll.all()
-      },
-
-      /** @param {string} folder */
-      getByFolder(folder) {
-        const segments = ["", ...(folder).split(path.sep)
-          .map((_, index, array) => `${array.slice(0, index + 1).join(path.sep)}`)
-          .filter(a => a)]
-
-        const settings = prepared.settings.getByFolder.all(JSON.stringify(segments))
-        const grouped = Object.fromEntries(
-          prepared.settings.getByFolder.all(JSON.stringify(segments)).
-            map(({ label, settings }) => {
-              const targets = Object.groupBy(JSON.parse(settings), ({ destination }) => destination)
-              for (const key in targets) {
-                targets[key] = targets[key].map(({ destination, value }) => value)
-              }
-
-              return [label, targets]
-            })
-        )
-
-        return grouped
-      }
-    },
-
-    dependency: {
-
-
-      getAll() {
-        return prepared.dependency.getAll.all()
-      },
-
-      /**
-       * @param {string} target
-       */
-      getAllByTarget(target) {
-        return prepared.dependency.getAllByTarget.all(target)
-      },
-
-      /**
-       * @param {object} dependencyFile
-       * @param {string} dependencyKey
-       * @param {any} dependencyValue
-       * @param {string} dependencyPath
-       * @param {string} dependentPath
-       */
-      track(dependencyFile, dependencyKey, dependencyValue, dependencyPath, dependentPath) {
-        Object.defineProperty(dependencyFile, dependencyKey, {
-          enumerable: true,
-          get() {
-            prepared.dependency.create.get(dependencyPath, dependencyKey, dependentPath)
-            return dependencyValue
-          }
-        })
-      }
-    },
+    const changedAbstract = JSON.stringify(dest.abstract) !== JSON.stringify(extant.abstract)
 
-    target: {
+    let changedMetadata = false
 
-      /**
-       * @param {string} filePath
-       * @returns {TargetOutput | undefined}
-       */
-      get(filePath) {
-        const target = prepared.target.get.get(filePath)
 
-        if (!target) return
+    // TODO: This is redundant with `getDestinationIndependently`
+    const cachedMetadata = getMetadataByPath.all(dest.path)
 
-        const { metadata, abstract, ...rest } = target
+    for (const key in metadata) {
+      const index = cachedMetadata.findIndex(el => el.label === key)
+      cachedMetadata.splice(index, 1)
+      if (JSON.stringify(metadata[key]) !== JSON.stringify(extant.metadata[key])) {
+        changedMetadata = true
+        updateMeta.get(metadata[key], dest.path, key)
+        const dependencies = getDepends.all(dest.path, key)
+        dependencies.forEach(({ dependent }) => {
+          staleDepen.get(dependent)
+        })
+      }
+    }
 
-        if (!abstract) return
+    cachedMetadata.forEach(deletedDatum => {
+      changedMetadata = true
+      const dependencies = getDepends.all(dest.path, deletedDatum.label)
+      dependencies.forEach(({ dependent }) => {
+        staleDepen.get(dependent)
+      })
+      deleteMetadata.get(deletedDatum.destination, deletedDatum.label)
+    })
+
+    if (changedAbstract || changedMetadata) staleDepen.get(dest.path)
+
+    if (changedAbstract) {
+      updateDest.get(JSON.stringify(dest.abstract), dest.path)
+      const dependencies = getDepends.all(dest.path, "abstract")
+      dependencies.forEach(({ dependent }) => {
+        staleDepen.get(dependent)
+      })
+    }
+  }
 
-        /** @type {TargetOutput} */
-        const copy = {
-          abstract: coerceJSON(abstract),
-          metadata: coerceJSON(metadata),
-          ...rest
-        }
+  const getMetadataByPath = databaseSync.prepare(`
+      SELECT * FROM metadata WHERE destination = ?
+    `)
 
-        return copy
-      },
+  /** @param {string} path */
+  database.getAllMetadataByPath = (path) => {
+    return getMetadataByPath.get(path)
+  }
 
+  /** @param {string[]} params */
+  database.getMetadataIndependently = (params) => {
+    return databaseSync.prepare(`
+      SELECT * FROM destinations d
+      LEFT JOIN metadata m ON d.path = m.destination AND m.label IN (${params.map(p => `'${p}'`).join(", ")})
+      WHERE d.path = ?
+    `)
+  }
 
-      /**
-       * @returns {TargetOutput[]}
-       */
-      getAll() {
-        const targets = prepared.target.getAll.all()
+  database.getDestinationWithoutMetadata = () => {
+    return databaseSync.prepare(`
+        SELECT * FROM destinations
+        WHERE path = ?
+      `)
+  }
 
-        return targets.map(({ metadata, abstract, ...rest }) => {
-          return {
-            abstract: coerceJSON(abstract),
-            metadata: coerceJSON(metadata),
-            ...rest
-          }
-        })
-      },
-
-      /**
-       * @returns {TargetOutput[]}
-       */
-      getStale() {
-        const targets = prepared.target.getAllStale.all()
-
-        return targets.map(({ metadata, abstract, ...rest }) => {
-          return {
-            abstract: coerceJSON(abstract),
-            metadata: coerceJSON(metadata),
-            ...rest
-          }
-        })
-      },
-
-      /**
-       * @param {string} filePath
-       * @param {string} dependent
-       */
-      getWithTrackers(filePath, dependent) {
-        const target = queries.target.get(filePath)
-
-        if(!target) return
-
-        const trackedTarget = { metadata: {} }
-
-        queries.dependency.track(
-          trackedTarget,
-          "abstract",
-          target.abstract,
-          filePath,
-          dependent
-        )
-
-        for (const key in target.metadata) {
-          queries.dependency.track(
-            trackedTarget.metadata,
-            key,
-            target.metadata[key],
-            filePath,
-            dependent
-          )
-        }
+  /**
+   * @param {string} path
+   * @param {string[]} [params]
+   */
+  database.getDestinationIndependently = (path, params) => {
+    // TODO: Could potentially speed up the next two db queries by using the tag store
+
+    const metadatas = (params && params.length)
+      ? database.getMetadataIndependently(params).all(path)
+      : [database.getDestinationWithoutMetadata().get(path)]
+
+    if (!metadatas) return
+
+    const [first] = metadatas
+
+    if (!first) return
+
+    const metadata = Object.fromEntries(
+      metadatas.map(({ label, value, type }) => {
+        const originalValue = type === "undefined"
+          ? undefined
+          : type === "string"
+            ? String(value)
+            : type === "boolean"
+              ? Boolean(value)
+              : typeof value !== "string"
+                ? value
+                : JSON.parse(value)
+        return [label, originalValue]
+      })
+    )
+
+
+    const result = {
+      path: first.path,
+      dir: first.dir,
+      syntax: first.syntax,
+      metadata
+    }
 
-        return target
-      },
-
-      /**
-       * @typedef {object} TargetGetManyWithTrackersParams
-       * @property {string | undefined} [folder]
-       * @property {boolean | undefined} [recursive]
-       * @property {string | undefined} [dependent]
-       * @property {Record<string, string> | undefined} [query]
-       */
-
-      /** @param {TargetGetManyWithTrackersParams | undefined} params */
-      getManyWithTrackers(params) {
-        const { folder = "%", recursive, dependent, query = {} } = params
-
-        const recursivePath = [folder, "%"].filter(a => a).join("/")
-
-        const many = prepared.target.getMany
-          .all({ folder, recursivePath: recursive ? recursivePath : folder, filter: JSON.stringify(query) })
-          .map(({ abstract, metadata, ...rest }) => {
-
-            const trackedTarget = {
-              abstract: coerceJSON(abstract),
-              metadata: coerceJSON(metadata),
-              ...rest
-            }
-
-            queries.dependency.track(
-              trackedTarget,
-              "abstract",
-              trackedTarget.abstract,
-              trackedTarget.path,
-              dependent
-            )
-
-            for (const key in trackedTarget.metadata) {
-              queries.dependency.track(
-                trackedTarget.metadata,
-                key,
-                trackedTarget.metadata[key],
-                trackedTarget.path,
-                dependent
-              )
-            }
-
-            return trackedTarget
-          })
-
-
-        many.sort((a, b) => {
-          if (a.metadata.date) {
-            if (b.metadata.date) {
-              return (new Date(b.metadata.date)).getTime() - (new Date(a.metadata.date)).getTime()
-            } else {
-              return -1
-            }
-          } else {
-            return 1
-          }
-        })
+    const includeAbstract = params && params.includes("abstract")
+    if (includeAbstract) result.abstract = JSON.parse(first.abstract)
 
-        return many
-      },
+    return result
+  }
 
+  /**
+   * @param {string} path
+   * @param {string[]} properties
+   * @param {string} dependent
+   */
+  database.getDestinationDependently = (path, properties, dependent) => {
+    const params = []
+    const deps = []
+
+    properties.forEach(p => {
+      params.push(p)
+      deps.push(`('${path}', '${p}', '${dependent}')`)
+    })
+
+    const result = database.getDestinationIndependently(path, params)
+    if (result.abstract) deps.push(`('${path}, 'abstract', '${dependent}')`)
+    databaseSync.prepare(`INSERT INTO dependencies (destination, property, dependent) VALUES ${deps.join(", ")} RETURNING *`).all()
+  }
 
-      /**
-       * @param {TargetInput} target
-       */
-      create(target) {
-        const dir = target.path && splitURL(target.path)
-        const ext = path.extname(target.path)
-        const relativePath = path.relative("", target.path).toLowerCase()
+  const selectSource = databaseSync.prepare(`SELECT * FROM sources WHERE path = ?`)
 
-        const extant = queries.target.get(target.path)
+  /**
+   * @param {string} path
+   */
+  database.getSource = (path) => {
+    const source = selectSource.get(path)
+    return source
+  }
 
-        if (!extant) {
-          const created = prepared.target.create.get(
-            relativePath,
-            dir,
-            ext,
-            JSON.stringify(target.abstract)
-          )
-          prepared.metadata.create.get(relativePath, JSON.stringify(target.metadata))
-          return created
-        }
+  database.getAllSources = () => {
+    const sources = store.all`SELECT * FROM sources`
+    return sources
+  }
 
-        const keys = Object.keys(target.metadata)
+  const deleteSource = databaseSync.prepare(`DELETE FROM sources WHERE path = ? RETURNING *`)
+  const deleteAllDependenciesByDestination = databaseSync.prepare(`DELETE FROM dependencies WHERE destination = ? RETURNING dependent`)
+  const deleteAllMetadataByDestination = databaseSync.prepare(`DELETE FROM metadata WHERE destination = ?`)
+  const deleteMetadata = databaseSync.prepare(`DELETE FROM metadata WHERE destination = ? AND label = ?`)
+  const deleteDestination = databaseSync.prepare(`DELETE FROM destinations WHERE path = ?`)
+
+  /** @param {string} path */
+  database.deleteSource = (path) => {
+    const deleted = deleteSource.all(path)
+    deleted.forEach(source => {
+      database.deleteSettings(String(source.path))
+      getDependenciesByDestination.all(source.destination)
+      deleteAllDependenciesByDestination.all(source.destination)
+        .forEach(({ dependent }) => staleDepen.get(dependent))
+      deleteAllMetadataByDestination.all(source.destination)
+      deleteDestination.get(source.destination)
+    })
+  }
 
-        for (const key in target.metadata) {
-          if (target.metadata[key] !== extant.metadata[key]) {
+  // TODO: DELETE SETTING
 
-            // TODO use triggers to mark dependencies as stale
-            prepared.metadata.create.get(relativePath, JSON.stringify({
-              [key]: target.metadata[key]
-            }))
+  database.getAllDestinations = () => {
+    return store.all`SELECT * FROM destinations`
+  }
 
-            // TODO delete dependencies after marking stale
-            prepared.dependency
-              .getByTargetAndProperty
-              .all(relativePath, key)
-              .forEach(dependency => {
-                prepared.target.markStale.get(dependency.dependent)
+  database.getStaleDestinations = () => {
+    const metadatas = store.all`
+      SELECT * FROM destinations d
+      LEFT JOIN metadata m on d.path = m.destination
+      WHERE stale = 1`
+
+    const grouped = metadatas.map((value, index, array) => {
+      if (array.slice(0, index)
+        .find(prior => prior.path === value.path)
+      ) {
+        return null
+      } else {
+        return {
+          path: value.path,
+          dir: value.dir,
+          syntax: value.syntax,
+          stale: value.stale,
+          abstract: JSON.parse(value.abstract),
+          metadata: Object.fromEntries(
+            array.slice(index)
+              .filter(following => following.path === value.path)
+              .map(succeeding => {
+                return reconstituteMetadata(succeeding)
               })
-          }
+          )
+
         }
+      }
+    }).filter(a => a)
+
+    function reconstituteMetadata({ label, value, type }) {
+      const originalValue = type === "undefined"
+        ? undefined
+        : type === "string"
+          ? String(value)
+          : type === "boolean"
+            ? Boolean(value)
+            : typeof value !== "string"
+              ? value
+              : JSON.parse(value)
+      return [label, originalValue]
+    }
+   
+    return grouped
+  }
 
-        for (const key in extant.metadata) {
-          if (!target.metadata[key]) {
-            prepared.metadata.delete.get(relativePath, key)
+  const createSetting = databaseSync.prepare(`INSERT INTO settings (destination, label, value, source) VALUES (?, ?, ?, ?) RETURNING *`)
+  const selectSetting = databaseSync.prepare(`SELECT * FROM settings WHERE label = ? AND destination = ?`)
+  const updateSetting = databaseSync.prepare(`UPDATE settings SET value = ? WHERE destination = ? AND label = ? RETURNING *`)
+  const deleteSettings = databaseSync.prepare(`DELETE FROM settings WHERE source = ?`)
 
-            // TODO delete dependencies after marking stale
-            prepared.dependency
-              .getByTargetAndProperty
-              .all(relativePath, key)
-              .forEach(dependency => {
-                prepared.target.markStale.get(dependency.dependent)
-              })
-          }
-        }
+  // const updateDest = databaseSync.prepare(`UPDATE destinations SET abstract = ? WHERE path = ?`)
+
+  // WRITE AN UPDATE SETTINGS FUNCTION FOR WHEN A SOURCE CHANGES
 
-        const changedAbstract = JSON.stringify(target.abstract) !== JSON.stringify(extant.abstract)
+  /** @param {string} source */
+  database.deleteSettings = (source) => {
+    const deleted = deleteSettings.all(source)
+    deleted.forEach(setting => {
+      staleDepen.get(setting.destination)
+      staleDescendents.all(`${setting.destination}/%`)
+    })
+  }
 
-        if (changedAbstract) {
-          prepared.target.update.get(JSON.stringify(target.abstract), relativePath)
+  /**
+   * @param {string} destinationFolder
+   * @param {string} key
+   * @param {string} value
+   * @param {string} [source]
+   * @example
+   * setSetting("", "theme", "summer", "settings.md")
+   * setSetting("data", "format", "csv", "/config.yaml")
+   */
+  database.setSetting = (destinationFolder, key, value, source = "") => {
+    const extant = selectSetting.get(key, destinationFolder)
 
-          prepared.dependency
-            .getByTargetAndProperty
-            .all(relativePath, "abstract")
-            .forEach(dependency => {
-              prepared.target.markStale.get(dependency.dependent)
-            })
-        }
+    if (!extant) return createSetting.get(destinationFolder, key, value, source)
+    if (extant.value === value) return
+    updateSetting.get(value, destinationFolder, key)
 
-        return extant
-      },
+    destinationFolder === ""
+      ? staleDescendents.all("%")
+      : staleDescendents.all(`${destinationFolder}/%`)
+  }
 
-      /** @param {string} filePath */
-      markFresh(filePath) {
-        return prepared.target.markFresh.get(filePath)
-      },
 
-      /** @param {string} filePath */
-      markStale(filePath) {
-        return prepared.target.markStale.get(filePath)
-      }
+  /**
+   * @param {string} destinationFolder
+   */
+  database.getSettings = (destinationFolder) => {
+    const segments = destinationFolder.split(path.sep)
+      .map((_, index, array) => `'${array.slice(0, index + 1).join(path.sep)}'`)
 
-    },
+    segments.unshift("''")
+    const statement = segments.join(", ")
 
-    url: {
+    const records = databaseSync.prepare(`SELECT * FROM settings WHERE destination IN (${statement})`).all()
 
-      /**
-        * @param {string} url
-        * @param {string} data
-        * @param {string} destination
-        */
-      create(url, data, destination) {
-        prepared.url.create.get(url, JSON.stringify(data))
-      },
+    const grouped = {}
+    records.sort((a, b) => a.length - b.length)
+      .forEach(record => {
+        if (!grouped[record.label]) grouped[record.label] = [record.value]
+        else grouped[record.label].push(record.value)
+      })
 
-      /** @param {string} url */
-      get(url) {
-        const { data } = prepared.url.get.get(url) || {}
-        if (!data) return
-        return JSON.parse(data)
-      }
-    }
+    return grouped
+  }
 
+  database.getEverything = () => {
+    return Object.fromEntries(
+      databaseSync.prepare(`SELECT name FROM sqlite_master WHERE type = 'table'`)
+        .all()
+        .map(table => [
+          table.name,
+          databaseSync.prepare(`SELECT * FROM ${table.name}`).all()
+        ])
+    )
   }
 
-  return Object.freeze(queries)
+  return database
 }
 
-/** @param {DatabaseSync} databaseSync */
-function createTables(databaseSync) {
-  databaseSync.exec(`
-    CREATE TABLE IF NOT EXISTS sources (
-      id INTEGER PRIMARY KEY,
-      destination STRING,
-      path STRING,
-      lastModified INTEGER
-    );
-
-    CREATE TABLE IF NOT EXISTS dependencies (
-      key INTEGER PRIMARY KEY,
-      destination STRING NOT NULL,
-      property STRING NOT NULL,
-      dependent STRING NOT NULL,
-      UNIQUE(destination, property, dependent)
-    );
-
-    CREATE TABLE IF NOT EXISTS destinations (
-      key INTEGER PRIMARY KEY,
-      path STRING UNIQUE,
-      dir TEXT,
-      syntax TEXT,
-      stale INTEGER,
-      abstract STRING
-    );
-
-    CREATE TABLE IF NOT EXISTS metadata (
-      id INTEGER PRIMARY KEY,
-      destination STRING,
-      label STRING,
-      value STRING,
-      type STRING,
-      UNIQUE(destination, label)
-    );
-
-    CREATE TABLE IF NOT EXISTS settings (
-      id INTEGER PRIMARY KEY,
-      destination STRING,
-      source STRING,
-      label STRING,
-      value STRING,
-      UNIQUE(destination, label, value, source)
-    );
-
-    CREATE TABLE IF NOT EXISTS urls (
-      url STRING PRIMARY KEY,
-      data STRING
-    );
-
-  `)
-}
+const sqlCreateTables = `
+CREATE TABLE IF NOT EXISTS sources (
+  id INTEGER PRIMARY KEY,
+  destination STRING,
+  path STRING,
+  lastModified INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS dependencies (
+  key INTEGER PRIMARY KEY,
+  destination STRING NOT NULL,
+  property STRING NOT NULL,
+  dependent STRING NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS destinations (
+  key INTEGER PRIMARY KEY,
+  path STRING UNIQUE,
+  dir TEXT,
+  syntax TEXT,
+  stale INTEGER,
+  abstract
+);
+
+CREATE TABLE IF NOT EXISTS metadata (
+  id INTEGER PRIMARY KEY,
+  destination STRING,
+  label STRING,
+  value STRING,
+  type STRING,
+  UNIQUE(destination, label)
+);
+
+CREATE TABLE IF NOT EXISTS settings (
+  id INTEGER PRIMARY KEY,
+  destination STRING,
+  source STRING,
+  label STRING,
+  value STRING
+);
+
+`
 
 export default createDatabase