votive 0.0.8 → 0.0.9

package/lib/createDatabase.js

@@ -1,13 +1,51 @@
 import { DatabaseSync, backup } from "node:sqlite"
 import { splitURL, checkFile } from "./utils/index.js"
-import { statSync } from "node:fs"
 import path from "node:path"
-import createStatement from "./sqlite.js"
+
+/** @typedef {ReturnType<createDatabase>} Database */
+
+/**
+ * @typedef {object | array} Abstract
+ */
+
+/**
+ * @typedef {any} MetadataProperty
+ */
+
+/**
+ * @typedef {Record<string, MetadataProperty>} Metadata 
+ */
 
 /**
- * @typedef {ReturnType<createDatabase>} Database
+ * @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
+ */
+
+
+/**
+ * @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) {
@@ -16,529 +54,936 @@ function loadDB(dbPath) {
 }
 
 
-/** @param {string} dbPath */
-function createDatabase(dbPath = ".votive.db") {
-  const databaseSync = loadDB(dbPath)
+/** @param {DatabaseSync} database */
+function prepareStatements(database) {
 
-  const store = databaseSync.createTagStore()
-
-  databaseSync.exec(sqlCreateTables)
-
-  const database = {}
-
-  database.saveDB = async () => {
-    if (databaseSync.location()) return // Only save if running in memory
-    await backup(databaseSync, dbPath)
-  }
+  const { prepare } = database
 
   /**
-   * @param {string} folderPath 
-   * @param {string} urlPath
+   * @typedef {string} JSONString - A string that is actually JSON.
    */
-  database.createFolder = (folderPath, urlPath) => {
-    return store.get`INSERT OR IGNORE INTO folders (folderPath, urlPath) VALUES :${folderPath} :${urlPath} RETURNING *`
-  }
-
-  const createSource = databaseSync.prepare(`INSERT INTO sources (path, destination, lastModified) VALUES (?, ?, ?)`)
 
   /**
-   * @param {string} source - Source file path.
-   * @param {string} destination - Destination file path.
-   * @param {number} lastModified - Source file date last modified.
+   * @typedef {object} SQLiteSource
+   * @property {number} id
+   * @property {string} destination
+   * @property {string} filePath
+   * @property {number} lastModified
    */
-  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 = ?`)
 
   /**
-   * @param {string} source
-   * @param {number} lastModified
+   * @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.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 OR REPLACE 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 = ? RETURNING *`)
-  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()
-  }
 
   /**
-   * @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
+   * @typedef {object} SQLiteDependency
+   * @property {number} key
+   * @property {string} destination
+   * @property {string} property
+   * @property {string} dependent
    */
-  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]) => {
-        const type = typeof v
-        const value = type === "object"
-          ? JSON.stringify(v)
-          : v
-
-        createMeta.get(dest.path, k, value, typeof v)
-      })
-      return
-    }
-
-    const changedAbstract = JSON.stringify(dest.abstract) !== JSON.stringify(extant.abstract)
-
-    let changedMetadata = false
 
+  /**
+   * @typedef {object} SQLiteMetadata
+   * @property {number} id
+   * @property {string} destination
+   * @property {string} label
+   * @property {string} value
+   * @property {string} type
+   */
 
-    // TODO: This is redundant with `getDestinationIndependently`
-    const cachedMetadata = getMetadataByPath.all(dest.path)
+  /**
+   * @typedef {object} SQLiteSetting
+   * @typedef {number} id
+   * @typedef {string} destination
+   * @typedef {string} source
+   * @typedef {string} label
+   * @typedef {string} value
+   */
 
-    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(JSON.stringify(metadata[key]), dest.path, key)
-        const dependencies = getDepends.all(dest.path, key)
-        dependencies.forEach(({ dependent }) => {
-          staleDepen.get(dependent)
-        })
-      }
-    }
+  /**
+   * @typedef {object} SQLiteURL
+   * @typedef {string} url
+   * @typedef {string} data
+   */
 
