@sphereon/ssi-sdk.data-store 0.17.6-next.5 → 0.17.6-next.52

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

@@ -0,0 +1,137 @@
+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/entities/eventLogger/AuditEventEntity.ts

@@ -0,0 +1,106 @@
+import {
+  BaseEntity,
+  Column,
+  CreateDateColumn,
+  Entity,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn
+} from 'typeorm'
+import {
+  ActionType,
+  InitiatorType,
+  LogLevel,
+  PartyCorrelationType,
+  SubSystem,
+  System,
+  SystemCorrelationIdType,
+  ActionSubType
+} from '@sphereon/ssi-sdk.core'
+import { NonPersistedAuditLoggingEvent } from '../../types'
+
+@Entity('AuditEvents')
+export class AuditEventEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'timestamp', nullable: false, unique: false})
+  timestamp!: Date
+
+  @Column('simple-enum', { name: 'level', enum: LogLevel, nullable: false, unique: false })
+  level!: LogLevel
+
+  @Column({ name: 'correlationId', nullable: false, unique: false})
+  correlationId!: string
+
+  @Column('simple-enum', { name: 'system', enum: System, nullable: false, unique: false })
+  system!: System
+
+  @Column('simple-enum', { name: 'subSystemType', enum: SubSystem, nullable: false, unique: false })
+  subSystemType!: SubSystem
+
+  @Column('simple-enum', { name: 'actionType', enum: ActionType, nullable: false, unique: false })
+  actionType!: ActionType
+
+  @Column({ name: 'actionSubType', nullable: false, unique: false })
+  actionSubType!: ActionSubType
+
+  @Column('simple-enum', { name: 'initiatorType', enum: InitiatorType, nullable: false, unique: false })
+  initiatorType!: InitiatorType
+
+  @Column('simple-enum', { name: 'systemCorrelationIdType', enum: SystemCorrelationIdType, nullable: true, unique: false })
+  systemCorrelationIdType?: SystemCorrelationIdType
+
+  @Column({ name: 'systemCorrelationId', nullable: true, unique: false})
+  systemCorrelationId?: string
+
+  @Column({ name: 'systemAlias', nullable: false, unique: false})
+  systemAlias?: string
+
+  @Column('simple-enum', { name: 'partyCorrelationType', enum: PartyCorrelationType, nullable: true, unique: false })
+  partyCorrelationType?: PartyCorrelationType
+
+  @Column({ name: 'partyCorrelationId', nullable: true, unique: false})
+  partyCorrelationId?: string
+
+  @Column({ name: 'partyAlias', nullable: true, unique: false})
+  partyAlias?: string
+
+  @Column({ name: 'description', nullable: false, unique: false})
+  description!: string
+
+  @Column({ name: 'data', nullable: true, unique: false})
+  data?: string
+
+  @Column({ name: 'diagnosticData', nullable: true, unique: false})
+  diagnosticData?: string
+
+  @CreateDateColumn({ name: 'created_at', nullable: false })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
+  lastUpdatedAt!: Date
+}
+
+export const auditEventEntityFrom = (args: NonPersistedAuditLoggingEvent): AuditEventEntity => {
+  const auditEventEntity: AuditEventEntity = new AuditEventEntity()
+  auditEventEntity.timestamp = args.timestamp
+  auditEventEntity.level = args.level
+  auditEventEntity.correlationId = args.correlationId
+  auditEventEntity.system = args.system
+  auditEventEntity.subSystemType = args.subSystemType
+  auditEventEntity.actionType = args.actionType
+  auditEventEntity.actionSubType = args.actionSubType
+  auditEventEntity.initiatorType = args.initiatorType
+  auditEventEntity.systemCorrelationIdType = args.systemCorrelationIdType
+  auditEventEntity.systemCorrelationId = args.systemCorrelationId
+  auditEventEntity.systemAlias = args.systemAlias
+  auditEventEntity.partyCorrelationType = args.partyCorrelationType
+  auditEventEntity.partyCorrelationId = args.partyCorrelationId
+  auditEventEntity.partyAlias = args.partyAlias
+  auditEventEntity.description = args.description
+  auditEventEntity.partyCorrelationType = args.partyCorrelationType
+  auditEventEntity.data = JSON.stringify(args.data)
+  auditEventEntity.diagnosticData = JSON.stringify(args.diagnosticData)
+
+  return auditEventEntity
+}

