markdown-notes-engine 1.0.2 → 2.0.1

package/lib/backend/version-control.js

@@ -0,0 +1,458 @@
+/**
+ * Version Control Client
+ * Git-like version control system backed by PostgreSQL
+ */
+
+import crypto from 'crypto';
+
+export class VersionControlClient {
+  constructor(db, branch = 'main', author = 'user') {
+    this.db = db;
+    this.branch = branch;
+    this.author = author;
+  }
+
+  /**
+   * Hash content using SHA-256
+   * @private
+   * @param {string} content - Content to hash
+   * @returns {string} SHA-256 hash
+   */
+  _hashContent(content) {
+    return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
+  }
+
+  /**
+   * Get the current commit for the branch
+   * @private
+   * @returns {Promise<string|null>} Commit ID or null
+   */
+  async _getCurrentCommit() {
+    const result = await this.db.query(
+      'SELECT commit_id FROM branches WHERE name = $1',
+      [this.branch]
+    );
+    return result.rows.length > 0 ? result.rows[0].commit_id : null;
+  }
+
+  /**
+   * Get all files in the current branch's latest commit
+   * @private
+   * @returns {Promise<Array>} Array of {path, blob_hash}
+   */
+  async _getCurrentFiles() {
+    const commitId = await this._getCurrentCommit();
+    if (!commitId) return [];
+
+    const result = await this.db.query(
+      'SELECT path, blob_hash FROM trees WHERE commit_id = $1',
+      [commitId]
+    );
+
+    return result.rows;
+  }
+
+  /**
+   * Create a new commit with the given file tree
+   * @private
+   * @param {Array} files - Array of {path, blob_hash}
+   * @param {string} message - Commit message
+   * @returns {Promise<string>} New commit ID
+   */
+  async _createCommit(files, message) {
+    const client = await this.db.getClient();
+
+    try {
+      await client.query('BEGIN');
+
+      const parentId = await this._getCurrentCommit();
+
+      // Create commit
+      const commitResult = await client.query(
+        `INSERT INTO commits (parent_id, message, author)
+         VALUES ($1, $2, $3)
+         RETURNING id`,
+        [parentId, message, this.author]
+      );
+
+      const commitId = commitResult.rows[0].id;
+
+      // Insert tree entries
+      for (const file of files) {
+        await client.query(
+          `INSERT INTO trees (commit_id, path, blob_hash)
+           VALUES ($1, $2, $3)`,
+          [commitId, file.path, file.blob_hash]
+        );
+      }
+
+      // Update branch pointer
+      await client.query(
+        `UPDATE branches SET commit_id = $1, updated_at = NOW()
+         WHERE name = $2`,
+        [commitId, this.branch]
+      );
+
+      await client.query('COMMIT');
+      return commitId;
+    } catch (error) {
+      await client.query('ROLLBACK');
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+
+  /**
+   * Store blob if it doesn't exist
+   * @private
+   * @param {string} content - Blob content
+   * @returns {Promise<string>} Blob hash
+   */
+  async _storeBlob(content) {
+    const hash = this._hashContent(content);
+
+    // Insert blob if it doesn't exist (upsert)
+    await this.db.query(
+      `INSERT INTO blobs (hash, content, size)
+       VALUES ($1, $2, $3)
+       ON CONFLICT (hash) DO NOTHING`,
+      [hash, content, Buffer.byteLength(content, 'utf8')]
+    );
+
+    return hash;
+  }
+
+  /**
+   * Get blob content by hash
+   * @private
+   * @param {string} hash - Blob hash
+   * @returns {Promise<string|null>} Blob content
+   */
+  async _getBlob(hash) {
+    const result = await this.db.query(
+      'SELECT content FROM blobs WHERE hash = $1',
+      [hash]
+    );
+    return result.rows.length > 0 ? result.rows[0].content : null;
+  }
+
+  /**
+   * Update search index for a blob
+   * @private
+   * @param {string} hash - Blob hash
+   * @param {string} content - Blob content
+   */
+  async _updateSearchIndex(hash, content) {
+    await this.db.query(
+      `INSERT INTO search_index (blob_hash, content_tsvector)
+       VALUES ($1, to_tsvector('english', $2))
+       ON CONFLICT (blob_hash)
+       DO UPDATE SET
+         content_tsvector = to_tsvector('english', $2),
+         updated_at = NOW()`,
+      [hash, content]
+    );
+  }
+
+  /**
+   * Build hierarchical file structure from flat file list
+   * @private
+   * @param {Array} files - Array of {path, blob_hash}
+   * @returns {Array} Hierarchical structure
+   */
+  _buildStructureFromFiles(files) {
+    const root = [];
+    const folderMap = new Map();
+
+    // Sort files for consistent ordering
+    files.sort((a, b) => a.path.localeCompare(b.path));
+
+    for (const file of files) {
+      const parts = file.path.split('/');
+      let currentLevel = root;
+      let currentPath = '';
+
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        currentPath = currentPath ? `${currentPath}/${part}` : part;
+
+        if (i === parts.length - 1) {
+          // It's a file
+          currentLevel.push({
+            name: part,
+            type: 'file',
+            path: file.path,
+            sha: file.blob_hash
+          });
+        } else {
+          // It's a folder
+          let folder = folderMap.get(currentPath);
+
+          if (!folder) {
+            folder = {
+              name: part,
+              type: 'folder',
+              path: currentPath,
+              children: []
+            };
+            folderMap.set(currentPath, folder);
+            currentLevel.push(folder);
+          }
+
+          currentLevel = folder.children;
+        }
+      }
+    }
+
+    // Sort: folders first, then alphabetically
+    const sortStructure = (items) => {
+      items.sort((a, b) => {
+        if (a.type === b.type) return a.name.localeCompare(b.name);
+        return a.type === 'folder' ? -1 : 1;
+      });
+
+      items.forEach((item) => {
+        if (item.type === 'folder' && item.children) {
+          sortStructure(item.children);
+        }
+      });
+    };
+
+    sortStructure(root);
+    return root;
+  }
+
+  /**
+   * Get file structure for the current branch
+   * @returns {Promise<Array>} Hierarchical file structure
+   */
+  async getFileStructure() {
+    const files = await this._getCurrentFiles();
+    return this._buildStructureFromFiles(files);
+  }
+
+  /**
+   * Get file content and metadata
+   * @param {string} path - File path
+   * @returns {Promise<Object|null>} File data or null if not found
+   */
+  async getFile(path) {
+    const files = await this._getCurrentFiles();
+    const file = files.find(f => f.path === path);
+
+    if (!file) {
+      return null;
+    }
+
+    const content = await this._getBlob(file.blob_hash);
+
+    if (!content) {
+      return null;
+    }
+
+    return {
+      content,
+      sha: file.blob_hash,
+      path
+    };
+  }
+
+  /**
+   * Save or update a file
+   * @param {string} path - File path
+   * @param {string} content - File content
+   * @param {string|null} sha - Expected current SHA (ignored, kept for API compatibility)
+   * @returns {Promise<Object>} Save result
+   */
+  async saveFile(path, content, sha = null) {
+    // Store blob
+    const blobHash = await this._storeBlob(content);
+
+    // Update search index
+    await this._updateSearchIndex(blobHash, content);
+
+    // Get current files
+    const currentFiles = await this._getCurrentFiles();
+
+    // Update or add the file
+    const existingIndex = currentFiles.findIndex(f => f.path === path);
+    if (existingIndex >= 0) {
+      currentFiles[existingIndex].blob_hash = blobHash;
+    } else {
+      currentFiles.push({ path, blob_hash: blobHash });
+    }
+
+    // Create commit
+    const message = sha ? `Update ${path}` : `Create ${path}`;
+    const commitId = await this._createCommit(currentFiles, message);
+
+    return {
+      commit: { sha: commitId },
+      content: { sha: blobHash, path }
+    };
+  }
+
+  /**
+   * Delete a file
+   * @param {string} path - File path
+   * @param {string} sha - File SHA (ignored, kept for API compatibility)
+   * @returns {Promise<Object>} Delete result
+   */
+  async deleteFile(path, sha) {
+    // Get current files
+    const currentFiles = await this._getCurrentFiles();
+
+    // Remove the file
+    const newFiles = currentFiles.filter(f => f.path !== path);
+
+    if (newFiles.length === currentFiles.length) {
+      throw new Error('File not found');
+    }
+
+    // Create commit
+    const commitId = await this._createCommit(newFiles, `Delete ${path}`);
+
+    return {
+      commit: { sha: commitId }
+    };
+  }
+
+  /**
+   * Create a folder (no-op in this system, folders are implicit)
+   * @param {string} path - Folder path
+   * @returns {Promise<Object>} Result
+   */
+  async createFolder(path) {
+    // In our system, folders are implicit and don't need explicit creation
+    // Return success for API compatibility
+    return { success: true };
+  }
+
+  /**
+   * Delete a folder and all its contents
+   * @param {string} path - Folder path
+   * @returns {Promise<Array>} Delete results
+   */
+  async deleteFolder(path) {
+    // Get current files
+    const currentFiles = await this._getCurrentFiles();
+
+    // Remove all files in the folder
+    const prefix = path.endsWith('/') ? path : `${path}/`;
+    const newFiles = currentFiles.filter(f => !f.path.startsWith(prefix));
+
+    if (newFiles.length === currentFiles.length) {
+      return []; // No files deleted
+    }
+
+    // Create commit
+    const commitId = await this._createCommit(newFiles, `Delete folder ${path}`);
+
+    return [{ commit: { sha: commitId } }];
+  }
+
+  /**
+   * Search notes for a query
+   * @param {string} query - Search query
+   * @returns {Promise<Array>} Search results
+   */
+  async searchNotes(query) {
+    // Use PostgreSQL full-text search
+    const searchResult = await this.db.query(
+      `SELECT si.blob_hash,
+              ts_rank(si.content_tsvector, query) as rank
+       FROM search_index si,
+            to_tsquery('english', $1) query
+       WHERE si.content_tsvector @@ query
+       ORDER BY rank DESC
+       LIMIT 50`,
+      [query.split(' ').join(' & ')]
+    );
+
+    const results = [];
+
+    // Get current files to map blob hashes to paths
+    const currentFiles = await this._getCurrentFiles();
+
+    for (const row of searchResult.rows) {
+      const file = currentFiles.find(f => f.blob_hash === row.blob_hash);
+      if (!file || !file.path.endsWith('.md')) continue;
+
+      const content = await this._getBlob(row.blob_hash);
+      if (!content) continue;
+
+      const lines = content.split('\n');
+      const matches = [];
+
+      lines.forEach((line, index) => {
+        if (line.toLowerCase().includes(query.toLowerCase())) {
+          matches.push({
+            line: index + 1,
+            content: line
+          });
+        }
+      });
+
+      if (matches.length > 0) {
+        results.push({
+          path: file.path,
+          matches
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Get commit history for a specific file
+   * @param {string} path - File path
+   * @returns {Promise<Array>} Array of commits that affected this file
+   */
+  async getFileHistory(path) {
+    // Get all commits where this file exists
+    const result = await this.db.query(
+      `SELECT DISTINCT
+         c.id,
+         c.message,
+         c.author,
+         c.created_at,
+         t.blob_hash,
+         t.path
+       FROM commits c
+       INNER JOIN trees t ON t.commit_id = c.id
+       WHERE t.path = $1
+       ORDER BY c.created_at DESC`,
+      [path]
+    );
+
+    const commits = [];
+    let previousHash = null;
+
+    for (const row of result.rows) {
+      const changed = previousHash === null || previousHash !== row.blob_hash;
+
+      commits.push({
+        sha: row.id,
+        message: row.message,
+        author: row.author,
+        date: row.created_at,
+        blobHash: row.blob_hash,
+        changed
+      });
+
+      previousHash = row.blob_hash;
+    }
+
+    return commits;
+  }
+
+  /**
+   * Get the default branch (compatibility method)
+   * @returns {Promise<string>} Default branch name
+   */
+  async getDefaultBranch() {
+    return this.branch;
+  }
+}

package/lib/frontend/index.js

@@ -657,9 +657,6 @@ class NotesEditor {
   }
 }
 
-// Export for different module systems
-if (typeof module !== 'undefined' && module.exports) {
-  module.exports = { NotesEditor };
-} else {
-  window.NotesEditor = NotesEditor;
-}
+
+export { NotesEditor };
+export default NotesEditor;

package/lib/index.js

@@ -8,21 +8,10 @@
  */
 
 // Backend exports
-const { createNotesRouter } = require('./backend/index');
-const { GitHubClient } = require('./backend/github');
-const { StorageClient } = require('./backend/storage');
-const { MarkdownRenderer } = require('./backend/markdown');
+export { createNotesRouter } from './backend/index.js';
+export { GitHubClient } from './backend/github.js';
+export { StorageClient } from './backend/storage.js';
+export { MarkdownRenderer } from './backend/markdown.js';
 
 // Frontend exports
-const { NotesEditor } = require('./frontend/index');
-
-module.exports = {
-  // Backend
-  createNotesRouter,
-  GitHubClient,
-  StorageClient,
-  MarkdownRenderer,
-
-  // Frontend
-  NotesEditor
-};
+export { NotesEditor } from './frontend/index.js';

package/package.json

@@ -1,34 +1,18 @@
 {
   "name": "markdown-notes-engine",
-  "version": "1.0.2",
-  "description": "A complete markdown note-taking engine with GitHub integration and media hosting (R2/S3)",
+  "version": "2.0.1",
+  "description": "A complete markdown note-taking engine with Git-like version control (PostgreSQL) or GitHub integration and media hosting (R2/S3)",
+  "type": "module",
   "main": "lib/index.js",
-  "module": "lib/index.mjs",
   "exports": {
-    ".": {
-      "import": "./lib/index.mjs",
-      "require": "./lib/index.js"
-    },
-    "./backend": {
-      "import": "./lib/backend/index.mjs",
-      "require": "./lib/backend/index.js"
-    },
-    "./backend/github": {
-      "import": "./lib/backend/github.mjs",
-      "require": "./lib/backend/github.js"
-    },
-    "./backend/storage": {
-      "import": "./lib/backend/storage.mjs",
-      "require": "./lib/backend/storage.js"
-    },
-    "./backend/markdown": {
-      "import": "./lib/backend/markdown.mjs",
-      "require": "./lib/backend/markdown.js"
-    },
-    "./frontend": {
-      "import": "./lib/frontend/index.mjs",
-      "require": "./lib/frontend/index.js"
-    }
+    ".": "./lib/index.js",
+    "./backend": "./lib/backend/index.js",
+    "./backend/github": "./lib/backend/github.js",
+    "./backend/storage": "./lib/backend/storage.js",
+    "./backend/markdown": "./lib/backend/markdown.js",
+    "./backend/version-control": "./lib/backend/version-control.js",
+    "./backend/db": "./lib/backend/db/connection.js",
+    "./frontend": "./lib/frontend/index.js"
   },
   "scripts": {
     "start": "node server.js",
@@ -38,6 +22,9 @@
   "keywords": [
     "markdown",
     "notes",
+    "version-control",
+    "git",
+    "postgresql",
     "github",
     "editor",
     "r2",
@@ -53,18 +40,21 @@
   },
   "files": [
     "lib/**/*.js",
-    "lib/**/*.mjs",
+    "lib/**/*.sql",
     "README.md",
     "LICENSE"
   ],
   "dependencies": {
     "@aws-sdk/client-s3": "^3.928.0",
-    "@octokit/rest": "^22.0.1",
     "express": "^5.1.0",
     "express-fileupload": "^1.5.2",
     "highlight.js": "^11.11.1",
     "marked": "^17.0.0",
-    "marked-highlight": "^2.2.3"
+    "marked-highlight": "^2.2.3",
+    "postgres": "^3.4.5"
+  },
+  "optionalDependencies": {
+    "@octokit/rest": "^22.0.1"
   },
   "devDependencies": {
     "dotenv": "^17.2.3",