@sphereon/ssi-sdk.data-store 0.19.1-next.2 → 0.19.1-unstable.63

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

@@ -0,0 +1,158 @@
+import { DataSource } from 'typeorm'
+import {
+  DataStoreXStateStoreEntities,
+  GetActiveStateArgs,
+  NonPersistedXStateStoreEvent,
+  SaveStateArgs,
+  State,
+  XStateStore,
+} from '../index'
+import { DataStoreXStateStoreMigrations } from '../migrations'
+
+describe('Database entities tests', (): void => {
+  let dbConnection: DataSource
+  let xstateStore: XStateStore
+
+  beforeEach(async (): Promise<void> => {
+    dbConnection = await new DataSource({
+      type: 'sqlite',
+      database: ':memory:',
+      logging: 'all',
+      migrationsRun: false,
+      migrations: DataStoreXStateStoreMigrations,
+      synchronize: false,
+      entities: DataStoreXStateStoreEntities,
+    }).initialize()
+    await dbConnection.runMigrations()
+    expect(await dbConnection.showMigrations()).toBeFalsy()
+    xstateStore = new XStateStore(dbConnection)
+  })
+
+  afterEach(async (): Promise<void> => {
+    await dbConnection.destroy()
+  })
+
+  it('should store xstate event', async (): Promise<void> => {
+    const xstateEvent: NonPersistedXStateStoreEvent = {
+      stateName: 'enterPersonalDetails',
+      machineType: 'Onboarding',
+      xStateEventType: 'SET_PERSONAL_DATA',
+      state: 'test_state',
+      expiresAt: new Date(new Date().getDate() + 100000),
+      tenantId: 'test_tenant_id',
+    }
+
+    const savedXStoreEvent: State = await xstateStore.saveState(xstateEvent)
+    expect(savedXStoreEvent).toBeDefined()
+  })
+
+  it('should get all state events', async (): Promise<void> => {
+    const xstateEvent: NonPersistedXStateStoreEvent = {
+      stateName: 'enterPersonalDetails',
+      machineType: 'Onboarding',
+      xStateEventType: 'SET_PERSONAL_DATA',
+      state: 'test_state',
+      expiresAt: new Date(new Date().getDate() + 100000),
+      tenantId: 'test_tenant_id',
+    }
+
+    const stateEvent1: NonPersistedXStateStoreEvent = await xstateStore.saveState({ ...xstateEvent })
+    expect(stateEvent1).toBeDefined()
+
+    const stateEvent2: NonPersistedXStateStoreEvent = await xstateStore.saveState({ ...xstateEvent })
+    expect(stateEvent2).toBeDefined()
+
+    const result: Array<State> = await xstateStore.getStates()
+    expect(result).toHaveLength(2)
+  })
+
+  it('should retrieve an xstate event', async (): Promise<void> => {
+    const expiresAt = new Date()
+    expiresAt.setTime(expiresAt.getTime() + 100000)
+    const xstateEvent: SaveStateArgs = {
+      stateName: 'enterPersonalDetails',
+      machineType: 'Onboarding',
+      xStateEventType: 'SET_PERSONAL_DATA',
+      state: 'test_state',
+      expiresAt,
+      tenantId: 'test_tenant_id',
+    }
+
+    const savedXStoreEvent1: State = await xstateStore.saveState(xstateEvent)
+    expect(savedXStoreEvent1).toBeDefined()
+    const result: State = await xstateStore.getActiveState({ machineType: xstateEvent.machineType, tenantId: xstateEvent.tenantId })
+    expect(result).toBeDefined()
+  })
+
+  it('should delete an xstate event', async (): Promise<void> => {
+    const xstateEvent: NonPersistedXStateStoreEvent = {
+      stateName: 'enterPersonalDetails',
+      machineType: 'Onboarding',
+      xStateEventType: 'SET_PERSONAL_DATA',
+      state: 'test_state',
+      expiresAt: new Date(new Date().getDate() + 100000),
+      tenantId: 'test_tenant_id',
+    }
+
+    const savedXStoreEvent: State = await xstateStore.saveState(xstateEvent)
+    expect(savedXStoreEvent).toBeDefined()
+
+    const result: boolean = await xstateStore.deleteState({ id: savedXStoreEvent.id })
+    expect(result).toBeTruthy()
+  })
+
+  it('should return an error if type filter does not match', async (): Promise<void> => {
+    const args: GetActiveStateArgs = {
+      machineType: 'unknown_machine',
+    }
+
+    await expect(xstateStore.getActiveState(args)).rejects.toEqual(
+      Error('No active state found for machineType: unknown_machine, tenantId: undefined')
+    )
+  })
+
+  it('should delete the expired records', async () => {
+    const futureExpiresAt = new Date()
+    futureExpiresAt.setTime(futureExpiresAt.getTime() + 100000) // Future expiration
+
+    const pastExpiresAt = new Date()
+    pastExpiresAt.setTime(pastExpiresAt.getTime() - 100000) // Past expiration, already expired
+
+    const oldestXstateEvent: SaveStateArgs = {
+      stateName: 'acceptAgreement',
+      machineType: 'Onboarding1',
+      xStateEventType: 'SET_TOC',
+      state: 'test_state',
+      expiresAt: futureExpiresAt,
+      tenantId: 'test_tenant_id',
+    }
+    const middleXstateEvent: SaveStateArgs = {
+      stateName: 'acceptAgreement',
+      machineType: 'Onboarding2',
+      xStateEventType: 'SET_POLICY2',
+      state: 'test_state',
+      expiresAt: futureExpiresAt,
+      tenantId: 'test_tenant_id',
+    }
+    const newestXstateEvent: SaveStateArgs = {
+      stateName: 'enterPersonalDetails',
+      machineType: 'Onboarding3',
+      xStateEventType: 'SET_PERSONAL_DATA',
+      state: 'test_state',
+      expiresAt: pastExpiresAt, // This event should be already expired
+      tenantId: 'test_tenant_id',
+    }
+
+    await xstateStore.saveState(oldestXstateEvent)
+    await xstateStore.saveState(middleXstateEvent)
+    await xstateStore.saveState(newestXstateEvent)
+
+    await xstateStore.deleteExpiredStates({})
+
+    await expect(xstateStore.getActiveState({ machineType: 'Onboarding1' })).resolves.toBeDefined()
+    await expect(xstateStore.getActiveState({ machineType: 'Onboarding2' })).resolves.toBeDefined()
+    await expect(xstateStore.getActiveState({ machineType: 'Onboarding3' })).rejects.toEqual(
+      Error('No active state found for machineType: Onboarding3, tenantId: undefined')
+    )
+  })
+})

