Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
/**
* Postgres-backed round-trip for the Trusted Organizations registry
* (issue #2141). Like privacyVault.db.test.js, this needs a live PostgreSQL
* with the schema applied. If no DB is reachable (CI, fresh checkout) it
* SKIPS cleanly rather than failing red. Exercises org CRUD, cascade deletes
* (org delete and vault-record delete both clean up holdings), the
* getOrgsHoldingRecord join, and the batch status flip. Runs via
* `npm run test:db` (→ portos_test) ONLY; the db.js guards refuse writes to
* a non-test DB.
*/
import { describe, it, expect, afterAll, beforeAll } from 'vitest';
import { checkHealth, ensureSchema, query, close } from '../lib/db.js';
import { requireDbOrSkip } from '../lib/dbTestGate.js';
const HEX_KEY = 'd'.repeat(64);
const originalKey = process.env.PRIVACY_VAULT_KEY;
process.env.PRIVACY_VAULT_KEY = HEX_KEY;
let dbReady = false;
let skipReason = '';
{
const health = await checkHealth().catch((e) => ({ connected: false, error: e?.message }));
if (!health.connected) {
skipReason = `Postgres not reachable (${health.error || 'no connection'})`;
} else {
await ensureSchema().catch(() => {});
const probe = await query(
`SELECT EXISTS(SELECT 1 FROM information_schema.tables WHERE table_name = 'privacy_orgs') AS ok`,
).catch(() => ({ rows: [{ ok: false }] }));
if (probe.rows?.[0]?.ok) dbReady = true;
else skipReason = 'privacy_orgs table not present';
}
}
const runDb = requireDbOrSkip('services/privacyOrgs.db.test', dbReady, skipReason);
describe.skipIf(!runDb)('privacy orgs DB round-trip', () => {
let orgs;
let vault;
const createdOrgs = [];
const createdVaultRecords = [];
beforeAll(async () => {
orgs = await import('./privacyOrgs.js');
vault = await import('./privacyVault.js');
});
afterAll(async () => {
for (const id of createdOrgs) {
await query(`DELETE FROM privacy_orgs WHERE id = $1`, [id]).catch(() => {});
}
for (const id of createdVaultRecords) {
await query(`DELETE FROM privacy_vault_records WHERE id = $1`, [id]).catch(() => {});
}
await close();
if (originalKey === undefined) delete process.env.PRIVACY_VAULT_KEY;
else process.env.PRIVACY_VAULT_KEY = originalKey;
});
it('creates an org, attaches vault holdings, and queries both directions', async () => {
const record = await vault.createVaultRecord({ type: 'email', label: 'Work email', value: '[email protected]' });
createdVaultRecords.push(record.id);
const org = await orgs.createOrg({ name: 'Acme Bank', category: 'bank', trust: 'trusted' });
createdOrgs.push(org.id);
expect(org.category).toBe('bank');
const holdings = await orgs.setOrgHoldings(org.id, [{ vaultRecordId: record.id, status: 'current' }]);
expect(holdings).toHaveLength(1);
expect(holdings[0]).toMatchObject({ vaultRecordId: record.id, vaultType: 'email', vaultMaskedValue: 'm•••@work.example' });
expect(JSON.stringify(holdings)).not.toContain('[email protected]');
const forOrg = await orgs.getHoldingsForOrg(org.id);
expect(forOrg).toHaveLength(1);
const holdingOrgs = await orgs.getOrgsHoldingRecord(record.id);
expect(holdingOrgs).toHaveLength(1);
expect(holdingOrgs[0]).toMatchObject({ orgId: org.id, orgName: 'Acme Bank' });
});
it('replace-set semantics: re-calling setOrgHoldings drops anything not listed', async () => {
const r1 = await vault.createVaultRecord({ type: 'phone', label: 'Cell', value: '+1 503 555 0100' });
const r2 = await vault.createVaultRecord({ type: 'address', label: 'Home', value: '1 Main St' });
createdVaultRecords.push(r1.id, r2.id);
const org = await orgs.createOrg({ name: 'Utility Co' });
createdOrgs.push(org.id);
await orgs.setOrgHoldings(org.id, [
{ vaultRecordId: r1.id }, { vaultRecordId: r2.id },
]);
expect(await orgs.getHoldingsForOrg(org.id)).toHaveLength(2);
await orgs.setOrgHoldings(org.id, [{ vaultRecordId: r1.id, status: 'update_pending' }]);
const after = await orgs.getHoldingsForOrg(org.id);
expect(after).toHaveLength(1);
expect(after[0]).toMatchObject({ vaultRecordId: r1.id, status: 'update_pending' });
});
it('keeps a held record\'s stored status when the replace-set omits it', async () => {
const held = await vault.createVaultRecord({ type: 'address', label: 'Old home', value: '2 Example Rd' });
const added = await vault.createVaultRecord({ type: 'email', label: 'Alt', value: '[email protected]' });
createdVaultRecords.push(held.id, added.id);
const org = await orgs.createOrg({ name: 'Example Insurer' });
createdOrgs.push(org.id);
await orgs.setOrgHoldings(org.id, [{ vaultRecordId: held.id, status: 'update_pending' }]);
// The org editor sends ids only — an unrelated edit must not reset the mark.
await orgs.setOrgHoldings(org.id, [{ vaultRecordId: held.id }, { vaultRecordId: added.id }]);
const byRecord = Object.fromEntries((await orgs.getHoldingsForOrg(org.id)).map((h) => [h.vaultRecordId, h.status]));
expect(byRecord).toEqual({ [held.id]: 'update_pending', [added.id]: 'current' });
});
it('cascades: deleting the org drops its holdings', async () => {
const record = await vault.createVaultRecord({ type: 'custom', label: 'Misc', value: 'x' });
createdVaultRecords.push(record.id);
const org = await orgs.createOrg({ name: 'Temp Org' });
await orgs.setOrgHoldings(org.id, [{ vaultRecordId: record.id }]);
await orgs.deleteOrg(org.id);
const { rows } = await query(`SELECT * FROM privacy_org_holdings WHERE org_id = $1`, [org.id]);
expect(rows).toHaveLength(0);
expect(await orgs.getOrg(org.id)).toBe(null);
});
it('rejects a nonexistent vaultRecordId as a 400 and rolls back the whole call (transactional)', async () => {
const record = await vault.createVaultRecord({ type: 'custom', label: 'Real one', value: 'z' });
createdVaultRecords.push(record.id);
const org = await orgs.createOrg({ name: 'Rollback Org' });
createdOrgs.push(org.id);
// Seed one real holding so we can confirm it survives the failed call untouched.
await orgs.setOrgHoldings(org.id, [{ vaultRecordId: record.id }]);
await expect(orgs.setOrgHoldings(org.id, [
{ vaultRecordId: record.id }, { vaultRecordId: '00000000-0000-4000-8000-000000000000' },
])).rejects.toMatchObject({ status: 400, code: 'VAULT_RECORD_NOT_FOUND' });
// The transaction must have rolled back the DELETE-complement too — the
// pre-existing holding for `record.id` is still there, unchanged.
const holdings = await orgs.getHoldingsForOrg(org.id);
expect(holdings).toHaveLength(1);
expect(holdings[0].vaultRecordId).toBe(record.id);
});
it('cascades: deleting the vault record drops its holdings', async () => {
const record = await vault.createVaultRecord({ type: 'custom', label: 'Misc2', value: 'y' });
const org = await orgs.createOrg({ name: 'Another Org' });
createdOrgs.push(org.id);
await orgs.setOrgHoldings(org.id, [{ vaultRecordId: record.id }]);
await vault.deleteVaultRecord(record.id);
const { rows } = await query(`SELECT * FROM privacy_org_holdings WHERE vault_record_id = $1`, [record.id]);
expect(rows).toHaveLength(0);
});
it('batch-flips holdings status across all orgs holding a record', async () => {
const record = await vault.createVaultRecord({ type: 'address', label: 'Old address', value: '9 Old Rd' });
createdVaultRecords.push(record.id);
const orgA = await orgs.createOrg({ name: 'Bank A' });
const orgB = await orgs.createOrg({ name: 'Bank B' });
createdOrgs.push(orgA.id, orgB.id);
await orgs.setOrgHoldings(orgA.id, [{ vaultRecordId: record.id, status: 'current' }]);
await orgs.setOrgHoldings(orgB.id, [{ vaultRecordId: record.id, status: 'current' }]);
const result = await orgs.setHoldingsStatus(record.id, 'current', 'update_pending');
expect(result.updated).toBe(2);
const holdingOrgs = await orgs.getOrgsHoldingRecord(record.id);
expect(holdingOrgs.every((h) => h.status === 'update_pending')).toBe(true);
});
it('validation rejects unknown enum values at the service boundary via the schema layer', async () => {
const { privacyOrgCreateSchema } = await import('../lib/privacyValidation.js');
expect(() => privacyOrgCreateSchema.parse({ name: 'X', trust: 'bogus' })).toThrow();
expect(() => privacyOrgCreateSchema.parse({ name: 'X', category: 'bogus' })).toThrow();
expect(() => privacyOrgCreateSchema.parse({ name: 'X', status: 'bogus' })).toThrow();
});
it('reports a holdings summary across orgs and vault records', async () => {
const summary = await orgs.getHoldingsSummary();
expect(Array.isArray(summary.byOrg)).toBe(true);
expect(Array.isArray(summary.byVaultRecord)).toBe(true);
});
});