@sphereon/ssi-sdk.data-store 0.18.2-unstable.98 → 0.19.1-next.100

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

@@ -0,0 +1,174 @@
+import { DataSource } from 'typeorm'
+import { DataStoreMachineStateEntities, MachineStateStore, StoreMachineStatesFindActiveArgs, StoreMachineStatePersistArgs } from '../index'
+import { DataStoreMachineStateMigrations } from '../migrations'
+
+describe('Machine State store tests', (): void => {
+  let dbConnection: DataSource
+  let store: MachineStateStore
+
+  beforeEach(async (): Promise<void> => {
+    dbConnection = await new DataSource({
+      type: 'sqlite',
+      database: ':memory:',
+      logging: 'all',
+      migrationsRun: false,
+      migrations: DataStoreMachineStateMigrations,
+      synchronize: false,
+      entities: DataStoreMachineStateEntities,
+    }).initialize()
+    await dbConnection.runMigrations()
+    expect(await dbConnection.showMigrations()).toBeFalsy()
+    store = new MachineStateStore(dbConnection)
+  })
+
+  afterEach(async (): Promise<void> => {
+    await dbConnection.destroy()
+  })
+
+  it('should store machine state info', async (): Promise<void> => {
+    const persistArgs: StoreMachineStatePersistArgs = {
+      instanceId: 'Onboarding1',
+      machineName: 'Onboarding',
+      updatedCount: 0,
+      latestStateName: 'enterPersonalDetails',
+      latestEventType: 'SET_PERSONAL_DATA',
+      state: 'test_state',
+      expiresAt: new Date(new Date().getDate() + 100000),
+      tenantId: 'test_tenant_id',
+    }
+
+    const persistMachineStateResult = await store.persistMachineState(persistArgs)
+    expect(persistMachineStateResult).toBeDefined()
+  })
+
+  it('should get all machines with their current state', async (): Promise<void> => {
+    const persistArgs: StoreMachineStatePersistArgs = {
+      instanceId: 'Onboarding1',
+      machineName: 'Onboarding',
+      latestStateName: 'enterPersonalDetails',
+      latestEventType: 'SET_PERSONAL_DATA',
+      updatedCount: 0,
+      state: 'test_state',
+      expiresAt: new Date(new Date().getDate() + 100000),
+      tenantId: 'test_tenant_id',
+    }
+
+    const stateEvent1 = await store.persistMachineState({ ...persistArgs })
+    expect(stateEvent1).toBeDefined()
+
+    const stateEvent2 = await store.persistMachineState({ ...persistArgs, instanceId: 'Onboarding2' })
+    expect(stateEvent2).toBeDefined()
+
+    const result = await store.findMachineStates()
+    expect(result).toHaveLength(2)
+  })
+
+  it('should retrieve a machine state', async (): Promise<void> => {
+    const expiresAt = new Date()
+    expiresAt.setTime(expiresAt.getTime() + 100000)
+    const persistArgs: StoreMachineStatePersistArgs = {
+      instanceId: 'Onboarding1',
+      machineName: 'Onboarding',
+      latestStateName: 'enterPersonalDetails',
+      latestEventType: 'SET_PERSONAL_DATA',
+      state: 'test_state',
+      updatedCount: 0,
+      expiresAt,
+      tenantId: 'test_tenant_id',
+    }
+
+    const machineStatePersisted = await store.persistMachineState(persistArgs)
+    expect(machineStatePersisted).toBeDefined()
+    const result = await store.findActiveMachineStates({ machineName: persistArgs.machineName, tenantId: persistArgs.tenantId })
+    expect(result).toBeDefined()
+  })
+
+  it('should delete a machine state', async (): Promise<void> => {
+    const persistArgs: StoreMachineStatePersistArgs = {
+      instanceId: 'Onboarding1',
+      machineName: 'Onboarding',
+      updatedCount: 0,
+      latestStateName: 'enterPersonalDetails',
+      latestEventType: 'SET_PERSONAL_DATA',
+      state: 'test_state',
+      expiresAt: new Date(new Date().getDate() + 100000),
+      tenantId: 'test_tenant_id',
+    }
+
+    const persistedState = await store.persistMachineState(persistArgs)
+    expect(persistedState).toBeDefined()
+
+    const result: boolean = await store.deleteMachineState({ instanceId: persistedState.instanceId })
+    expect(result).toBeTruthy()
+  })
+
+  it('should return an error if type filter does not match', async (): Promise<void> => {
+    const args: StoreMachineStatesFindActiveArgs = {
+      machineName: 'unknown_machine',
+    }
+
+    await expect(store.findActiveMachineStates(args)).resolves.toEqual([])
+  })
+
+  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: StoreMachineStatePersistArgs = {
+      instanceId: 'Onboarding1',
+      machineName: 'Onboarding',
+      latestStateName: 'enterPersonalDetails',
+      latestEventType: 'SET_TOC',
+      updatedCount: 0,
+      state: 'test_state',
+      expiresAt: futureExpiresAt,
+      tenantId: 'test_tenant_id',
+    }
+    const middleXstateEvent: StoreMachineStatePersistArgs = {
+      instanceId: 'Onboarding1',
+      machineName: 'Onboarding',
+      latestStateName: 'TOC',
+      latestEventType: 'SET_POLICY2',
+      updatedCount: 1,
+      state: 'test_state',
+      expiresAt: futureExpiresAt,
+      tenantId: 'test_tenant_id',
+    }
+    const newestXstateEvent: StoreMachineStatePersistArgs = {
+      instanceId: 'OnboardingExpired',
+      machineName: 'Onboarding',
+      latestStateName: 'POLICY',
+      latestEventType: 'SET_PERSONAL_DATA',
+      updatedCount: 0,
+      state: 'test_state',
+      expiresAt: pastExpiresAt, // This event should be already expired
+      tenantId: 'test_tenant_id',
+    }
+
+    await store.persistMachineState(oldestXstateEvent)
+    await store.persistMachineState(middleXstateEvent)
+    await store.persistMachineState(newestXstateEvent)
+
+    await expect(store.findActiveMachineStates({ machineName: 'Onboarding' })).resolves.toHaveLength(1)
+
+    await store.deleteExpiredMachineStates({})
+    await expect(store.findActiveMachineStates({ machineName: 'Onboarding' })).resolves.toHaveLength(1)
+    await expect(store.findActiveMachineStates({ machineName: 'Onboarding' })).resolves.toMatchObject([
+      {
+        completedAt: null,
+        createdAt: expect.anything(),
+        expiresAt: expect.anything(),
+        instanceId: 'Onboarding1',
+        latestEventType: 'SET_POLICY2',
+        latestStateName: 'TOC',
+        machineName: 'Onboarding',
+        state: 'test_state',
+        tenantId: 'test_tenant_id',
+        updatedAt: expect.anything(),
+      },
+    ])
+  })
+})