package/src/digitalCredential/AbstractDigitalCredentialStore.ts

@@ -0,0 +1,17 @@
+import {
+  AddCredentialArgs,
+  GetCredentialArgs,
+  GetCredentialsArgs,
+  GetCredentialsResponse,
+  RemoveCredentialArgs,
+  UpdateCredentialStateArgs,
+} from '../types/digitalCredential/IAbstractDigitalCredentialStore'
+import { DigitalCredentialEntity } from '../entities/digitalCredential/DigitalCredentialEntity'
+
+export abstract class AbstractDigitalCredentialStore {
+  abstract getCredential(args: GetCredentialArgs): Promise<DigitalCredentialEntity>
+  abstract getCredentials(args?: GetCredentialsArgs): Promise<GetCredentialsResponse>
+  abstract addCredential(args: AddCredentialArgs): Promise<DigitalCredentialEntity>
+  abstract updateCredentialState(args: UpdateCredentialStateArgs): Promise<DigitalCredentialEntity>
+  abstract removeCredential(args: RemoveCredentialArgs): Promise<boolean>
+}

package/src/digitalCredential/DigitalCredentialStore.ts

@@ -0,0 +1,127 @@
+import { AbstractDigitalCredentialStore } from './AbstractDigitalCredentialStore'
+import {
+  AddCredentialArgs,
+  GetCredentialArgs,
+  GetCredentialsArgs,
+  GetCredentialsResponse,
+  RemoveCredentialArgs,
+  UpdateCredentialStateArgs,
+} from '../types/digitalCredential/IAbstractDigitalCredentialStore'
+import { OrPromise } from '@sphereon/ssi-types'
+import { DataSource, FindOptionsOrder, Repository } from 'typeorm'
+import Debug from 'debug'
+import { DigitalCredentialEntity } from '../entities/digitalCredential/DigitalCredentialEntity'
+import { nonPersistedDigitalCredentialEntityFromAddArgs } from '../utils/digitalCredential/MappingUtils'
+import { FindOptionsWhere } from 'typeorm/find-options/FindOptionsWhere'
+import { CredentialStateType, DigitalCredential, NonPersistedDigitalCredential } from '../types/digitalCredential/digitalCredential'
+import { parseAndValidateOrderOptions } from '../utils/SortingUtils'
+
+const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:credential-store')
+
+export class DigitalCredentialStore extends AbstractDigitalCredentialStore {
+  private readonly dbConnection: OrPromise<DataSource>
+
+  constructor(dbConnection: OrPromise<DataSource>) {
+    super()
+    this.dbConnection = dbConnection
+  }
+
+  addCredential = async (args: AddCredentialArgs): Promise<DigitalCredentialEntity> => {
+    debug('Adding credential', args)
+    const digitalCredentialEntityRepository: Repository<DigitalCredentialEntity> = (await this.dbConnection).getRepository(DigitalCredentialEntity)
+    const credentialEntity: NonPersistedDigitalCredential = nonPersistedDigitalCredentialEntityFromAddArgs(args)
+    const createdResult: DigitalCredentialEntity = await digitalCredentialEntityRepository.save(credentialEntity)
+    return Promise.resolve(createdResult)
+  }
+
+  getCredential = async (args: GetCredentialArgs): Promise<DigitalCredentialEntity> => {
+    const result: DigitalCredentialEntity | null = await (await this.dbConnection).getRepository(DigitalCredentialEntity).findOne({
+      where: args,
+    })
+
+    if (!result) {
+      return Promise.reject(Error(`No credential found for arg: ${args.toString()}`))
+    }
+    return result
+  }
+
+  getCredentials = async (args?: GetCredentialsArgs): Promise<GetCredentialsResponse> => {
+    const { filter = {}, offset, limit, order = 'id.asc' } = args ?? {}
+    const sortOptions: FindOptionsOrder<DigitalCredentialEntity> =
+      order && typeof order === 'string'
+        ? parseAndValidateOrderOptions<DigitalCredentialEntity>(order)
+        : <FindOptionsOrder<DigitalCredentialEntity>>order
+    const [result, total] = await (await this.dbConnection).getRepository(DigitalCredentialEntity).findAndCount({
+      where: filter,
+      skip: offset,
+      take: limit,
+      order: sortOptions,
+    })
+    return {
+      data: result,
+      total,
+    }
+  }
+
+  removeCredential = async (args: RemoveCredentialArgs): Promise<boolean> => {
+    if (!args) {
+      return false
+    }
+
+    let query: FindOptionsWhere<DigitalCredentialEntity> = {}
+
+    if ('id' in args) {
+      query.id = args.id
+    } else if ('hash' in args) {
+      query.hash = args.hash
+    } else {
+      return false
+    }
+    try {
+      const connection = await this.dbConnection
+      const result = await connection.getRepository(DigitalCredentialEntity).delete(query)
+      return result.affected === 1
+    } catch (error) {
+      console.error('Error removing digital credential:', error)
+      return false
+    }
+  }
+
+  updateCredentialState = async (args: UpdateCredentialStateArgs): Promise<DigitalCredentialEntity> => {
+    const credentialRepository: Repository<DigitalCredentialEntity> = (await this.dbConnection).getRepository(DigitalCredentialEntity)
+    const whereClause: Record<string, any> = {}
+    if ('id' in args) {
+      whereClause.id = args.id
+    } else if ('hash' in args) {
+      whereClause.hash = args.hash
+    } else {
+      throw new Error('No id or hash param is provided.')
+    }
+    if (!args.verifiedState) {
+      throw new Error('No verifiedState param is provided.')
+    }
+    if (args.verifiedState === CredentialStateType.REVOKED && !args.revokedAt) {
+      throw new Error('No revokedAt param is provided.')
+    }
+    if (args.verifiedState !== CredentialStateType.REVOKED && !args.verifiedAt) {
+      throw new Error('No verifiedAt param is provided.')
+    }
+    const credential: DigitalCredentialEntity | null = await credentialRepository.findOne({
+      where: whereClause,
+    })
+
+    if (!credential) {
+      return Promise.reject(Error(`No credential found for args: ${whereClause}`))
+    }
+    const updatedCredential: DigitalCredential = {
+      ...credential,
+      ...(args.verifiedState !== CredentialStateType.REVOKED && { verifiedAt: args.verifiedAt }),
+      ...(args.verifiedState === CredentialStateType.REVOKED && { revokedAt: args.revokedAt }),
+      lastUpdatedAt: new Date(),
+      verifiedState: args.verifiedState,
+    }
+    debug('Updating credential', credential)
+    const updatedResult: DigitalCredentialEntity = await credentialRepository.save(updatedCredential, { transaction: true })
+    return updatedResult
+  }
+}

