@sphereon/ssi-sdk.data-store 0.37.2-next.14 → 0.37.2-next.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sphereon/ssi-sdk.data-store",
-  "version": "0.37.2-next.14+b7a013bb",
+  "version": "0.37.2-next.21+d0cb5b4b",
   "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.37.2-next.14+b7a013bb",
-    "@sphereon/ssi-sdk-ext.identifier-resolution": "0.37.2-next.14+b7a013bb",
-    "@sphereon/ssi-sdk.agent-config": "0.37.2-next.14+b7a013bb",
-    "@sphereon/ssi-sdk.core": "0.37.2-next.14+b7a013bb",
-    "@sphereon/ssi-sdk.data-store-types": "0.37.2-next.14+b7a013bb",
-    "@sphereon/ssi-types": "0.37.2-next.14+b7a013bb",
+    "@sphereon/ssi-sdk-ext.did-utils": "0.37.2-next.21+d0cb5b4b",
+    "@sphereon/ssi-sdk-ext.identifier-resolution": "0.37.2-next.21+d0cb5b4b",
+    "@sphereon/ssi-sdk.agent-config": "0.37.2-next.21+d0cb5b4b",
+    "@sphereon/ssi-sdk.core": "0.37.2-next.21+d0cb5b4b",
+    "@sphereon/ssi-sdk.data-store-types": "0.37.2-next.21+d0cb5b4b",
+    "@sphereon/ssi-types": "0.37.2-next.21+d0cb5b4b",
     "@veramo/core": "4.2.0",
     "@veramo/data-store": "4.2.0",
     "@veramo/utils": "4.2.0",
@@ -67,5 +67,5 @@
     "PostgreSQL",
     "Contact Store"
   ],
-  "gitHead": "b7a013bb77cba07e43a97bb2fed6d085ece4d65f"
+  "gitHead": "d0cb5b4ba4baf038fc8d64be3524b0a5b83d54cb"
 }

package/src/__tests__/credential-design-store.test.ts

