@sphereon/ssi-sdk.data-store 0.30.2-next.103 → 0.30.2-next.129

package/src/__tests__/eventLogger.store.test.ts

@@ -1,11 +1,29 @@
 import { DataSources } from '@sphereon/ssi-sdk.agent-config'
-import { ActionType, InitiatorType, LogLevel, SubSystem, System, SystemCorrelationIdType } from '@sphereon/ssi-types'
+import {
+  ActivityLoggingEvent,
+  AuditLoggingEvent,
+  CredentialType,
+  PartyCorrelationType
+} from '@sphereon/ssi-sdk.core'
+import {
+  ActionType,
+  InitiatorType,
+  LoggingEventType,
+  LogLevel,
+  SubSystem,
+  System,
+  SystemCorrelationIdType
+} from '@sphereon/ssi-types'
 import { DataSource } from 'typeorm'
 import { DataStoreEventLoggerMigrations } from '../migrations'
 import { DataStoreEventLoggerEntities } from '../index'
-import { AuditLoggingEvent, PartyCorrelationType } from '@sphereon/ssi-sdk.core'
 import { EventLoggerStore } from '../eventLogger/EventLoggerStore'
-import { GetAuditEventsArgs, NonPersistedAuditLoggingEvent } from '../types'
+import {
+  GetActivityEventsArgs,
+  GetAuditEventsArgs,
+  NonPersistedAuditLoggingEvent,
+  NonPersistedActivityLoggingEvent
+} from '../types'
 
 describe('Database entities tests', (): void => {
   let dbConnection: DataSource
@@ -54,6 +72,7 @@ describe('Database entities tests', (): void => {
 
     const savedAuditEvent: AuditLoggingEvent = await eventLoggerStore.storeAuditEvent({ event: auditEvent })
     expect(savedAuditEvent).toBeDefined()
+    expect(savedAuditEvent.type).toEqual(LoggingEventType.AUDIT)
   })
 
   it('should get all audit events', async (): Promise<void> => {
@@ -83,6 +102,32 @@ describe('Database entities tests', (): void => {
     const auditEvent2: AuditLoggingEvent = await eventLoggerStore.storeAuditEvent({ event: auditEvent })
     expect(auditEvent2).toBeDefined()
 
+    const activityEvent: NonPersistedActivityLoggingEvent = {
+      timestamp: new Date(),
+      level: LogLevel.DEBUG,
+      correlationId: 'b40b8474-58a2-4b23-9fde-bd6ee1902cdb',
+      originalCredential: 'test_credential_string',
+      credentialHash: '341a7897df58e472f9bf19b3b9abf7d5',
+      credentialType: CredentialType.SD_JWT,
+      system: System.GENERAL,
+      subSystemType: SubSystem.DID_PROVIDER,
+      actionType: ActionType.EXECUTE,
+      actionSubType: 'Share credential',
+      initiatorType: InitiatorType.EXTERNAL,
+      systemCorrelationIdType: SystemCorrelationIdType.DID,
+      systemCorrelationId: 'did:example:123456789abcdefghi',
+      systemAlias: 'test_alias',
+      partyCorrelationType: PartyCorrelationType.DID,
+      partyCorrelationId: '75cfd84a-0f3b-4fb1-97a3-a1506c7ab850',
+      partyAlias: 'test_alias',
+      description: 'test_description',
+      data: 'test_data_string',
+      diagnosticData: { data: 'test_data_string' },
+    }
+
+    const storedActivityEvent: ActivityLoggingEvent = await eventLoggerStore.storeActivityEvent({ event: activityEvent })
+    expect(storedActivityEvent).toBeDefined()
+
     const result: Array<AuditLoggingEvent> = await eventLoggerStore.getAuditEvents()
     expect(result.length).toEqual(2)
   })
@@ -120,6 +165,29 @@ describe('Database entities tests', (): void => {
   })
 
   it('should return no audit events if filter does not match', async (): Promise<void> => {
+    const auditEvent: NonPersistedAuditLoggingEvent = {
+      timestamp: new Date(),
+      level: LogLevel.DEBUG,
+      correlationId: 'b40b8474-58a2-4b23-9fde-bd6ee1902cdb',
+      system: System.GENERAL,
+      subSystemType: SubSystem.DID_PROVIDER,
+      actionType: ActionType.CREATE,
+      actionSubType: 'Key generation',
+      initiatorType: InitiatorType.EXTERNAL,
+      systemCorrelationIdType: SystemCorrelationIdType.DID,
+      systemCorrelationId: 'did:example:123456789abcdefghi',
+      systemAlias: 'test_alias',
+      partyCorrelationType: PartyCorrelationType.DID,
+      partyCorrelationId: '75cfd84a-0f3b-4fb1-97a3-a1506c7ab850',
+      partyAlias: 'test_alias',
+      description: 'test_description',
+      data: 'test_data_string',
+      diagnosticData: { data: 'test_data_string' },
+    }
+
+    const savedAuditEvent: AuditLoggingEvent = await eventLoggerStore.storeAuditEvent({ event: auditEvent })
+    expect(savedAuditEvent).toBeDefined()
+
     const args: GetAuditEventsArgs = {
       filter: [{ correlationId: 'unknown_id' }],
     }
@@ -127,4 +195,413 @@ describe('Database entities tests', (): void => {
 
     expect(result.length).toEqual(0)
   })
+
+  it('should store activity event', async (): Promise<void> => {
+    const activityEvent: NonPersistedActivityLoggingEvent = {
+      timestamp: new Date(),
+      level: LogLevel.DEBUG,
+      correlationId: 'b40b8474-58a2-4b23-9fde-bd6ee1902cdb',
+      originalCredential: 'test_credential_string',
+      credentialHash: '341a7897df58e472f9bf19b3b9abf7d5',
+      credentialType: CredentialType.SD_JWT,
+      system: System.GENERAL,
+      subSystemType: SubSystem.DID_PROVIDER,
+      actionType: ActionType.EXECUTE,
+      actionSubType: 'Share credential',
+      initiatorType: InitiatorType.EXTERNAL,
+      systemCorrelationIdType: SystemCorrelationIdType.DID,
+      systemCorrelationId: 'did:example:123456789abcdefghi',
+      systemAlias: 'test_alias',
+      partyCorrelationType: PartyCorrelationType.DID,
+      partyCorrelationId: '75cfd84a-0f3b-4fb1-97a3-a1506c7ab850',
+      partyAlias: 'test_alias',
+      description: 'test_description',
+      data: 'test_data_string',
+      diagnosticData: { data: 'test_data_string' },
+    }
+
+    const savedActivityEvent: ActivityLoggingEvent = await eventLoggerStore.storeActivityEvent({ event: activityEvent })
+    expect(savedActivityEvent).toBeDefined()
+    expect(savedActivityEvent.type).toEqual(LoggingEventType.ACTIVITY)
+    expect(savedActivityEvent.originalCredential).toEqual(activityEvent.originalCredential)
+    expect(savedActivityEvent.credentialHash).toEqual(activityEvent.credentialHash)
+    expect(savedActivityEvent.credentialType).toEqual(activityEvent.credentialType)
+    expect(savedActivityEvent.data).toEqual(activityEvent.data)
+  })
+
+  it('should get all activity events', async (): Promise<void> => {
+    const activityEvent: NonPersistedActivityLoggingEvent = {
+      timestamp: new Date(),
+      level: LogLevel.DEBUG,
+      correlationId: 'b40b8474-58a2-4b23-9fde-bd6ee1902cdb',
+      originalCredential: 'test_credential_string',
+      credentialHash: '341a7897df58e472f9bf19b3b9abf7d5',
+      credentialType: CredentialType.SD_JWT,
+      system: System.GENERAL,
+      subSystemType: SubSystem.DID_PROVIDER,
+      actionType: ActionType.EXECUTE,
+      actionSubType: 'Share credential',
+      initiatorType: InitiatorType.EXTERNAL,
+      systemCorrelationIdType: SystemCorrelationIdType.DID,
+      systemCorrelationId: 'did:example:123456789abcdefghi',
+      systemAlias: 'test_alias',
+      partyCorrelationType: PartyCorrelationType.DID,
+      partyCorrelationId: '75cfd84a-0f3b-4fb1-97a3-a1506c7ab850',
+      partyAlias: 'test_alias',
+      description: 'test_description',
+      data: 'test_data_string',
+      diagnosticData: { data: 'test_data_string' },
+    }
+
+    const activityEvent1: ActivityLoggingEvent = await eventLoggerStore.storeActivityEvent({ event: activityEvent })
+    expect(activityEvent1).toBeDefined()
+
+    const activityEvent2: ActivityLoggingEvent = await eventLoggerStore.storeActivityEvent({ event: activityEvent })
+    expect(activityEvent2).toBeDefined()
+
+    const auditEvent: NonPersistedAuditLoggingEvent = {
+      timestamp: new Date(),
+      level: LogLevel.DEBUG,
+      correlationId: 'b40b8474-58a2-4b23-9fde-bd6ee1902cdb',
+      system: System.GENERAL,
+      subSystemType: SubSystem.DID_PROVIDER,
+      actionType: ActionType.CREATE,
+      actionSubType: 'Key generation',
+      initiatorType: InitiatorType.EXTERNAL,
+      systemCorrelationIdType: SystemCorrelationIdType.DID,
+      systemCorrelationId: 'did:example:123456789abcdefghi',
+      systemAlias: 'test_alias',
+      partyCorrelationType: PartyCorrelationType.DID,
+      partyCorrelationId: '75cfd84a-0f3b-4fb1-97a3-a1506c7ab850',
+      partyAlias: 'test_alias',
+      description: 'test_description',
+      data: 'test_data_string',
+      diagnosticData: { data: 'test_data_string' },
+    }
+
+    const storedAuditEvent: AuditLoggingEvent = await eventLoggerStore.storeAuditEvent({ event: auditEvent })
+    expect(storedAuditEvent).toBeDefined()
+
+    const result: Array<ActivityLoggingEvent> = await eventLoggerStore.getActivityEvents()
+    expect(result.length).toEqual(2)
+  })
+
+  it('should get activity events by filter', async (): Promise<void> => {
+    const activityEvent: NonPersistedActivityLoggingEvent = {
+      timestamp: new Date(),
+      level: LogLevel.DEBUG,
+      correlationId: 'b40b8474-58a2-4b23-9fde-bd6ee1902cdb',
+      originalCredential: 'test_credential_string',
+      credentialHash: '341a7897df58e472f9bf19b3b9abf7d5',
+      credentialType: CredentialType.SD_JWT,
+      system: System.GENERAL,
+      subSystemType: SubSystem.DID_PROVIDER,
+      actionType: ActionType.EXECUTE,
+      actionSubType: 'Share credential',
+      initiatorType: InitiatorType.EXTERNAL,
+      systemCorrelationIdType: SystemCorrelationIdType.DID,
+      systemCorrelationId: 'did:example:123456789abcdefghi',
+      systemAlias: 'test_alias',
+      partyCorrelationType: PartyCorrelationType.DID,
+      partyCorrelationId: '75cfd84a-0f3b-4fb1-97a3-a1506c7ab850',
+      partyAlias: 'test_alias',
+      description: 'test_description',
+      data: 'test_data_string',
+      diagnosticData: { data: 'test_data_string' },
+    }
+
+    const savedActivityEvent: ActivityLoggingEvent = await eventLoggerStore.storeActivityEvent({ event: activityEvent })
+    expect(savedActivityEvent).toBeDefined()
+
+    const args: GetActivityEventsArgs = {
+      filter: [{ credentialHash: savedActivityEvent.credentialHash }],
+    }
+    const result: Array<ActivityLoggingEvent> = await eventLoggerStore.getActivityEvents(args)
+
+    expect(result.length).toEqual(1)
+  })
+
+  it('should return no audit events if filter does not match', async (): Promise<void> => {
+    const activityEvent: NonPersistedActivityLoggingEvent = {
+      timestamp: new Date(),
+      level: LogLevel.DEBUG,
+      correlationId: 'b40b8474-58a2-4b23-9fde-bd6ee1902cdb',
+      originalCredential: 'test_credential_string',
+      credentialHash: '341a7897df58e472f9bf19b3b9abf7d5',
+      credentialType: CredentialType.SD_JWT,
+      system: System.GENERAL,
+      subSystemType: SubSystem.DID_PROVIDER,
+      actionType: ActionType.EXECUTE,
+      actionSubType: 'Share credential',
+      initiatorType: InitiatorType.EXTERNAL,
+      systemCorrelationIdType: SystemCorrelationIdType.DID,
+      systemCorrelationId: 'did:example:123456789abcdefghi',
+      systemAlias: 'test_alias',
+      partyCorrelationType: PartyCorrelationType.DID,
+      partyCorrelationId: '75cfd84a-0f3b-4fb1-97a3-a1506c7ab850',
+      partyAlias: 'test_alias',
+      description: 'test_description',
+      data: 'test_data_string',
+      diagnosticData: { data: 'test_data_string' },
+    }
+
+    const savedActivityEvent: ActivityLoggingEvent = await eventLoggerStore.storeActivityEvent({ event: activityEvent })
+    expect(savedActivityEvent).toBeDefined()
+
+    const args: GetActivityEventsArgs = {
+      filter: [{ credentialHash: 'unknown_hash' }],
+    }
+    const result: Array<ActivityLoggingEvent> = await eventLoggerStore.getActivityEvents(args)
+
+    expect(result.length).toEqual(0)
+  })
+
+  it('should get all activity events for a parent credential', async (): Promise<void> => {
+    const parentCredentialHash = 'df7037831edbde7f0f65f723ef5494d6'
+
+    const parentActivityEvent: NonPersistedActivityLoggingEvent = {
+      timestamp: new Date(),
+      level: LogLevel.DEBUG,
+      correlationId: 'b40b8474-58a2-4b23-9fde-bd6ee1902cdb',
+      originalCredential: 'test_credential_string',
+      credentialHash: parentCredentialHash,
+      credentialType: CredentialType.SD_JWT,
+      system: System.GENERAL,
+      subSystemType: SubSystem.DID_PROVIDER,
+      actionType: ActionType.EXECUTE,
+      actionSubType: 'Share credential',
+      initiatorType: InitiatorType.EXTERNAL,
+      systemCorrelationIdType: SystemCorrelationIdType.DID,
+      systemCorrelationId: 'did:example:123456789abcdefghi',
+      systemAlias: 'test_alias',
+      partyCorrelationType: PartyCorrelationType.DID,
+      partyCorrelationId: '75cfd84a-0f3b-4fb1-97a3-a1506c7ab850',
+      partyAlias: 'test_alias',
+      description: 'test_description',
+      data: 'test_data_string',
+      diagnosticData: { data: 'test_data_string' },
+    }
+
+    const storedParentActivityEvent: ActivityLoggingEvent = await eventLoggerStore.storeActivityEvent({ event: parentActivityEvent })
+    expect(storedParentActivityEvent).toBeDefined()
+
+    const childActivityEvent: NonPersistedActivityLoggingEvent = {
+      timestamp: new Date(),
+      level: LogLevel.DEBUG,
+      correlationId: 'b40b8474-58a2-4b23-9fde-bd6ee1902cdb',
+      originalCredential: 'test_credential_string',
+      credentialHash: '341a7897df58e472f9bf19b3b9abf7d5',
+      parentCredentialHash,
+      credentialType: CredentialType.SD_JWT,
+      system: System.GENERAL,
+      subSystemType: SubSystem.DID_PROVIDER,
+      actionType: ActionType.EXECUTE,
+      actionSubType: 'Share credential',
+      initiatorType: InitiatorType.EXTERNAL,
+      systemCorrelationIdType: SystemCorrelationIdType.DID,
+      systemCorrelationId: 'did:example:123456789abcdefghi',
+      systemAlias: 'test_alias',
+      partyCorrelationType: PartyCorrelationType.DID,
+      partyCorrelationId: '75cfd84a-0f3b-4fb1-97a3-a1506c7ab850',
+      partyAlias: 'test_alias',
+      description: 'test_description',
+      data: 'test_data_string',
+      diagnosticData: { data: 'test_data_string' },
+    }
+
+    const storedChildActivityEvent: ActivityLoggingEvent = await eventLoggerStore.storeActivityEvent({ event: childActivityEvent })
+    expect(storedChildActivityEvent).toBeDefined()
+
+    const otherActivityEvent: NonPersistedActivityLoggingEvent = {
+      timestamp: new Date(),
+      level: LogLevel.DEBUG,
+      correlationId: 'b40b8474-58a2-4b23-9fde-bd6ee1902cdb',
+      originalCredential: 'test_credential_string',
+      credentialHash: 'a8360b0b0b2eed8d185738536ff5b841',
+      credentialType: CredentialType.SD_JWT,
+      system: System.GENERAL,
+      subSystemType: SubSystem.DID_PROVIDER,
+      actionType: ActionType.EXECUTE,
+      actionSubType: 'Share credential', // TODO
+      initiatorType: InitiatorType.EXTERNAL,
+      systemCorrelationIdType: SystemCorrelationIdType.DID,
+      systemCorrelationId: 'did:example:123456789abcdefghi',
+      systemAlias: 'test_alias',
+      partyCorrelationType: PartyCorrelationType.DID,
+      partyCorrelationId: '75cfd84a-0f3b-4fb1-97a3-a1506c7ab850',
+      partyAlias: 'test_alias',
+      description: 'test_description',
+      data: 'test_data_string',
+      diagnosticData: { data: 'test_data_string' },
+    }
+
+    const storedOtherActivityEvent: ActivityLoggingEvent = await eventLoggerStore.storeActivityEvent({ event: otherActivityEvent })
+    expect(storedOtherActivityEvent).toBeDefined()
+
+    const receiveActivityEvent: NonPersistedActivityLoggingEvent = {
+      timestamp: new Date(),
+      level: LogLevel.DEBUG,
+      correlationId: 'b40b8474-58a2-4b23-9fde-bd6ee1902cdb',
+      originalCredential: 'test_credential_string',
+      credentialHash: parentCredentialHash,
+      credentialType: CredentialType.SD_JWT,
+      system: System.GENERAL,
+      subSystemType: SubSystem.DID_PROVIDER,
+      actionType: ActionType.EXECUTE,
+      actionSubType: 'Receive credential',
+      initiatorType: InitiatorType.EXTERNAL,
+      systemCorrelationIdType: SystemCorrelationIdType.DID,
+      systemCorrelationId: 'did:example:123456789abcdefghi',
+      systemAlias: 'test_alias',
+      partyCorrelationType: PartyCorrelationType.DID,
+      partyCorrelationId: '75cfd84a-0f3b-4fb1-97a3-a1506c7ab850',
+      partyAlias: 'test_alias',
+      description: 'test_description',
+      data: 'test_data_string',
+      diagnosticData: { data: 'test_data_string' },
+    }
+
+    const storedReceiveActivityEvent: ActivityLoggingEvent = await eventLoggerStore.storeActivityEvent({ event: receiveActivityEvent })
+    expect(storedReceiveActivityEvent).toBeDefined()
+
+    const args: GetActivityEventsArgs = {
+      filter: [
+        {
+          credentialHash: parentCredentialHash
+        },
+        {
+          parentCredentialHash
+        }
+      ]
+    }
+
+    const result: Array<ActivityLoggingEvent> = await eventLoggerStore.getActivityEvents(args)
+    expect(result.length).toEqual(3)
+  })
+
+  it('should get all activity events for a parent credential with a certain action', async (): Promise<void> => {
+    const parentCredentialHash = 'df7037831edbde7f0f65f723ef5494d6'
+
+    const parentActivityEvent: NonPersistedActivityLoggingEvent = {
+      timestamp: new Date(),
+      level: LogLevel.DEBUG,
+      correlationId: 'b40b8474-58a2-4b23-9fde-bd6ee1902cdb',
+      originalCredential: 'test_credential_string',
+      credentialHash: parentCredentialHash,
+      credentialType: CredentialType.SD_JWT,
+      system: System.GENERAL,
+      subSystemType: SubSystem.DID_PROVIDER,
+      actionType: ActionType.EXECUTE,
+      actionSubType: 'Share credential',
+      initiatorType: InitiatorType.EXTERNAL,
+      systemCorrelationIdType: SystemCorrelationIdType.DID,
+      systemCorrelationId: 'did:example:123456789abcdefghi',
+      systemAlias: 'test_alias',
+      partyCorrelationType: PartyCorrelationType.DID,
+      partyCorrelationId: '75cfd84a-0f3b-4fb1-97a3-a1506c7ab850',
+      partyAlias: 'test_alias',
+      description: 'test_description',
+      data: 'test_data_string',
+      diagnosticData: { data: 'test_data_string' },
+    }
+
+    const storedParentActivityEvent: ActivityLoggingEvent = await eventLoggerStore.storeActivityEvent({ event: parentActivityEvent })
+    expect(storedParentActivityEvent).toBeDefined()
+
+    const childActivityEvent: NonPersistedActivityLoggingEvent = {
+      timestamp: new Date(),
+      level: LogLevel.DEBUG,
+      correlationId: 'b40b8474-58a2-4b23-9fde-bd6ee1902cdb',
+      originalCredential: 'test_credential_string',
+      credentialHash: '341a7897df58e472f9bf19b3b9abf7d5',
+      parentCredentialHash,
+      credentialType: CredentialType.SD_JWT,
+      system: System.GENERAL,
+      subSystemType: SubSystem.DID_PROVIDER,
+      actionType: ActionType.EXECUTE,
+      actionSubType: 'Share credential',
+      initiatorType: InitiatorType.EXTERNAL,
+      systemCorrelationIdType: SystemCorrelationIdType.DID,
+      systemCorrelationId: 'did:example:123456789abcdefghi',
+      systemAlias: 'test_alias',
+      partyCorrelationType: PartyCorrelationType.DID,
+      partyCorrelationId: '75cfd84a-0f3b-4fb1-97a3-a1506c7ab850',
+      partyAlias: 'test_alias',
+      description: 'test_description',
+      data: 'test_data_string',
+      diagnosticData: { data: 'test_data_string' },
+    }
+
+    const storedChildActivityEvent: ActivityLoggingEvent = await eventLoggerStore.storeActivityEvent({ event: childActivityEvent })
+    expect(storedChildActivityEvent).toBeDefined()
+
+    const otherActivityEvent: NonPersistedActivityLoggingEvent = {
+      timestamp: new Date(),
+      level: LogLevel.DEBUG,
+      correlationId: 'b40b8474-58a2-4b23-9fde-bd6ee1902cdb',
+      originalCredential: 'test_credential_string',
+      credentialHash: 'a8360b0b0b2eed8d185738536ff5b841',
+      credentialType: CredentialType.SD_JWT,
+      system: System.GENERAL,
+      subSystemType: SubSystem.DID_PROVIDER,
+      actionType: ActionType.EXECUTE,
+      actionSubType: 'Share credential', // TODO
+      initiatorType: InitiatorType.EXTERNAL,
+      systemCorrelationIdType: SystemCorrelationIdType.DID,
+      systemCorrelationId: 'did:example:123456789abcdefghi',
+      systemAlias: 'test_alias',
+      partyCorrelationType: PartyCorrelationType.DID,
+      partyCorrelationId: '75cfd84a-0f3b-4fb1-97a3-a1506c7ab850',
+      partyAlias: 'test_alias',
+      description: 'test_description',
+      data: 'test_data_string',
+      diagnosticData: { data: 'test_data_string' },
+    }
+
+    const storedOtherActivityEvent: ActivityLoggingEvent = await eventLoggerStore.storeActivityEvent({ event: otherActivityEvent })
+    expect(storedOtherActivityEvent).toBeDefined()
+
+    const receiveActivityEvent: NonPersistedActivityLoggingEvent = {
+      timestamp: new Date(),
+      level: LogLevel.DEBUG,
+      correlationId: 'b40b8474-58a2-4b23-9fde-bd6ee1902cdb',
+      originalCredential: 'test_credential_string',
+      credentialHash: parentCredentialHash,
+      credentialType: CredentialType.SD_JWT,
+      system: System.GENERAL,
+      subSystemType: SubSystem.DID_PROVIDER,
+      actionType: ActionType.EXECUTE,
+      actionSubType: 'Receive credential',
+      initiatorType: InitiatorType.EXTERNAL,
+      systemCorrelationIdType: SystemCorrelationIdType.DID,
+      systemCorrelationId: 'did:example:123456789abcdefghi',
+      systemAlias: 'test_alias',
+      partyCorrelationType: PartyCorrelationType.DID,
+      partyCorrelationId: '75cfd84a-0f3b-4fb1-97a3-a1506c7ab850',
+      partyAlias: 'test_alias',
+      description: 'test_description',
+      data: 'test_data_string',
+      diagnosticData: { data: 'test_data_string' },
+    }
+
+    const storedReceiveActivityEvent: ActivityLoggingEvent = await eventLoggerStore.storeActivityEvent({ event: receiveActivityEvent })
+    expect(storedReceiveActivityEvent).toBeDefined()
+
+    const args: GetActivityEventsArgs = {
+      filter: [
+        {
+          credentialHash: parentCredentialHash,
+          actionSubType: 'Share credential'
+        },
+        {
+          parentCredentialHash,
+          actionSubType: 'Share credential'
+        }
+      ]
+    }
+
+    const result: Array<ActivityLoggingEvent> = await eventLoggerStore.getActivityEvents(args)
+    expect(result.length).toEqual(2)
+  })
+
 })

package/src/digitalCredential/DigitalCredentialStore.ts

@@ -106,9 +106,7 @@ export class DigitalCredentialStore extends AbstractDigitalCredentialStore {
     let affected: number = 0
     const findResult = await dcRepo.findBy(query)
     for (const dc of findResult) {
-      if (dc.parentId !== null && dc.parentId !== undefined) {
-        affected += await this.deleteTree(dcRepo, { id: dc.parentId })
-      }
+      affected += await this.deleteTree(dcRepo, { parentId: dc.id })
       const result = await dcRepo.delete(dc.id)
       if (result.affected) {
         affected += result.affected

package/src/entities/eventLogger/AuditEventEntity.ts

@@ -1,9 +1,11 @@
-import { ActionSubType, ActionType, InitiatorType, LogLevel, SubSystem, System, SystemCorrelationIdType } from '@sphereon/ssi-types'
+import { ActionSubType, ActionType, InitiatorType, LoggingEventType, LogLevel, SubSystem, System, SystemCorrelationIdType } from '@sphereon/ssi-types'
 import { BaseEntity, Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
-import { PartyCorrelationType } from '@sphereon/ssi-sdk.core'
-import { NonPersistedAuditLoggingEvent } from '../../types'
+import { CredentialType, PartyCorrelationType } from '@sphereon/ssi-sdk.core'
 import { typeOrmDateTime } from '@sphereon/ssi-sdk.agent-config'
+import { NonPersistedAuditLoggingEvent, NonPersistedActivityLoggingEvent } from '../../types'
 
+//TODO this entity, also contains some optional fields that are related to another event type (Activity) later we might want to refactor and reorganize this.
+// For now I've added a discriminator value called eventType that can be one of the three types of events: 1. General, 2. Audit, and 3. Activity
 @Entity('AuditEvents')
 export class AuditEventEntity extends BaseEntity {
   @PrimaryGeneratedColumn('uuid')
@@ -12,6 +14,9 @@ export class AuditEventEntity extends BaseEntity {
   @Column({ name: 'timestamp', nullable: false, unique: false, type: typeOrmDateTime() })
   timestamp!: Date
 
+  @Column('simple-enum', { name: 'eventType', enum: LoggingEventType, nullable: false, unique: false })
+  type!: LoggingEventType
+
   @Column('simple-enum', { name: 'level', enum: LogLevel, nullable: false, unique: false })
   level!: LogLevel
 
@@ -54,6 +59,21 @@ export class AuditEventEntity extends BaseEntity {
   @Column('text', { name: 'description', nullable: false, unique: false })
   description!: string
 
+  @Column('simple-enum', { name: 'credentialType', enum: CredentialType, nullable: true, unique: false })
+  credentialType?: CredentialType
+
+  @Column('text', { name: 'credentialHash', nullable: true, unique: false })
+  credentialHash?: string
+
+  @Column('text', { name: 'parentCredentialHash', nullable: true, unique: false })
+  parentCredentialHash?: string
+
+  @Column('text', { name: 'originalCredential', nullable: true, unique: false })
+  originalCredential?: string
+
+  @Column('text', { name: 'sharePurpose', nullable: true, unique: false })
+  sharePurpose?: string
+
   @Column('text', { name: 'data', nullable: true, unique: false })
   data?: string
 
@@ -69,6 +89,7 @@ export class AuditEventEntity extends BaseEntity {
 
 export const auditEventEntityFrom = (args: NonPersistedAuditLoggingEvent): AuditEventEntity => {
   const auditEventEntity: AuditEventEntity = new AuditEventEntity()
+  auditEventEntity.type = LoggingEventType.AUDIT
   auditEventEntity.timestamp = args.timestamp
   auditEventEntity.level = args.level
   auditEventEntity.correlationId = args.correlationId
@@ -90,3 +111,33 @@ export const auditEventEntityFrom = (args: NonPersistedAuditLoggingEvent): Audit
 
   return auditEventEntity
 }
+
+export const activityEventEntityFrom = (args: NonPersistedActivityLoggingEvent): AuditEventEntity => {
+  const activityEventEntity: AuditEventEntity = new AuditEventEntity()
+  activityEventEntity.type = LoggingEventType.ACTIVITY
+  activityEventEntity.timestamp = args.timestamp
+  activityEventEntity.level = args.level
+  activityEventEntity.correlationId = args.correlationId
+  activityEventEntity.system = args.system
+  activityEventEntity.subSystemType = args.subSystemType
+  activityEventEntity.actionType = args.actionType
+  activityEventEntity.actionSubType = args.actionSubType
+  activityEventEntity.initiatorType = args.initiatorType
+  activityEventEntity.systemCorrelationIdType = args.systemCorrelationIdType
+  activityEventEntity.systemCorrelationId = args.systemCorrelationId
+  activityEventEntity.systemAlias = args.systemAlias
+  activityEventEntity.partyCorrelationType = args.partyCorrelationType
+  activityEventEntity.partyCorrelationId = args.partyCorrelationId
+  activityEventEntity.partyAlias = args.partyAlias
+  activityEventEntity.description = args.description
+  activityEventEntity.partyCorrelationType = args.partyCorrelationType
+  activityEventEntity.data = JSON.stringify(args.data)
+  activityEventEntity.sharePurpose = args.sharePurpose
+  activityEventEntity.credentialType = args.credentialType
+  activityEventEntity.originalCredential = args.originalCredential
+  activityEventEntity.credentialHash = args.credentialHash
+  activityEventEntity.parentCredentialHash = args.parentCredentialHash
+  activityEventEntity.diagnosticData = JSON.stringify(args.diagnosticData)
+
+  return activityEventEntity
+}

package/src/eventLogger/AbstractEventLoggerStore.ts

@@ -1,7 +1,14 @@
-import { GetAuditEventsArgs, StoreAuditEventArgs } from '../types'
-import { AuditLoggingEvent } from '@sphereon/ssi-sdk.core'
+import { ActivityLoggingEvent, AuditLoggingEvent } from '@sphereon/ssi-sdk.core'
+import {
+  GetActivityEventsArgs,
+  GetAuditEventsArgs,
+  StoreActivityEventArgs,
+  StoreAuditEventArgs
+} from '../types'
 
 export abstract class AbstractEventLoggerStore {
   abstract getAuditEvents(args: GetAuditEventsArgs): Promise<Array<AuditLoggingEvent>>
+  abstract getActivityEvents(args: GetActivityEventsArgs): Promise<Array<ActivityLoggingEvent>>
   abstract storeAuditEvent(args: StoreAuditEventArgs): Promise<AuditLoggingEvent>
+  abstract storeActivityEvent(args: StoreActivityEventArgs): Promise<ActivityLoggingEvent>
 }