package/src/entities/digitalCredential/DigitalCredentialEntity.ts

@@ -0,0 +1,64 @@
+import { BaseEntity, Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
+import {
+  CredentialCorrelationType,
+  CredentialDocumentFormat,
+  CredentialStateType,
+  DocumentType,
+} from '../../types/digitalCredential/digitalCredential'
+
+@Entity('DigitalCredential')
+export class DigitalCredentialEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column('simple-enum', { name: 'document_type', enum: DocumentType, nullable: false })
+  documentType!: DocumentType
+
+  @Column('simple-enum', { name: 'document_format', enum: CredentialDocumentFormat, nullable: false })
+  documentFormat!: CredentialDocumentFormat
+
+  @Column('text', { name: 'raw_document', nullable: false })
+  rawDocument!: string
+
+  @Column('text', { name: 'uniform_document', nullable: false })
+  uniformDocument!: string
+
+  @Column('text', { name: 'hash', nullable: false, unique: true })
+  hash!: string
+
+  @Column('simple-enum', { name: 'issuer_correlation_type', enum: CredentialCorrelationType, nullable: false })
+  issuerCorrelationType!: CredentialCorrelationType
+
+  @Column('simple-enum', { name: 'subject_correlation_type', enum: CredentialCorrelationType, nullable: true })
+  subjectCorrelationType?: CredentialCorrelationType
+
+  @Column('text', { name: 'issuer_correlation_id', nullable: false })
+  issuerCorrelationId!: string
+
+  @Column('text', { name: 'subject_correlation_id', nullable: true })
+  subjectCorrelationId?: string
+
+  @Column('simple-enum', { name: 'verified_state', enum: CredentialStateType, nullable: true })
+  verifiedState?: CredentialStateType
+
+  @Column('text', { name: 'tenant_id', nullable: true })
+  tenantId?: string
+
+  @CreateDateColumn({ name: 'created_at', nullable: false })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
+  lastUpdatedAt!: Date
+
+  @Column('date', { name: 'valid_until', nullable: true })
+  validUntil?: Date
+
+  @Column('date', { name: 'valid_from', nullable: true })
+  validFrom?: Date
+
+  @Column('date', { name: 'verified_at', nullable: true })
+  verifiedAt?: Date
+
+  @Column('date', { name: 'revoked_at', nullable: true })
+  revokedAt?: Date
+}

