septum 0.1.4 → 0.1.5

package/src/core/database/repositories/domain.repository.ts

@@ -1,198 +1,218 @@
-import type { Database } from "bun:sqlite";
-import type {
-  DomainCatalogResponse,
-  DomainConfig,
-  DomainRecord,
-  FileRecord,
-  SymbolKind,
-  SymbolRecord,
-} from "../../../types/index.ts";
-
-export class DomainRepository {
-  constructor(private db: Database) {}
-
-  public upsertDomain(name: string, config: DomainConfig): number {
-    const normalizedName = name.trim();
-    const existing = this.getDomainByName(normalizedName);
-
-    // Merge dependencies and archetypes if existing and incoming is empty
-    let allowed = config.allowed_dependencies ?? [];
-    let forbidden = config.forbidden_dependencies ?? [];
-    let archetypes = config.archetypes ?? {};
-
-    if (existing) {
-      if (allowed.length === 0 && existing.allowed_deps_json && existing.allowed_deps_json !== "[]") {
-        try {
-          allowed = JSON.parse(existing.allowed_deps_json);
-        } catch {}
-      }
-      if (forbidden.length === 0 && existing.forbidden_deps_json && existing.forbidden_deps_json !== "[]") {
-        try {
-          forbidden = JSON.parse(existing.forbidden_deps_json);
-        } catch {}
-      }
-      if (Object.keys(archetypes).length === 0 && existing.archetypes_json && existing.archetypes_json !== "{}") {
-        try {
-          archetypes = JSON.parse(existing.archetypes_json);
-        } catch {}
-      }
-    }
-
-    const allowedJson = JSON.stringify(allowed);
-    const forbiddenJson = JSON.stringify(forbidden);
-    const archetypesJson = JSON.stringify(archetypes);
-
-    const query = `
-      INSERT INTO domains (name, root_path, allowed_deps_json, forbidden_deps_json, archetypes_json)
-      VALUES (?, ?, ?, ?, ?)
-      ON CONFLICT(name) DO UPDATE SET
-        root_path = excluded.root_path,
-        allowed_deps_json = excluded.allowed_deps_json,
-        forbidden_deps_json = excluded.forbidden_deps_json,
-        archetypes_json = excluded.archetypes_json,
-        updated_at = CURRENT_TIMESTAMP
-    `;
-    this.db.query(query).run(normalizedName, config.root, allowedJson, forbiddenJson, archetypesJson);
-
-    const record = this.getDomainByName(normalizedName);
-    return record?.id ?? 0;
-  }
-
-  public getDomainByName(name: string): DomainRecord | null {
-    return this.db
-      .query<DomainRecord, [string]>("SELECT * FROM domains WHERE LOWER(name) = LOWER(?)")
-      .get(name.trim());
-  }
-
-  public getAllDomains(): DomainRecord[] {
-    return this.db.query<DomainRecord, []>("SELECT * FROM domains ORDER BY name ASC").all();
-  }
-
-  public getDomainCatalog(
-    domainName: string,
-    archetypeFilter?: string
-  ): DomainCatalogResponse | null {
-    const domain = this.getDomainByName(domainName);
-    if (!domain) return null;
-
-    const allowedDeps: string[] = JSON.parse(domain.allowed_deps_json || "[]");
-    const forbiddenDeps: string[] = JSON.parse(domain.forbidden_deps_json || "[]");
-
-    let filesQuery = "SELECT * FROM files WHERE domain_id = ?";
-    const params: [number, string?] = [domain.id];
-
-    if (archetypeFilter) {
-      filesQuery += " AND archetype = ?";
-      params.push(archetypeFilter);
-    }
-    filesQuery += " ORDER BY path ASC";
-
-    const files = this.db.query<FileRecord, any>(filesQuery).all(...params);
-
-    const catalogFiles: DomainCatalogResponse["files"] = [];
-
-    for (const file of files) {
-      const symbols = this.db
-        .query<SymbolRecord, [number]>(
-          "SELECT * FROM symbols WHERE file_id = ? ORDER BY line_start ASC"
-        )
-        .all(file.id);
-
-      const symbolMap = new Map<
-        string,
-        {
-          name: string;
-          kind: SymbolKind;
-          properties: string[];
-          methods: string[];
-          signatures: string[];
-        }
-      >();
-
-      for (const sym of symbols) {
-        if (
-          sym.kind === "class" ||
-          sym.kind === "interface" ||
-          sym.kind === "trait" ||
-          sym.kind === "enum"
-        ) {
-          if (!symbolMap.has(sym.name)) {
-            symbolMap.set(sym.name, {
-              name: sym.name,
-              kind: sym.kind,
-              properties: [],
-              methods: [],
-              signatures: [sym.signature],
-            });
-          }
-        } else if (sym.kind === "method") {
-          let targetContainer = Array.from(symbolMap.values()).pop();
-          if (sym.name.includes("::")) {
-            const containerName = sym.name.split("::")[0];
-            if (symbolMap.has(containerName)) {
-              targetContainer = symbolMap.get(containerName);
-            }
-          }
-          if (targetContainer) {
-            targetContainer.methods.push(sym.signature);
-          } else {
-            symbolMap.set(sym.name, {
-              name: sym.name,
-              kind: sym.kind,
-              properties: [],
-              methods: [],
-              signatures: [sym.signature],
-            });
-          }
-        } else if (sym.kind === "property") {
-          let targetContainer = Array.from(symbolMap.values()).pop();
-          if (sym.name.includes("::")) {
-            const containerName = sym.name.split("::")[0];
-            if (symbolMap.has(containerName)) {
-              targetContainer = symbolMap.get(containerName);
-            }
-          }
-          if (targetContainer) {
-            targetContainer.properties.push(sym.signature);
-          } else {
-            symbolMap.set(sym.name, {
-              name: sym.name,
-              kind: sym.kind,
-              properties: [sym.signature],
-              methods: [],
-              signatures: [sym.signature],
-            });
-          }
-        } else {
-          symbolMap.set(sym.name, {
-            name: sym.name,
-            kind: sym.kind,
-            properties: [],
-            methods: [],
-            signatures: [sym.signature],
-          });
-        }
-      }
-
-      catalogFiles.push({
-        path: file.path,
-        archetype: file.archetype,
-        symbols: Array.from(symbolMap.values()).map((s) => ({
-          name: s.name,
-          kind: s.kind,
-          properties: s.properties.length > 0 ? s.properties : undefined,
-          methods: s.methods.length > 0 ? s.methods : undefined,
-          signatures: s.signatures.length > 0 ? s.signatures : undefined,
-        })),
-      });
-    }
-
-    return {
-      domain: domain.name,
-      root: domain.root_path,
-      allowed_dependencies: allowedDeps,
-      forbidden_dependencies: forbiddenDeps,
-      files: catalogFiles,
-    };
-  }
-}
+import type { Database } from "bun:sqlite";
+import type {
+  DomainCatalogResponse,
+  DomainConfig,
+  DomainRecord,
+  FileRecord,
+  SymbolKind,
+  SymbolRecord,
+} from "../../../types/index.ts";
+
+export class DomainRepository {
+  constructor(private db: Database) {}
+
+  public upsertDomain(name: string, config: DomainConfig): number {
+    const normalizedName = name.trim();
+    const existing = this.getDomainByName(normalizedName);
+
+    // Merge dependencies and archetypes if existing and incoming is empty
+    let allowed = config.allowed_dependencies ?? [];
+    let forbidden = config.forbidden_dependencies ?? [];
+    let archetypes = config.archetypes ?? {};
+
+    if (existing) {
+      if (allowed.length === 0 && existing.allowed_deps_json && existing.allowed_deps_json !== "[]") {
+        try {
+          allowed = JSON.parse(existing.allowed_deps_json);
+        } catch {}
+      }
+      if (forbidden.length === 0 && existing.forbidden_deps_json && existing.forbidden_deps_json !== "[]") {
+        try {
+          forbidden = JSON.parse(existing.forbidden_deps_json);
+        } catch {}
+      }
+      if (Object.keys(archetypes).length === 0 && existing.archetypes_json && existing.archetypes_json !== "{}") {
+        try {
+          archetypes = JSON.parse(existing.archetypes_json);
+        } catch {}
+      }
+    }
+
+    const allowedJson = JSON.stringify(allowed);
+    const forbiddenJson = JSON.stringify(forbidden);
+    const archetypesJson = JSON.stringify(archetypes);
+
+    const query = `
+      INSERT INTO domains (name, root_path, allowed_deps_json, forbidden_deps_json, archetypes_json)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(name) DO UPDATE SET
+        root_path = excluded.root_path,
+        allowed_deps_json = excluded.allowed_deps_json,
+        forbidden_deps_json = excluded.forbidden_deps_json,
+        archetypes_json = excluded.archetypes_json,
+        updated_at = CURRENT_TIMESTAMP
+    `;
+    this.db.query(query).run(normalizedName, config.root, allowedJson, forbiddenJson, archetypesJson);
+
+    const record = this.getDomainByName(normalizedName);
+    return record?.id ?? 0;
+  }
+
+  public getDomainByName(name: string): DomainRecord | null {
+    return this.db
+      .query<DomainRecord, [string]>("SELECT * FROM domains WHERE LOWER(name) = LOWER(?)")
+      .get(name.trim());
+  }
+
+  public getAllDomains(): DomainRecord[] {
+    return this.db.query<DomainRecord, []>("SELECT * FROM domains ORDER BY name ASC").all();
+  }
+
+  public getDomainCatalog(
+    domainName: string,
+    archetypeFilter?: string
+  ): DomainCatalogResponse | null {
+    const domain = this.getDomainByName(domainName);
+    if (!domain) return null;
+
+    const allowedDeps: string[] = JSON.parse(domain.allowed_deps_json || "[]");
+    const forbiddenDeps: string[] = JSON.parse(domain.forbidden_deps_json || "[]");
+
+    let filesQuery = "SELECT * FROM files WHERE domain_id = ?";
+    const params: [number, string?] = [domain.id];
+
+    if (archetypeFilter) {
+      filesQuery += " AND archetype = ?";
+      params.push(archetypeFilter);
+    }
+    filesQuery += " ORDER BY path ASC";
+
+    const files = this.db.query<FileRecord, any>(filesQuery).all(...params);
+
+    const catalogFiles: DomainCatalogResponse["files"] = [];
+
+    // Batch retrieve symbols for all files in one query to eliminate N+1 roundtrips
+    const symbolsByFileId = new Map<number, SymbolRecord[]>();
+    for (const f of files) {
+      symbolsByFileId.set(f.id, []);
+    }
+
+    if (files.length > 0) {
+      const allDomainSymbols = this.db
+        .query<SymbolRecord, [number]>(
+          `SELECT s.* FROM symbols s
+           JOIN files f ON s.file_id = f.id
+           WHERE f.domain_id = ?
+           ORDER BY s.file_id ASC, s.line_start ASC`
+        )
+        .all(domain.id);
+
+      for (const sym of allDomainSymbols) {
+        const list = symbolsByFileId.get(sym.file_id);
+        if (list) {
+          list.push(sym);
+        }
+      }
+    }
+
+    for (const file of files) {
+      const symbols = symbolsByFileId.get(file.id) ?? [];
+
+      const symbolMap = new Map<
+        string,
+        {
+          name: string;
+          kind: SymbolKind;
+          properties: string[];
+          methods: string[];
+          signatures: string[];
+        }
+      >();
+
+      for (const sym of symbols) {
+        if (
+          sym.kind === "class" ||
+          sym.kind === "interface" ||
+          sym.kind === "trait" ||
+          sym.kind === "enum"
+        ) {
+          if (!symbolMap.has(sym.name)) {
+            symbolMap.set(sym.name, {
+              name: sym.name,
+              kind: sym.kind,
+              properties: [],
+              methods: [],
+              signatures: [sym.signature],
+            });
+          }
+        } else if (sym.kind === "method") {
+          let targetContainer = Array.from(symbolMap.values()).pop();
+          if (sym.name.includes("::")) {
+            const containerName = sym.name.split("::")[0];
+            if (symbolMap.has(containerName)) {
+              targetContainer = symbolMap.get(containerName);
+            }
+          }
+          if (targetContainer) {
+            targetContainer.methods.push(sym.signature);
+          } else {
+            symbolMap.set(sym.name, {
+              name: sym.name,
+              kind: sym.kind,
+              properties: [],
+              methods: [],
+              signatures: [sym.signature],
+            });
+          }
+        } else if (sym.kind === "property") {
+          let targetContainer = Array.from(symbolMap.values()).pop();
+          if (sym.name.includes("::")) {
+            const containerName = sym.name.split("::")[0];
+            if (symbolMap.has(containerName)) {
+              targetContainer = symbolMap.get(containerName);
+            }
+          }
+          if (targetContainer) {
+            targetContainer.properties.push(sym.signature);
+          } else {
+            symbolMap.set(sym.name, {
+              name: sym.name,
+              kind: sym.kind,
+              properties: [sym.signature],
+              methods: [],
+              signatures: [sym.signature],
+            });
+          }
+        } else {
+          symbolMap.set(sym.name, {
+            name: sym.name,
+            kind: sym.kind,
+            properties: [],
+            methods: [],
+            signatures: [sym.signature],
+          });
+        }
+      }
+
+      catalogFiles.push({
+        path: file.path,
+        archetype: file.archetype,
+        symbols: Array.from(symbolMap.values()).map((s) => ({
+          name: s.name,
+          kind: s.kind,
+          properties: s.properties.length > 0 ? s.properties : undefined,
+          methods: s.methods.length > 0 ? s.methods : undefined,
+          signatures: s.signatures.length > 0 ? s.signatures : undefined,
+        })),
+      });
+    }
+
+    return {
+      domain: domain.name,
+      root: domain.root_path,
+      allowed_dependencies: allowedDeps,
+      forbidden_dependencies: forbiddenDeps,
+      files: catalogFiles,
+    };
+  }
+}

