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

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

@@ -1,34 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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))
-}