package/src/entities/xstate/StateEntity.ts

@@ -0,0 +1,34 @@
+import { BaseEntity, Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
+
+@Entity('StateEntity')
+export class StateEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid', { name: 'id' })
+  id!: string
+
+  @Column({ name: 'state_name', nullable: false })
+  stateName!: string
+
+  @Column({ name: 'machine_type', nullable: false })
+  machineType!: string
+
+  @Column({ name: 'xstate_event_type', nullable: false })
+  xStateEventType!: string
+
+  @Column({ name: 'state', nullable: false })
+  state!: string
+
+  @CreateDateColumn({ name: 'created_at', nullable: false })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'updated_at', nullable: false })
+  updatedAt!: Date
+
+  @Column({ name: 'expires_at', type: 'datetime', nullable: true })
+  expiresAt?: Date
+
+  @Column({ name: 'completed_at', type: 'datetime', nullable: true })
+  completedAt?: Date
+
+  @Column({ name: 'tenant_id', type: 'varchar', nullable: true })
+  tenantId?: string
+}

package/src/index.ts

@@ -18,6 +18,7 @@ import { IssuerBrandingEntity, issuerBrandingEntityFrom } from './entities/issua
 import { TextAttributesEntity, textAttributesEntityFrom } from './entities/issuanceBranding/TextAttributesEntity'
 import { StatusListEntity } from './entities/statusList2021/StatusList2021Entity'
 import { StatusListEntryEntity } from './entities/statusList2021/StatusList2021EntryEntity'