package/src/entities/statusList2021/StatusList2021Entity.ts

@@ -1,11 +1,12 @@
 import {
   IIssuer,
-  OriginalVerifiableCredential,
+  JwtDecodedVerifiableCredential,
   StatusListCredentialIdMode,
   StatusListDriverType,
   StatusListIndexingDirection,
   StatusListType,
   StatusPurpose2021,
+  W3CVerifiableCredential,
 } from '@sphereon/ssi-types'
 import { ProofFormat } from '@veramo/core'
 import { BaseEntity, Column, Entity, OneToMany, PrimaryColumn, Unique } from 'typeorm'
@@ -74,13 +75,13 @@ export class StatusListEntity extends BaseEntity {
     nullable: true,
     unique: false,
     transformer: {
-      from(value: string): OriginalVerifiableCredential {
+      from(value: string): W3CVerifiableCredential | JwtDecodedVerifiableCredential {
         if (value?.startsWith('ey')) {
           return value
         }
         return JSON.parse(value)
       },
-      to(value: OriginalVerifiableCredential): string {
+      to(value: W3CVerifiableCredential | JwtDecodedVerifiableCredential): string {
         if (typeof value === 'string') {
           return value
         }
@@ -88,7 +89,7 @@ export class StatusListEntity extends BaseEntity {
       },
     },
   })
-  statusListCredential?: OriginalVerifiableCredential
+  statusListCredential?: W3CVerifiableCredential | JwtDecodedVerifiableCredential
 
   @OneToMany((type) => StatusListEntryEntity, (entry) => entry.statusList)
   statusListEntries!: StatusListEntryEntity[]

package/src/eventLogger/AbstractEventLoggerStore.ts

@@ -0,0 +1,8 @@
+import { GetAuditEventsArgs, StoreAuditEventArgs } from '../types'
+import { AuditLoggingEvent } from '@sphereon/ssi-sdk.core'
+
+export abstract class AbstractEventLoggerStore {
+  abstract getAuditEvents(args: GetAuditEventsArgs): Promise<Array<AuditLoggingEvent>>
+  abstract storeAuditEvent(args: StoreAuditEventArgs): Promise<AuditLoggingEvent>
+}
+

package/src/eventLogger/EventLoggerStore.ts

@@ -0,0 +1,62 @@
+import Debug, {Debugger} from 'debug'
+import {DataSource} from 'typeorm'
+import {AuditLoggingEvent} from '@sphereon/ssi-sdk.core'
+import {OrPromise} from '@sphereon/ssi-types'
+import {AbstractEventLoggerStore} from './AbstractEventLoggerStore'
+import {AuditEventEntity, auditEventEntityFrom} from '../entities/eventLogger/AuditEventEntity'
+import {GetAuditEventsArgs, StoreAuditEventArgs} from '../types'
+
+const debug: Debugger = Debug('sphereon:ssi-sdk:event-store')
+
+export class EventLoggerStore extends AbstractEventLoggerStore {
+  private readonly dbConnection: OrPromise<DataSource>
+
+  constructor(dbConnection: OrPromise<DataSource>) {
+    super()
+    this.dbConnection = dbConnection
+  }
+
+  getAuditEvents = async (args?: GetAuditEventsArgs): Promise<Array<AuditLoggingEvent>> => {
+    const connection: DataSource = await this.dbConnection // TODO apply everywhere
+    debug('Getting audit events', args)
+    const result: Array<AuditEventEntity> = await connection.getRepository(AuditEventEntity).find({
+      ...(args?.filter && { where: args?.filter }),
+    })
+
+    return result.map((event: AuditEventEntity) => this.auditEventFrom(event))
+  }
+
+  storeAuditEvent = async (args: StoreAuditEventArgs): Promise<AuditLoggingEvent> => {
+    const { event } = args
+
+    const auditEventEntity: AuditEventEntity = auditEventEntityFrom(event)
+    const connection: DataSource = await this.dbConnection
+    debug('Storing audit event', auditEventEntity)
+    const createdResult: AuditEventEntity = await connection.getRepository(AuditEventEntity).save(auditEventEntity)
+
+    return this.auditEventFrom(createdResult)
+  }
+
+  private auditEventFrom = (event: AuditEventEntity): AuditLoggingEvent => {
+    return {
+      id: event.id,
+      description: event.description,
+      timestamp: event.timestamp,
+      level: event.level,
+      correlationId: event.correlationId,
+      actionType: event.actionType,
+      actionSubType: event.actionSubType,
+      initiatorType: event.initiatorType,
+      partyAlias: event.partyAlias,
+      partyCorrelationId: event.partyCorrelationId,
+      partyCorrelationType: event.partyCorrelationType,
+      subSystemType: event.subSystemType,
+      system: event.system,
+      systemAlias: event.systemAlias,
+      systemCorrelationId: event.systemCorrelationId,
+      systemCorrelationIdType: event.systemCorrelationIdType,
+      ...(event.data && {data: JSON.parse(event.data)}),
+      ...(event.diagnosticData && {diagnosticData: JSON.parse(event.diagnosticData)}),
+    }
+  }
+}

package/src/index.ts

@@ -29,6 +29,9 @@ export { AbstractContactStore } from './contact/AbstractContactStore'
 export { AbstractIssuanceBrandingStore } from './issuanceBranding/AbstractIssuanceBrandingStore'
 export { IssuanceBrandingStore } from './issuanceBranding/IssuanceBrandingStore'
 export { StatusListStore } from './statusList/StatusListStore'
+import { AuditEventEntity, auditEventEntityFrom } from './entities/eventLogger/AuditEventEntity'
+export { AbstractEventLoggerStore } from './eventLogger/AbstractEventLoggerStore'
+export { EventLoggerStore } from './eventLogger/EventLoggerStore'
 export { DataStoreMigrations } from './migrations'
 export * from './types'
 export * from './utils/contact/MappingUtils'
@@ -64,8 +67,18 @@ export const DataStoreIssuanceBrandingEntities = [
 
 export const DataStoreStatusListEntities = [StatusListEntity, StatusListEntryEntity]
 
+export const DataStoreEventLoggerEntities = [
+  AuditEventEntity
+]
+
+
 // All entities combined if a party wants to enable them all at once
-export const DataStoreEntities = [...DataStoreContactEntities, ...DataStoreIssuanceBrandingEntities, ...DataStoreStatusListEntities]
+export const DataStoreEntities = [
+  ...DataStoreContactEntities,
+  ...DataStoreIssuanceBrandingEntities,
+  ...DataStoreStatusListEntities,
+  ...DataStoreEventLoggerEntities
+]
 
 export {
   BaseConfigEntity,
@@ -98,4 +111,6 @@ export {
   IStatusListEntryEntity,
   StatusListEntity,
   StatusListEntryEntity,
+  AuditEventEntity,
+  auditEventEntityFrom
 }

package/src/migrations/generic/1-CreateContacts.ts

@@ -31,7 +31,7 @@ export class CreateContacts1659463079429 implements MigrationInterface {
       }
       default:
         return Promise.reject(
-          `Migrations are currently only supported for sqlite, react-native, expor and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
+          `Migrations are currently only supported for sqlite, react-native, expo and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
         )
     }
   }
@@ -59,7 +59,7 @@ export class CreateContacts1659463079429 implements MigrationInterface {
       }
       default:
         return Promise.reject(
-          `Migrations are currently only supported for sqlite, react-native, expor and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
+          `Migrations are currently only supported for sqlite, react-native, expo and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
         )
     }
   }