-    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)
-      })
+  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[]}
+       */
+
+      getByTarget: /** @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 = ?
+      `)))
     }
   }
+}
 
-  const getMetadataByPath = databaseSync.prepare(`
-      SELECT * FROM metadata WHERE destination = ?
-    `)
+/**
+ * @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.dependency.markStale.get(dependent)
+          })
+        prepared.metadata.deleteByTarget.all(deletedSource.destination)
+        prepared.target.delete.get(deletedSource.destination)
+      },
+
+      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
 
-  /** @param {string} path */
-  database.getAllMetadataByPath = (path) => {
-    return getMetadataByPath.get(path)
-  }
+        const descendents = folder === ""
+          ? "%"
+          : `${folder}/%`
 
-  database.getMetadataIndependently = () => {
-    return databaseSync.prepare(`
-      SELECT * FROM destinations d
-      LEFT JOIN metadata m ON d.path = m.destination
-      WHERE d.path = ?
-    `)
-  }
+        prepared.target.markDescendentsStale.all(descendents)
 
-  database.getDestinationWithoutMetadata = () => {
-    return databaseSync.prepare(`
-        SELECT * FROM destinations
-        WHERE path = ?
-      `)
-  }
+        return prepared.settings.create.get(folder, key, safeValue, source)
+      },
 
-  function castMetadata({ label, value, type }) {
-    return [label,
-      type === "undefined"
-        ? undefined
-        : type === "boolean"
-          ? Boolean(value)
-          : value
-    ]
-  }
-
-  function parseMetadatas(metadatas) {
-    return Object.fromEntries(
-      metadatas.map(castMetadata)
-    )
-  }
 
-  /**
-   * @param {string} path
-   */
-  database.getDestinationIndependently = (path) => {
-    // TODO: Could potentially speed up the next two db queries by using the tag store
+      /** @param {string} source */
+      deleteBySource(source) {
+        const deletedSettings = prepared.settings.delete.all(source)
 
-    const metadatas = database.getMetadataIndependently().all(path)
-
-    if (!metadatas) return
+        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]
+            })
+        )
 
-    const [first] = metadatas
+        return grouped
+      }
+    },
 
