@sphereon/ssi-sdk.data-store 0.36.1-next.119 → 0.36.1-next.129

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sphereon/ssi-sdk.data-store",
-  "version": "0.36.1-next.119+86f2dfd2",
+  "version": "0.36.1-next.129+2a4f4386",
   "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.36.1-next.119+86f2dfd2",
-    "@sphereon/ssi-sdk-ext.identifier-resolution": "0.36.1-next.119+86f2dfd2",
-    "@sphereon/ssi-sdk.agent-config": "0.36.1-next.119+86f2dfd2",
-    "@sphereon/ssi-sdk.core": "0.36.1-next.119+86f2dfd2",
-    "@sphereon/ssi-sdk.data-store-types": "0.36.1-next.119+86f2dfd2",
-    "@sphereon/ssi-types": "0.36.1-next.119+86f2dfd2",
+    "@sphereon/ssi-sdk-ext.did-utils": "0.36.1-next.129+2a4f4386",
+    "@sphereon/ssi-sdk-ext.identifier-resolution": "0.36.1-next.129+2a4f4386",
+    "@sphereon/ssi-sdk.agent-config": "0.36.1-next.129+2a4f4386",
+    "@sphereon/ssi-sdk.core": "0.36.1-next.129+2a4f4386",
+    "@sphereon/ssi-sdk.data-store-types": "0.36.1-next.129+2a4f4386",
+    "@sphereon/ssi-types": "0.36.1-next.129+2a4f4386",
     "@veramo/core": "4.2.0",
     "@veramo/utils": "4.2.0",
     "blakejs": "^1.2.1",
@@ -66,5 +66,5 @@
     "PostgreSQL",
     "Contact Store"
   ],
-  "gitHead": "86f2dfd2bac43df28073b4e079a83b85f92c3157"
+  "gitHead": "2a4f43863a1544f53c63485daee40bcb2abbfa81"
 }

package/src/__tests__/issuanceBranding.entities.test.ts

