@sphereon/ssi-sdk.data-store 0.34.1-feature.SSISDK.82.linkedVP.328 → 0.34.1-feature.SSISDK.82.linkedVP.341

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sphereon/ssi-sdk.data-store",
-  "version": "0.34.1-feature.SSISDK.82.linkedVP.328+20af9c29",
+  "version": "0.34.1-feature.SSISDK.82.linkedVP.341+483672e1",
   "source": "src/index.ts",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -28,12 +28,12 @@
   "dependencies": {
     "@sphereon/kmp-mdoc-core": "0.2.0-SNAPSHOT.26",
     "@sphereon/pex": "5.0.0-unstable.28",
-    "@sphereon/ssi-sdk-ext.did-utils": "0.34.1-feature.SSISDK.82.linkedVP.328+20af9c29",
-    "@sphereon/ssi-sdk-ext.identifier-resolution": "0.34.1-feature.SSISDK.82.linkedVP.328+20af9c29",
-    "@sphereon/ssi-sdk.agent-config": "0.34.1-feature.SSISDK.82.linkedVP.328+20af9c29",
-    "@sphereon/ssi-sdk.core": "0.34.1-feature.SSISDK.82.linkedVP.328+20af9c29",
-    "@sphereon/ssi-sdk.data-store-types": "0.34.1-feature.SSISDK.82.linkedVP.328+20af9c29",
-    "@sphereon/ssi-types": "0.34.1-feature.SSISDK.82.linkedVP.328+20af9c29",
+    "@sphereon/ssi-sdk-ext.did-utils": "0.34.1-feature.SSISDK.82.linkedVP.341+483672e1",
+    "@sphereon/ssi-sdk-ext.identifier-resolution": "0.34.1-feature.SSISDK.82.linkedVP.341+483672e1",
+    "@sphereon/ssi-sdk.agent-config": "0.34.1-feature.SSISDK.82.linkedVP.341+483672e1",
+    "@sphereon/ssi-sdk.core": "0.34.1-feature.SSISDK.82.linkedVP.341+483672e1",
+    "@sphereon/ssi-sdk.data-store-types": "0.34.1-feature.SSISDK.82.linkedVP.341+483672e1",
+    "@sphereon/ssi-types": "0.34.1-feature.SSISDK.82.linkedVP.341+483672e1",
     "@veramo/core": "4.2.0",
     "@veramo/utils": "4.2.0",
     "blakejs": "^1.2.1",
@@ -66,5 +66,5 @@
     "PostgreSQL",
     "Contact Store"
   ],
-  "gitHead": "20af9c298b5d6764da6c804d1c6d8a758b710513"
+  "gitHead": "483672e1d9b2891a346216a0ebea64745561d6ed"
 }

package/src/digitalCredential/DigitalCredentialStore.ts

@@ -15,7 +15,13 @@ import { CredentialRole, OrPromise } from '@sphereon/ssi-types'
 import Debug from 'debug'
 import { DataSource, type FindOptionsOrder, type FindOptionsWhere, Repository } from 'typeorm'
 
-import { digitalCredentialFrom, digitalCredentialsFrom, nonPersistedDigitalCredentialEntityFromAddArgs } from '../../src'
+import {
+  digitalCredentialFrom,
+  digitalCredentialsFrom,
+  nonPersistedDigitalCredentialEntityFromAddArgs,
+  persistedDigitalCredentialEntityFromStateArgs,
+  persistedDigitalCredentialEntityFromUpdateArgs,
+} from '../../src'
 import { DigitalCredentialEntity } from '../entities/digitalCredential/DigitalCredentialEntity'
 import { parseAndValidateOrderOptions } from '../utils/SortingUtils'
 
@@ -38,7 +44,7 @@ export class DigitalCredentialStore extends AbstractDigitalCredentialStore {
       return Promise.reject(validationError)
     }
     const dcRepo = await this.getRepository()
-    const createdResult: DigitalCredentialEntity = await dcRepo.save(credentialEntity)
+    const createdResult: DigitalCredentialEntity = await dcRepo.save(credentialEntity as any)
     return Promise.resolve(digitalCredentialFrom(createdResult))
   }
 
@@ -93,20 +99,18 @@ export class DigitalCredentialStore extends AbstractDigitalCredentialStore {
       return Promise.reject(Error(`No credential found for args: ${JSON.stringify(whereClause)}`))
     }
 
-    // Separate identifier from updates
-    const { id, hash, ...updates } = args as any
+    // Extract updates by removing the identifier fields
+    const updates = Object.fromEntries(Object.entries(args).filter(([key]) => key !== 'id' && key !== 'hash')) as Partial<DigitalCredential>
+
+    const entityToSave = persistedDigitalCredentialEntityFromUpdateArgs(credential, updates)
 
-    const updatedCredential: DigitalCredential = {
-      ...credential,
-      ...updates,
-      id: credential.id,
-      hash: credential.hash,
-      createdAt: credential.createdAt,
-      lastUpdatedAt: new Date(),
+    const validationError = this.assertValidDigitalCredential(entityToSave)
+    if (validationError) {
+      return Promise.reject(validationError)
     }
 
-    debug('Updating credential', updatedCredential)
-    const updatedResult: DigitalCredentialEntity = await dcRepo.save(updatedCredential, { transaction: true })
+    debug('Updating credential', entityToSave)
+    const updatedResult = await dcRepo.save(entityToSave as any, { transaction: true })
     return digitalCredentialFrom(updatedResult)
   }
 