package/src/migrations/generic/2-CreateIssuanceBranding.ts

@@ -30,7 +30,7 @@ export class CreateIssuanceBranding1659463079429 implements MigrationInterface {
       }
       default:
         return Promise.reject(
-          `Migrations are currently only supported for sqlite, react-native, expor and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
+          `Migrations are currently only supported for sqlite, react-native, expo and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
         )
     }
   }
@@ -57,7 +57,7 @@ export class CreateIssuanceBranding1659463079429 implements MigrationInterface {
       }
       default:
         return Promise.reject(
-          `Migrations are currently only supported for sqlite, react-native, expor and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
+          `Migrations are currently only supported for sqlite, react-native, expo and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
         )
     }
   }

package/src/migrations/generic/{2-CreateContacts.ts → 3-CreateContacts.ts}

@@ -31,7 +31,7 @@ export class CreateContacts1690925872318 implements MigrationInterface {
       }
       default:
         return Promise.reject(
-          `Migrations are currently only supported for sqlite, react-native, expor and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
+          `Migrations are currently only supported for sqlite, react-native, expo and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
         )
     }
   }
@@ -59,7 +59,7 @@ export class CreateContacts1690925872318 implements MigrationInterface {
       }
       default:
         return Promise.reject(
-          `Migrations are currently only supported for sqlite, react-native, expor and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
+          `Migrations are currently only supported for sqlite, react-native, expo and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
         )
     }
   }