-    if (!first) return
+    dependency: {
 
-    const metadata = parseMetadatas(metadatas)
 
-    const result = {
-      abstract: JSON.parse(first.abstract),
-      path: first.path,
-      dir: first.dir,
-      syntax: first.syntax,
-      metadata
-    }
+      getAll() {
+        return prepared.dependency.getAll.all()
+      },
 
-    return result
-  }
+      /**
+       * @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 createDependency = databaseSync.prepare(`INSERT OR IGNORE INTO dependencies (destination, property, dependent) VALUES (?, ?, ?) `)
-  const getDependency = databaseSync.prepare("SELECT * FROM dependencies WHERE destination = ? AND property = ?")
-  /**
-   * @param {string} path
-   * @param {string} dependent
-   */
-  database.getDestinationDependently = (path, dependent) => {
-    const result = database.getDestinationIndependently(path)
+    target: {
 
-    const { abstract, metadata, ...copy } = result
+      /**
+       * @param {string} filePath
+       * @returns {TargetOutput}
+       */
+      get(filePath) {
+        const target = prepared.target.get.get(filePath)
 
-    copy.metadata = {}
+        if (!target) return
 
-    Object.defineProperty(copy, "abstract", {
-      enumerable: true,
-      get() {
-        createDependency.get(path, "abstract", dependent)
-        return abstract
-      }
-    })
+        const { metadata, abstract, ...rest } = target
 
-    const keys = Object.keys(metadata)
+        if (!abstract) return
 
-    keys.forEach(key => {
-      Object.defineProperty(copy.metadata, key, {
-        enumerable: true,
-        get() {
-          createDependency.get(path, key, dependent)
-          return metadata[key]
+        /** @type {TargetOutput} */
+        const copy = {
+          abstract: coerceJSON(abstract),
+          metadata: coerceJSON(metadata),
+          ...rest
         }
-      })
-    })
 
+        return copy
+      },
 
-    return copy
-  }
 
-  /** @param {import("./sqlite.js").Query} query */
-  database.getDestinations = (query = {}, dependent) => {
-    const statement = createStatement(query)
-    const results = databaseSync.prepare(statement).all()
-    const destinations = Object.values(results.reduce((pv, cv) => {
-      if (!pv || !pv[cv.path]) {
-        pv[cv.path] = {
-          dir: cv.dir,
-          path: cv.path,
-          syntax: cv.syntax,
-          metadata: {}
-        }
+      /**
+       * @returns {TargetOutput[]}
+       */
+      getAll() {
+        const targets = prepared.target.getAll.all()
 
-        Object.defineProperty(pv[cv.path], "abstract",
-          {
-            enumerable: true,
-            get() {
-              createDependency.get(cv.path, "abstract", dependent)
-              return cv.abstract
-            }
+        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)
+
+        const trackedTarget = { metadata: {} }
+
+        queries.dependency.track(
+          trackedTarget,
+          "abstract",
+          target.abstract,
+          filePath,
+          dependent
         )
-      }
 
-      Object.defineProperty(pv[cv.path].metadata, cv.label,
-        {
-          enumerable: true,
-          get() {
-            createDependency.get(cv.path, cv.label, dependent)
-            return castMetadata(cv)[1]
-          }
+        for (const key in target.metadata) {
+          queries.dependency.track(
+            trackedTarget.metadata,
+            key,
+            target.metadata[key],
+            filePath,
+            dependent
+          )
         }
-      )
 
-      return pv
-    }, {}))
+        return target
+      },
 
-    return destinations
-  }
+      /**
+       * @typedef {object} TargetGetManyWithTrackersParams
+       * @property {string | undefined} [folder]
+       * @property {boolean | undefined} [recursive]
+       * @property {string | undefined} [dependent]
+       * @property {Record<string, string> | undefined} [query]
+       */
 
-  const selectSource = databaseSync.prepare(`SELECT * FROM sources WHERE path = ?`)
+      /** @param {TargetGetManyWithTrackersParams | undefined} params */
+      getManyWithTrackers(params) {
+        const { folder = "%", recursive, dependent, query = {} } = params
 
-  /**
-   * @param {string} path
-   */
-  database.getSource = (path) => {
-    const source = selectSource.get(path)
-    return source
-  }
+        const recursivePath = [folder, "%"].filter(a => a).join("/")
 
-  database.getAllSources = () => {
-    const sources = store.all`SELECT * FROM sources`
-    return sources
-  }
-
-  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)
-    })
-  }
-
-  // TODO: DELETE SETTING
+        const many = prepared.target.getMany
+          .all({ folder, recursivePath: recursive ? recursivePath : folder, filter: JSON.stringify(query) })
+          .map(({ abstract, metadata, ...rest }) => {
 
-  database.getAllDestinations = () => {
-    return store.all`SELECT * FROM destinations`
-  }
+            const trackedTarget = {
+              abstract: coerceJSON(abstract),
+              metadata: coerceJSON(metadata),
+              ...rest
+            }
 
-  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)
-              })
-          )
+            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
+              )
+            }
 
-        }
-      }
-    }).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 trackedTarget
+          })
 
-    return grouped
-  }
 
-  const createSetting = databaseSync.prepare(`INSERT OR IGNORE 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 = ?`)
+        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 updateDest = databaseSync.prepare(`UPDATE destinations SET abstract = ? WHERE path = ?`)
+        return many
+      },
 
-  // WRITE AN UPDATE SETTINGS FUNCTION FOR WHEN A SOURCE CHANGES
 
