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

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/index.ts

@@ -31,6 +31,8 @@ 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 {
@@ -77,12 +79,15 @@ export const DataStoreStatusListEntities = [StatusListEntity, StatusListEntryEnt
 
 export const DataStoreEventLoggerEntities = [AuditEventEntity]
 
+export const DataStoreDigitalCredentialEntities = [DigitalCredentialEntity]
+
 // All entities combined if a party wants to enable them all at once
 export const DataStoreEntities = [
   ...DataStoreContactEntities,
   ...DataStoreIssuanceBrandingEntities,
   ...DataStoreStatusListEntities,
   ...DataStoreEventLoggerEntities,
+  ...DataStoreDigitalCredentialEntities,
 ]
 
 export {
@@ -119,4 +124,8 @@ export {
   StatusListEntryEntity,
   AuditEventEntity,
   auditEventEntityFrom,
+  DigitalCredentialEntity,
+  digitalCredentialFrom,
+  digitalCredentialsFrom,
+  nonPersistedDigitalCredentialEntityFromAddArgs,
 }

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/index.ts

@@ -3,6 +3,7 @@ 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'
 
 /**
  * The migrations array that SHOULD be used when initializing a TypeORM database connection.
@@ -17,6 +18,7 @@ export const DataStoreContactMigrations = [CreateContacts1659463079429, CreateCo
 export const DataStoreIssuanceBrandingMigrations = [CreateIssuanceBranding1659463079429]
 export const DataStoreStatusListMigrations = [CreateStatusList1693866470000]
 export const DataStoreEventLoggerMigrations = [CreateAuditEvents1701635835330]
+export const DataStoreDigitalCredentialMigrations = [CreateDigitalCredential1708525189000]
 
 // All migrations together
 export const DataStoreMigrations = [
@@ -24,4 +26,5 @@ export const DataStoreMigrations = [
   ...DataStoreIssuanceBrandingMigrations,
   ...DataStoreStatusListMigrations,
   ...DataStoreEventLoggerMigrations,
+  ...DataStoreDigitalCredentialMigrations,
 ]

package/src/migrations/index.ts

@@ -4,4 +4,5 @@ export {
   DataStoreContactMigrations,
   DataStoreIssuanceBrandingMigrations,
   DataStoreStatusListMigrations,
+  DataStoreDigitalCredentialMigrations,
 } 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/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/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/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
+}

package/src/utils/digitalCredential/MappingUtils.ts

@@ -0,0 +1,122 @@
+import { AddCredentialArgs } from '../../types/digitalCredential/IAbstractDigitalCredentialStore'
+import { DigitalCredentialEntity } from '../../entities/digitalCredential/DigitalCredentialEntity'
+import {
+  CredentialMapper,
+  decodeSdJwtVc,
+  DocumentFormat,
+  IVerifiableCredential,
+  IVerifiablePresentation,
+  OriginalVerifiableCredential,
+  OriginalVerifiablePresentation,
+  SdJwtDecodedVerifiableCredentialPayload,
+} from '@sphereon/ssi-types'
+import {
+  CredentialDocumentFormat,
+  DocumentType,
+  DigitalCredential,
+  NonPersistedDigitalCredential,
+} from '../../types/digitalCredential/digitalCredential'
+import { computeEntryHash } from '@veramo/utils'
+
+function determineDocumentType(raw: string): DocumentType {
+  const rawDocument = parseRawDocument(raw)
+  if (!rawDocument) {
+    throw new Error(`Couldn't parse the credential: ${raw}`)
+  }
+
+  const hasProof = CredentialMapper.hasProof(rawDocument)
+  const isCredential = CredentialMapper.isCredential(rawDocument)
+  const isPresentation = CredentialMapper.isPresentation(rawDocument)
+
+  if (isCredential) {
+    return hasProof ? DocumentType.VC : DocumentType.C
+  } else if (isPresentation) {
+    return hasProof ? DocumentType.VP : DocumentType.P
+  }
+  throw new Error(`Couldn't determine the type of the credential: ${raw}`)
+}
+
+function parseRawDocument(raw: string): OriginalVerifiableCredential | OriginalVerifiablePresentation {
+  if (CredentialMapper.isJwtEncoded(raw) || CredentialMapper.isSdJwtEncoded(raw)) {
+    return raw
+  }
+  try {
+    return JSON.parse(raw)
+  } catch (e) {
+    throw new Error(`Can't parse the raw credential: ${raw}`)
+  }
+}
+
+function determineCredentialDocumentFormat(documentFormat: DocumentFormat): CredentialDocumentFormat {
+  switch (documentFormat) {
+    case DocumentFormat.JSONLD:
+      return CredentialDocumentFormat.JSON_LD
+    case DocumentFormat.JWT:
+      return CredentialDocumentFormat.JWT
+    case DocumentFormat.SD_JWT_VC:
+      return CredentialDocumentFormat.SD_JWT
+    default:
+      throw new Error(`Not supported document format: ${documentFormat}`)
+  }
+}
+
+function getValidUntil(uniformDocument: IVerifiableCredential | IVerifiablePresentation | SdJwtDecodedVerifiableCredentialPayload): Date | undefined {
+  if ('expirationDate' in uniformDocument) {
+    return new Date(uniformDocument.expirationDate)
+  } else if ('validUntil' in uniformDocument) {
+    return new Date(uniformDocument.validUntil)
+  } else if ('exp' in uniformDocument) {
+    return new Date(uniformDocument.exp)
+  }
+  return undefined
+}
+
+function getValidFrom(uniformDocument: IVerifiableCredential | IVerifiablePresentation | SdJwtDecodedVerifiableCredentialPayload): Date | undefined {
+  if ('issuanceDate' in uniformDocument) {
+    return new Date(uniformDocument.issuanceDate)
+  } else if ('validFrom' in uniformDocument) {
+    return new Date(uniformDocument['validFrom'])
+  } else if ('nbf' in uniformDocument) {
+    return new Date(uniformDocument['nbf'] * 1000)
+  } else if ('iat' in uniformDocument) {
+    return new Date(uniformDocument['iat'] * 1000)
+  }
+  return undefined
+}
+
+export const nonPersistedDigitalCredentialEntityFromAddArgs = (addCredentialArgs: AddCredentialArgs): NonPersistedDigitalCredential => {
+  const documentType: DocumentType = determineDocumentType(addCredentialArgs.rawDocument)
+  const documentFormat: DocumentFormat = CredentialMapper.detectDocumentType(addCredentialArgs.rawDocument)
+  if (documentFormat === DocumentFormat.SD_JWT_VC && !addCredentialArgs.opts?.hasher) {
+    throw new Error('No hasher function is provided for SD_JWT credential.')
+  }
+  const uniformDocument =
+    documentFormat === DocumentFormat.SD_JWT_VC
+      ? decodeSdJwtVc(addCredentialArgs.rawDocument, addCredentialArgs.opts!.hasher!).decodedPayload
+      : documentType === DocumentType.VC || documentType === DocumentType.C
+      ? CredentialMapper.toUniformCredential(addCredentialArgs.rawDocument)
+      : CredentialMapper.toUniformPresentation(addCredentialArgs.rawDocument)
+  const validFrom: Date | undefined = getValidFrom(uniformDocument)
+  const validUntil: Date | undefined = getValidUntil(uniformDocument)
+  return {
+    ...addCredentialArgs,
+    documentType,
+    documentFormat: determineCredentialDocumentFormat(documentFormat),
+    createdAt: new Date(),
+    hash: computeEntryHash(addCredentialArgs.rawDocument),
+    uniformDocument: JSON.stringify(uniformDocument),
+    validFrom,
+    validUntil,
+    lastUpdatedAt: new Date(),
+  }
+}
+
+export const digitalCredentialFrom = (credentialEntity: DigitalCredentialEntity): DigitalCredential => {
+  return {
+    ...credentialEntity,
+  }
+}
+
+export const digitalCredentialsFrom = (credentialEntities: Array<DigitalCredentialEntity>): DigitalCredential[] => {
+  return credentialEntities.map((credentialEntity) => digitalCredentialFrom(credentialEntity))
+}