@soleri/core 2.5.0 → 2.7.0

package/src/__tests__/postgres-provider.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest';
+import { translateSql } from '../persistence/postgres-provider.js';
+import { PostgresPersistenceProvider } from '../persistence/postgres-provider.js';
+
+describe('translateSql', () => {
+  it('converts positional ? to $N', () => {
+    const result = translateSql('SELECT * FROM t WHERE a = ? AND b = ?', ['x', 'y']);
+    expect(result.sql).toBe('SELECT * FROM t WHERE a = $1 AND b = $2');
+    expect(result.values).toEqual(['x', 'y']);
+  });
+
+  it('converts named @params to $N', () => {
+    const result = translateSql('INSERT INTO t (a, b) VALUES (@name, @age)', {
+      name: 'Alice',
+      age: 30,
+    });
+    expect(result.sql).toBe('INSERT INTO t (a, b) VALUES ($1, $2)');
+    expect(result.values).toEqual(['Alice', 30]);
+  });
+
+  it('deduplicates repeated named params', () => {
+    const result = translateSql('SELECT * FROM t WHERE a = @x OR b = @x', { x: 42 });
+    expect(result.sql).toBe('SELECT * FROM t WHERE a = $1 OR b = $1');
+    expect(result.values).toEqual([42]);
+  });
+
+  it('replaces unixepoch()', () => {
+    const result = translateSql('INSERT INTO t (ts) VALUES (unixepoch())');
+    expect(result.sql).toBe('INSERT INTO t (ts) VALUES (EXTRACT(EPOCH FROM NOW())::integer)');
+    expect(result.values).toEqual([]);
+  });
+
+  it('handles no params', () => {
+    const result = translateSql('SELECT 1');
+    expect(result.sql).toBe('SELECT 1');
+    expect(result.values).toEqual([]);
+  });
+
+  it('handles mixed: ? params + unixepoch()', () => {
+    const result = translateSql('UPDATE t SET name = ?, updated_at = unixepoch() WHERE id = ?', [
+      'Bob',
+      'id-1',
+    ]);
+    expect(result.sql).toBe(
+      'UPDATE t SET name = $1, updated_at = EXTRACT(EPOCH FROM NOW())::integer WHERE id = $2',
+    );
+    expect(result.values).toEqual(['Bob', 'id-1']);
+  });
+});
+
+describe('PostgresPersistenceProvider', () => {
+  it('backend returns postgres', () => {
+    // Access backend without connecting (class-level property)
+    // We can't instantiate without pg, so we test the translateSql export
+    // and verify the class exists with correct typing
+    expect(PostgresPersistenceProvider).toBeDefined();
+  });
+});

package/src/__tests__/vault-extra-ops.test.ts