@@ -823,7 +823,7 @@ describe('Database entities tests', (): void => {
     }
 
     const issuerLocaleBrandingEntity: IssuerLocaleBrandingEntity = issuerLocaleBrandingEntityFrom(localeBranding)
-    const fromDb: IssuerLocaleBrandingEntity = await dbConnection.getRepository(CredentialLocaleBrandingEntity).save(issuerLocaleBrandingEntity)
+    const fromDb: IssuerLocaleBrandingEntity = await dbConnection.getRepository(IssuerLocaleBrandingEntity).save(issuerLocaleBrandingEntity)
 
     expect(fromDb).toBeDefined()
     expect(fromDb?.alias).toEqual(localeBranding.alias)

package/src/__tests__/issuanceBranding.store.test.ts

@@ -1884,4 +1884,314 @@ describe('Issuance branding store tests', (): void => {
     expect(result?.localeBranding[0].background!.image!.alt).toBeUndefined()
     expect(result?.localeBranding[0].text!.color).toBeUndefined()
   })
+
+  // State-related tests
+
+  it('should populate state field when adding credential branding', async (): Promise<void> => {
+    const credentialBranding: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const result: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding)
+
+    expect(result).toBeDefined()
+    expect(result.state).toBeDefined()
+    expect(typeof result.state).toBe('string')
+    expect(result.state.length).toBeGreaterThan(0)
+    expect(result.localeBranding[0].state).toBeDefined()
+    expect(typeof result.localeBranding[0].state).toBe('string')
+    expect(result.localeBranding[0].state.length).toBeGreaterThan(0)
+  })
+
+  it('should generate different states for different credential brandings', async (): Promise<void> => {
+    const credentialBranding1: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId1',
+      vcHash: 'vcHash1',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias1',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const credentialBranding2: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId2',
+      vcHash: 'vcHash2',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias2',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const result1: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding1)
+    const result2: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding2)
+
+    expect(result1.state).toBeDefined()
+    expect(result2.state).toBeDefined()
+    expect(result1.state).not.toEqual(result2.state)
+    expect(result1.localeBranding[0].state).not.toEqual(result2.localeBranding[0].state)
+  })
+
+  it('should keep same state when credential branding content does not change', async (): Promise<void> => {
+    const credentialBranding: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+          description: 'Description',
+        },
+      ],
+    }
+
+    const original: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding)
+    const originalState: string = original.state
+    const originalLocaleState: string = original.localeBranding[0].state
+
+    const retrieved: Array<ICredentialBranding> = await issuanceBrandingStore.getCredentialBranding({ filter: [{ id: original.id }] })
+
+    expect(retrieved).toBeDefined()
+    expect(retrieved.length).toEqual(1)
+    expect(retrieved[0].state).toEqual(originalState)
+    expect(retrieved[0].localeBranding[0].state).toEqual(originalLocaleState)
+  })
+
+  it('should filter credential branding by knownStates when all states match', async (): Promise<void> => {
+    const credentialBranding: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const saved: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding)
+    const knownStates: Record<string, string> = {
+      [saved.id]: saved.state,
+    }
+
+    const result: Array<ICredentialBranding> = await issuanceBrandingStore.getCredentialBranding({ knownStates })
+
+    expect(result.length).toEqual(0)
+  })
+
+  it('should return credential branding when knownStates differs', async (): Promise<void> => {
+    const credentialBranding: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const saved: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding)
+    const knownStates: Record<string, string> = {
+      [saved.id]: 'differentState',
+    }
+
+    const result: Array<ICredentialBranding> = await issuanceBrandingStore.getCredentialBranding({ knownStates })
+
+    expect(result.length).toEqual(1)
+    expect(result[0].id).toEqual(saved.id)
+  })
+
+  it('should return credential branding when not in knownStates map', async (): Promise<void> => {
+    const credentialBranding: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const saved: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding)
+    const knownStates: Record<string, string> = {}
+
+    const result: Array<ICredentialBranding> = await issuanceBrandingStore.getCredentialBranding({ knownStates })
+
+    expect(result.length).toEqual(1)
+    expect(result[0].id).toEqual(saved.id)
+  })
+
+  it('should filter multiple credential brandings correctly with knownStates', async (): Promise<void> => {
+    const credentialBranding1: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId1',
+      vcHash: 'vcHash1',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias1',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const credentialBranding2: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId2',
+      vcHash: 'vcHash2',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias2',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const credentialBranding3: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId3',
+      vcHash: 'vcHash3',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias3',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const saved1: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding1)
+    const saved2: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding2)
+    const saved3: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding3)
+
+    const knownStates: Record<string, string> = {
+      [saved1.id]: saved1.state,
+      [saved2.id]: 'differentState',
+    }
+
+    const result: Array<ICredentialBranding> = await issuanceBrandingStore.getCredentialBranding({ knownStates })
+
+    expect(result.length).toEqual(2)
+    const resultIds: Array<string> = result.map((r: ICredentialBranding) => r.id)
+    expect(resultIds).toContain(saved2.id)
+    expect(resultIds).toContain(saved3.id)
+    expect(resultIds).not.toContain(saved1.id)
+  })
+
+  it('should add new locale branding with state field populated', async (): Promise<void> => {
+    const credentialBranding: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const saved: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding)
+
+    const addLocaleBrandingArgs: IAddCredentialLocaleBrandingArgs = {
+      credentialBrandingId: saved.id,
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-GB',
+        },
+      ],
+    }
+
+    const result: ICredentialBranding = await issuanceBrandingStore.addCredentialLocaleBranding(addLocaleBrandingArgs)
+
+    expect(result.localeBranding.length).toEqual(2)
+    expect(result.localeBranding[0].state).toBeDefined()
+    expect(result.localeBranding[1].state).toBeDefined()
+    expect(result.localeBranding[0].state).not.toEqual(result.localeBranding[1].state)
+  })
+
+  it('should compute state based on locale branding claims', async (): Promise<void> => {
+    const credentialBranding1: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash1',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+          claims: [
+            {
+              key: 'name',
+              name: 'Full Name',
+            },
+          ],
+        },
+      ],
+    }
+
+    const credentialBranding2: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash2',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+          claims: [
+            {
+              key: 'email',
+              name: 'Email Address',
+            },
+          ],
+        },
+      ],
+    }
+
+    const saved1: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding1)
+    const saved2: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding2)
+
+    expect(saved1.localeBranding[0].state).toBeDefined()
+    expect(saved2.localeBranding[0].state).toBeDefined()
+    expect(saved1.localeBranding[0].state).not.toEqual(saved2.localeBranding[0].state)
+  })
+
+  it('should compute deterministic state for same content', async (): Promise<void> => {
+    const credentialBranding1: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+          description: 'Test description',
+        },
+      ],
+    }
+
+    const saved1: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding1)
+
+    await issuanceBrandingStore.removeCredentialBranding({ filter: [{ id: saved1.id }] })
+
+    const credentialBranding2: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+          description: 'Test description',
+        },
+      ],
+    }
+
+    const saved2: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding2)
+
+    expect(saved1.state).toEqual(saved2.state)
+    expect(saved1.localeBranding[0].state).toEqual(saved2.localeBranding[0].state)
+  })
 })

package/src/contact/ContactStore.ts