package/src/contact/AbstractContactStore.ts

@@ -21,7 +21,8 @@ import {
   Identity,
   Party,
   PartyRelationship,
-  PartyType, PhysicalAddress,
+  PartyType,
+  PhysicalAddress,
   RemoveElectronicAddressArgs,
   RemoveIdentityArgs,
   RemovePartyArgs,
@@ -33,7 +34,7 @@ import {
   UpdatePartyArgs,
   UpdatePartyTypeArgs,
   UpdatePhysicalAddressArgs,
-  UpdateRelationshipArgs
+  UpdateRelationshipArgs,
 } from '../types'
 
 export abstract class AbstractContactStore {

package/src/contact/ContactStore.ts

@@ -29,7 +29,7 @@ import {
   partyTypeEntityFrom,
   partyTypeFrom,
   physicalAddressEntityFrom,
-  physicalAddressFrom
+  physicalAddressFrom,
 } from '../utils/contact/MappingUtils'
 import {
   AddElectronicAddressArgs,
@@ -653,23 +653,27 @@ export class ContactStore extends AbstractContactStore {
     const identityRepository: Repository<IdentityEntity> = connection.getRepository(IdentityEntity)
 
     identities.map(async (identity: IdentityEntity): Promise<void> => {
-      await correlationIdentifierRepository.delete(identity.identifier.id)
+      await correlationIdentifierRepository
+        .delete(identity.identifier.id)
         .catch((error) => Promise.reject(Error(`Unable to remove identity.identifier with id ${identity.identifier.id}. ${error}`)))
 
       if (identity.connection) {
         await baseConfigRepository.delete(identity.connection.config.id)
-        await connectionRepository.delete(identity.connection.id)
+        await connectionRepository
+          .delete(identity.connection.id)
           .catch((error) => Promise.reject(Error(`Unable to remove identity.connection with id ${identity.connection?.id}. ${error}`)))
       }
 
       if (identity.metadata) {
         identity.metadata.map(async (metadataItem: IdentityMetadataItemEntity): Promise<void> => {
-          await identityMetadataItemRepository.delete(metadataItem.id)
+          await identityMetadataItemRepository
+            .delete(metadataItem.id)
             .catch((error) => Promise.reject(Error(`Unable to remove identity.metadataItem with id ${metadataItem.id}. ${error}`)))
         })
       }
 
-      await identityRepository.delete(identity.id)
+      await identityRepository
+        .delete(identity.id)
         .catch((error) => Promise.reject(Error(`Unable to remove identity with id ${identity.id}. ${error}`)))
     })
   }
@@ -679,8 +683,9 @@ export class ContactStore extends AbstractContactStore {
 
     const electronicAddressRepository: Repository<ElectronicAddressEntity> = (await this.dbConnection).getRepository(ElectronicAddressEntity)
     electronicAddresses.map(async (electronicAddress: ElectronicAddressEntity): Promise<void> => {
-      await electronicAddressRepository.delete(electronicAddress.id)
-      .catch((error) => Promise.reject(Error(`Unable to remove electronic address with id ${electronicAddress.id}. ${error}`)))
+      await electronicAddressRepository
+        .delete(electronicAddress.id)
+        .catch((error) => Promise.reject(Error(`Unable to remove electronic address with id ${electronicAddress.id}. ${error}`)))
     })
   }
 
@@ -689,8 +694,9 @@ export class ContactStore extends AbstractContactStore {
 
     const physicalAddressRepository: Repository<PhysicalAddressEntity> = (await this.dbConnection).getRepository(PhysicalAddressEntity)
     physicalAddresses.map(async (physicalAddress: PhysicalAddressEntity): Promise<void> => {
-      await physicalAddressRepository.delete(physicalAddress.id)
-      .catch((error) => Promise.reject(Error(`Unable to remove physical address with id ${physicalAddress.id}. ${error}`)))
+      await physicalAddressRepository
+        .delete(physicalAddress.id)
+        .catch((error) => Promise.reject(Error(`Unable to remove physical address with id ${physicalAddress.id}. ${error}`)))
     })
   }
 

package/src/entities/contact/PhysicalAddressEntity.ts

@@ -8,7 +8,7 @@ import {
   Entity,
   ManyToOne,
   PrimaryGeneratedColumn,
-  UpdateDateColumn
+  UpdateDateColumn,
 } from 'typeorm'
 import { getConstraint } from '../../utils/ValidatorUtils'
 import { PhysicalAddressType, ValidationConstraint } from '../../types'

package/src/entities/machineState/MachineStateInfoEntity.ts

@@ -0,0 +1,58 @@
+import { BaseEntity, Column, CreateDateColumn, Entity, PrimaryColumn, UpdateDateColumn } from 'typeorm'
+
+/**
+ * @class MachineStateInfoEntity
+ * Represents a machine state. It allows to continue a machine at a later point in time at the point it was left of
+ *
+ * @param {string} instanceId - The instance ID of the machine state.
+ * @param {string} [sessionId] - The session ID of the machine state. (optional)
+ * @param {string} machineName - The name of the machine.
+ * @param {string} [latestStateName] - The name of the latest state. (optional)
+ * @param {string} latestEventType - The type of the latest event.
+ * @param {string} state - The current state of the machine.
+ * @param {Date} createdAt - The date and time when the machine state was created.
+ * @param {Date} updatedAt - The date and time when the machine state was last updated.
+ * @param {number} updatedCount - The number of times the machine state has been updated.
+ * @param {Date} [expiresAt] - The date and time when the machine state expires. (optional)
+ * @param {Date} [completedAt] - The date and time when the machine state was completed. (optional)
+ * @param {string} [tenantId] - The ID of the tenant associated with the machine state. (optional)
+ */
+@Entity('MachineStateInfoEntity')
+export class MachineStateInfoEntity extends BaseEntity {
+  @PrimaryColumn({ name: 'instance_id', type: 'varchar', nullable: false })
+  instanceId!: string
+
+  @Column({ name: 'session_id', type: 'varchar', nullable: true })
+  sessionId?: string
+
+  // Xstate moved to name instead of instanceId for V5. Also makes more sense
+  @Column({ name: 'machine_name', type: 'varchar', nullable: false })
+  machineName!: string
+
+  @Column({ name: 'latest_state_name', type: 'varchar', nullable: true })
+  latestStateName?: string
+
+  @Column({ name: 'latest_event_type', type: 'varchar', nullable: false })
+  latestEventType!: string
+
+  @Column({ name: 'state', type: 'text', nullable: false })
+  state!: string
+
+  @CreateDateColumn({ name: 'created_at', type: 'datetime', nullable: false })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'datetime', nullable: false })
+  updatedAt!: Date
+
+  @Column({ name: 'updated_count', type: 'integer', nullable: false })
+  updatedCount!: number
+
+  @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 { MachineStateInfoEntity } from './entities/machineState/MachineStateInfoEntity'
 import { IStatusListEntity, IStatusListEntryEntity } from './types'
 import { PartyRelationshipEntity } from './entities/contact/PartyRelationshipEntity'
 import { PartyTypeEntity } from './entities/contact/PartyTypeEntity'
@@ -35,12 +36,16 @@ import { DigitalCredentialEntity } from './entities/digitalCredential/DigitalCre
 import { digitalCredentialFrom, digitalCredentialsFrom, nonPersistedDigitalCredentialEntityFromAddArgs } from './utils/digitalCredential/MappingUtils'
 export { AbstractEventLoggerStore } from './eventLogger/AbstractEventLoggerStore'
 export { EventLoggerStore } from './eventLogger/EventLoggerStore'
+export { IAbstractMachineStateStore } from './machineState/IAbstractMachineStateStore'
+export { MachineStateStore } from './machineState/MachineStateStore'
+
 export {
   DataStoreMigrations,
   DataStoreEventLoggerMigrations,
   DataStoreContactMigrations,
   DataStoreIssuanceBrandingMigrations,
   DataStoreStatusListMigrations,
+  DataStoreMachineStateMigrations,
 } from './migrations'
 export * from './types'
 export * from './utils/contact/MappingUtils'
@@ -81,6 +86,8 @@ export const DataStoreEventLoggerEntities = [AuditEventEntity]
 
 export const DataStoreDigitalCredentialEntities = [DigitalCredentialEntity]
 
+export const DataStoreMachineStateEntities = [MachineStateInfoEntity]
+
 // All entities combined if a party wants to enable them all at once
 export const DataStoreEntities = [
   ...DataStoreContactEntities,
@@ -88,6 +95,7 @@ export const DataStoreEntities = [
   ...DataStoreStatusListEntities,
   ...DataStoreEventLoggerEntities,
   ...DataStoreDigitalCredentialEntities,
+  ...DataStoreMachineStateEntities,
 ]
 
 export {
@@ -128,4 +136,5 @@ export {
   digitalCredentialFrom,
   digitalCredentialsFrom,
   nonPersistedDigitalCredentialEntityFromAddArgs,
+  MachineStateInfoEntity,
 }

package/src/issuanceBranding/IssuanceBrandingStore.ts

@@ -376,14 +376,12 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
     }
 
     const issuerLocaleBrandingRepository: Repository<IssuerLocaleBrandingEntity> = (await this.dbConnection).getRepository(IssuerLocaleBrandingEntity)
-    const addIssuerLocaleBranding: Array<Promise<void>> = localeBranding.map(
-      async (localeBranding: IBasicIssuerLocaleBranding): Promise<void> => {
-        const issuerLocaleBrandingEntity: IssuerLocaleBrandingEntity = issuerLocaleBrandingEntityFrom(localeBranding)
-        debug('Adding issuer locale branding', issuerLocaleBrandingEntity)
-        issuerLocaleBrandingEntity.issuerBranding = issuerBranding
-        await issuerLocaleBrandingRepository.save(issuerLocaleBrandingEntity, { transaction: true })
-      }
-    )
+    const addIssuerLocaleBranding: Array<Promise<void>> = localeBranding.map(async (localeBranding: IBasicIssuerLocaleBranding): Promise<void> => {
+      const issuerLocaleBrandingEntity: IssuerLocaleBrandingEntity = issuerLocaleBrandingEntityFrom(localeBranding)
+      debug('Adding issuer locale branding', issuerLocaleBrandingEntity)
+      issuerLocaleBrandingEntity.issuerBranding = issuerBranding
+      await issuerLocaleBrandingRepository.save(issuerLocaleBrandingEntity, { transaction: true })
+    })
 
     await Promise.all(addIssuerLocaleBranding)
 

package/src/machineState/IAbstractMachineStateStore.ts

@@ -0,0 +1,65 @@
+import {
+  StoreMachineStateDeleteExpiredArgs,
+  StoreMachineStateDeleteArgs,
+  StoreMachineStatesFindActiveArgs,
+  StoreFindMachineStatesArgs,
+  StoreMachineStatePersistArgs,
+  StoreMachineStateInfo,
+  StoreMachineStateGetArgs,
+} from '../types'
+
+/**
+ * Represents an abstract class for storing machine states.
+ * This class provides methods for persisting, retrieving, and deleting machine states.
+ *
+ * @interface
+ */
+export abstract class IAbstractMachineStateStore {
+  /**
+   * Persists the machine state.
+   *
+   * @param {StoreMachineStatePersistArgs} state - The object containing the machine state to persist.
+   * @return {Promise<StoreMachineStateInfo>} - A Promise that resolves to the information about the persisted machine state.
+   */
+  abstract persistMachineState(state: StoreMachineStatePersistArgs): Promise<StoreMachineStateInfo>
+
+  /**
+   * Finds active machine states based on the given arguments.
+   *
+   * @param {StoreMachineStatesFindActiveArgs} args - The arguments for finding active machine states.
+   * @return {Promise<Array<StoreMachineStateInfo>>} - A promise that resolves with an array of active machine states.
+   */
+  abstract findActiveMachineStates(args: StoreMachineStatesFindActiveArgs): Promise<Array<StoreMachineStateInfo>>
+
+  /**
+   * Retrieves the state of a particular machine.
+   *
+   * @param {StoreMachineStateGetArgs} args - The arguments for retrieving the machine state.
+   * @returns {Promise<StoreMachineStateInfo>} - A promise that resolves to the machine state information.
+   */
+  abstract getMachineState(args: StoreMachineStateGetArgs): Promise<StoreMachineStateInfo>
+
+  /**
+   * Finds the machine states based on the given arguments.
+   *
+   * @param {StoreFindMachineStatesArgs} [args] - The arguments to filter the machine states.
+   * @returns {Promise<Array<StoreMachineStateInfo>>} - A promise that resolves to an array of machine state information.
+   */
+  abstract findMachineStates(args?: StoreFindMachineStatesArgs): Promise<Array<StoreMachineStateInfo>>
+
+  /**
+   * Deletes a machine state.
+   *
+   * @param {StoreMachineStateDeleteArgs} args - The arguments for deleting the machine state.
+   * @return {Promise<boolean>} - A promise that resolves to a boolean indicating if the machine state was successfully deleted or not.
+   */
+  abstract deleteMachineState(args: StoreMachineStateDeleteArgs): Promise<boolean>
+
+  /**
+   * Deletes expired machine states from the database.
+   *
+   * @param {StoreMachineStateDeleteExpiredArgs} args - The arguments for deleting expired machine states.
+   * @return {Promise<number>} - A promise that resolves to the number of deleted machine states.
+   */
+  abstract deleteExpiredMachineStates(args: StoreMachineStateDeleteExpiredArgs): Promise<number>
+}

package/src/machineState/MachineStateStore.ts

@@ -0,0 +1,149 @@
+import { OrPromise } from '@sphereon/ssi-types'
+import Debug from 'debug'
+import { Brackets, DataSource, FindOptionsWhere, IsNull, LessThan, Not } from 'typeorm'
+
+import { MachineStateInfoEntity } from '../entities/machineState/MachineStateInfoEntity'
+import {
+  StoreFindMachineStatesArgs,
+  StoreMachineStateDeleteArgs,
+  StoreMachineStateDeleteExpiredArgs,
+  StoreMachineStateGetArgs,
+  StoreMachineStateInfo,
+  StoreMachineStatePersistArgs,
+  StoreMachineStatesFindActiveArgs,
+} from '../types'
+import { IAbstractMachineStateStore } from './IAbstractMachineStateStore'
+
+const debug = Debug('sphereon:ssi-sdk:machine-state:store')
+
+/**
+ * Represents a data store for managing machine states.
+ */
+export class MachineStateStore extends IAbstractMachineStateStore {
+  private readonly _dbConnection: OrPromise<DataSource>
+
+  constructor(dbConnection: OrPromise<DataSource>) {
+    super()
+    this._dbConnection = dbConnection
+  }
+
+  async persistMachineState(state: StoreMachineStatePersistArgs): Promise<StoreMachineStateInfo> {
+    const connection: DataSource = await this._dbConnection
+    const { machineName, instanceId, tenantId } = state
+    debug(`Executing persistMachineState for machine ${machineName}, instance ${instanceId}, tenantId: ${tenantId}...`)
+    const entity = MachineStateStore.machineStateInfoEntityFrom(state)
+    const existing = await connection.getRepository(MachineStateInfoEntity).findOne({
+      where: {
+        instanceId: state.instanceId,
+      },
+    })
+    if (existing && existing.updatedCount > state.updatedCount) {
+      const error = `Updating machine state with an older version is not allowed. Machine ${existing.machineName}, last count: ${
+        existing.updatedCount
+      }, new count: ${existing.updatedCount}, last updated: ${existing.updatedAt}, current: ${new Date()}, instance: ${existing.instanceId}`
+      console.log(error)
+      return Promise.reject(new Error(error))
+    }
+    // No need for a transaction. This is a single entity. We don't want to be surprised by an isolation level hiding the state from others
+    const result = await connection.getRepository(MachineStateInfoEntity).save(entity, { transaction: false })
+    debug(`Done persistMachineState machine ${machineName}, instance ${instanceId}, tenantId: ${tenantId}`)
+    return MachineStateStore.machineInfoFrom(result)
+  }
+
+  async findActiveMachineStates(args: StoreMachineStatesFindActiveArgs): Promise<Array<StoreMachineStateInfo>> {
+    const { tenantId, machineName, instanceId } = args
+    const connection: DataSource = await this._dbConnection
+    debug(`Executing findActiveMachineStates query with machineName: ${machineName}, tenantId: ${tenantId}`)
+    const queryBuilder = connection
+      .getRepository(MachineStateInfoEntity)
+      .createQueryBuilder('state')
+      .where('state.completedAt IS NULL')
+      .andWhere(
+        new Brackets((qb) => {
+          qb.where('state.expiresAt IS NULL').orWhere('state.expiresAt > :now', { now: new Date() })
+        })
+      )
+
+    if (instanceId) {
+      queryBuilder.andWhere('state.instanceId = :instanceId', { instanceId })
+    }
+    if (tenantId) {
+      queryBuilder.andWhere('state.tenantId = :tenantId', { tenantId })
+    }
+    if (machineName) {
+      queryBuilder.andWhere('state.machineName = :machineName', { machineName })
+    }
+
+    return (
+      (await queryBuilder
+        .orderBy('state.updatedAt', 'DESC')
+        .getMany()
+        .then((entities) => entities.map(MachineStateStore.machineInfoFrom))) ?? []
+    )
+  }
+
+  async findMachineStates(args?: StoreFindMachineStatesArgs): Promise<Array<StoreMachineStateInfo>> {
+    const connection: DataSource = await this._dbConnection
+    debug('findMachineStates', args)
+    const result: Array<MachineStateInfoEntity> = await connection.getRepository(MachineStateInfoEntity).find({
+      ...(args?.filter && { where: args?.filter }),
+      transaction: false,
+    })
+
+    return result.map((event: MachineStateInfoEntity) => MachineStateStore.machineInfoFrom(event))
+  }
+
+  async getMachineState(args: StoreMachineStateGetArgs): Promise<StoreMachineStateInfo> {
+    const connection: DataSource = await this._dbConnection
+    debug('getMachineState', args)
+    return connection.getRepository(MachineStateInfoEntity).findOneOrFail({ where: { instanceId: args.instanceId } })
+  }
+
+  async deleteMachineState(args: StoreMachineStateDeleteArgs): Promise<boolean> {
+    debug(`Executing deleteMachineState query with id: ${args.instanceId}`)
+    if (!args.instanceId) {
+      throw new Error('No instanceId parameter is provided.')
+    }
+    try {
+      const connection: DataSource = await this._dbConnection
+
+      const result = await connection.getRepository(MachineStateInfoEntity).delete(args.instanceId)
+      return result.affected != null && result.affected > 0
+    } catch (error) {
+      debug(`Error deleting state: ${error}`)
+      return false
+    }
+  }
+
+  async deleteExpiredMachineStates(args: StoreMachineStateDeleteExpiredArgs): Promise<number> {
+    const { machineName, tenantId, deleteDoneStates } = args
+    debug(`Executing deleteExpiredMachineStates query with params: ${JSON.stringify(args)}`)
+    try {
+      const connection: DataSource = await this._dbConnection
+
+      const deleteCriteria: FindOptionsWhere<MachineStateInfoEntity> = {
+        ...(machineName && { machineName }),
+        ...(tenantId && { tenantId }),
+        // When deleteOnDone state is set we only look at completedAt, in other cases we compare current time with expiresAt
+        ...(!deleteDoneStates && { expiresAt: LessThan(new Date()) }),
+        ...(deleteDoneStates && { completedAt: Not(IsNull()) }),
+      }
+      const result = await connection.getRepository(MachineStateInfoEntity).delete(deleteCriteria)
+      return result.affected ?? 0
+    } catch (error) {
+      debug(`Error deleting machine info: ${error}`)
+      return Promise.reject(new Error(`Error deleting expired machine states for machine type ${machineName}`))
+    }
+  }
+
+  protected static machineInfoFrom = (machineStateInfoEntity: MachineStateInfoEntity): StoreMachineStateInfo => {
+    // We are making sure no entity function get copied
+    return JSON.parse(JSON.stringify(machineStateInfoEntity))
+  }
+
+  static machineStateInfoEntityFrom = (machineStateInfo: StoreMachineStateInfo | StoreMachineStatePersistArgs): MachineStateInfoEntity => {
+    const entity = new MachineStateInfoEntity()
+    Object.assign(entity, machineStateInfo)
+    return entity
+  }
+}

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

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