From 5dd40e5aaefc03cfcf652de25e247913365de767 Mon Sep 17 00:00:00 2001 From: Carlos Lopez Date: Fri, 20 Nov 2026 14:15:20 +0100 Subject: [PATCH] feat(events): vault domain events (#78) - vault.secret.created/updated/deleted with key, folder and affected environment ids (never values); updated also reports changedFields - vault.env.imported once per import instead of one event per secret - vault.environment.created/deleted - shared resolveProjectScope in #lib/server/events/scope - es/en translations and no-leak tests Co-Authored-By: Claude Opus 5.5 --- src/lib/events/catalog/index.ts | 3 + src/lib/events/catalog/vault.events.ts | 135 ++++++++++++ src/lib/events/domain-events.ts | 38 ++++ src/lib/i18n/locales/en.json | 68 ++++++ src/lib/i18n/locales/es.json | 68 ++++++ src/lib/server/events/index.ts | 1 + src/lib/server/events/scope.ts | 19 ++ .../application/code-report-events.ts | 17 +- .../vault/application/vault.service.test.ts | 203 +++++++++++++++++- .../vault/application/vault.service.ts | 145 ++++++++++++- src/modules/vault/index.ts | 7 +- 11 files changed, 677 insertions(+), 27 deletions(-) create mode 100644 src/lib/events/catalog/vault.events.ts create mode 100644 src/lib/server/events/scope.ts diff --git a/src/lib/events/catalog/index.ts b/src/lib/events/catalog/index.ts index ec1379e..bd3a0eb 100644 --- a/src/lib/events/catalog/index.ts +++ b/src/lib/events/catalog/index.ts @@ -1,5 +1,6 @@ import type { DomainEventMap, EventType } from '../domain-events'; import { codeReportEvents } from './code-report.events'; +import { vaultEvents } from './vault.events'; import type { EventCatalog, EventDefinition, @@ -11,6 +12,7 @@ import type { export type * from './types'; export { OPERATORS } from './fields'; export { CODE_REPORT_TOOLS } from './code-report.events'; +export { VAULT_SECRET_CHANGED_FIELDS } from './vault.events'; /** * Builds the catalog. The parameter type makes it exhaustive (every `DomainEventMap` entry needs a @@ -32,6 +34,7 @@ export function defineEventCatalog(catalog: C): C export const EVENT_CATALOG: EventCatalog = defineEventCatalog({ ...codeReportEvents, + ...vaultEvents, }); export function isEventType(value: string): value is EventType { diff --git a/src/lib/events/catalog/vault.events.ts b/src/lib/events/catalog/vault.events.ts new file mode 100644 index 0000000..748b4cf --- /dev/null +++ b/src/lib/events/catalog/vault.events.ts @@ -0,0 +1,135 @@ +import { OPERATORS, enumOptions, eventText, fieldLabel } from './fields'; +import type { EventDefinitions } from './types'; + +export const VAULT_SECRET_CHANGED_FIELDS = ['key', 'description', 'folder', 'values'] as const; + +const READ_SECRETS = 'project:vault:secrets:read'; +const READ_ENVIRONMENTS = 'project:vault:environments:read'; + +const SECRET_CREATED = 'vault.secret.created'; +const SECRET_UPDATED = 'vault.secret.updated'; +const SECRET_DELETED = 'vault.secret.deleted'; +const ENV_IMPORTED = 'vault.env.imported'; +const ENVIRONMENT_CREATED = 'vault.environment.created'; +const ENVIRONMENT_DELETED = 'vault.environment.deleted'; + +type SecretEvent = typeof SECRET_CREATED | typeof SECRET_UPDATED | typeof SECRET_DELETED; +type EnvironmentEvent = typeof ENVIRONMENT_CREATED | typeof ENVIRONMENT_DELETED; + +function secretFields(type: K) { + return [ + { key: 'key', label: fieldLabel(type, 'key'), type: 'string', operators: OPERATORS.string }, + { + key: 'environmentIds', + label: fieldLabel(type, 'environmentIds'), + type: 'reference', + reference: 'vault_environment', + operators: OPERATORS.list, + }, + { + key: 'folderPath', + label: fieldLabel(type, 'folderPath'), + type: 'string', + operators: OPERATORS.string, + }, + ] as const; +} + +function environmentFields(type: K) { + return [ + { + key: 'environmentId', + label: fieldLabel(type, 'environmentId'), + type: 'reference', + reference: 'vault_environment', + operators: OPERATORS.reference, + }, + { key: 'name', label: fieldLabel(type, 'name'), type: 'string', operators: OPERATORS.string }, + ] as const; +} + +export const vaultEvents: EventDefinitions = { + [SECRET_CREATED]: { + ...eventText(SECRET_CREATED), + module: 'vault', + scope: 'project', + readPermission: READ_SECRETS, + alertable: true, + fields: secretFields(SECRET_CREATED), + }, + [SECRET_UPDATED]: { + ...eventText(SECRET_UPDATED), + module: 'vault', + scope: 'project', + readPermission: READ_SECRETS, + alertable: true, + fields: [ + ...secretFields(SECRET_UPDATED), + { + key: 'changedFields', + label: fieldLabel(SECRET_UPDATED, 'changedFields'), + type: 'enum', + options: enumOptions('secretChangedField', VAULT_SECRET_CHANGED_FIELDS), + operators: OPERATORS.list, + }, + ], + }, + [SECRET_DELETED]: { + ...eventText(SECRET_DELETED), + module: 'vault', + scope: 'project', + readPermission: READ_SECRETS, + alertable: true, + fields: secretFields(SECRET_DELETED), + }, + [ENV_IMPORTED]: { + ...eventText(ENV_IMPORTED), + module: 'vault', + scope: 'project', + readPermission: READ_SECRETS, + alertable: true, + fields: [ + { + key: 'environmentId', + label: fieldLabel(ENV_IMPORTED, 'environmentId'), + type: 'reference', + reference: 'vault_environment', + operators: OPERATORS.reference, + }, + { + key: 'folderPath', + label: fieldLabel(ENV_IMPORTED, 'folderPath'), + type: 'string', + operators: OPERATORS.string, + }, + { + key: 'created', + label: fieldLabel(ENV_IMPORTED, 'created'), + type: 'number', + operators: OPERATORS.number, + }, + { + key: 'updated', + label: fieldLabel(ENV_IMPORTED, 'updated'), + type: 'number', + operators: OPERATORS.number, + }, + ], + }, + [ENVIRONMENT_CREATED]: { + ...eventText(ENVIRONMENT_CREATED), + module: 'vault', + scope: 'project', + readPermission: READ_ENVIRONMENTS, + alertable: true, + fields: environmentFields(ENVIRONMENT_CREATED), + }, + [ENVIRONMENT_DELETED]: { + ...eventText(ENVIRONMENT_DELETED), + module: 'vault', + scope: 'project', + readPermission: READ_ENVIRONMENTS, + alertable: true, + fields: environmentFields(ENVIRONMENT_DELETED), + }, +}; diff --git a/src/lib/events/domain-events.ts b/src/lib/events/domain-events.ts index b5a802a..64321c6 100644 --- a/src/lib/events/domain-events.ts +++ b/src/lib/events/domain-events.ts @@ -67,12 +67,50 @@ export type CodeReportServicePayload = { slug: string; }; +export type VaultSecretChangedField = 'key' | 'description' | 'folder' | 'values'; + +/** Never carries secret values: only which environments hold (or changed) a value. */ +export type VaultSecretPayload = { + secretId: string; + key: string; + folderId: string | null; + /** `/` for the vault root. */ + folderPath: string; + /** Environments with a value (created/deleted) or whose value changed (updated). */ + environmentIds: string[]; +}; + +export type VaultSecretUpdatedPayload = VaultSecretPayload & { + changedFields: VaultSecretChangedField[]; +}; + +export type VaultEnvImportedPayload = { + environmentId: string; + environmentSlug: string; + folderId: string | null; + folderPath: string; + created: number; + updated: number; +}; + +export type VaultEnvironmentPayload = { + environmentId: string; + name: string; + slug: string; +}; + export interface DomainEventMap { 'code_report.analysis.completed': CodeReportAnalysisCompletedPayload; 'code_report.analysis.failed': CodeReportAnalysisFailedPayload; 'code_report.policy.violated': CodeReportPolicyViolatedPayload; 'code_report.service.created': CodeReportServicePayload; 'code_report.service.deleted': CodeReportServicePayload; + 'vault.secret.created': VaultSecretPayload; + 'vault.secret.updated': VaultSecretUpdatedPayload; + 'vault.secret.deleted': VaultSecretPayload; + 'vault.env.imported': VaultEnvImportedPayload; + 'vault.environment.created': VaultEnvironmentPayload; + 'vault.environment.deleted': VaultEnvironmentPayload; } export type EventType = Extract; diff --git a/src/lib/i18n/locales/en.json b/src/lib/i18n/locales/en.json index e214aab..3bd5394 100644 --- a/src/lib/i18n/locales/en.json +++ b/src/lib/i18n/locales/en.json @@ -1036,6 +1036,74 @@ "enforcement": { "warn": "Warning", "block": "Blocking" + }, + "secretChangedField": { + "key": "Key", + "description": "Description", + "folder": "Folder", + "values": "Values" + } + }, + "vault": { + "secret": { + "created": { + "label": "Secret created", + "description": "A secret was created in the project vault.", + "fields": { + "key": "Secret key", + "environmentIds": "Environments", + "folderPath": "Folder" + } + }, + "updated": { + "label": "Secret updated", + "description": "A secret of the project vault was modified.", + "fields": { + "key": "Secret key", + "environmentIds": "Environments", + "folderPath": "Folder", + "changedFields": "Changed fields" + } + }, + "deleted": { + "label": "Secret deleted", + "description": "A secret was deleted from the project vault.", + "fields": { + "key": "Secret key", + "environmentIds": "Environments", + "folderPath": "Folder" + } + } + }, + "env": { + "imported": { + "label": ".env file imported", + "description": "Secrets were imported from a .env file.", + "fields": { + "environmentId": "Environment", + "folderPath": "Folder", + "created": "Secrets created", + "updated": "Secrets updated" + } + } + }, + "environment": { + "created": { + "label": "Environment created", + "description": "An environment was created in the project vault.", + "fields": { + "environmentId": "Environment", + "name": "Name" + } + }, + "deleted": { + "label": "Environment deleted", + "description": "An environment was deleted from the project vault.", + "fields": { + "environmentId": "Environment", + "name": "Name" + } + } } } } diff --git a/src/lib/i18n/locales/es.json b/src/lib/i18n/locales/es.json index c5c0147..a25af6a 100644 --- a/src/lib/i18n/locales/es.json +++ b/src/lib/i18n/locales/es.json @@ -1036,6 +1036,74 @@ "enforcement": { "warn": "Aviso", "block": "Bloqueante" + }, + "secretChangedField": { + "key": "Key", + "description": "Descripción", + "folder": "Carpeta", + "values": "Valores" + } + }, + "vault": { + "secret": { + "created": { + "label": "Secreto creado", + "description": "Se ha creado un secreto en el vault del proyecto.", + "fields": { + "key": "Key del secreto", + "environmentIds": "Entornos", + "folderPath": "Carpeta" + } + }, + "updated": { + "label": "Secreto actualizado", + "description": "Se ha modificado un secreto del vault del proyecto.", + "fields": { + "key": "Key del secreto", + "environmentIds": "Entornos", + "folderPath": "Carpeta", + "changedFields": "Campos modificados" + } + }, + "deleted": { + "label": "Secreto eliminado", + "description": "Se ha eliminado un secreto del vault del proyecto.", + "fields": { + "key": "Key del secreto", + "environmentIds": "Entornos", + "folderPath": "Carpeta" + } + } + }, + "env": { + "imported": { + "label": "Fichero .env importado", + "description": "Se han importado secretos desde un fichero .env.", + "fields": { + "environmentId": "Entorno", + "folderPath": "Carpeta", + "created": "Secretos creados", + "updated": "Secretos actualizados" + } + } + }, + "environment": { + "created": { + "label": "Entorno creado", + "description": "Se ha creado un entorno en el vault del proyecto.", + "fields": { + "environmentId": "Entorno", + "name": "Nombre" + } + }, + "deleted": { + "label": "Entorno eliminado", + "description": "Se ha eliminado un entorno del vault del proyecto.", + "fields": { + "environmentId": "Entorno", + "name": "Nombre" + } + } } } } diff --git a/src/lib/server/events/index.ts b/src/lib/server/events/index.ts index 7aff03b..6e0f1c2 100644 --- a/src/lib/server/events/index.ts +++ b/src/lib/server/events/index.ts @@ -3,6 +3,7 @@ import { InProcessEventBus, type EventBus } from './event-bus'; export { InProcessEventBus, actorFromRequest } from './event-bus'; export type { EventBus, InProcessEventBusOptions } from './event-bus'; export type * from './types'; +export { resolveProjectScope, type ProjectScopeLookup } from './scope'; const GLOBAL_KEY = Symbol.for('gitops.events.bus'); diff --git a/src/lib/server/events/scope.ts b/src/lib/server/events/scope.ts new file mode 100644 index 0000000..4fcda84 --- /dev/null +++ b/src/lib/server/events/scope.ts @@ -0,0 +1,19 @@ +import type { EventScope } from './types'; + +/** Project lookup used to add the organization to a project-scoped event. */ +export type ProjectScopeLookup = { + getProject(id: string): Promise<{ organization?: { id: string } | null }>; +}; + +/** + * Scope of an event that happened inside a project. A failed lookup only drops the organization: + * resolving the scope must never fail the write that already succeeded. + */ +export async function resolveProjectScope( + projectId: string | null | undefined, + projects: ProjectScopeLookup | undefined, +): Promise { + if (!projectId) return { organizationId: null, projectId: null }; + const project = projects ? await projects.getProject(projectId).catch(() => null) : null; + return { organizationId: project?.organization?.id ?? null, projectId }; +} diff --git a/src/modules/code-report/application/code-report-events.ts b/src/modules/code-report/application/code-report-events.ts index 2f60b2e..19d4b28 100644 --- a/src/modules/code-report/application/code-report-events.ts +++ b/src/modules/code-report/application/code-report-events.ts @@ -1,24 +1,11 @@ -import type { EventBus, EventScope } from '#lib/server/events'; +import type { EventBus } from '#lib/server/events'; +export { resolveProjectScope, type ProjectScopeLookup } from '#lib/server/events/scope'; import type { CodeReportEventGitInfo } from '#lib/events/domain-events'; import type { CodeReportGitInfo } from '../domain/code-report-analysis.domain'; /** What the code-report services need from the bus. */ export type CodeReportEventPublisher = Pick; -/** Project lookup used to add the organization to the event scope. */ -export type ProjectScopeLookup = { - getProject(id: string): Promise<{ organization?: { id: string } | null }>; -}; - -export async function resolveProjectScope( - projectId: string | null | undefined, - projects: ProjectScopeLookup | undefined, -): Promise { - if (!projectId) return { organizationId: null, projectId: null }; - const project = projects ? await projects.getProject(projectId).catch(() => null) : null; - return { organizationId: project?.organization?.id ?? null, projectId }; -} - /** Only the identifying git fields travel in events (no commit messages or author emails). */ export function eventGitInfo( gitInfo: CodeReportGitInfo | null | undefined, diff --git a/src/modules/vault/application/vault.service.test.ts b/src/modules/vault/application/vault.service.test.ts index ec53119..5452b60 100644 --- a/src/modules/vault/application/vault.service.test.ts +++ b/src/modules/vault/application/vault.service.test.ts @@ -1,4 +1,5 @@ import { beforeEach, describe, expect, it } from 'vitest'; +import { RecordingEventBus } from '#lib/server/events/testing'; import { VaultService } from './vault.service'; type Json = Record; @@ -20,6 +21,29 @@ class FakeVaultRepository { return found ? jsonRow(found) : null; } + failWrites = false; + + async listEnvironments(projectId: string) { + return this.environments + .filter((environment) => environment.projectId === projectId) + .map((environment) => ({ ...jsonRow(environment), order: Number(environment.order ?? 0) })); + } + + async findEnvironmentById(id: string) { + const found = this.environments.find((environment) => environment.id === id); + return found ? jsonRow(found) : null; + } + + async createEnvironment(input: Json) { + if (this.failWrites) throw new Error('GitDB write failed'); + this.environments.push(input); + } + + async deleteEnvironment(id: string) { + if (this.failWrites) throw new Error('GitDB write failed'); + this.environments = this.environments.filter((environment) => environment.id !== id); + } + async listFolders(projectId: string) { return this.folders.filter((folder) => folder.projectId === projectId).map(jsonRow); } @@ -56,15 +80,18 @@ class FakeVaultRepository { } async createSecret(input: Json) { + if (this.failWrites) throw new Error('GitDB write failed'); this.secrets.push({ ...input, folderId: input.folderId ?? null }); } async updateSecret(id: string, changes: Json) { + if (this.failWrites) throw new Error('GitDB write failed'); const secret = this.secrets.find((candidate) => candidate.id === id); if (secret) Object.assign(secret, changes); } async deleteSecret(id: string) { + if (this.failWrites) throw new Error('GitDB write failed'); this.secrets = this.secrets.filter((secret) => secret.id !== id); } @@ -155,9 +182,9 @@ describe('VaultService secrets', () => { it('rejects creating a secret in a folder from another project', async () => { repository.folders.push({ id: 'folder-1', projectId: 'other', path: '/x' }); - await expect( - service.createSecret('p1', { folderId: 'folder-1', key: 'X' }), - ).rejects.toThrow('Folder not found'); + await expect(service.createSecret('p1', { folderId: 'folder-1', key: 'X' })).rejects.toThrow( + 'Folder not found', + ); }); it('finds a secret by key', async () => { @@ -181,9 +208,9 @@ describe('VaultService secrets', () => { it('throws when updating a secret from another project', async () => { await repository.createSecret({ id: 's1', projectId: 'other', folderId: null, key: 'X' }); - await expect( - service.updateSecret('p1', 's1', { key: 'X', values: {} }), - ).rejects.toThrow('Secret not found'); + await expect(service.updateSecret('p1', 's1', { key: 'X', values: {} })).rejects.toThrow( + 'Secret not found', + ); }); it('deletes a secret', async () => { @@ -212,7 +239,11 @@ describe('VaultService secrets', () => { }); it('overrides the description when provided to setSecretValue', async () => { - await service.createSecret('p1', { key: 'zone', description: 'Region', values: { prod: 'eu' } }); + await service.createSecret('p1', { + key: 'zone', + description: 'Region', + values: { prod: 'eu' }, + }); const updated = await service.setSecretValue('p1', null, 'zone', 'prod', 'us', 'New region'); expect(updated.description).toBe('New region'); }); @@ -223,3 +254,161 @@ describe('VaultService secrets', () => { ); }); }); + +describe('VaultService events', () => { + const SECRET_VALUE = 'super-secret-value-123'; + let repository: FakeVaultRepository; + let events: RecordingEventBus; + let service: VaultService; + + beforeEach(() => { + repository = new FakeVaultRepository(); + events = new RecordingEventBus(); + service = new VaultService(repository as never, { + events, + projects: { getProject: async () => ({ organization: { id: 'org-1' } }) }, + }); + repository.environments.push( + { id: 'env-dev', projectId: 'p1', slug: 'dev', name: 'Development', order: 0 }, + { id: 'env-prod', projectId: 'p1', slug: 'prod', name: 'Production', order: 1 }, + ); + repository.folders.push({ id: 'folder-1', projectId: 'p1', path: '/database' }); + }); + + it('publishes secret.created with environments and folder, scoped to the project', async () => { + const secret = await service.createSecret('p1', { + folderId: 'folder-1', + key: 'db password', + values: { prod: SECRET_VALUE }, + }); + + expect(events.types()).toEqual(['vault.secret.created']); + const [event] = events.ofType('vault.secret.created'); + expect(event.scope).toEqual({ organizationId: 'org-1', projectId: 'p1' }); + expect(event.payload).toEqual({ + secretId: secret.id, + key: 'DB_PASSWORD', + folderId: 'folder-1', + folderPath: '/database', + environmentIds: ['env-prod'], + }); + }); + + it('publishes secret.updated with only the changed environments and fields', async () => { + const secret = await service.createSecret('p1', { + key: 'zone', + values: { dev: 'eu', prod: 'eu' }, + }); + events.clear(); + + await service.updateSecret('p1', secret.id, { key: 'zone', values: { dev: 'eu', prod: 'us' } }); + + expect(events.ofType('vault.secret.updated').map((event) => event.payload)).toEqual([ + { + secretId: secret.id, + key: 'ZONE', + folderId: null, + folderPath: '/', + environmentIds: ['env-prod'], + changedFields: ['values'], + }, + ]); + }); + + it('publishes secret.updated from setSecretValue and secret.deleted from deleteSecretByKey', async () => { + await service.createSecret('p1', { key: 'zone', values: { prod: 'eu' } }); + events.clear(); + + await service.setSecretValue('p1', null, 'zone', 'dev', SECRET_VALUE); + await service.deleteSecretByKey('p1', null, 'zone'); + + expect(events.types()).toEqual(['vault.secret.updated', 'vault.secret.deleted']); + expect(events.ofType('vault.secret.updated')[0].payload.environmentIds).toEqual(['env-dev']); + expect(events.ofType('vault.secret.deleted')[0].payload).toMatchObject({ + key: 'ZONE', + environmentIds: ['env-dev', 'env-prod'], + }); + }); + + it('publishes a single env.imported event for an import', async () => { + await service.createSecret('p1', { key: 'EXISTING', values: { dev: 'old' } }); + events.clear(); + + await service.importEnvFile( + 'p1', + 'dev', + null, + `EXISTING=new\nNEW_ONE=${SECRET_VALUE}\nOTHER=x`, + ); + + expect(events.types()).toEqual(['vault.env.imported']); + expect(events.ofType('vault.env.imported')[0].payload).toEqual({ + environmentId: 'env-dev', + environmentSlug: 'dev', + folderId: null, + folderPath: '/', + created: 2, + updated: 1, + }); + }); + + it('publishes environment.created and environment.deleted', async () => { + await service.createEnvironment('p1', { name: 'Stage' }); + const stage = repository.environments.find((environment) => environment.slug === 'stage')!; + await service.deleteEnvironment('p1', String(stage.id)); + + expect(events.types()).toEqual(['vault.environment.created', 'vault.environment.deleted']); + expect(events.ofType('vault.environment.created')[0].payload).toEqual({ + environmentId: stage.id, + name: 'Stage', + slug: 'stage', + }); + expect(events.ofType('vault.environment.deleted')[0].payload.environmentId).toBe(stage.id); + }); + + it('publishes nothing when the operation is rejected', async () => { + await expect(service.updateSecret('p1', 'missing', { key: 'X' })).rejects.toThrow(); + await expect(service.deleteSecret('p1', 'missing')).rejects.toThrow(); + await expect(service.createEnvironment('p1', { name: 'dev' })).rejects.toThrow(); + await expect(service.importEnvFile('p1', 'missing', null, 'A=1')).rejects.toThrow(); + await expect(service.importEnvFile('p1', 'dev', null, '# nothing')).rejects.toThrow(); + + expect(events.events).toEqual([]); + }); + + it('publishes nothing when the GitDB write fails', async () => { + const secret = await service.createSecret('p1', { key: 'zone', values: { prod: 'eu' } }); + events.clear(); + repository.failWrites = true; + + await expect(service.createSecret('p1', { key: 'other' })).rejects.toThrow(); + await expect( + service.updateSecret('p1', secret.id, { key: 'zone', values: { prod: 'us' } }), + ).rejects.toThrow(); + await expect(service.deleteSecret('p1', secret.id)).rejects.toThrow(); + await expect(service.createEnvironment('p1', { name: 'Stage' })).rejects.toThrow(); + + expect(events.events).toEqual([]); + }); + + it('never includes secret values in any vault event', async () => { + const secret = await service.createSecret('p1', { + key: 'token', + values: { prod: SECRET_VALUE }, + }); + await service.updateSecret('p1', secret.id, { + key: 'token', + values: { prod: `${SECRET_VALUE}-rotated`, dev: SECRET_VALUE }, + }); + await service.importEnvFile('p1', 'prod', null, `IMPORTED=${SECRET_VALUE}`); + await service.deleteSecret('p1', secret.id); + + expect(events.types()).toEqual([ + 'vault.secret.created', + 'vault.secret.updated', + 'vault.env.imported', + 'vault.secret.deleted', + ]); + expect(JSON.stringify(events.events)).not.toContain(SECRET_VALUE); + }); +}); diff --git a/src/modules/vault/application/vault.service.ts b/src/modules/vault/application/vault.service.ts index e86c2d0..c7dc962 100644 --- a/src/modules/vault/application/vault.service.ts +++ b/src/modules/vault/application/vault.service.ts @@ -1,6 +1,16 @@ import crypto from 'crypto'; import { VaultRepository } from '../infrastructure/repositories/vault.repository'; import type { VaultEncryptionProvider, VaultSecretValues } from '../domain/vault.domain'; +import type { EventBus } from '#lib/server/events'; +import { resolveProjectScope, type ProjectScopeLookup } from '#lib/server/events/scope'; +import type { + DomainEventMap, + VaultSecretChangedField, + VaultSecretPayload, +} from '#lib/events/domain-events'; +import { createLogger } from '#lib/server/logger'; + +const log = createLogger('vault'); const DEFAULT_ENVIRONMENTS = [ { slug: 'dev', name: 'Development' }, @@ -19,8 +29,32 @@ export type VaultSecretInput = { values?: VaultSecretValues; }; +type VaultEventType = Extract; + +type VaultEventsOptions = { + events?: Pick; + projects?: ProjectScopeLookup; +}; + +type SecretSnapshot = { + id: string; + key: string; + folderId?: string | null; + description?: string | null; + values?: VaultSecretValues; +}; + export class VaultService { - constructor(private readonly repository: VaultRepository) {} + private readonly events?: Pick; + private readonly projects?: ProjectScopeLookup; + + constructor( + private readonly repository: VaultRepository, + options: VaultEventsOptions = {}, + ) { + this.events = options.events; + this.projects = options.projects; + } async getProjectVault(projectId: string) { await this.ensureDefaultEnvironments(projectId); @@ -67,6 +101,11 @@ export class VaultService { description: input.description?.trim() || undefined, order: nextOrder, }); + await this.emit(projectId, 'vault.environment.created', { + environmentId: id, + name, + slug, + }); return this.repository.findEnvironmentById(id); } @@ -102,6 +141,11 @@ export class VaultService { if (environments.length <= 1) throw new Error('Debe existir al menos un entorno'); await this.repository.deleteEnvironment(environment.id); + await this.emit(projectId, 'vault.environment.deleted', { + environmentId: environment.id, + name: environment.name, + slug: environment.slug, + }); } async moveEnvironment(projectId: string, id: string, direction: 'up' | 'down') { @@ -286,7 +330,8 @@ export class VaultService { continue; } - await this.createSecret(projectId, { + // one vault.env.imported event for the whole file instead of one per secret + await this.insertSecret(projectId, { folderId, key: normalizedKey, values: { [environmentSlug]: value }, @@ -294,6 +339,15 @@ export class VaultService { created += 1; } + await this.emit(projectId, 'vault.env.imported', { + environmentId: environment.id, + environmentSlug, + folderId: folderId ?? null, + folderPath: await this.folderPath(folderId), + created, + updated, + }); + return { created, updated }; } @@ -350,6 +404,16 @@ export class VaultService { } async createSecret(projectId: string, input: VaultSecretInput) { + const secret = await this.insertSecret(projectId, input); + await this.emit( + projectId, + 'vault.secret.created', + await this.secretPayload(projectId, secret, Object.keys(secret.values ?? {})), + ); + return secret; + } + + private async insertSecret(projectId: string, input: VaultSecretInput) { await this.requireOptionalProjectFolder(projectId, input.folderId); const capitalize = (await this.getSettings(projectId)).capitalizeSecrets; const key = this.normalizeSecretKey(input.key, capitalize); @@ -373,13 +437,30 @@ export class VaultService { await this.requireOptionalProjectFolder(projectId, input.folderId); const capitalize = (await this.getSettings(projectId)).capitalizeSecrets; + // copy: the stored row may be the same object the repository mutates on update + const current = secret.toJson() as SecretSnapshot; + const before: SecretSnapshot = { ...current, values: { ...current.values } }; + await this.repository.updateSecret(id, { folderId: input.folderId || null, key: this.normalizeSecretKey(input.key, capitalize), description: input.description?.trim(), values: this.normalizeValues(input.values), }); - return (await this.repository.findSecretById(id))!.toJson(); + const after = (await this.repository.findSecretById(id))!.toJson(); + + const changedValues = this.changedEnvironmentSlugs(before.values, after.values); + const changedFields: VaultSecretChangedField[] = []; + if (before.key !== after.key) changedFields.push('key'); + if ((before.description ?? '') !== (after.description ?? '')) changedFields.push('description'); + if ((before.folderId ?? null) !== (after.folderId ?? null)) changedFields.push('folder'); + if (changedValues.length > 0) changedFields.push('values'); + + await this.emit(projectId, 'vault.secret.updated', { + ...(await this.secretPayload(projectId, after, changedValues)), + changedFields, + }); + return after; } async deleteSecret(projectId: string, id: string) { @@ -387,6 +468,62 @@ export class VaultService { if (!secret || secret.projectId !== projectId) throw new Error('Secret not found'); await this.repository.deleteSecret(id); + const snapshot = secret.toJson() as SecretSnapshot; + await this.emit( + projectId, + 'vault.secret.deleted', + await this.secretPayload(projectId, snapshot, Object.keys(snapshot.values ?? {})), + ); + } + + // events never break the write that already succeeded: failures are only logged + private async emit( + projectId: string, + type: K, + payload: DomainEventMap[K], + ) { + if (!this.events) return; + try { + const scope = await resolveProjectScope(projectId, this.projects); + this.events.publish(type, payload, { scope }); + } catch (error) { + log.error({ err: error, eventType: type, projectId }, 'failed to publish vault event'); + } + } + + /** Secret metadata for events: never the values, only the environments involved. */ + private async secretPayload( + projectId: string, + secret: SecretSnapshot, + environmentSlugs: string[], + ): Promise { + const environments = await this.repository.listEnvironments(projectId).catch(() => []); + const slugs = new Set(environmentSlugs); + return { + secretId: secret.id, + key: secret.key, + folderId: secret.folderId ?? null, + folderPath: await this.folderPath(secret.folderId), + // in the vault's environment order, so payloads are deterministic + environmentIds: environments + .sort((a, b) => a.order - b.order) + .filter((environment) => slugs.has(environment.slug)) + .map((environment) => environment.id), + }; + } + + private async folderPath(folderId: string | null | undefined): Promise { + if (!folderId) return '/'; + const folder = await this.repository.findFolderById(folderId).catch(() => null); + return folder?.path ?? '/'; + } + + private changedEnvironmentSlugs( + before: VaultSecretValues | undefined, + after: VaultSecretValues | undefined, + ): string[] { + const slugs = new Set([...Object.keys(before ?? {}), ...Object.keys(after ?? {})]); + return [...slugs].filter((slug) => before?.[slug] !== after?.[slug]); } async findSecretByKey(projectId: string, folderId: string | null, key: string) { @@ -413,7 +550,7 @@ export class VaultService { return this.updateSecret(projectId, secret.id, { folderId, key, - description: description !== undefined ? description : secret.description ?? undefined, + description: description !== undefined ? description : (secret.description ?? undefined), values: { ...secret.values, [environment]: value }, }); } diff --git a/src/modules/vault/index.ts b/src/modules/vault/index.ts index 0797d4c..d8f591f 100644 --- a/src/modules/vault/index.ts +++ b/src/modules/vault/index.ts @@ -1,7 +1,12 @@ import { VAULT_ENCRYPTION_PROVIDERS, VaultService } from './application/vault.service'; import { VaultRepository } from './infrastructure/repositories/vault.repository'; +import { eventBus } from '#lib/server/events'; +import { projectService } from '../projects'; const vaultRepository = new VaultRepository(); -export const vaultService = new VaultService(vaultRepository); +export const vaultService = new VaultService(vaultRepository, { + events: eventBus, + projects: projectService, +}); export { VAULT_ENCRYPTION_PROVIDERS };