package/src/migrations/generic/{3-CreateStatusList.ts → 4-CreateStatusList.ts}

@@ -1,6 +1,6 @@
 import Debug from 'debug'
 import { MigrationInterface, QueryRunner } from 'typeorm'
-import { CreateStatusList1693866470001 } from '../postgres/CreateStatusList1693866470001-CreateStatusList'
+import { CreateStatusList1693866470001 } from '../postgres/1693866470001-CreateStatusList'
 import { CreateStatusList1693866470002 } from '../sqlite/1693866470000-CreateStatusList'
 
 const debug = Debug('sphereon:ssi-sdk:migrations')
@@ -25,7 +25,7 @@ export class CreateStatusList1693866470000 implements MigrationInterface {
       return up
     } else {
       return Promise.reject(
-        `Migrations are currently only supported for sqlite, react-native, expor and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
+        `Migrations are currently only supported for sqlite, react-native, expo and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
       )
     }
   }
@@ -47,7 +47,7 @@ export class CreateStatusList1693866470000 implements MigrationInterface {
       return down
     } else {
       return Promise.reject(
-        `Migrations are currently only supported for sqlite, react-native, expor and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
+        `Migrations are currently only supported for sqlite, react-native, expo and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
       )
     }
   }

package/src/migrations/generic/5-CreateAuditEvents.ts

@@ -0,0 +1,66 @@
+import { DatabaseType, MigrationInterface, QueryRunner } from 'typeorm'
+import Debug, { Debugger } from 'debug'
+import { CreateAuditEvents1701634819487 } from '../sqlite/1701634819487-CreateAuditEvents'
+import { CreateAuditEvents1701634812183 } from '../postgres/1701634812183-CreateAuditEvents'
+
+const debug: Debugger = Debug('sphereon:ssi-sdk:migrations')
+
+export class CreateAuditEvents1701635835330 implements MigrationInterface {
+  name: string = 'CreateAuditEvents1701635835330'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    debug('migration: creating audit events tables')
+    const dbType: DatabaseType = queryRunner.connection.driver.options.type
+
+    switch (dbType) {
+      case 'postgres': {
+        debug('using postgres migration file')
+        const mig: CreateAuditEvents1701634812183 = new CreateAuditEvents1701634812183()
+        await mig.up(queryRunner)
+        debug('Migration statements executed')
+        return
+      }
+      case 'sqlite':
+      case 'expo':
+      case 'react-native': {
+        debug('using sqlite/react-native migration file')
+        const mig: CreateAuditEvents1701634819487 = new CreateAuditEvents1701634819487()
+        await mig.up(queryRunner)
+        debug('Migration statements executed')
+        return
+      }
+      default:
+        return Promise.reject(
+          `Migrations are currently only supported for sqlite, react-native, expo and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
+        )
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    debug('migration: reverting audit events tables')
+    const dbType: DatabaseType = queryRunner.connection.driver.options.type
+
+    switch (dbType) {
+      case 'postgres': {
+        debug('using postgres migration file')
+        const mig: CreateAuditEvents1701634812183 = new CreateAuditEvents1701634812183()
+        await mig.down(queryRunner)
+        debug('Migration statements executed')
+        return
+      }
+      case 'sqlite':
+      case 'expo':
+      case 'react-native': {
+        debug('using sqlite/react-native migration file')
+        const mig: CreateAuditEvents1701634819487 = new CreateAuditEvents1701634819487()
+        await mig.down(queryRunner)
+        debug('Migration statements executed')
+        return
+      }
+      default:
+        return Promise.reject(
+          `Migrations are currently only supported for sqlite, react-native, expo and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
+        )
+    }
+  }
+}