@@ -37,16 +37,16 @@ describe('Credential Design store tests', (): void => {
 
   it('should get a credential design by id', async (): Promise<void> => {
     const args: AddCredentialDesignArgs = {
-      name: 'GetByIdDesign',
+      identifier: 'GetByIdDesign',
       tenantId: 'tenant-get-by-id',
       design: {
-        label: 'GetByIdDesign',
+        identifier: 'GetByIdDesign',
         tenantId: 'tenant-get-by-id',
-        metaDataKeys: [
+        metadataKeys: [
           {
             key: 'credentialType',
             valueType: ValueType.Text,
-            metaDataValues: [{ index: 0, textValue: 'VerifiableCredential' }],
+            metadataValues: [{ index: 0, textValue: 'VerifiableCredential' }],
           },
         ],
         schemaDefinitions: [
@@ -67,7 +67,7 @@ describe('Credential Design store tests', (): void => {
 
     expect(result).toBeDefined()
     expect(result.id).toEqual(savedDesign.id)
-    expect(result.label).toEqual('GetByIdDesign')
+    expect(result.identifier).toEqual('GetByIdDesign')
     expect(result.tenantId).toEqual('tenant-get-by-id')
   })
 
@@ -81,16 +81,16 @@ describe('Credential Design store tests', (): void => {
 
   it('should get all credential designs', async (): Promise<void> => {
     const design1: AddCredentialDesignArgs = {
-      name: 'Design1',
+      identifier: 'Design1',
       tenantId: 'tenant-1',
       design: {
-        label: 'Design1',
+        identifier: 'Design1',
         tenantId: 'tenant-1',
-        metaDataKeys: [
+        metadataKeys: [
           {
             key: 'credentialType',
             valueType: ValueType.Text,
-            metaDataValues: [{ index: 0, textValue: 'VerifiableCredential' }],
+            metadataValues: [{ index: 0, textValue: 'VerifiableCredential' }],
           },
         ],
         schemaDefinitions: [
@@ -107,16 +107,16 @@ describe('Credential Design store tests', (): void => {
     expect(savedDesign1).toBeDefined()
 
     const design2: AddCredentialDesignArgs = {
-      name: 'Design2',
+      identifier: 'Design2',
       tenantId: 'tenant-2',
       design: {
-        label: 'Design2',
+        identifier: 'Design2',
         tenantId: 'tenant-2',
-        metaDataKeys: [
+        metadataKeys: [
           {
             key: 'credentialFormat',
             valueType: ValueType.Text,
-            metaDataValues: [{ index: 0, textValue: 'sd-jwt' }],
+            metadataValues: [{ index: 0, textValue: 'sd-jwt' }],
           },
         ],
         schemaDefinitions: [
@@ -139,8 +139,8 @@ describe('Credential Design store tests', (): void => {
   })
 
   it('should get credential designs by filter', async (): Promise<void> => {
-    await store.addCredentialDesign({ name: 'FilterDesign1', tenantId: 'tenant-filter' })
-    await store.addCredentialDesign({ name: 'FilterDesign2', tenantId: 'tenant-other' })
+    await store.addCredentialDesign({ identifier: 'FilterDesign1', tenantId: 'tenant-filter' })
+    await store.addCredentialDesign({ identifier: 'FilterDesign2', tenantId: 'tenant-other' })
 
     const args: GetCredentialDesignsArgs = {
       filter: {
@@ -150,21 +150,21 @@ describe('Credential Design store tests', (): void => {
     const result: Array<CredentialDesign> = await store.getCredentialDesigns(args)
 
     expect(result.length).toEqual(1)
-    expect(result[0].label).toEqual('FilterDesign1')
+    expect(result[0].identifier).toEqual('FilterDesign1')
   })
 
   it('should get whole credential design with all relations by filter', async (): Promise<void> => {
     const args: AddCredentialDesignArgs = {
-      name: 'WholeDesign',
+      identifier: 'WholeDesign',
       tenantId: 'tenant-whole',
       design: {
-        label: 'WholeDesign',
+        identifier: 'WholeDesign',
         tenantId: 'tenant-whole',
-        metaDataKeys: [
+        metadataKeys: [
           {
             key: 'credentialType',
             valueType: ValueType.Text,
-            metaDataValues: [
+            metadataValues: [
               { index: 0, textValue: 'VerifiableCredential' },
               { index: 1, textValue: 'WholeDesign' },
             ],
@@ -172,12 +172,12 @@ describe('Credential Design store tests', (): void => {
           {
             key: 'credentialFormat',
             valueType: ValueType.Text,
-            metaDataValues: [{ index: 0, textValue: 'jwt_vc_json' }],
+            metadataValues: [{ index: 0, textValue: 'jwt_vc_json' }],
           },
           {
             key: 'advancedSchema',
             valueType: ValueType.Boolean,
-            metaDataValues: [{ index: 0, booleanValue: false }],
+            metadataValues: [{ index: 0, booleanValue: false }],
           },
         ],
         schemaDefinitions: [
@@ -207,12 +207,12 @@ describe('Credential Design store tests', (): void => {
       },
     }
     await store.addCredentialDesign(args)
-    await store.addCredentialDesign({ name: 'OtherDesign', tenantId: 'tenant-other' })
+    await store.addCredentialDesign({ identifier: 'OtherDesign', tenantId: 'tenant-other' })
 
     const result: Array<CredentialDesign> = await store.getCredentialDesigns({ filter: { tenantId: 'tenant-whole' } })
 
     expect(result.length).toEqual(1)
-    expect(result[0].metaDataKeys.length).toEqual(3)
+    expect(result[0].metadataKeys.length).toEqual(3)
     expect(result[0].schemaDefinitions.length).toEqual(2)
     expect(result[0].branding).toBeDefined()
     expect(result[0].branding!.logo).toBeDefined()
@@ -220,7 +220,7 @@ describe('Credential Design store tests', (): void => {
   })
 
   it('should return no credential designs if filter does not match', async (): Promise<void> => {
-    await store.addCredentialDesign({ name: 'SomeDesign', tenantId: 'tenant-exists' })
+    await store.addCredentialDesign({ identifier: 'SomeDesign', tenantId: 'tenant-exists' })
 
     const result: Array<CredentialDesign> = await store.getCredentialDesigns({ filter: { tenantId: 'non-existent-tenant' } })
 
@@ -229,16 +229,16 @@ describe('Credential Design store tests', (): void => {
 
   it('should add credential design', async (): Promise<void> => {
     const args: AddCredentialDesignArgs = {
-      name: 'AddDesign',
+      identifier: 'AddDesign',
       tenantId: 'tenant-add',
       design: {
-        label: 'AddDesign',
+        identifier: 'AddDesign',
         tenantId: 'tenant-add',
-        metaDataKeys: [
+        metadataKeys: [
           {
             key: 'credentialType',
             valueType: ValueType.Text,
-            metaDataValues: [
+            metadataValues: [
               { index: 0, textValue: 'VerifiableCredential' },
               { index: 1, textValue: 'AddDesign' },
             ],
@@ -246,7 +246,7 @@ describe('Credential Design store tests', (): void => {
           {
             key: 'credentialFormat',
             valueType: ValueType.Text,
-            metaDataValues: [{ index: 0, textValue: 'jwt_vc_json' }],
+            metadataValues: [{ index: 0, textValue: 'jwt_vc_json' }],
           },
         ],
         schemaDefinitions: [
@@ -286,9 +286,9 @@ describe('Credential Design store tests', (): void => {
 
     expect(result).toBeDefined()
     expect(result.id).toBeDefined()
-    expect(result.label).toEqual(args.name)
+    expect(result.identifier).toEqual(args.identifier)
     expect(result.tenantId).toEqual(args.tenantId)
-    expect(result.metaDataKeys.length).toEqual(2)
+    expect(result.metadataKeys.length).toEqual(2)
     expect(result.schemaDefinitions.length).toEqual(2)
     expect(result.branding).toBeDefined()
     expect(result.branding!.textColor).toEqual('#FFFFFF')
@@ -304,21 +304,21 @@ describe('Credential Design store tests', (): void => {
 
   it('should update credential design by id', async (): Promise<void> => {
     const created: CredentialDesign = await store.addCredentialDesign({
-      name: 'OriginalDesign',
+      identifier: 'OriginalDesign',
       tenantId: 'tenant-original',
       design: {
-        label: 'OriginalDesign',
+        identifier: 'OriginalDesign',
         tenantId: 'tenant-original',
-        metaDataKeys: [
+        metadataKeys: [
           {
             key: 'credentialType',
             valueType: ValueType.Text,
-            metaDataValues: [{ index: 0, textValue: 'VerifiableCredential' }],
+            metadataValues: [{ index: 0, textValue: 'VerifiableCredential' }],
           },
           {
             key: 'credentialFormat',
             valueType: ValueType.Text,
-            metaDataValues: [{ index: 0, textValue: 'jwt_vc_json' }],
+            metadataValues: [{ index: 0, textValue: 'jwt_vc_json' }],
           },
         ],
         schemaDefinitions: [
@@ -339,13 +339,13 @@ describe('Credential Design store tests', (): void => {
 
     const updateArgs: UpdateCredentialDesignArgs = {
       credentialDesignId: created.id,
-      name: 'UpdatedDesign',
+      identifier: 'UpdatedDesign',
       design: {
-        metaDataKeys: [
+        metadataKeys: [
           {
             key: 'credentialType',
             valueType: ValueType.Text,
-            metaDataValues: [
+            metadataValues: [
               { index: 0, textValue: 'VerifiableCredential' },
               { index: 1, textValue: 'UpdatedDesign' },
             ],
@@ -353,12 +353,12 @@ describe('Credential Design store tests', (): void => {
           {
             key: 'credentialFormat',
             valueType: ValueType.Text,
-            metaDataValues: [{ index: 0, textValue: 'sd-jwt' }],
+            metadataValues: [{ index: 0, textValue: 'sd-jwt' }],
           },
           {
             key: 'vct',
             valueType: ValueType.Text,
-            metaDataValues: [{ index: 0, textValue: 'https://example.com/vct' }],
+            metadataValues: [{ index: 0, textValue: 'https://example.com/vct' }],
           },
         ],
       },
@@ -368,18 +368,18 @@ describe('Credential Design store tests', (): void => {
     const result: CredentialDesign = await store.getCredentialDesign({ credentialDesignId: created.id })
 
     expect(result).toBeDefined()
-    expect(result.label).toEqual('UpdatedDesign')
-    expect(result.metaDataKeys.length).toEqual(3)
+    expect(result.identifier).toEqual('UpdatedDesign')
+    expect(result.metadataKeys.length).toEqual(3)
 
-    const credentialFormatKey = result.metaDataKeys.find((k) => k.key === 'credentialFormat')
+    const credentialFormatKey = result.metadataKeys.find((k) => k.key === 'credentialFormat')
     expect(credentialFormatKey).toBeDefined()
-    expect(credentialFormatKey!.metaDataValues[0].textValue).toEqual('sd-jwt')
+    expect(credentialFormatKey!.metadataValues[0].textValue).toEqual('sd-jwt')
 
-    const vctKey = result.metaDataKeys.find((k) => k.key === 'vct')
+    const vctKey = result.metadataKeys.find((k) => k.key === 'vct')
     expect(vctKey).toBeDefined()
-    expect(vctKey!.metaDataValues[0].textValue).toEqual('https://example.com/vct')
+    expect(vctKey!.metadataValues[0].textValue).toEqual('https://example.com/vct')
 
-    // Branding should remain untouched since we only updated metaDataKeys
+    // Branding should remain untouched since we only updated metadataKeys
     expect(result.branding).toBeDefined()
     expect(result.branding!.textColor).toEqual('#000000')
   })
@@ -387,14 +387,14 @@ describe('Credential Design store tests', (): void => {
   it('should throw error when updating credential design with unknown id', async (): Promise<void> => {
     const credentialDesignId = 'unknownCredentialDesignId'
 
-    await expect(store.updateCredentialDesign({ credentialDesignId, name: 'ShouldFail' })).rejects.toThrow(
+    await expect(store.updateCredentialDesign({ credentialDesignId, identifier: 'ShouldFail' })).rejects.toThrow(
       `No credential design found for id: ${credentialDesignId}`,
     )
   })
 
   it('should remove credential design', async (): Promise<void> => {
     const created: CredentialDesign = await store.addCredentialDesign({
-      name: 'ToBeRemoved',
+      identifier: 'ToBeRemoved',
       tenantId: 'tenant-remove',
     })
     expect(created).toBeDefined()

package/src/__tests__/credential-design.entities.test.ts

@@ -2,12 +2,12 @@ import { DataSources } from '@sphereon/ssi-sdk.agent-config'
 import { NonPersistedCredentialDesign, ValueType } from '@sphereon/ssi-sdk.data-store-types'
 import { DataSource } from 'typeorm'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-import { MetaDataSetEntity, MetaDataKeyEntity, MetaDataValueEntity } from '../entities/credentialDesign'
+import { MetadataSetEntity, MetadataKeyEntity, MetadataValueEntity } from '../entities/credentialDesign'
 import { DataStoreEntities, DataStoreMigrations } from '../index'
 import {
   credentialDesignBrandingEntityFrom,
   credentialDesignFrom,
-  metaDataKeyEntityFrom,
+  metadataKeyEntityFrom,
   schemaDefinitionEntityFrom,
 } from '../utils/credentialDesign/MappingUtils'
 
@@ -35,13 +35,13 @@ describe('Credential Design entities tests', (): void => {
 
   it('Should save credential design to database', async (): Promise<void> => {
     const design: NonPersistedCredentialDesign = {
-      label: 'TestCredentialDesign',
+      identifier: 'TestCredentialDesign',
       tenantId: 'tenant-entity-test',
-      metaDataKeys: [
+      metadataKeys: [
         {
           key: 'credentialType',
           valueType: ValueType.Text,
-          metaDataValues: [
+          metadataValues: [
             { index: 0, textValue: 'VerifiableCredential' },
             { index: 1, textValue: 'TestCredentialDesign' },
           ],
@@ -49,12 +49,12 @@ describe('Credential Design entities tests', (): void => {
         {
           key: 'credentialFormat',
           valueType: ValueType.Text,
-          metaDataValues: [{ index: 0, textValue: 'jwt_vc_json' }],
+          metadataValues: [{ index: 0, textValue: 'jwt_vc_json' }],
         },
         {
           key: 'advancedSchema',
           valueType: ValueType.Boolean,
-          metaDataValues: [{ index: 0, booleanValue: false }],
+          metadataValues: [{ index: 0, booleanValue: false }],
         },
       ],
       schemaDefinitions: [
@@ -90,15 +90,15 @@ describe('Credential Design entities tests', (): void => {
     }
 
     // Build entity graph using mappers
-    const metaDataSetEntity = new MetaDataSetEntity()
-    metaDataSetEntity.name = design.label
-    metaDataSetEntity.tenantId = design.tenantId
-    metaDataSetEntity.metaDataKeys = design.metaDataKeys!.map(metaDataKeyEntityFrom)
-    metaDataSetEntity.schemaDefinitions = design.schemaDefinitions!.map(schemaDefinitionEntityFrom)
-    metaDataSetEntity.credentialDesignBranding = credentialDesignBrandingEntityFrom(design.branding!)
+    const metadataSetEntity = new MetadataSetEntity()
+    metadataSetEntity.name = design.identifier
+    metadataSetEntity.tenantId = design.tenantId
+    metadataSetEntity.metadataKeys = design.metadataKeys!.map(metadataKeyEntityFrom)
+    metadataSetEntity.schemaDefinitions = design.schemaDefinitions!.map(schemaDefinitionEntityFrom)
+    metadataSetEntity.credentialDesignBranding = credentialDesignBrandingEntityFrom(design.branding!)
 
     // Save to DB
-    const savedEntity = await dbConnection.getRepository(MetaDataSetEntity).save(metaDataSetEntity)
+    const savedEntity = await dbConnection.getRepository(MetadataSetEntity).save(metadataSetEntity)
 
     // Map back to type
     const fromDb = credentialDesignFrom(savedEntity)
@@ -106,35 +106,35 @@ describe('Credential Design entities tests', (): void => {
     // ── Root level ──
     expect(fromDb).toBeDefined()
     expect(fromDb.id).toBeDefined()
-    expect(fromDb.label).toEqual(design.label)
+    expect(fromDb.identifier).toEqual(design.identifier)
     expect(fromDb.tenantId).toEqual(design.tenantId)
 
-    // ── MetaDataKeys ──
-    expect(fromDb.metaDataKeys).toBeDefined()
-    expect(fromDb.metaDataKeys.length).toEqual(3)
+    // ── MetadataKeys ──
+    expect(fromDb.metadataKeys).toBeDefined()
+    expect(fromDb.metadataKeys.length).toEqual(3)
 
-    const credentialTypeKey = fromDb.metaDataKeys.find((k) => k.key === 'credentialType')
+    const credentialTypeKey = fromDb.metadataKeys.find((k) => k.key === 'credentialType')
     expect(credentialTypeKey).toBeDefined()
     expect(credentialTypeKey!.id).toBeDefined()
     expect(credentialTypeKey!.valueType).toEqual(ValueType.Text)
-    expect(credentialTypeKey!.metaDataValues.length).toEqual(2)
-    expect(credentialTypeKey!.metaDataValues[0].id).toBeDefined()
-    expect(credentialTypeKey!.metaDataValues[0].index).toEqual(0)
-    expect(credentialTypeKey!.metaDataValues[0].textValue).toEqual('VerifiableCredential')
-    expect(credentialTypeKey!.metaDataValues[1].index).toEqual(1)
-    expect(credentialTypeKey!.metaDataValues[1].textValue).toEqual('TestCredentialDesign')
-
-    const credentialFormatKey = fromDb.metaDataKeys.find((k) => k.key === 'credentialFormat')
+    expect(credentialTypeKey!.metadataValues.length).toEqual(2)
+    expect(credentialTypeKey!.metadataValues[0].id).toBeDefined()
+    expect(credentialTypeKey!.metadataValues[0].index).toEqual(0)
+    expect(credentialTypeKey!.metadataValues[0].textValue).toEqual('VerifiableCredential')
+    expect(credentialTypeKey!.metadataValues[1].index).toEqual(1)
+    expect(credentialTypeKey!.metadataValues[1].textValue).toEqual('TestCredentialDesign')
+
+    const credentialFormatKey = fromDb.metadataKeys.find((k) => k.key === 'credentialFormat')
     expect(credentialFormatKey).toBeDefined()
     expect(credentialFormatKey!.valueType).toEqual(ValueType.Text)
-    expect(credentialFormatKey!.metaDataValues.length).toEqual(1)
-    expect(credentialFormatKey!.metaDataValues[0].textValue).toEqual('jwt_vc_json')
+    expect(credentialFormatKey!.metadataValues.length).toEqual(1)
+    expect(credentialFormatKey!.metadataValues[0].textValue).toEqual('jwt_vc_json')
 
-    const advancedSchemaKey = fromDb.metaDataKeys.find((k) => k.key === 'advancedSchema')
+    const advancedSchemaKey = fromDb.metadataKeys.find((k) => k.key === 'advancedSchema')
     expect(advancedSchemaKey).toBeDefined()
     expect(advancedSchemaKey!.valueType).toEqual(ValueType.Boolean)
-    expect(advancedSchemaKey!.metaDataValues.length).toEqual(1)
-    expect(advancedSchemaKey!.metaDataValues[0].booleanValue).toEqual(false)
+    expect(advancedSchemaKey!.metadataValues.length).toEqual(1)
+    expect(advancedSchemaKey!.metadataValues[0].booleanValue).toEqual(false)
 
     // ── SchemaDefinitions ──
     expect(fromDb.schemaDefinitions).toBeDefined()
@@ -180,25 +180,25 @@ describe('Credential Design entities tests', (): void => {
     expect(fromDb.branding!.backgroundImage!.dimensions!.height).toEqual(design.branding!.backgroundImage!.dimensions!.height)
   })
 
-  it('should cascade delete keys and values when removing MetaDataSet', async (): Promise<void> => {
-    const metaDataSetEntity = new MetaDataSetEntity()
-    metaDataSetEntity.name = 'cascade_test'
-    metaDataSetEntity.metaDataKeys = [
-      metaDataKeyEntityFrom({
+  it('should cascade delete keys and values when removing MetadataSet', async (): Promise<void> => {
+    const metadataSetEntity = new MetadataSetEntity()
+    metadataSetEntity.name = 'cascade_test'
+    metadataSetEntity.metadataKeys = [
+      metadataKeyEntityFrom({
         key: 'testKey',
         valueType: ValueType.Text,
-        metaDataValues: [{ index: 0, textValue: 'test_value' }],
+        metadataValues: [{ index: 0, textValue: 'test_value' }],
       }),
     ]
-    metaDataSetEntity.schemaDefinitions = []
+    metadataSetEntity.schemaDefinitions = []
 
-    const saved = await dbConnection.getRepository(MetaDataSetEntity).save(metaDataSetEntity)
-    expect(saved.metaDataKeys.length).toEqual(1)
+    const saved = await dbConnection.getRepository(MetadataSetEntity).save(metadataSetEntity)
+    expect(saved.metadataKeys.length).toEqual(1)
 
-    await dbConnection.getRepository(MetaDataSetEntity).remove(saved)
+    await dbConnection.getRepository(MetadataSetEntity).remove(saved)
 
-    const keys = await dbConnection.getRepository(MetaDataKeyEntity).find()
-    const values = await dbConnection.getRepository(MetaDataValueEntity).find()
+    const keys = await dbConnection.getRepository(MetadataKeyEntity).find()
+    const values = await dbConnection.getRepository(MetadataValueEntity).find()
     expect(keys.length).toEqual(0)
     expect(values.length).toEqual(0)
   })