Init

src/lib/project-system/db.ts

@@ -0,0 +1,233 @@
+import type { CsoundProject } from './types';
+
+const DB_NAME = 'csound-projects-db';
+const DB_VERSION = 1;
+const STORE_NAME = 'projects';
+
+/**
+ * Database wrapper for IndexedDB operations
+ */
+class ProjectDatabase {
+  private db: IDBDatabase | null = null;
+  private initPromise: Promise<void> | null = null;
+
+  /**
+   * Initialize the database connection
+   */
+  async init(): Promise<void> {
+    if (this.db) {
+      return;
+    }
+
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+
+    this.initPromise = new Promise((resolve, reject) => {
+      const request = indexedDB.open(DB_NAME, DB_VERSION);
+
+      request.onerror = () => {
+        reject(new Error(`Failed to open database: ${request.error?.message}`));
+      };
+
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve();
+      };
+
+      request.onupgradeneeded = (event) => {
+        const db = (event.target as IDBOpenDBRequest).result;
+
+        // Create object store if it doesn't exist
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+          const objectStore = db.createObjectStore(STORE_NAME, {
+            keyPath: 'id',
+          });
+
+          // Create indexes for efficient querying
+          objectStore.createIndex('title', 'title', { unique: false });
+          objectStore.createIndex('author', 'author', { unique: false });
+          objectStore.createIndex('dateCreated', 'dateCreated', { unique: false });
+          objectStore.createIndex('dateModified', 'dateModified', { unique: false });
+          objectStore.createIndex('tags', 'tags', { unique: false, multiEntry: true });
+        }
+      };
+    });
+
+    return this.initPromise;
+  }
+
+  /**
+   * Ensure database is initialized
+   */
+  private async ensureDb(): Promise<IDBDatabase> {
+    await this.init();
+    if (!this.db) {
+      throw new Error('Database not initialized');
+    }
+    return this.db;
+  }
+
+  /**
+   * Get a project by ID
+   */
+  async get(id: string): Promise<CsoundProject | null> {
+    const db = await this.ensureDb();
+
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], 'readonly');
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.get(id);
+
+      request.onsuccess = () => {
+        resolve(request.result || null);
+      };
+
+      request.onerror = () => {
+        reject(new Error(`Failed to get project: ${request.error?.message}`));
+      };
+    });
+  }
+
+  /**
+   * Get all projects
+   */
+  async getAll(): Promise<CsoundProject[]> {
+    const db = await this.ensureDb();
+
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], 'readonly');
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.getAll();
+
+      request.onsuccess = () => {
+        resolve(request.result || []);
+      };
+
+      request.onerror = () => {
+        reject(new Error(`Failed to get all projects: ${request.error?.message}`));
+      };
+    });
+  }
+
+  /**
+   * Save or update a project
+   */
+  async put(project: CsoundProject): Promise<void> {
+    const db = await this.ensureDb();
+
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], 'readwrite');
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.put(project);
+
+      request.onsuccess = () => {
+        resolve();
+      };
+
+      request.onerror = () => {
+        reject(new Error(`Failed to save project: ${request.error?.message}`));
+      };
+    });
+  }
+
+  /**
+   * Delete a project by ID
+   */
+  async delete(id: string): Promise<void> {
+    const db = await this.ensureDb();
+
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], 'readwrite');
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.delete(id);
+
+      request.onsuccess = () => {
+        resolve();
+      };
+
+      request.onerror = () => {
+        reject(new Error(`Failed to delete project: ${request.error?.message}`));
+      };
+    });
+  }
+
+  /**
+   * Search projects by tag
+   */
+  async getByTag(tag: string): Promise<CsoundProject[]> {
+    const db = await this.ensureDb();
+
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], 'readonly');
+      const store = transaction.objectStore(STORE_NAME);
+      const index = store.index('tags');
+      const request = index.getAll(tag);
+
+      request.onsuccess = () => {
+        resolve(request.result || []);
+      };
+
+      request.onerror = () => {
+        reject(new Error(`Failed to get projects by tag: ${request.error?.message}`));
+      };
+    });
+  }
+
+  /**
+   * Search projects by author
+   */
+  async getByAuthor(author: string): Promise<CsoundProject[]> {
+    const db = await this.ensureDb();
+
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], 'readonly');
+      const store = transaction.objectStore(STORE_NAME);
+      const index = store.index('author');
+      const request = index.getAll(author);
+
+      request.onsuccess = () => {
+        resolve(request.result || []);
+      };
+
+      request.onerror = () => {
+        reject(new Error(`Failed to get projects by author: ${request.error?.message}`));
+      };
+    });
+  }
+
+  /**
+   * Clear all projects (use with caution!)
+   */
+  async clear(): Promise<void> {
+    const db = await this.ensureDb();
+
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([STORE_NAME], 'readwrite');
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.clear();
+
+      request.onsuccess = () => {
+        resolve();
+      };
+
+      request.onerror = () => {
+        reject(new Error(`Failed to clear projects: ${request.error?.message}`));
+      };
+    });
+  }
+
+  /**
+   * Close the database connection
+   */
+  close(): void {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+      this.initPromise = null;
+    }
+  }
+}
+
+// Export singleton instance
+export const projectDb = new ProjectDatabase();