package/src/migrations/generic/index.ts

@@ -1,7 +1,8 @@
 import { CreateContacts1659463079429 } from './1-CreateContacts'
-import { CreateContacts1690925872318 } from './2-CreateContacts'
 import { CreateIssuanceBranding1659463079429 } from './2-CreateIssuanceBranding'
-import { CreateStatusList1693866470000 } from './3-CreateStatusList'
+import { CreateContacts1690925872318 } from './3-CreateContacts'
+import { CreateStatusList1693866470000 } from './4-CreateStatusList'
+import { CreateAuditEvents1701635835330 } from './5-CreateAuditEvents'
 
 /**
  * The migrations array that SHOULD be used when initializing a TypeORM database connection.
@@ -15,6 +16,12 @@ import { CreateStatusList1693866470000 } from './3-CreateStatusList'
 export const DataStoreContactMigrations = [CreateContacts1659463079429, CreateContacts1690925872318]
 export const DataStoreIssuanceBrandingMigrations = [CreateIssuanceBranding1659463079429]
 export const DataStoreStatusListMigrations = [CreateStatusList1693866470000]
+export const DataStoreEventLoggerMigrations= [CreateAuditEvents1701635835330]
 
 // All migrations together
-export const DataStoreMigrations = [...DataStoreContactMigrations, ...DataStoreIssuanceBrandingMigrations, ...DataStoreStatusListMigrations]
+export const DataStoreMigrations = [
+  ...DataStoreContactMigrations,
+  ...DataStoreIssuanceBrandingMigrations,
+  ...DataStoreStatusListMigrations,
+  ...DataStoreEventLoggerMigrations
+]

package/src/migrations/postgres/1659463079428-CreateContacts.ts

@@ -1,11 +1,11 @@
 import { MigrationInterface, QueryRunner } from 'typeorm'
-import { enableUuidv4 } from './uuid'
+import { enablePostgresUuidExtension } from '@sphereon/ssi-sdk.core'
 
 export class CreateContacts1659463079428 implements MigrationInterface {
   name = 'CreateContacts1659463079428'
 
   public async up(queryRunner: QueryRunner): Promise<void> {
-    await enableUuidv4(queryRunner)
+    await enablePostgresUuidExtension(queryRunner)
     await queryRunner.query(
       `CREATE TABLE "BaseConfigEntity" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "client_id" character varying(255), "client_secret" character varying(255), "scopes" text, "issuer" character varying(255), "redirect_url" text, "dangerously_allow_insecure_http_requests" boolean, "client_auth_method" text, "identifier" character varying(255), "session_id" character varying(255), "type" character varying NOT NULL, "connectionId" uuid, CONSTRAINT "REL_BaseConfig_connectionId" UNIQUE ("connectionId"), CONSTRAINT "PK_BaseConfigEntity_id" PRIMARY KEY ("id"))`
     )

package/src/migrations/postgres/1685628974232-CreateIssuanceBranding.ts

@@ -1,11 +1,11 @@
 import { MigrationInterface, QueryRunner } from 'typeorm'
-import { enableUuidv4 } from './uuid'
+import { enablePostgresUuidExtension } from '@sphereon/ssi-sdk.core'
 
 export class CreateIssuanceBranding1685628974232 implements MigrationInterface {
   name = 'CreateIssuanceBranding1685628974232'
 
   public async up(queryRunner: QueryRunner): Promise<void> {
-    await enableUuidv4(queryRunner)
+    await enablePostgresUuidExtension(queryRunner)
     await queryRunner.query(
       `CREATE TABLE "ImageDimensions" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "width" integer NOT NULL, "height" integer NOT NULL, CONSTRAINT "PK_ImageDimensions_id" PRIMARY KEY ("id"))`
     )

package/src/migrations/postgres/1690925872592-CreateContacts.ts

@@ -1,11 +1,11 @@
 import { MigrationInterface, QueryRunner } from 'typeorm'
-import { enableUuidv4 } from './uuid'
+import { enablePostgresUuidExtension } from '@sphereon/ssi-sdk.core'
 
 export class CreateContacts1690925872592 implements MigrationInterface {
   name = 'CreateContacts1690925872592'
 
   public async up(queryRunner: QueryRunner): Promise<void> {
-    await enableUuidv4(queryRunner)
+    await enablePostgresUuidExtension(queryRunner)
     await queryRunner.query(`ALTER TABLE "CorrelationIdentifier" DROP CONSTRAINT "FK_CorrelationIdentifier_identityId"`)
     await queryRunner.query(`ALTER TABLE "IdentityMetadata" DROP CONSTRAINT "FK_IdentityMetadata_identityId"`)
     await queryRunner.query(`ALTER TABLE "Identity" DROP CONSTRAINT "FK_Identity_contactId"`)

package/src/migrations/postgres/1701634812183-CreateAuditEvents.ts

@@ -0,0 +1,27 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class CreateAuditEvents1701634812183 implements MigrationInterface {
+  name = 'CreateAuditEvents1701634812183'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`CREATE TYPE "public"."Level_enum" AS ENUM('0', '1', '2', '3')`)
+    await queryRunner.query(`CREATE TYPE "public"."System_enum" AS ENUM('general', 'kms', 'identity', 'oid4vci', 'credentials', 'web3', 'profile', 'contact')`)
+    await queryRunner.query(`CREATE TYPE "public"."Subsystem_type_enum" AS ENUM('key', 'did_provider', 'did_resolver', 'oid4vp_op', 'oid4vci_client', 'siopv2_op', 'contact_manager', 'vc_issuer', 'vc_verifier', 'vc_persistence', 'transport', 'profile')`)
+    await queryRunner.query(`CREATE TYPE "public"."Action_type_enum" AS ENUM('create', 'read', 'update', 'delete', 'execute')`)
+    await queryRunner.query(`CREATE TYPE "public"."Initiator_type_enum" AS ENUM('user', 'system', 'external')`)
+    await queryRunner.query(`CREATE TYPE "public"."System_correlation_id_type_enum" AS ENUM('did', 'email', 'hostname', 'phone', 'user')`)
+    await queryRunner.query(`CREATE TYPE "public"."Party_correlation_type_enum" AS ENUM('did', 'email', 'hostname', 'phone')`)
+    await queryRunner.query(`CREATE TABLE "AuditEvents" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "timestamp" TIMESTAMP NOT NULL, "level" "public"."Level_enum" NOT NULL, "correlationId" TEXT NOT NULL, "system" "public"."System_enum" NOT NULL, "subSystemType" "public"."Subsystem_type_enum" NOT NULL, "actionType" "public"."Action_type_enum" NOT NULL, "actionSubType" TEXT NOT NULL, "initiatorType" "public"."Initiator_type_enum" NOT NULL, "systemCorrelationIdType" "public"."System_correlation_id_type_enum", "systemCorrelationId" TEXT, "systemAlias" TEXT NOT NULL, "partyCorrelationType" "public"."Party_correlation_type_enum", "partyCorrelationId" TEXT, "partyAlias" TEXT, "description" TEXT NOT NULL, "data" TEXT, "diagnosticData" TEXT, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "last_updated_at" TIMESTAMP NOT NULL DEFAULT now(), CONSTRAINT "PK_AuditEvents_id" PRIMARY KEY ("id"))`)
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "AuditEvents"`)
+    await queryRunner.query(`DROP TYPE "public"."Party_correlation_type_enum`)
+    await queryRunner.query(`DROP TYPE "public"."System_correlation_id_type_enum`)
+    await queryRunner.query(`DROP TYPE "public"."Initiator_type_enum`)
+    await queryRunner.query(`DROP TYPE "public"."Action_type_enum`)
+    await queryRunner.query(`DROP TYPE "public"."Subsystem_type_enum`)
+    await queryRunner.query(`DROP TYPE "public"."System_enum`)
+    await queryRunner.query(`DROP TYPE "public"."Level_enum`)
+  }
+}