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

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/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/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'
@@ -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 { 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'
@@ -77,12 +84,18 @@ export const DataStoreStatusListEntities = [StatusListEntity, StatusListEntryEnt
 
 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,
   ...DataStoreIssuanceBrandingEntities,
   ...DataStoreStatusListEntities,
   ...DataStoreEventLoggerEntities,
+  ...DataStoreDigitalCredentialEntities,
+  ...DataStoreMachineStateEntities,
 ]
 
 export {
@@ -119,4 +132,9 @@ export {
   StatusListEntryEntity,
   AuditEventEntity,
   auditEventEntityFrom,
+  DigitalCredentialEntity,
+  digitalCredentialFrom,
+  digitalCredentialsFrom,
+  nonPersistedDigitalCredentialEntityFromAddArgs,
+  MachineStateInfoEntity,
 }

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