+import { StateEntity } from './entities/xstate/StateEntity'
 import { IStatusListEntity, IStatusListEntryEntity } from './types'
 import { PartyRelationshipEntity } from './entities/contact/PartyRelationshipEntity'
 import { PartyTypeEntity } from './entities/contact/PartyTypeEntity'
@@ -31,14 +32,20 @@ export { AbstractIssuanceBrandingStore } from './issuanceBranding/AbstractIssuan
 export { IssuanceBrandingStore } from './issuanceBranding/IssuanceBrandingStore'
 export { StatusListStore } from './statusList/StatusListStore'
 import { AuditEventEntity, auditEventEntityFrom } from './entities/eventLogger/AuditEventEntity'
+import { DigitalCredentialEntity } from './entities/digitalCredential/DigitalCredentialEntity'
+import { digitalCredentialFrom, digitalCredentialsFrom, nonPersistedDigitalCredentialEntityFromAddArgs } from './utils/digitalCredential/MappingUtils'
 export { AbstractEventLoggerStore } from './eventLogger/AbstractEventLoggerStore'
 export { EventLoggerStore } from './eventLogger/EventLoggerStore'
+export { IAbstractXStateStore } from './xstate/IAbstractXStateStore'
+export { XStateStore } from './xstate/XStateStore'
+
 export {
   DataStoreMigrations,
   DataStoreEventLoggerMigrations,
   DataStoreContactMigrations,
   DataStoreIssuanceBrandingMigrations,
   DataStoreStatusListMigrations,
+  DataStoreXStateStoreMigrations,
 } from './migrations'
 export * from './types'
 export * from './utils/contact/MappingUtils'
