@sphereon/ssi-sdk.data-store 0.23.5-unstable.88 → 0.24.0

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

@@ -1,73 +1,73 @@
-import { DataSource } from 'typeorm'
-import { DataStoreEventLoggerEntities } from '../index'
-import { DataStoreEventLoggerMigrations } from '../migrations/generic'
-import { ActionType, InitiatorType, LogLevel, PartyCorrelationType, SubSystem, System, SystemCorrelationIdType } from '@sphereon/ssi-sdk.core'
-import { auditEventEntityFrom, AuditEventEntity } from '../entities/eventLogger/AuditEventEntity'
-import { NonPersistedAuditLoggingEvent } from '../types'
-
-describe('Database entities tests', (): void => {
-  let dbConnection: DataSource
-
-  beforeEach(async (): Promise<void> => {
-    dbConnection = await new DataSource({
-      type: 'sqlite',
-      database: ':memory:',
-      //logging: 'all',
-      migrationsRun: false,
-      migrations: DataStoreEventLoggerMigrations,
-      synchronize: false,
-      entities: [...DataStoreEventLoggerEntities],
-    }).initialize()
-    await dbConnection.runMigrations()
-    expect(await dbConnection.showMigrations()).toBeFalsy()
-  })
-
-  afterEach(async (): Promise<void> => {
-    await (await dbConnection).destroy()
-  })
-
-  it('should save audit event to database', 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 auditEventEntity: AuditEventEntity = auditEventEntityFrom(auditEvent)
-    const fromDb: AuditEventEntity = await dbConnection.getRepository(AuditEventEntity).save(auditEventEntity)
-
-    expect(fromDb).toBeDefined()
-    expect(fromDb?.id).not.toBeNull()
-    expect(fromDb?.timestamp).toEqual(auditEvent.timestamp)
-    expect(fromDb?.level).toEqual(auditEvent.level)
-    expect(fromDb?.correlationId).toEqual(auditEvent.correlationId)
-    expect(fromDb?.system).toEqual(auditEvent.system)
-    expect(fromDb?.subSystemType).toEqual(auditEvent.subSystemType)
-    expect(fromDb?.actionType).toEqual(auditEvent.actionType)
-    expect(fromDb?.actionSubType).toEqual(auditEvent.actionSubType)
-    expect(fromDb?.initiatorType).toEqual(auditEvent.initiatorType)
-    expect(fromDb?.systemCorrelationIdType).toEqual(auditEvent.systemCorrelationIdType)
-    expect(fromDb?.systemCorrelationId).toEqual(auditEvent.systemCorrelationId)
-    expect(fromDb?.systemAlias).toEqual(auditEvent.systemAlias)
-    expect(fromDb?.partyCorrelationType).toEqual(auditEvent.partyCorrelationType)
-    expect(fromDb?.partyCorrelationId).toEqual(auditEvent.partyCorrelationId)
-    expect(fromDb?.partyAlias).toEqual(auditEvent.partyAlias)
-    expect(fromDb?.description).toEqual(auditEvent.description)
-    expect(fromDb?.data).toEqual(JSON.stringify(auditEvent.data))
-    expect(fromDb?.diagnosticData).toEqual(JSON.stringify(auditEvent.diagnosticData))
-  })
-})
+import { DataSource } from 'typeorm'
+import { DataStoreEventLoggerEntities } from '../index'
+import { DataStoreEventLoggerMigrations } from '../migrations/generic'
+import { ActionType, InitiatorType, LogLevel, PartyCorrelationType, SubSystem, System, SystemCorrelationIdType } from '@sphereon/ssi-sdk.core'
+import { auditEventEntityFrom, AuditEventEntity } from '../entities/eventLogger/AuditEventEntity'
+import { NonPersistedAuditLoggingEvent } from '../types'
+
+describe('Database entities tests', (): void => {
+  let dbConnection: DataSource
+
+  beforeEach(async (): Promise<void> => {
+    dbConnection = await new DataSource({
+      type: 'sqlite',
+      database: ':memory:',
+      //logging: 'all',
+      migrationsRun: false,
+      migrations: DataStoreEventLoggerMigrations,
+      synchronize: false,
+      entities: [...DataStoreEventLoggerEntities],
+    }).initialize()
+    await dbConnection.runMigrations()
+    expect(await dbConnection.showMigrations()).toBeFalsy()
+  })
+
+  afterEach(async (): Promise<void> => {
+    await (await dbConnection).destroy()
+  })
+
+  it('should save audit event to database', 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 auditEventEntity: AuditEventEntity = auditEventEntityFrom(auditEvent)
+    const fromDb: AuditEventEntity = await dbConnection.getRepository(AuditEventEntity).save(auditEventEntity)
+
+    expect(fromDb).toBeDefined()
+    expect(fromDb?.id).not.toBeNull()
+    expect(fromDb?.timestamp).toEqual(auditEvent.timestamp)
+    expect(fromDb?.level).toEqual(auditEvent.level)
+    expect(fromDb?.correlationId).toEqual(auditEvent.correlationId)
+    expect(fromDb?.system).toEqual(auditEvent.system)
+    expect(fromDb?.subSystemType).toEqual(auditEvent.subSystemType)
+    expect(fromDb?.actionType).toEqual(auditEvent.actionType)
+    expect(fromDb?.actionSubType).toEqual(auditEvent.actionSubType)
+    expect(fromDb?.initiatorType).toEqual(auditEvent.initiatorType)
+    expect(fromDb?.systemCorrelationIdType).toEqual(auditEvent.systemCorrelationIdType)
+    expect(fromDb?.systemCorrelationId).toEqual(auditEvent.systemCorrelationId)
+    expect(fromDb?.systemAlias).toEqual(auditEvent.systemAlias)
+    expect(fromDb?.partyCorrelationType).toEqual(auditEvent.partyCorrelationType)
+    expect(fromDb?.partyCorrelationId).toEqual(auditEvent.partyCorrelationId)
+    expect(fromDb?.partyAlias).toEqual(auditEvent.partyAlias)
+    expect(fromDb?.description).toEqual(auditEvent.description)
+    expect(fromDb?.data).toEqual(JSON.stringify(auditEvent.data))
+    expect(fromDb?.diagnosticData).toEqual(JSON.stringify(auditEvent.diagnosticData))
+  })
+})

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

