@sphereon/ssi-sdk.data-store 0.19.0 → 0.19.1-next.100

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

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 { CreateMachineStateStore1708098041262 } from './7-CreateMachineStateStore'
 
 /**
  * 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 DataStoreMachineStateMigrations = [CreateMachineStateStore1708098041262]
 
 // All migrations together
 export const DataStoreMigrations = [
@@ -24,4 +28,6 @@ export const DataStoreMigrations = [
   ...DataStoreIssuanceBrandingMigrations,
   ...DataStoreStatusListMigrations,
   ...DataStoreEventLoggerMigrations,
+  ...DataStoreDigitalCredentialMigrations,
+  ...DataStoreMachineStateMigrations,
 ]

package/src/migrations/index.ts

@@ -4,4 +4,6 @@ export {
   DataStoreContactMigrations,
   DataStoreIssuanceBrandingMigrations,
   DataStoreStatusListMigrations,
+  DataStoreDigitalCredentialMigrations,
+  DataStoreMachineStateMigrations,
 } 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"`)
+  }
+}

package/src/migrations/postgres/1708797018115-CreateMachineStateStore.ts

@@ -0,0 +1,29 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class CreateMachineStateStore1708797018115 implements MigrationInterface {
+  name = 'CreateMachineStateStore1708797018115'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+            CREATE TABLE "MachineStateInfoEntity" (
+                "instance_id" text NOT NULL,
+                "session_id" text,
+                "latest_state_name" text,
+                "machine_name" text NOT NULL,
+                "latest_event_type" text NOT NULL,
+                "state" text NOT NULL,
+                "created_at" TIMESTAMP NOT NULL DEFAULT now(),
+                "updated_at" TIMESTAMP NOT NULL DEFAULT now(),
+                "updated_count" integer NOT NULL DEFAULT 0,
+                "expires_at" TIMESTAMP,
+                "completed_at" TIMESTAMP,
+                "tenant_id" text,
+                CONSTRAINT "PK_MachineStateInfoEntity_id" PRIMARY KEY ("instance_id")
+            )
+        `)
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "MachineStateInfoEntity"`)
+  }
+}

package/src/migrations/sqlite/1708525189002-CreateDigitalCredential.ts

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

package/src/migrations/sqlite/1708796002272-CreateMachineStateStore.ts

@@ -0,0 +1,28 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class CreateMachineStateStore1708796002272 implements MigrationInterface {
+  name = 'CreateMachineStateStore1708796002272'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+            CREATE TABLE "MachineStateInfoEntity" (
+                "instance_id" varchar PRIMARY KEY NOT NULL,
+                "session_id" varchar,
+                "machine_name" varchar NOT NULL,
+                "latest_state_name" varchar,
+                "latest_event_type" varchar NOT NULL,
+                "state" text NOT NULL,
+                "created_at" datetime NOT NULL DEFAULT (datetime('now')),
+                "updated_at" datetime NOT NULL DEFAULT (datetime('now')),
+                "updated_count" integer NOT NULL DEFAULT 0,
+                "expires_at" datetime,
+                "completed_at" datetime,
+                "tenant_id" varchar
+            )
+        `)
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "MachineStateInfoEntity"`)
+  }
+}

package/src/types/digitalCredential/IAbstractDigitalCredentialStore.ts

@@ -0,0 +1,37 @@
+import { CredentialCorrelationType, CredentialStateType, DigitalCredential } from './digitalCredential'
+import { Hasher } from '@sphereon/ssi-types'
+import { FindOptionsOrder } from 'typeorm'
+import { DigitalCredentialEntity } from '../../entities/digitalCredential/DigitalCredentialEntity'
+
+export type GetCredentialArgs = { id: string } | { hash: string }
+
+export type FindDigitalCredentialArgs = Array<Partial<DigitalCredential>>
+
+export type GetCredentialsArgs = {
+  filter?: FindDigitalCredentialArgs
+  offset?: number
+  limit?: number
+  order?: string | FindOptionsOrder<DigitalCredentialEntity>
+}
+
+export type GetCredentialsResponse = {
+  data: Array<DigitalCredential>
+  total: number
+}
+
+export type AddCredentialArgs = {
+  rawDocument: string
+  issuerCorrelationType: CredentialCorrelationType
+  subjectCorrelationType?: CredentialCorrelationType
+  issuerCorrelationId: string
+  subjectCorrelationId?: string
+  tenantId?: string
+  state?: CredentialStateType
+  verifiedAt?: Date
+  revokedAt?: Date
+  opts?: { maxTimeSkewInMS?: number; hasher?: Hasher }
+}
+
+export type UpdateCredentialStateArgs = GetCredentialArgs & { verifiedState: CredentialStateType; verifiedAt?: Date; revokedAt?: Date }
+
+export type RemoveCredentialArgs = GetCredentialArgs

package/src/types/digitalCredential/digitalCredential.ts

@@ -0,0 +1,46 @@
+export type NonPersistedDigitalCredential = Omit<DigitalCredential, 'id'>
+
+export type DigitalCredential = {
+  id: string
+  documentType: DocumentType
+  documentFormat: CredentialDocumentFormat
+  rawDocument: string
+  uniformDocument: string
+  hash: string
+  issuerCorrelationType: CredentialCorrelationType
+  subjectCorrelationType?: CredentialCorrelationType
+  issuerCorrelationId: string
+  subjectCorrelationId?: string
+  verifiedState?: CredentialStateType
+  tenantId?: string
+  createdAt: Date
+  lastUpdatedAt: Date
+  validUntil?: Date
+  validFrom?: Date
+  verifiedAt?: Date
+  revokedAt?: Date
+}
+
+export enum DocumentType {
+  VC = 'VC',
+  VP = 'VP',
+  P = 'P',
+  C = 'C',
+}
+
+export enum CredentialDocumentFormat {
+  JSON_LD = 'JSON_LD',
+  JWT = 'JWT',
+  SD_JWT = 'SD_JWT',
+  MDOC = 'MDOC',
+}
+
+export enum CredentialCorrelationType {
+  DID = 'DID',
+}
+
+export enum CredentialStateType {
+  REVOKED = 'REVOKED',
+  VERIFIED = 'VERIFIED',
+  EXPIRED = 'EXPIRED',
+}

package/src/types/index.ts

@@ -7,3 +7,4 @@ export * from './statusList/statusList'
 export * from './statusList/IAbstractStatusListStore'
 export * from './eventLogger/IAbstractEventLoggerStore'
 export * from './eventLogger/eventLogger'
+export * from './machineState/IAbstractMachineStateStore'

package/src/types/machineState/IAbstractMachineStateStore.ts

@@ -0,0 +1,68 @@
+export type StoreMachineStatePersistArgs = Omit<StoreMachineStateInfo, 'createdAt' | 'updatedAt'>
+
+export type StoreMachineStatesFindActiveArgs = Partial<Pick<StoreMachineStateInfo, 'machineName' | 'tenantId' | 'instanceId'>>
+
+export type FindMachineStatesFilterArgs = Array<Partial<Omit<StoreMachineStateInfo, 'state'>>>
+
+export type StoreFindMachineStatesArgs = {
+  filter: FindMachineStatesFilterArgs
+}
+
+export type StoreMachineStateGetArgs = Pick<StoreMachineStateInfo, 'instanceId' | 'tenantId'>
+
+export type StoreMachineStateDeleteArgs = StoreMachineStateGetArgs
+export type StoreMachineStateDeleteExpiredArgs = { machineName?: string; tenantId?: string; deleteDoneStates?: boolean }
+
+export interface StoreMachineStateInfo {
+  /**
+   * Unique instance ID of the machine
+   */
+  instanceId: string
+
+  /**
+   * Session Id of the machine. Not necessarily unique
+   */
+  sessionId?: string
+
+  /**
+   * Machine name
+   */
+  machineName: string
+
+  /**
+   * The latest state name. Can be empty for a newly initialize machine
+   */
+  latestStateName?: string
+
+  /**
+   * event types like SET_TOC, SET_FIRSTNAME, .... Will be xstate.init on a newly initialized machine
+   */
+  latestEventType: string
+
+  /**
+   * Serialized Machine state
+   */
+  state: string
+
+  /**
+   * Represents the creation date
+   */
+  createdAt: Date
+
+  /**
+   * Represents the expiration date
+   */
+  expiresAt?: Date
+
+  /**
+   * Represents the update date
+   */
+  updatedAt: Date
+
+  /**
+   * Represents a counter for tracking updates.
+   */
+  updatedCount: number
+  completedAt?: Date
+  tenantId?: string
+}

package/src/utils/SortingUtils.ts

@@ -0,0 +1,16 @@
+import { BaseEntity, FindOptionsOrder } from 'typeorm'
+
+export const parseAndValidateOrderOptions = <T extends BaseEntity>(order: string): FindOptionsOrder<T> => {
+  const orderPairs = order.split(',').map((pair) => pair.trim().split('.'))
+  const orderOptions: FindOptionsOrder<T> = {}
+
+  orderPairs.forEach(([field, direction]) => {
+    const dir = direction.toUpperCase()
+    if (dir !== 'ASC' && dir !== 'DESC') {
+      throw new Error(`Invalid order direction: '${direction}'. Must be 'asc' or 'desc'.`)
+    }
+    ;(orderOptions as any)[field] = dir
+  })
+
+  return orderOptions
+}