package/src/core/database/repositories/file.repository.ts

@@ -1,106 +1,116 @@
-import type { Database } from "bun:sqlite";
-import type { ArchetypeKind, DomainRecord, FileRecord } from "../../../types/index.ts";
-
-export class FileRepository {
-  constructor(private db: Database) {}
-
-  public getFileByPath(path: string): FileRecord | null {
-    return this.db
-      .query<FileRecord, [string]>("SELECT * FROM files WHERE path = ?")
-      .get(path);
-  }
-
-  public getFileById(id: number): FileRecord | null {
-    return this.db
-      .query<FileRecord, [number]>("SELECT * FROM files WHERE id = ?")
-      .get(id);
-  }
-
-  public getFilesByDomain(domainId: number): FileRecord[] {
-    return this.db
-      .query<FileRecord, [number]>("SELECT * FROM files WHERE domain_id = ? ORDER BY path ASC")
-      .all(domainId);
-  }
-
-  public countFiles(): number {
-    const row = this.db
-      .query<{ count: number }, []>("SELECT COUNT(*) as count FROM files")
-      .get();
-    return row?.count ?? 0;
-  }
-
-  public upsertFile(
-    domainId: number,
-    path: string,
-    archetype: ArchetypeKind,
-    contentHash: string,
-    lineCount: number,
-    mtimeMs: number = 0,
-    sizeBytes: number = 0
-  ): number {
-    const existing = this.getFileByPath(path);
-    if (existing) {
-      this.db
-        .query(
-          `UPDATE files 
-           SET domain_id = ?, archetype = ?, content_hash = ?, line_count = ?, mtime_ms = ?, size_bytes = ?, last_scanned_at = CURRENT_TIMESTAMP 
-           WHERE id = ?`
-        )
-        .run(domainId, archetype, contentHash, lineCount, mtimeMs, sizeBytes, existing.id);
-      return existing.id;
-    } else {
-      const result = this.db
-        .query(
-          `INSERT INTO files (domain_id, path, archetype, content_hash, line_count, mtime_ms, size_bytes) 
-           VALUES (?, ?, ?, ?, ?, ?, ?)`
-        )
-        .run(domainId, path, archetype, contentHash, lineCount, mtimeMs, sizeBytes);
-      return Number(result.lastInsertRowid);
-    }
-  }
-
-  public updateFileMetadataOnly(id: number, mtimeMs: number, sizeBytes: number): void {
-    this.db
-      .query(
-        `UPDATE files 
-         SET mtime_ms = ?, size_bytes = ?, last_scanned_at = CURRENT_TIMESTAMP 
-         WHERE id = ?`
-      )
-      .run(mtimeMs, sizeBytes, id);
-  }
-
-  public deleteFilesNotInPaths(domainId: number, validPaths: string[]): number {
-    if (validPaths.length === 0) {
-      const res = this.db.query("DELETE FROM files WHERE domain_id = ?").run(domainId);
-      return Number(res.changes);
-    }
-    const existingFiles = this.getFilesByDomain(domainId);
-    const validSet = new Set(validPaths);
-    let deletedCount = 0;
-    for (const f of existingFiles) {
-      if (!validSet.has(f.path)) {
-        this.db.query("DELETE FROM files WHERE id = ?").run(f.id);
-        deletedCount++;
-      }
-    }
-    return deletedCount;
-  }
-
-  public deleteFile(path: string): void {
-    this.db.query("DELETE FROM files WHERE path = ?").run(path);
-  }
-
-  public getFileWithDomain(
-    filePath: string
-  ): { file: FileRecord; domain: DomainRecord } | null {
-    const file = this.getFileByPath(filePath);
-    if (!file) return null;
-
-    const domain = this.db
-      .query<DomainRecord, [number]>("SELECT * FROM domains WHERE id = ?")
-      .get(file.domain_id);
-    if (!domain) return null;
-
-    return { file, domain };
-  }
-}
+import type { Database } from "bun:sqlite";
+import type { ArchetypeKind, DomainRecord, FileRecord } from "../../../types/index.ts";
+
+export class FileRepository {
+  constructor(private db: Database) {}
+
+  public getFileByPath(path: string): FileRecord | null {
+    return this.db
+      .query<FileRecord, [string]>("SELECT * FROM files WHERE path = ?")
+      .get(path);
+  }
+
+  public getFileById(id: number): FileRecord | null {
+    return this.db
+      .query<FileRecord, [number]>("SELECT * FROM files WHERE id = ?")
+      .get(id);
+  }
+
+  public getFilesByDomain(domainId: number): FileRecord[] {
+    return this.db
+      .query<FileRecord, [number]>("SELECT * FROM files WHERE domain_id = ? ORDER BY path ASC")
+      .all(domainId);
+  }
+
+  public getAllFiles(): FileRecord[] {
+    return this.db
+      .query<FileRecord, []>("SELECT * FROM files ORDER BY path ASC")
+      .all();
+  }
+
+  public countFiles(): number {
+    const row = this.db
+      .query<{ count: number }, []>("SELECT COUNT(*) as count FROM files")
+      .get();
+    return row?.count ?? 0;
+  }
+
+  public upsertFile(
+    domainId: number,
+    path: string,
+    archetype: ArchetypeKind,
+    contentHash: string,
+    lineCount: number,
+    mtimeMs: number = 0,
+    sizeBytes: number = 0
+  ): number {
+    const existing = this.getFileByPath(path);
+    if (existing) {
+      this.db
+        .query(
+          `UPDATE files 
+           SET domain_id = ?, archetype = ?, content_hash = ?, line_count = ?, mtime_ms = ?, size_bytes = ?, last_scanned_at = CURRENT_TIMESTAMP 
+           WHERE id = ?`
+        )
+        .run(domainId, archetype, contentHash, lineCount, mtimeMs, sizeBytes, existing.id);
+      return existing.id;
+    } else {
+      const result = this.db
+        .query(
+          `INSERT INTO files (domain_id, path, archetype, content_hash, line_count, mtime_ms, size_bytes) 
+           VALUES (?, ?, ?, ?, ?, ?, ?)`
+        )
+        .run(domainId, path, archetype, contentHash, lineCount, mtimeMs, sizeBytes);
+      return Number(result.lastInsertRowid);
+    }
+  }
+
+  public updateFileMetadataOnly(id: number, mtimeMs: number, sizeBytes: number): void {
+    this.db
+      .query(
+        `UPDATE files 
+         SET mtime_ms = ?, size_bytes = ?, last_scanned_at = CURRENT_TIMESTAMP 
+         WHERE id = ?`
+      )
+      .run(mtimeMs, sizeBytes, id);
+  }
+
+  public deleteFilesNotInPaths(domainId: number, validPaths: string[]): number {
+    if (validPaths.length === 0) {
+      const res = this.db.query("DELETE FROM files WHERE domain_id = ?").run(domainId);
+      return Number(res.changes);
+    }
+    const existingFiles = this.getFilesByDomain(domainId);
+    const validSet = new Set(validPaths);
+    const idsToDelete = existingFiles.filter((f) => !validSet.has(f.path)).map((f) => f.id);
+    if (idsToDelete.length === 0) return 0;
+
+    const chunkSize = 200;
+    let totalDeleted = 0;
+    for (let i = 0; i < idsToDelete.length; i += chunkSize) {
+      const chunk = idsToDelete.slice(i, i + chunkSize);
+      const placeholders = chunk.map(() => "?").join(",");
+      const res = this.db.query(`DELETE FROM files WHERE id IN (${placeholders})`).run(...chunk);
+      totalDeleted += Number(res.changes);
+    }
+    return totalDeleted;
+  }
+
+  public deleteFile(path: string): void {
+    this.db.query("DELETE FROM files WHERE path = ?").run(path);
+  }
+
+  public getFileWithDomain(
+    filePath: string
+  ): { file: FileRecord; domain: DomainRecord } | null {
+    const file = this.getFileByPath(filePath);
+    if (!file) return null;
+
+    const domain = this.db
+      .query<DomainRecord, [number]>("SELECT * FROM domains WHERE id = ?")
+      .get(file.domain_id);
+    if (!domain) return null;
+
+    return { file, domain };
+  }
+}