@@ -77,12 +84,18 @@ export const DataStoreStatusListEntities = [StatusListEntity, StatusListEntryEnt
 
 export const DataStoreEventLoggerEntities = [AuditEventEntity]
 
+export const DataStoreDigitalCredentialEntities = [DigitalCredentialEntity]
+
+export const DataStoreXStateStoreEntities = [StateEntity]
+
 // All entities combined if a party wants to enable them all at once
 export const DataStoreEntities = [
   ...DataStoreContactEntities,
   ...DataStoreIssuanceBrandingEntities,
   ...DataStoreStatusListEntities,
   ...DataStoreEventLoggerEntities,
+  ...DataStoreDigitalCredentialEntities,
+  ...DataStoreXStateStoreEntities,
 ]
 
 export {
@@ -119,4 +132,9 @@ export {
   StatusListEntryEntity,
   AuditEventEntity,
   auditEventEntityFrom,
+  DigitalCredentialEntity,
+  digitalCredentialFrom,
+  digitalCredentialsFrom,
+  nonPersistedDigitalCredentialEntityFromAddArgs,
+  StateEntity,
 }

package/src/migrations/generic/6-CreateDigitalCredential.ts

@@ -0,0 +1,66 @@
+import { DatabaseType, MigrationInterface, QueryRunner } from 'typeorm'
+import Debug, { Debugger } from 'debug'
+import { CreateDigitalCredential1708525189001 } from '../postgres/1708525189001-CreateDigitalCredential'
+import { CreateDigitalCredential1708525189002 } from '../sqlite/1708525189002-CreateDigitalCredential'
+
+const debug: Debugger = Debug('sphereon:ssi-sdk:migrations')
+
+export class CreateDigitalCredential1708525189000 implements MigrationInterface {
+  name: string = 'CreateDigitalCredential1708525189000'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    debug('migration: creating DigitalCredential tables')
+    const dbType: DatabaseType = queryRunner.connection.driver.options.type
+
+    switch (dbType) {
+      case 'postgres': {
+        debug('using postgres migration file for DigitalCredential')
+        const mig: CreateDigitalCredential1708525189001 = new CreateDigitalCredential1708525189001()
+        await mig.up(queryRunner)
+        debug('Postgres Migration statements for DigitalCredential executed')
+        return
+      }
+      case 'sqlite':
+      case 'expo':
+      case 'react-native': {
+        debug('using sqlite/react-native migration file for DigitalCredential')
+        const mig: CreateDigitalCredential1708525189002 = new CreateDigitalCredential1708525189002()
+        await mig.up(queryRunner)
+        debug('SQLite Migration statements for DigitalCredential executed')
+        return
+      }
+      default:
+        return Promise.reject(
+          `Migrations are currently only supported for sqlite, react-native, expo, and postgres for UniformCredential. 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 DigitalCredential tables')
+    const dbType: DatabaseType = queryRunner.connection.driver.options.type
+
+    switch (dbType) {
+      case 'postgres': {
+        debug('using postgres migration file for DigitalCredential')
+        const mig: CreateDigitalCredential1708525189001 = new CreateDigitalCredential1708525189001()
+        await mig.down(queryRunner)
+        debug('Postgres Migration statements for DigitalCredential reverted')
+        return
+      }
+      case 'sqlite':
+      case 'expo':
+      case 'react-native': {
+        debug('using sqlite/react-native migration file for DigitalCredential')
+        const mig: CreateDigitalCredential1708525189002 = new CreateDigitalCredential1708525189002()
+        await mig.down(queryRunner)
+        debug('SQLite Migration statements for DigitalCredential reverted')
+        return
+      }
+      default:
+        return Promise.reject(
+          `Migrations are currently only supported for sqlite, react-native, expo, and postgres for DigitalCredential. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`
+        )
+    }
+  }
+}

package/src/migrations/generic/7-CreateXStateStore.ts

@@ -0,0 +1,66 @@
+import { DatabaseType, MigrationInterface, QueryRunner } from 'typeorm'
+import Debug from 'debug'
+import { CreateXStateStore1708797018115 } from '../postgres/1708797018115-CreateXStateStore'
+import { CreateXStateStore1708796002272 } from '../sqlite/1708796002272-CreateXStateStore'
+
+const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:migrations')
+
+export class CreateXStateStore1708098041262 implements MigrationInterface {
+  name = 'CreateXStateStore1708098041262'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    debug('migration: creating contacts tables')
+    const dbType: DatabaseType = queryRunner.connection.driver.options.type
+
+    switch (dbType) {
+      case 'postgres': {
+        debug('using postgres migration file')
+        const mig: CreateXStateStore1708797018115 = new CreateXStateStore1708797018115()
+        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: CreateXStateStore1708796002272 = new CreateXStateStore1708796002272()
+        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 contacts tables')
+    const dbType: DatabaseType = queryRunner.connection.driver.options.type
+
+    switch (dbType) {
+      case 'postgres': {
+        debug('using postgres migration file')
+        const mig: CreateXStateStore1708797018115 = new CreateXStateStore1708797018115()
+        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: CreateXStateStore1708796002272 = new CreateXStateStore1708796002272()
+        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

@@ -3,6 +3,8 @@ import { CreateIssuanceBranding1659463079429 } from './2-CreateIssuanceBranding'
 import { CreateContacts1690925872318 } from './3-CreateContacts'
 import { CreateStatusList1693866470000 } from './4-CreateStatusList'
 import { CreateAuditEvents1701635835330 } from './5-CreateAuditEvents'
+import { CreateDigitalCredential1708525189000 } from './6-CreateDigitalCredential'
+import { CreateXStateStore1708098041262 } from './7-CreateXStateStore'
 
 /**
  * The migrations array that SHOULD be used when initializing a TypeORM database connection.
@@ -17,6 +19,8 @@ export const DataStoreContactMigrations = [CreateContacts1659463079429, CreateCo
 export const DataStoreIssuanceBrandingMigrations = [CreateIssuanceBranding1659463079429]
 export const DataStoreStatusListMigrations = [CreateStatusList1693866470000]
 export const DataStoreEventLoggerMigrations = [CreateAuditEvents1701635835330]
+export const DataStoreDigitalCredentialMigrations = [CreateDigitalCredential1708525189000]
+export const DataStoreXStateStoreMigrations = [CreateXStateStore1708098041262]
 
 // All migrations together
 export const DataStoreMigrations = [
@@ -24,4 +28,6 @@ export const DataStoreMigrations = [
   ...DataStoreIssuanceBrandingMigrations,
   ...DataStoreStatusListMigrations,
   ...DataStoreEventLoggerMigrations,
+  ...DataStoreDigitalCredentialMigrations,
+  ...DataStoreXStateStoreMigrations,
 ]

package/src/migrations/index.ts

@@ -4,4 +4,6 @@ export {
   DataStoreContactMigrations,
   DataStoreIssuanceBrandingMigrations,
   DataStoreStatusListMigrations,
+  DataStoreDigitalCredentialMigrations,
+  DataStoreXStateStoreMigrations,
 } from './generic'

package/src/migrations/postgres/1708525189001-CreateDigitalCredential.ts

@@ -0,0 +1,44 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class CreateDigitalCredential1708525189001 implements MigrationInterface {
+  name = 'CreateDigitalCredential1708525189001'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`CREATE TYPE "digital_document_type" AS ENUM('VC', 'VP', 'C', 'P')`)
+    await queryRunner.query(`CREATE TYPE "digital_credential_document_format" AS ENUM('JSON_LD', 'JWT', 'SD_JWT', 'MDOC')`)
+    await queryRunner.query(`CREATE TYPE "digital_credential_correlation_type" AS ENUM('DID')`)
+    await queryRunner.query(`CREATE TYPE "digital_credential_state_type" AS ENUM('REVOKED', 'VERIFIED', 'EXPIRED')`)
+
+    await queryRunner.query(`
+      CREATE TABLE "DigitalCredential" (
+        "id" uuid NOT NULL DEFAULT uuid_generate_v4(),
+        "document_type" "digital_document_type" NOT NULL,
+        "document_format" "digital_credential_document_format" NOT NULL,
+        "raw_document" text NOT NULL,
+        "uniform_document" text NOT NULL,
+        "hash" text NOT NULL UNIQUE,
+        "issuer_correlation_type" "digital_credential_correlation_type" NOT NULL,
+        "subject_correlation_type" "digital_credential_correlation_type",
+        "issuer_correlation_id" text NOT NULL,
+        "subject_correlation_id" text,
+        "verified_state" "digital_credential_state_type",
+        "tenant_id" text,
+        "created_at" TIMESTAMP NOT NULL DEFAULT now(),
+        "last_updated_at" TIMESTAMP NOT NULL DEFAULT now(),
+        "valid_from" DATE,
+        "valid_until" DATE,
+        "verified_at" DATE,
+        "revoked_at" DATE,
+        PRIMARY KEY ("id")
+      )
+    `)
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "DigitalCredential"`)
+    await queryRunner.query(`DROP TYPE "digital_credential_state_type"`)
+    await queryRunner.query(`DROP TYPE "digital_credential_correlation_type"`)
+    await queryRunner.query(`DROP TYPE "digital_credential_document_format"`)
+    await queryRunner.query(`DROP TYPE "digital_document_type"`)
+  }
+}