@@ -109,9 +109,21 @@ export class ContactStore extends AbstractContactStore {
     const initialResult = await partyRepository.find({ select: ['id'], where: filterConditions })
 
     // Fetch the complete entities based on the initial result IDs
-    const result = await partyRepository.find({ where: { id: In(initialResult.map((party) => party.id)) } })
+    const result = await partyRepository.find({
+      where: { id: In(initialResult.map((party) => party.id)) },
+      relations: ['contact'], // Explicit load prevents eager loading issues
+    })
     debug(`getParties() resulted in ${result.length} parties`)
-    return result.map(partyFrom)
+    return result
+      .filter((party) => {
+        // Do not crash fetching the entire contacts list over one missing contact relation
+        if (!party.contact) {
+          console.warn(`party ${party.id} does not have an associated contact`)
+          return false
+        }
+        return true
+      })
+      .map(partyFrom)
   }
 
   addParty = async (args: AddPartyArgs): Promise<Party> => {

package/src/entities/issuanceBranding/CredentialBrandingEntity.ts

@@ -12,7 +12,8 @@ import {
   PrimaryGeneratedColumn,
   UpdateDateColumn,
 } from 'typeorm'
-import { CredentialLocaleBrandingEntity } from './CredentialLocaleBrandingEntity'
+import { CredentialLocaleBrandingEntity, computeCredentialLocaleBrandingState } from './CredentialLocaleBrandingEntity'
+import { computeCompactHash } from '../../utils/issuanceBranding/HashUtils'
 
 @Entity('CredentialBranding')
 @Index('IDX_CredentialBrandingEntity_vcHash', ['vcHash'])
@@ -29,6 +30,9 @@ export class CredentialBrandingEntity extends BaseEntity {
   @IsNotEmpty({ message: 'Blank issuerCorrelationIds are not allowed' })
   issuerCorrelationId!: string
 
+  @Column('varchar', { name: 'state', length: 255, nullable: false })
+  state!: string
+
   @OneToMany(
     () => CredentialLocaleBrandingEntity,
     (credentialLocaleBrandingEntity: CredentialLocaleBrandingEntity) => credentialLocaleBrandingEntity.credentialBranding,
@@ -55,6 +59,14 @@ export class CredentialBrandingEntity extends BaseEntity {
     this.lastUpdatedAt = new Date()
   }
 
+  @BeforeInsert()
+  @BeforeUpdate()
+  setState(): void {
+    if (this.localeBranding && Array.isArray(this.localeBranding)) {
+      this.state = this.computeState()
+    }
+  }
+
   @BeforeInsert()
   @BeforeUpdate()
   async validate(): Promise<undefined> {
@@ -64,4 +76,35 @@ export class CredentialBrandingEntity extends BaseEntity {
     }
     return
   }
+
+  private computeState(): string {
+    const localeStates: Array<{ locale: string; alias: string; id: string; state: string }> = (this.localeBranding ?? []).map(
+      (localeBranding: CredentialLocaleBrandingEntity) => ({
+        locale: localeBranding.locale ?? '',
+        alias: localeBranding.alias ?? '',
+        id: localeBranding.id ?? '',
+        state: computeCredentialLocaleBrandingState(localeBranding),
+      }),
+    )
+
+    localeStates.sort((first, second) => {
+      const localeCompare: number = first.locale.localeCompare(second.locale)
+      if (localeCompare !== 0) {
+        return localeCompare
+      }
+      const aliasCompare: number = first.alias.localeCompare(second.alias)
+      if (aliasCompare !== 0) {
+        return aliasCompare
+      }
+      return first.id.localeCompare(second.id)
+    })
+
+    const payload = {
+      issuerCorrelationId: this.issuerCorrelationId,
+      vcHash: this.vcHash,
+      localeBranding: localeStates.map((entry) => entry.state),
+    }
+
+    return computeCompactHash(JSON.stringify(payload))
+  }
 }

package/src/entities/issuanceBranding/CredentialLocaleBrandingEntity.ts

@@ -1,4 +1,5 @@
-import { ChildEntity, Column, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm'
+import { BeforeInsert, BeforeUpdate, ChildEntity, Column, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm'
+import { computeCompactHash } from '../../utils/issuanceBranding/HashUtils'
 import { BaseLocaleBrandingEntity } from './BaseLocaleBrandingEntity'
 import { CredentialBrandingEntity } from './CredentialBrandingEntity'
 import { CredentialClaimsEntity } from './CredentialClaimsEntity'
@@ -23,4 +24,66 @@ export class CredentialLocaleBrandingEntity extends BaseLocaleBrandingEntity {
 
   @Column('uuid', { name: 'credentialBrandingId', nullable: false })
   credentialBrandingId!: string
+
+  @Column('varchar', { name: 'state', length: 255, nullable: false })
+  state!: string
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  setState(): void {
+    this.state = computeCredentialLocaleBrandingState(this)
+  }
+}
+
+export const computeCredentialLocaleBrandingState = (localeBranding: CredentialLocaleBrandingEntity): string => {
+  const sortedClaims: Array<{ key: string; name: string }> = (localeBranding.claims ?? [])
+    .map((claim: CredentialClaimsEntity) => ({ key: claim.key, name: claim.name }))
+    .sort((first: { key: string }, second: { key: string }) => first.key.localeCompare(second.key))
+
+  const payload = {
+    alias: localeBranding.alias ?? null,
+    locale: localeBranding.locale ?? null,
+    description: localeBranding.description ?? null,
+    logo: localeBranding.logo
+      ? {
+          uri: localeBranding.logo.uri ?? null,
+          dataUri: localeBranding.logo.dataUri ?? null,
+          mediaType: localeBranding.logo.mediaType ?? null,
+          alt: localeBranding.logo.alt ?? null,
+          dimensions: localeBranding.logo.dimensions
+            ? {
+                width: localeBranding.logo.dimensions.width,
+                height: localeBranding.logo.dimensions.height,
+              }
+            : null,
+        }
+      : null,
+    background: localeBranding.background
+      ? {
+          color: localeBranding.background.color ?? null,
+          image: localeBranding.background.image
+            ? {
+                uri: localeBranding.background.image.uri ?? null,
+                dataUri: localeBranding.background.image.dataUri ?? null,
+                mediaType: localeBranding.background.image.mediaType ?? null,
+                alt: localeBranding.background.image.alt ?? null,
+                dimensions: localeBranding.background.image.dimensions
+                  ? {
+                      width: localeBranding.background.image.dimensions.width,
+                      height: localeBranding.background.image.dimensions.height,
+                    }
+                  : null,
+              }
+            : null,
+        }
+      : null,
+    text: localeBranding.text
+      ? {
+          color: localeBranding.text.color ?? null,
+        }
+      : null,
+    claims: sortedClaims,
+  }
+
+  return computeCompactHash(JSON.stringify(payload))
 }

package/src/entities/issuanceBranding/IssuerLocaleBrandingEntity.ts

@@ -1,5 +1,6 @@
 import { Validate } from 'class-validator'
-import { ChildEntity, Column, Index, JoinColumn, ManyToOne } from 'typeorm'
+import { BeforeInsert, BeforeUpdate, ChildEntity, Column, Index, JoinColumn, ManyToOne } from 'typeorm'
+import { computeCompactHash } from '../../utils/issuanceBranding/HashUtils'
 import { IsNonEmptyStringConstraint } from '../validators'
 import { BaseLocaleBrandingEntity } from './BaseLocaleBrandingEntity'
 import { IssuerBrandingEntity } from './IssuerBrandingEntity'
@@ -30,4 +31,65 @@ export class IssuerLocaleBrandingEntity extends BaseLocaleBrandingEntity {
 
   @Column('text', { name: 'issuerBrandingId', nullable: false })
   issuerBrandingId!: string
+
+  @Column('varchar', { name: 'state', length: 255, nullable: false })
+  state!: string
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  setState(): void {
+    this.state = this.computeState()
+  }
+
+  private computeState(): string {
+    const payload = {
+      alias: this.alias ?? null,
+      locale: this.locale ?? null,
+      description: this.description ?? null,
+      clientUri: this.clientUri ?? null,
+      tosUri: this.tosUri ?? null,
+      policyUri: this.policyUri ?? null,
+      contacts: this.contacts ?? null,
+      logo: this.logo
+        ? {
+            uri: this.logo.uri ?? null,
+            dataUri: this.logo.dataUri ?? null,
+            mediaType: this.logo.mediaType ?? null,
+            alt: this.logo.alt ?? null,
+            dimensions: this.logo.dimensions
+              ? {
+                  width: this.logo.dimensions.width,
+                  height: this.logo.dimensions.height,
+                }
+              : null,
+          }
+        : null,
+      background: this.background
+        ? {
+            color: this.background.color ?? null,
+            image: this.background.image
+              ? {
+                  uri: this.background.image.uri ?? null,
+                  dataUri: this.background.image.dataUri ?? null,
+                  mediaType: this.background.image.mediaType ?? null,
+                  alt: this.background.image.alt ?? null,
+                  dimensions: this.background.image.dimensions
+                    ? {
+                        width: this.background.image.dimensions.width,
+                        height: this.background.image.dimensions.height,
+                      }
+                    : null,
+                }
+              : null,
+          }
+        : null,
+      text: this.text
+        ? {
+            color: this.text.color ?? null,
+          }
+        : null,
+    }
+
+    return computeCompactHash(JSON.stringify(payload))
+  }
 }