@sphereon/ssi-sdk.data-store 0.18.2-unstable.7 → 0.18.2-unstable.85

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)
+  })
+})

package/src/contact/AbstractContactStore.ts

@@ -1,28 +1,39 @@
 import {
-  Party,
-  Identity,
+  AddElectronicAddressArgs,
   AddIdentityArgs,
-  GetIdentityArgs,
+  AddPartyArgs,
+  AddPartyTypeArgs,
+  AddPhysicalAddressArgs,
+  AddRelationshipArgs,
+  ElectronicAddress,
+  GetElectronicAddressArgs,
+  GetElectronicAddressesArgs,
   GetIdentitiesArgs,
+  GetIdentityArgs,
+  GetPartiesArgs,
   GetPartyArgs,
+  GetPartyTypeArgs,
+  GetPartyTypesArgs,
+  GetPhysicalAddressArgs,
+  GetPhysicalAddressesArgs,
+  GetRelationshipArgs,
+  GetRelationshipsArgs,
+  Identity,
+  Party,
+  PartyRelationship,
+  PartyType, PhysicalAddress,
+  RemoveElectronicAddressArgs,
   RemoveIdentityArgs,
-  UpdateIdentityArgs,
-  AddPartyArgs,
-  GetPartiesArgs,
   RemovePartyArgs,
-  UpdatePartyArgs,
-  AddRelationshipArgs,
-  PartyRelationship,
+  RemovePartyTypeArgs,
+  RemovePhysicalAddressArgs,
   RemoveRelationshipArgs,
-  AddPartyTypeArgs,
-  PartyType,
-  GetPartyTypeArgs,
+  UpdateElectronicAddressArgs,
+  UpdateIdentityArgs,
+  UpdatePartyArgs,
   UpdatePartyTypeArgs,
-  GetPartyTypesArgs,
-  RemovePartyTypeArgs,
-  GetRelationshipsArgs,
-  GetRelationshipArgs,
-  UpdateRelationshipArgs,
+  UpdatePhysicalAddressArgs,
+  UpdateRelationshipArgs
 } from '../types'
 
 export abstract class AbstractContactStore {
@@ -46,4 +57,14 @@ export abstract class AbstractContactStore {
   abstract addPartyType(args: AddPartyTypeArgs): Promise<PartyType>
   abstract updatePartyType(args: UpdatePartyTypeArgs): Promise<PartyType>
   abstract removePartyType(args: RemovePartyTypeArgs): Promise<void>
+  abstract getElectronicAddress(args: GetElectronicAddressArgs): Promise<ElectronicAddress>
+  abstract getElectronicAddresses(args?: GetElectronicAddressesArgs): Promise<Array<ElectronicAddress>>
+  abstract addElectronicAddress(args: AddElectronicAddressArgs): Promise<ElectronicAddress>
+  abstract updateElectronicAddress(args: UpdateElectronicAddressArgs): Promise<ElectronicAddress>
+  abstract removeElectronicAddress(args: RemoveElectronicAddressArgs): Promise<void>
+  abstract getPhysicalAddress(args: GetPhysicalAddressArgs): Promise<PhysicalAddress>
+  abstract getPhysicalAddresses(args?: GetPhysicalAddressesArgs): Promise<Array<PhysicalAddress>>
+  abstract addPhysicalAddress(args: AddPhysicalAddressArgs): Promise<PhysicalAddress>
+  abstract updatePhysicalAddress(args: UpdatePhysicalAddressArgs): Promise<PhysicalAddress>
+  abstract removePhysicalAddress(args: RemovePhysicalAddressArgs): Promise<void>
 }