-  /** @param {string} source */
-  database.deleteSettings = (source) => {
-    const deleted = deleteSettings.all(source)
-    deleted.forEach(setting => {
-      staleDepen.get(setting.destination)
-      staleDescendents.all(`${setting.destination}/%`)
-    })
-  }
+      /**
+       * @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()
 
-  /**
-   * @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)
+        const extant = queries.target.get(target.path)
 
-    const type = typeof value
-    const safeValue = type === "object"
-      ? JSON.stringify(value)
-      : value
+        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
+        }
 
-    if (!extant) return createSetting.get(destinationFolder, key, safeValue, source)
-    if (extant.value === safeValue) return
-    updateSetting.get(safeValue, destinationFolder, key)
+        const keys = Object.keys(target.metadata)
 
-    destinationFolder === ""
-      ? staleDescendents.all("%")
-      : staleDescendents.all(`${destinationFolder}/%`)
-  }
+        for (const key in target.metadata) {
+          if (target.metadata[key] !== extant.metadata[key]) {
 
+            // TODO use triggers to mark dependencies as stale
+            prepared.metadata.create.get(relativePath, JSON.stringify({
+              [key]: target.metadata[key]
+            }))
 
-  /**
-   * @param {string} destinationFolder
-   */
-  database.getSettings = (destinationFolder) => {
-    const segments = destinationFolder.split(path.sep)
-      .map((_, index, array) => `'${array.slice(0, index + 1).join(path.sep)}'`)
+            // TODO delete dependencies after marking stale
+            prepared.dependency
+              .getByTargetAndProperty
+              .all(relativePath, key)
+              .forEach(dependency => {
+                prepared.target.markStale.get(dependency.dependent)
+              })
+          }
+        }
 
-    segments.unshift("''")
-    const statement = segments.join(", ")
+        for (const key in extant.metadata) {
+          if (!target.metadata[key]) {
+            prepared.metadata.delete.get(relativePath, key)
 
-    const records = databaseSync.prepare(`SELECT * FROM settings WHERE destination IN (${statement})`).all()
+            // TODO delete dependencies after marking stale
+            prepared.dependency
+              .getByTargetAndProperty
+              .all(relativePath, key)
+              .forEach(dependency => {
+                prepared.target.markStale.get(dependency.dependent)
+              })
+          }
+        }
 
-    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)
-      })
+        const changedAbstract = JSON.stringify(target.abstract) !== JSON.stringify(extant.abstract)
 
-    return grouped
-  }
+        if (changedAbstract) {
+          prepared.target.update.get(JSON.stringify(target.abstract), relativePath)
 
-  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()
-        ])
-    )
-  }
+          prepared.dependency
+            .getByTargetAndProperty
+            .all(relativePath, "abstract")
+            .forEach(dependency => {
+              prepared.target.markStale.get(dependency.dependent)
+            })
+        }
 
-  const createURL = databaseSync.prepare(`INSERT OR IGNORE INTO urls (url, data) VALUES (?, ?) RETURNING *`)
-  const getURL = databaseSync.prepare(`SELECT data FROM urls WHERE url = ?`)
+        return extant
+      },
 
-  /**
-   * @param {string} url
-   * @param {string} data
-   * @param {string} destination
-   */
-  database.createURL = (url, data, destination) => {
-    const created = createURL.get(url, JSON.stringify(data))
-    const staled = staleDepen.get(destination)
-    // TODO: Better signal propagation here?
-  }
+      /** @param {string} filePath */
+      markFresh(filePath) {
+        return prepared.target.markFresh.get(filePath)
+      }
+    },
+
+    url: {
+
+      /**
+        * @param {string} url
+        * @param {string} data
+        * @param {string} destination
+        */
+      create(url, data, destination) {
+        prepared.url.create.get(url, JSON.stringify(data))
+      },
+
+      /** @param {string} url */
+      get(url) {
+        const { data } = prepared.url.get.get(url) || {}
+        if (!data) return
+        return JSON.parse(data)
+      }
+    }
 
-  /**
-   * @param {string} url
-   */
-  database.getURL = (url) => {
-    const { data } = getURL.get(url) || {}
-    if(!data) return
-    return JSON.parse(data)
   }
 
-  return database
+  return Object.freeze(queries)
 }
 
-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,
-  UNIQUE(destination, property, dependent)
-);
-
-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,
-  UNIQUE(destination, label, source)
-);
-
-CREATE TABLE IF NOT EXISTS urls (
-  url STRING PRIMARY KEY,
-  data STRING
-);
-
-`
+/** @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
+    );
+
+  `)
+}
 
 export default createDatabase