@@ -185,20 +189,16 @@ export class DigitalCredentialStore extends AbstractDigitalCredentialStore {
     if (!credential) {
       return Promise.reject(Error(`No credential found for args: ${JSON.stringify(whereClause)}`))
     }
-    const updatedCredential: DigitalCredential = {
-      ...credential,
-      ...(args.verifiedState !== CredentialStateType.REVOKED && { verifiedAt: args.verifiedAt }),
-      ...(args.verifiedState === CredentialStateType.REVOKED && { revokedAt: args.revokedAt }),
-      identifierMethod: credential.identifierMethod,
-      lastUpdatedAt: new Date(),
-      verifiedState: args.verifiedState,
-    }
-    debug('Updating credential', credential)
-    const updatedResult: DigitalCredentialEntity = await credentialRepository.save(updatedCredential, { transaction: true })
+
+    // Create entity with state updates applied
+    const entityToSave = persistedDigitalCredentialEntityFromStateArgs(credential, args)
+
+    debug('Updating credential state', entityToSave)
+    const updatedResult: DigitalCredentialEntity = await credentialRepository.save(entityToSave as any, { transaction: true })
     return digitalCredentialFrom(updatedResult)
   }
 
-  private assertValidDigitalCredential(credentialEntity: NonPersistedDigitalCredential): Error | undefined {
+  private assertValidDigitalCredential(credentialEntity: NonPersistedDigitalCredential | DigitalCredentialEntity): Error | undefined {
     const { kmsKeyRef, identifierMethod, credentialRole, isIssuerSigned } = credentialEntity
 
     const isRoleInvalid = credentialRole === CredentialRole.ISSUER || (credentialRole === CredentialRole.HOLDER && !isIssuerSigned)

package/src/utils/digitalCredential/MappingUtils.ts

@@ -1,6 +1,11 @@
 import { defaultHasher } from '@sphereon/ssi-sdk.core'
-import type { AddCredentialArgs, DigitalCredential, NonPersistedDigitalCredential } from '@sphereon/ssi-sdk.data-store-types'
-import { CredentialDocumentFormat, DocumentType, RegulationType } from '@sphereon/ssi-sdk.data-store-types'
+import type {
+  AddCredentialArgs,
+  DigitalCredential,
+  NonPersistedDigitalCredential,
+  UpdateCredentialStateArgs,
+} from '@sphereon/ssi-sdk.data-store-types'
+import { CredentialDocumentFormat, CredentialStateType, DocumentType, RegulationType } from '@sphereon/ssi-sdk.data-store-types'
 import {
   CredentialMapper,
   DocumentFormat,
@@ -66,6 +71,20 @@ function determineCredentialDocumentFormat(documentFormat: DocumentFormat): Cred
   }
 }
 
+/**
+ * Normalizes nullable fields by converting undefined to null.
+ * This ensures TypeORM actually clears the database fields instead of ignoring them.
+ */
+export function normalizeNullableFields<T extends Record<string, any>>(obj: T, nullableKeys: Array<keyof T>): T {
+  const normalized = { ...obj }
+  for (const key of nullableKeys) {
+    if (normalized[key] === undefined) {
+      normalized[key] = null as any
+    }
+  }
+  return normalized
+}
+
 function getValidUntil(uniformDocument: IVerifiableCredential | IVerifiablePresentation | SdJwtDecodedVerifiableCredentialPayload): Date | undefined {
   if ('expirationDate' in uniformDocument && uniformDocument.expirationDate) {
     return new Date(uniformDocument.expirationDate)
@@ -127,6 +146,54 @@ export const nonPersistedDigitalCredentialEntityFromAddArgs = (addCredentialArgs
   }
 }
 
+export const persistedDigitalCredentialEntityFromUpdateArgs = (
+  existingCredential: DigitalCredentialEntity,
+  updates: Partial<DigitalCredential>,
+): DigitalCredentialEntity => {
+  const entity = new DigitalCredentialEntity()
+
+  // Copy all fields from existing credential
+  Object.assign(entity, existingCredential)
+
+  // Normalize nullable fields before applying updates
+  const normalizedUpdates = normalizeNullableFields(updates, ['linkedVpId', 'linkedVpFrom'])
+
+  // Apply updates
+  Object.assign(entity, normalizedUpdates)
+
+  // Ensure these fields are never overwritten
+  entity.id = existingCredential.id
+  entity.hash = existingCredential.hash
+  entity.createdAt = existingCredential.createdAt
+  entity.lastUpdatedAt = new Date()
+
+  return entity
+}
+
+export const persistedDigitalCredentialEntityFromStateArgs = (
+  existingCredential: DigitalCredentialEntity,
+  args: UpdateCredentialStateArgs,
+): DigitalCredentialEntity => {
+  const entity = new DigitalCredentialEntity()
+
+  // Copy all fields from existing credential
+  Object.assign(entity, existingCredential)
+
+  // Apply state updates
+  entity.verifiedState = args.verifiedState
+  entity.lastUpdatedAt = new Date()
+
+  if (args.verifiedState === CredentialStateType.REVOKED && args.revokedAt) {
+    entity.revokedAt = args.revokedAt
+  }
+
+  if (args.verifiedState !== CredentialStateType.REVOKED && args.verifiedAt) {
+    entity.verifiedAt = args.verifiedAt
+  }
+
+  return entity
+}
+
 export const digitalCredentialFrom = (credentialEntity: DigitalCredentialEntity): DigitalCredential => {
   const result: DigitalCredential = {
     ...credentialEntity,