@@ -1,136 +1,136 @@
-import { DataSource } from 'typeorm'
-import { DataStoreEventLoggerMigrations } from '../migrations/generic'
-import { DataStoreEventLoggerEntities } from '../index'
-import {
-  ActionType,
-  AuditLoggingEvent,
-  InitiatorType,
-  LogLevel,
-  PartyCorrelationType,
-  SubSystem,
-  System,
-  SystemCorrelationIdType,
-} from '@sphereon/ssi-sdk.core'
-import { EventLoggerStore } from '../eventLogger/EventLoggerStore'
-import { GetAuditEventsArgs, NonPersistedAuditLoggingEvent } from '../types'
-
-describe('Database entities tests', (): void => {
-  let dbConnection: DataSource
-  let eventLoggerStore: EventLoggerStore
-
-  beforeEach(async (): Promise<void> => {
-    dbConnection = await new DataSource({
-      type: 'sqlite',
-      database: ':memory:',
-      //logging: 'all',
-      migrationsRun: false,
-      migrations: DataStoreEventLoggerMigrations,
-      synchronize: false,
-      entities: DataStoreEventLoggerEntities,
-    }).initialize()
-    await dbConnection.runMigrations()
-    expect(await dbConnection.showMigrations()).toBeFalsy()
-    eventLoggerStore = new EventLoggerStore(dbConnection)
-  })
-
-  afterEach(async (): Promise<void> => {
-    await (await dbConnection).destroy()
-  })
-
-  it('should store audit event', 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()
-  })
-
-  it('should get all audit events', 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 auditEvent1: AuditLoggingEvent = await eventLoggerStore.storeAuditEvent({ event: auditEvent })
-    expect(auditEvent1).toBeDefined()
-
-    const auditEvent2: AuditLoggingEvent = await eventLoggerStore.storeAuditEvent({ event: auditEvent })
-    expect(auditEvent2).toBeDefined()
-
-    const result: Array<AuditLoggingEvent> = await eventLoggerStore.getAuditEvents()
-    expect(result.length).toEqual(2)
-  })
-
-  it('should get audit events by filter', 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: auditEvent.correlationId }],
-    }
-    const result: Array<AuditLoggingEvent> = await eventLoggerStore.getAuditEvents(args)
-
-    expect(result.length).toEqual(1)
-  })
-
-  it('should return no audit events if filter does not match', async (): Promise<void> => {
-    const args: GetAuditEventsArgs = {
-      filter: [{ correlationId: 'unknown_id' }],
-    }
-    const result: Array<AuditLoggingEvent> = await eventLoggerStore.getAuditEvents(args)
-
-    expect(result.length).toEqual(0)
-  })
-})
+import { DataSource } from 'typeorm'
+import { DataStoreEventLoggerMigrations } from '../migrations/generic'
+import { DataStoreEventLoggerEntities } from '../index'
+import {
+  ActionType,
+  AuditLoggingEvent,
+  InitiatorType,
+  LogLevel,
+  PartyCorrelationType,
+  SubSystem,
+  System,
+  SystemCorrelationIdType,
+} from '@sphereon/ssi-sdk.core'
+import { EventLoggerStore } from '../eventLogger/EventLoggerStore'
+import { GetAuditEventsArgs, NonPersistedAuditLoggingEvent } from '../types'
+
+describe('Database entities tests', (): void => {
+  let dbConnection: DataSource
+  let eventLoggerStore: EventLoggerStore
+
+  beforeEach(async (): Promise<void> => {
+    dbConnection = await new DataSource({
+      type: 'sqlite',
+      database: ':memory:',
+      //logging: 'all',
+      migrationsRun: false,
+      migrations: DataStoreEventLoggerMigrations,
+      synchronize: false,
+      entities: DataStoreEventLoggerEntities,
+    }).initialize()
+    await dbConnection.runMigrations()
+    expect(await dbConnection.showMigrations()).toBeFalsy()
+    eventLoggerStore = new EventLoggerStore(dbConnection)
+  })
+
+  afterEach(async (): Promise<void> => {
+    await (await dbConnection).destroy()
+  })
+
+  it('should store audit event', 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()
+  })
+
+  it('should get all audit events', 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 auditEvent1: AuditLoggingEvent = await eventLoggerStore.storeAuditEvent({ event: auditEvent })
+    expect(auditEvent1).toBeDefined()
+
+    const auditEvent2: AuditLoggingEvent = await eventLoggerStore.storeAuditEvent({ event: auditEvent })
+    expect(auditEvent2).toBeDefined()
+
+    const result: Array<AuditLoggingEvent> = await eventLoggerStore.getAuditEvents()
+    expect(result.length).toEqual(2)
+  })
+
+  it('should get audit events by filter', 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: auditEvent.correlationId }],
+    }
+    const result: Array<AuditLoggingEvent> = await eventLoggerStore.getAuditEvents(args)
+
+    expect(result.length).toEqual(1)
+  })
+
+  it('should return no audit events if filter does not match', async (): Promise<void> => {
+    const args: GetAuditEventsArgs = {
+      filter: [{ correlationId: 'unknown_id' }],
+    }
+    const result: Array<AuditLoggingEvent> = await eventLoggerStore.getAuditEvents(args)
+
+    expect(result.length).toEqual(0)
+  })
+})