@@ -47,8 +47,8 @@ describe('createVaultExtraOps', () => {
     return op;
   }
 
-  it('should return 20 ops', () => {
-    expect(ops.length).toBe(20);
+  it('should return 23 ops', () => {
+    expect(ops.length).toBe(23);
   });
 
   it('should have all expected op names', () => {

package/src/__tests__/vault.test.ts

@@ -491,4 +491,188 @@ describe('Vault', () => {
       expect(stats.byProject).toEqual({ '/a': 2, '/b': 1 });
     });
   });
+
+  describe('Vault archival and optimization', () => {
+    it('archive moves old entries', () => {
+      const v = new Vault(':memory:');
+      v.seed([
+        {
+          id: 'old-1',
+          type: 'pattern',
+          domain: 'test',
+          title: 'Old Pattern',
+          severity: 'suggestion',
+          description: 'Old entry',
+          tags: ['test'],
+        },
+      ]);
+      // Manually set the updated_at to 200 days ago
+      v.getProvider().run('UPDATE entries SET updated_at = ? WHERE id = ?', [
+        Math.floor(Date.now() / 1000) - 200 * 86400,
+        'old-1',
+      ]);
+      v.seed([
+        {
+          id: 'new-1',
+          type: 'pattern',
+          domain: 'test',
+          title: 'New Pattern',
+          severity: 'suggestion',
+          description: 'New entry',
+          tags: ['test'],
+        },
+      ]);
+
+      const result = v.archive({ olderThanDays: 90 });
+      expect(result.archived).toBe(1);
+      expect(v.get('old-1')).toBeNull();
+      expect(v.get('new-1')).not.toBeNull();
+      v.close();
+    });
+
+    it('archive respects olderThanDays', () => {
+      const v = new Vault(':memory:');
+      v.seed([
+        {
+          id: 'e1',
+          type: 'pattern',
+          domain: 'test',
+          title: 'Entry',
+          severity: 'suggestion',
+          description: 'Not old enough',
+          tags: ['test'],
+        },
+      ]);
+      // Entry is fresh (just created), archive with 1 day threshold
+      const result = v.archive({ olderThanDays: 1 });
+      expect(result.archived).toBe(0);
+      expect(v.get('e1')).not.toBeNull();
+      v.close();
+    });
+
+    it('archive returns 0 when no candidates', () => {
+      const v = new Vault(':memory:');
+      const result = v.archive({ olderThanDays: 30 });
+      expect(result.archived).toBe(0);
+      v.close();
+    });
+
+    it('archived entries excluded from search', () => {
+      const v = new Vault(':memory:');
+      v.seed([
+        {
+          id: 'search-1',
+          type: 'pattern',
+          domain: 'test',
+          title: 'Searchable Pattern',
+          severity: 'suggestion',
+          description: 'Should be archived',
+          tags: ['search'],
+        },
+      ]);
+      v.getProvider().run('UPDATE entries SET updated_at = ? WHERE id = ?', [
+        Math.floor(Date.now() / 1000) - 200 * 86400,
+        'search-1',
+      ]);
+
+      // Before archive: should appear in search
+      const before = v.search('searchable');
+      expect(before.length).toBeGreaterThan(0);
+
+      v.archive({ olderThanDays: 90 });
+
+      // After archive: should not appear
+      const after = v.search('searchable');
+      expect(after.length).toBe(0);
+      v.close();
+    });
+
+    it('restore brings entry back', () => {
+      const v = new Vault(':memory:');
+      v.seed([
+        {
+          id: 'restore-1',
+          type: 'pattern',
+          domain: 'test',
+          title: 'Restore Me',
+          severity: 'suggestion',
+          description: 'Will be restored',
+          tags: ['test'],
+        },
+      ]);
+      v.getProvider().run('UPDATE entries SET updated_at = ? WHERE id = ?', [
+        Math.floor(Date.now() / 1000) - 200 * 86400,
+        'restore-1',
+      ]);
+      v.archive({ olderThanDays: 90 });
+      expect(v.get('restore-1')).toBeNull();
+
+      const restored = v.restore('restore-1');
+      expect(restored).toBe(true);
+      expect(v.get('restore-1')).not.toBeNull();
+      expect(v.get('restore-1')!.title).toBe('Restore Me');
+      v.close();
+    });
+
+    it('restore returns false for missing id', () => {
+      const v = new Vault(':memory:');
+      const result = v.restore('nonexistent');
+      expect(result).toBe(false);
+      v.close();
+    });
+
+    it('restored entry appears in search', () => {
+      const v = new Vault(':memory:');
+      v.seed([
+        {
+          id: 'search-restore',
+          type: 'pattern',
+          domain: 'test',
+          title: 'Unique Findable Pattern',
+          severity: 'suggestion',
+          description: 'Will be found after restore',
+          tags: ['test'],
+        },
+      ]);
+      v.getProvider().run('UPDATE entries SET updated_at = ? WHERE id = ?', [
+        Math.floor(Date.now() / 1000) - 200 * 86400,
+        'search-restore',
+      ]);
+      v.archive({ olderThanDays: 90 });
+      v.restore('search-restore');
+
+      const results = v.search('unique findable');
+      expect(results.length).toBeGreaterThan(0);
+      v.close();
+    });
+
+    it('optimize runs without error', () => {
+      const v = new Vault(':memory:');
+      v.seed([
+        {
+          id: 'opt-1',
+          type: 'pattern',
+          domain: 'test',
+          title: 'Optimize Test',
+          severity: 'suggestion',
+          description: 'For optimization',
+          tags: ['test'],
+        },
+      ]);
+
+      expect(() => v.optimize()).not.toThrow();
+      v.close();
+    });
+
+    it('optimize returns status', () => {
+      const v = new Vault(':memory:');
+      const status = v.optimize();
+      expect(status).toHaveProperty('vacuumed');
+      expect(status).toHaveProperty('analyzed');
+      expect(status).toHaveProperty('ftsRebuilt');
+      // SQLite backend should analyze and rebuild FTS
+      expect(status.analyzed).toBe(true);
+      v.close();
+    });
+  });
 });