@sphereon/ssi-sdk.data-store 0.34.1-feature.FIDES.1.274 → 0.34.1-feature.IDK.11.49

package/src/__tests__/pd-manager.store.test.ts

@@ -1,46 +1,8 @@
 import { DataSources } from '@sphereon/ssi-sdk.agent-config'
-import { DcqlQuery } from 'dcql'
 import { DataSource } from 'typeorm'
+import { DataStorePresentationDefinitionEntities, DataStorePresentationDefinitionMigrations, PDStore } from '../index'
+import { GetDefinitionsArgs, NonPersistedPresentationDefinitionItem, PresentationDefinitionItem } from '../types'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-import {
-  DataStorePresentationDefinitionEntities,
-  DataStorePresentationDefinitionMigrations,
-  type DeleteDefinitionsArgs,
-  ImportDcqlQueryItem,
-  PDStore,
-} from '../index'
-import { DcqlQueryItem, GetDefinitionsArgs, NonPersistedDcqlQueryItem } from '@sphereon/ssi-sdk.data-store-types'
-
-export const SAMPLE_DCQL_QUERY_IMPORT: ImportDcqlQueryItem = {
-  queryId: 'ajax-club',
-  query: {
-    credentials: [
-      {
-        id: 'clubcard-v1',
-        format: 'dc+sd-jwt',
-        require_cryptographic_holder_binding: true,
-        multiple: false,
-        meta: {
-          vct_values: ['clubcard-v1'],
-        },
-        claims: [
-          {
-            path: ['personData', 'name'],
-          },
-          {
-            path: ['personData', 'birthDate'],
-          },
-          {
-            path: ['membershipData', 'membershipId'],
-          },
-          {
-            path: ['membershipData', 'season'],
-          },
-        ],
-      },
-    ],
-  },
-}
 
 describe('PDStore tests', (): void => {
   let dbConnection: DataSource
@@ -66,148 +28,136 @@ describe('PDStore tests', (): void => {
     await dbConnection.destroy()
   })
 
-  it('should throw error when getting query with unknown id', async (): Promise<void> => {
+  it('should check if definition exists', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
+      version: '1.0',
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
+    }
+    const savedDefinition: PresentationDefinitionItem = await pdStore.addDefinition(definition)
+    expect(savedDefinition).toBeDefined()
+
+    const exists: boolean = await pdStore.hasDefinition({ itemId: savedDefinition.id })
+
+    expect(exists).toBeTruthy()
+  })
+
+  it('should check if definitions exist by filter', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
+      version: '1.0',
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
+    }
+    const savedDefinition: PresentationDefinitionItem = await pdStore.addDefinition(definition)
+    expect(savedDefinition).toBeDefined()
+
+    const exists: boolean = await pdStore.hasDefinitions({ filter: [{ definitionId: 'definition1' }] })
+
+    expect(exists).toBeTruthy()
+  })
+
+  it('should get definition by id', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
+      version: '1.0',
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
+    }
+
+    const savedDefinition: PresentationDefinitionItem = await pdStore.addDefinition(definition)
+    expect(savedDefinition).toBeDefined()
+
+    const result: PresentationDefinitionItem = await pdStore.getDefinition({ itemId: savedDefinition.id })
+
+    expect(result).toBeDefined()
+  })
+
+  it('should throw error when getting definition with unknown id', async (): Promise<void> => {
     const itemId = 'unknownDefinitionId'
 
     await expect(pdStore.getDefinition({ itemId })).rejects.toThrow(`No presentation definition item found for id: ${itemId}`)
   })
 
-  it('should get all queries', async (): Promise<void> => {
-    const definition1: NonPersistedDcqlQueryItem = {
-      queryId: 'definition1',
+  it('should get all definitions', async (): Promise<void> => {
+    const definition1: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
       version: '1.0',
-      query: {
-        credentials: [
-          {
-            id: 'id-card-v1',
-            format: 'dc+sd-jwt',
-            require_cryptographic_holder_binding: true,
-            multiple: false,
-            claims: [
-              {
-                path: ['name'],
-              },
-            ],
-          },
-        ],
-      },
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
     }
-    const savedDefinition1: DcqlQueryItem = await pdStore.addDefinition(definition1)
+    const savedDefinition1: PresentationDefinitionItem = await pdStore.addDefinition(definition1)
     expect(savedDefinition1).toBeDefined()
 
-    const definition2: NonPersistedDcqlQueryItem = {
-      queryId: 'definition2',
+    const definition2: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition2',
       version: '1.0',
-      query: {
-        credentials: [
-          {
-            id: 'driver-license-v1',
-            format: 'dc+sd-jwt',
-            require_cryptographic_holder_binding: true,
-            multiple: false,
-            claims: [
-              {
-                path: ['dateOfBirth'],
-              },
-            ],
-          },
-        ],
-      },
+      definitionPayload: { id: 'definition2', input_descriptors: [] },
     }
-    const savedDefinition2: DcqlQueryItem = await pdStore.addDefinition(definition2)
+    const savedDefinition2: PresentationDefinitionItem = await pdStore.addDefinition(definition2)
     expect(savedDefinition2).toBeDefined()
 
-    const result: Array<DcqlQueryItem> = await pdStore.getDefinitions({})
+    const result: Array<PresentationDefinitionItem> = await pdStore.getDefinitions({})
 
     expect(result).toBeDefined()
     expect(result.length).toEqual(2)
   })
 
-  it('should update dcql query', async (): Promise<void> => {
-    const definition: NonPersistedDcqlQueryItem = {
-      queryId: SAMPLE_DCQL_QUERY_IMPORT.queryId,
+  it('should get definitions by filter', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
       version: '1.0',
-      query: SAMPLE_DCQL_QUERY_IMPORT.query,
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
     }
-    const savedDefinition: DcqlQueryItem = await pdStore.addDefinition(definition)
+    const savedDefinition: PresentationDefinitionItem = await pdStore.addDefinition(definition)
     expect(savedDefinition).toBeDefined()
 
-    const updatedDcqlQuery = DcqlQuery.parse({
-      credentials: [
-        {
-          id: 'updated-clubcard',
-          format: 'dc+sd-jwt',
-          claims: [
-            {
-              path: ['name'],
-            },
-          ],
-        },
-      ],
-    })
-
-    const updatedDefinition: DcqlQueryItem = {
-      ...savedDefinition,
-      version: '1.1',
-      query: updatedDcqlQuery,
+    const args: GetDefinitionsArgs = {
+      filter: [{ definitionId: 'definition1' }],
     }
+    const result: Array<PresentationDefinitionItem> = await pdStore.getDefinitions(args)
 
-    await pdStore.updateDefinition(updatedDefinition)
-    const result: DcqlQueryItem = await pdStore.getDefinition({ itemId: savedDefinition.id })
-
-    expect(result).toBeDefined()
-    expect(result.version).toEqual('1.1')
-    expect(result.query?.credentials[0].id).toEqual('updated-clubcard')
-    expect(result.query?.credentials[0].format).toEqual('dc+sd-jwt')
+    expect(result.length).toEqual(1)
   })
 
-  it('should get dcql queries by id', async (): Promise<void> => {
-    const definition: NonPersistedDcqlQueryItem = {
-      queryId: SAMPLE_DCQL_QUERY_IMPORT.queryId,
+  it('should add definition', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
       version: '1.0',
-      query: SAMPLE_DCQL_QUERY_IMPORT.query,
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
     }
 
-    const savedDefinition: DcqlQueryItem = await pdStore.addDefinition(definition)
-    expect(savedDefinition).toBeDefined()
-
-    const result: DcqlQueryItem = await pdStore.getDefinition({ itemId: savedDefinition.id })
+    const result: PresentationDefinitionItem = await pdStore.addDefinition(definition)
 
     expect(result).toBeDefined()
-    expect(result.query).toBeDefined()
-    expect(result.query.credentials[0].format).toBe('dc+sd-jwt')
-    if (result.query.credentials[0].format === 'dc+sd-jwt') {
-      expect(result.query.credentials[0].meta?.vct_values).toContain('clubcard-v1')
-    }
-    expect(result.query.credentials[0].claims).toHaveLength(4)
+    expect(result.definitionId).toEqual(definition.definitionId)
   })
 
-  it('should get dcql queries by filter', async (): Promise<void> => {
-    const definition: NonPersistedDcqlQueryItem = {
-      queryId: SAMPLE_DCQL_QUERY_IMPORT.queryId,
+  it('should update definition', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
       version: '1.0',
-      query: SAMPLE_DCQL_QUERY_IMPORT.query,
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
     }
-    const savedDefinition: DcqlQueryItem = await pdStore.addDefinition(definition)
+    const savedDefinition: PresentationDefinitionItem = await pdStore.addDefinition(definition)
     expect(savedDefinition).toBeDefined()
 
-    const args: GetDefinitionsArgs = {
-      filter: [{ queryId: 'ajax-club' }],
+    const updatedDefinition: PresentationDefinitionItem = {
+      ...savedDefinition,
+      version: '1.1',
     }
-    const result: Array<DcqlQueryItem> = await pdStore.getDefinitions(args)
 
-    expect(result.length).toEqual(1)
-    expect(result[0].query).toBeDefined()
-    expect(result[0].query.credentials[0].id).toEqual('clubcard-v1')
+    await pdStore.updateDefinition(updatedDefinition)
+    const result: PresentationDefinitionItem = await pdStore.getDefinition({ itemId: savedDefinition.id })
+
+    expect(result).toBeDefined()
+    expect(result.version).toEqual('1.1')
   })
 
-  it('should delete dcql query', async (): Promise<void> => {
-    const definition: NonPersistedDcqlQueryItem = {
-      queryId: 'definition1',
+  it('should delete definition', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
       version: '1.0',
-      query: SAMPLE_DCQL_QUERY_IMPORT.query,
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
     }
-    const savedDefinition: DcqlQueryItem = await pdStore.addDefinition(definition)
+    const savedDefinition: PresentationDefinitionItem = await pdStore.addDefinition(definition)
     expect(savedDefinition).toBeDefined()
 
     await pdStore.deleteDefinition({ itemId: savedDefinition.id })
@@ -217,28 +167,28 @@ describe('PDStore tests', (): void => {
     )
   })
 
-  it('should delete dcql queries by filter', async (): Promise<void> => {
-    const definition1: NonPersistedDcqlQueryItem = {
-      queryId: 'definition1',
+  it('should delete definitions by filter', async (): Promise<void> => {
+    const definition1: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
       version: '1.0',
-      query: SAMPLE_DCQL_QUERY_IMPORT.query,
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
     }
-    const savedDefinition1: DcqlQueryItem = await pdStore.addDefinition(definition1)
+    const savedDefinition1: PresentationDefinitionItem = await pdStore.addDefinition(definition1)
     expect(savedDefinition1).toBeDefined()
 
-    const definition2: NonPersistedDcqlQueryItem = {
-      queryId: 'definition2',
+    const definition2: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition2',
       version: '1.0',
-      query: SAMPLE_DCQL_QUERY_IMPORT.query,
+      definitionPayload: { id: 'definition2', input_descriptors: [] },
     }
-    const savedDefinition2: DcqlQueryItem = await pdStore.addDefinition(definition2)
+    const savedDefinition2: PresentationDefinitionItem = await pdStore.addDefinition(definition2)
     expect(savedDefinition2).toBeDefined()
 
-    const filter = { filter: [{ queryId: 'definition1' }] } satisfies DeleteDefinitionsArgs
+    const filter = { filter: [{ definitionId: 'definition1' }] }
     await pdStore.deleteDefinitions(filter)
 
-    const remainingDefinitions: Array<DcqlQueryItem> = await pdStore.getDefinitions({})
+    const remainingDefinitions: Array<PresentationDefinitionItem> = await pdStore.getDefinitions({})
     expect(remainingDefinitions.length).toEqual(1)
-    expect(remainingDefinitions[0].queryId).toEqual('definition2')
+    expect(remainingDefinitions[0].definitionId).toEqual('definition2')
   })
 })

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

@@ -1,10 +1,10 @@
-import { DataSources } from '@sphereon/ssi-sdk.agent-config'
-import { IIssuer, StatusListCredentialIdMode, StatusListDriverType } from '@sphereon/ssi-types'
 import { DataSource } from 'typeorm'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-import { OAuthStatusListEntity, StatusList2021Entity } from '../entities/statusList/StatusListEntities'
+import { DataSources } from '@sphereon/ssi-sdk.agent-config'
 import { BitstringStatusListEntity, BitstringStatusListEntryEntity, DataStoreStatusListEntities, StatusListEntryEntity } from '../index'
 import { DataStoreStatusListMigrations } from '../migrations'
+import { OAuthStatusListEntity, StatusList2021Entity } from '../entities/statusList/StatusListEntities'
+import { IIssuer, StatusListCredentialIdMode, StatusListDriverType } from '@sphereon/ssi-types'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 
 describe('Status list entities tests', () => {
   let dbConnection: DataSource

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

@@ -1,11 +1,11 @@
-import { DataSources } from '@sphereon/ssi-sdk.agent-config'
-import { StatusListCredentialIdMode, StatusListDriverType, StatusListType } from '@sphereon/ssi-types'
 import { DataSource } from 'typeorm'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { DataSources } from '@sphereon/ssi-sdk.agent-config'
 import { DataStoreStatusListEntities, IBitstringStatusListEntity } from '../index'
 import { DataStoreStatusListMigrations } from '../migrations'
 import { StatusListStore } from '../statusList/StatusListStore'
 import { IOAuthStatusListEntity, IStatusList2021Entity, IStatusListEntryEntity } from '../types'
+import { StatusListCredentialIdMode, StatusListDriverType, StatusListType } from '@sphereon/ssi-types'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 
 describe('Status list store tests', () => {
   let dbConnection: DataSource

package/src/contact/AbstractContactStore.ts

@@ -0,0 +1,71 @@
+import {
+  AddElectronicAddressArgs,
+  AddIdentityArgs,
+  AddPartyArgs,
+  AddPartyTypeArgs,
+  AddPhysicalAddressArgs,
+  AddRelationshipArgs,
+  ElectronicAddress,
+  GetElectronicAddressArgs,
+  GetElectronicAddressesArgs,
+  GetIdentitiesArgs,
+  GetIdentityArgs,
+  GetPartiesArgs,
+  GetPartyArgs,
+  GetPartyTypeArgs,
+  GetPartyTypesArgs,
+  GetPhysicalAddressArgs,
+  GetPhysicalAddressesArgs,
+  GetRelationshipArgs,
+  GetRelationshipsArgs,
+  Identity,
+  Party,
+  PartyRelationship,
+  PartyType,
+  PhysicalAddress,
+  RemoveElectronicAddressArgs,
+  RemoveIdentityArgs,
+  RemovePartyArgs,
+  RemovePartyTypeArgs,
+  RemovePhysicalAddressArgs,
+  RemoveRelationshipArgs,
+  UpdateElectronicAddressArgs,
+  UpdateIdentityArgs,
+  UpdatePartyArgs,
+  UpdatePartyTypeArgs,
+  UpdatePhysicalAddressArgs,
+  UpdateRelationshipArgs,
+} from '../types'
+
+export abstract class AbstractContactStore {
+  abstract getParty(args: GetPartyArgs): Promise<Party>
+  abstract getParties(args?: GetPartiesArgs): Promise<Array<Party>>
+  abstract addParty(args: AddPartyArgs): Promise<Party>
+  abstract updateParty(args: UpdatePartyArgs): Promise<Party>
+  abstract removeParty(args: RemovePartyArgs): Promise<void>
+  abstract getIdentity(args: GetIdentityArgs): Promise<Identity>
+  abstract getIdentities(args?: GetIdentitiesArgs): Promise<Array<Identity>>
+  abstract addIdentity(args: AddIdentityArgs): Promise<Identity>
+  abstract updateIdentity(args: UpdateIdentityArgs): Promise<Identity>
+  abstract removeIdentity(args: RemoveIdentityArgs): Promise<void>
+  abstract getRelationship(args: GetRelationshipArgs): Promise<PartyRelationship>
+  abstract getRelationships(args?: GetRelationshipsArgs): Promise<Array<PartyRelationship>>
+  abstract addRelationship(args: AddRelationshipArgs): Promise<PartyRelationship>
+  abstract updateRelationship(args: UpdateRelationshipArgs): Promise<PartyRelationship>
+  abstract removeRelationship(args: RemoveRelationshipArgs): Promise<void>
+  abstract getPartyType(args: GetPartyTypeArgs): Promise<PartyType>
+  abstract getPartyTypes(args?: GetPartyTypesArgs): Promise<Array<PartyType>>
+  abstract addPartyType(args: AddPartyTypeArgs): Promise<PartyType>
+  abstract updatePartyType(args: UpdatePartyTypeArgs): Promise<PartyType>
+  abstract removePartyType(args: RemovePartyTypeArgs): Promise<void>
+  abstract getElectronicAddress(args: GetElectronicAddressArgs): Promise<ElectronicAddress>
+  abstract getElectronicAddresses(args?: GetElectronicAddressesArgs): Promise<Array<ElectronicAddress>>
+  abstract addElectronicAddress(args: AddElectronicAddressArgs): Promise<ElectronicAddress>
+  abstract updateElectronicAddress(args: UpdateElectronicAddressArgs): Promise<ElectronicAddress>
+  abstract removeElectronicAddress(args: RemoveElectronicAddressArgs): Promise<void>
+  abstract getPhysicalAddress(args: GetPhysicalAddressArgs): Promise<PhysicalAddress>
+  abstract getPhysicalAddresses(args?: GetPhysicalAddressesArgs): Promise<Array<PhysicalAddress>>
+  abstract addPhysicalAddress(args: AddPhysicalAddressArgs): Promise<PhysicalAddress>
+  abstract updatePhysicalAddress(args: UpdatePhysicalAddressArgs): Promise<PhysicalAddress>
+  abstract removePhysicalAddress(args: RemovePhysicalAddressArgs): Promise<void>
+}

package/src/contact/ContactStore.ts

@@ -1,5 +1,37 @@
+import { OrPromise } from '@sphereon/ssi-types'
+import { BaseEntity, DataSource, type FindOptionsWhere, In, type Repository } from 'typeorm'
+import Debug from 'debug'
+import { AbstractContactStore } from './AbstractContactStore'
+import { PartyEntity } from '../entities/contact/PartyEntity'
+import { IdentityEntity } from '../entities/contact/IdentityEntity'
+import { IdentityMetadataItemEntity } from '../entities/contact/IdentityMetadataItemEntity'
+import { CorrelationIdentifierEntity } from '../entities/contact/CorrelationIdentifierEntity'
+import { ConnectionEntity } from '../entities/contact/ConnectionEntity'
+import { BaseConfigEntity } from '../entities/contact/BaseConfigEntity'
+import { PartyRelationshipEntity } from '../entities/contact/PartyRelationshipEntity'
+import { PartyTypeEntity } from '../entities/contact/PartyTypeEntity'
+import { BaseContactEntity } from '../entities/contact/BaseContactEntity'
+import { ElectronicAddressEntity } from '../entities/contact/ElectronicAddressEntity'
+import { PhysicalAddressEntity } from '../entities/contact/PhysicalAddressEntity'
+import {
+  electronicAddressEntityFrom,
+  electronicAddressFrom,
+  identityEntityFrom,
+  identityFrom,
+  isDidAuthConfig,
+  isNaturalPerson,
+  isOpenIdConfig,
+  isOrganization,
+  partyEntityFrom,
+  partyFrom,
+  partyRelationshipEntityFrom,
+  partyRelationshipFrom,
+  partyTypeEntityFrom,
+  partyTypeFrom,
+  physicalAddressEntityFrom,
+  physicalAddressFrom,
+} from '../utils/contact/MappingUtils'
 import {
-  AbstractContactStore,
   AddElectronicAddressArgs,
   AddIdentityArgs,
   AddPartyArgs,
@@ -21,8 +53,8 @@ import {
   GetPhysicalAddressesArgs,
   GetRelationshipArgs,
   GetRelationshipsArgs,
-  Identity,
   IMetadataEntity,
+  Identity,
   MetadataItem,
   MetadataTypes,
   NonPersistedConnectionConfig,
@@ -44,39 +76,7 @@ import {
   UpdatePartyTypeArgs,
   UpdatePhysicalAddressArgs,
   UpdateRelationshipArgs,
-} from '@sphereon/ssi-sdk.data-store-types'
-import { OrPromise } from '@sphereon/ssi-types'
-import Debug from 'debug'
-import { BaseEntity, DataSource, type FindOptionsWhere, In, type Repository } from 'typeorm'
-import { BaseConfigEntity } from '../entities/contact/BaseConfigEntity'
-import { BaseContactEntity } from '../entities/contact/BaseContactEntity'
-import { ConnectionEntity } from '../entities/contact/ConnectionEntity'
-import { CorrelationIdentifierEntity } from '../entities/contact/CorrelationIdentifierEntity'
-import { ElectronicAddressEntity } from '../entities/contact/ElectronicAddressEntity'
-import { IdentityEntity } from '../entities/contact/IdentityEntity'
-import { IdentityMetadataItemEntity } from '../entities/contact/IdentityMetadataItemEntity'
-import { PartyEntity } from '../entities/contact/PartyEntity'
-import { PartyRelationshipEntity } from '../entities/contact/PartyRelationshipEntity'
-import { PartyTypeEntity } from '../entities/contact/PartyTypeEntity'
-import { PhysicalAddressEntity } from '../entities/contact/PhysicalAddressEntity'
-import {
-  electronicAddressEntityFrom,
-  electronicAddressFrom,
-  identityEntityFrom,
-  identityFrom,
-  isDidAuthConfig,
-  isNaturalPerson,
-  isOpenIdConfig,
-  isOrganization,
-  partyEntityFrom,
-  partyFrom,
-  partyRelationshipEntityFrom,
-  partyRelationshipFrom,
-  partyTypeEntityFrom,
-  partyTypeFrom,
-  physicalAddressEntityFrom,
-  physicalAddressFrom,
-} from '../utils/contact/MappingUtils'
+} from '../types'
 
 const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:contact-store')
 

package/src/digitalCredential/AbstractDigitalCredentialStore.ts

@@ -0,0 +1,21 @@
+import {
+  AddCredentialArgs,
+  DigitalCredential,
+  GetCredentialArgs,
+  GetCredentialsArgs,
+  GetCredentialsResponse,
+  RemoveCredentialArgs,
+  UpdateCredentialStateArgs,
+} from '../types'
+
+export abstract class AbstractDigitalCredentialStore {
+  abstract getCredential(args: GetCredentialArgs): Promise<DigitalCredential>
+
+  abstract getCredentials(args?: GetCredentialsArgs): Promise<GetCredentialsResponse>
+
+  abstract addCredential(args: AddCredentialArgs): Promise<DigitalCredential>
+
+  abstract updateCredentialState(args: UpdateCredentialStateArgs): Promise<DigitalCredential>
+
+  abstract removeCredential(args: RemoveCredentialArgs): Promise<boolean>
+}

package/src/digitalCredential/DigitalCredentialStore.ts

@@ -1,6 +1,7 @@
+import { AbstractDigitalCredentialStore } from './AbstractDigitalCredentialStore'
 import {
-  AbstractDigitalCredentialStore,
   AddCredentialArgs,
+  CredentialRole,
   CredentialStateType,
   DigitalCredential,
   GetCredentialArgs,
@@ -9,13 +10,13 @@ import {
   NonPersistedDigitalCredential,
   RemoveCredentialArgs,
   UpdateCredentialStateArgs,
-} from '@sphereon/ssi-sdk.data-store-types'
-import { CredentialRole, OrPromise } from '@sphereon/ssi-types'
-import Debug from 'debug'
+} from '../types'
+import { OrPromise } from '@sphereon/ssi-types'
 import { DataSource, type FindOptionsOrder, type FindOptionsWhere, Repository } from 'typeorm'
+import Debug from 'debug'
+import { DigitalCredentialEntity } from '../entities/digitalCredential/DigitalCredentialEntity'
 
 import { digitalCredentialFrom, digitalCredentialsFrom, nonPersistedDigitalCredentialEntityFromAddArgs } from '../../src'
-import { DigitalCredentialEntity } from '../entities/digitalCredential/DigitalCredentialEntity'
 import { parseAndValidateOrderOptions } from '../utils/SortingUtils'
 
 const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:credential-store')
@@ -77,7 +78,7 @@ export class DigitalCredentialStore extends AbstractDigitalCredentialStore {
       return false
     }
 
-    const query: FindOptionsWhere<DigitalCredentialEntity> = {}
+    let query: FindOptionsWhere<DigitalCredentialEntity> = {}
 
     if ('id' in args) {
       query.id = args.id

package/src/entities/contact/BaseConfigEntity.ts

@@ -1,5 +1,5 @@
-import { BaseEntity, Entity, JoinColumn, OneToOne, PrimaryGeneratedColumn, TableInheritance } from 'typeorm'
-
+import typeorm from 'typeorm'
+const { BaseEntity, Entity, JoinColumn, OneToOne, PrimaryGeneratedColumn, TableInheritance } = typeorm
 import { ConnectionEntity } from './ConnectionEntity'
 
 @Entity('BaseConfig')

package/src/entities/contact/BaseContactEntity.ts

@@ -1,5 +1,5 @@
-import { typeOrmDateTime } from '@sphereon/ssi-sdk.agent-config'
-import {
+import typeorm from 'typeorm'
+const {
   BaseEntity,
   BeforeInsert,
   BeforeUpdate,
@@ -11,9 +11,10 @@ import {
   PrimaryGeneratedColumn,
   TableInheritance,
   UpdateDateColumn,
-} from 'typeorm'
-import { ContactMetadataItemEntity } from './ContactMetadataItemEntity'
+} = typeorm
+import { typeOrmDateTime } from '@sphereon/ssi-sdk.agent-config'
 import { PartyEntity } from './PartyEntity'
+import { ContactMetadataItemEntity } from './ContactMetadataItemEntity'
 
 @Entity('BaseContact')
 @TableInheritance({ column: { type: 'varchar', name: 'type' } })

package/src/entities/contact/ConnectionEntity.ts

@@ -1,10 +1,10 @@
-import { ConnectionType } from '@sphereon/ssi-sdk.data-store-types'
-import { BaseEntity, Column, Entity, JoinColumn, OneToOne, PrimaryGeneratedColumn } from 'typeorm'
-
+import typeorm from 'typeorm'
+const { Entity, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn, BaseEntity } = typeorm
 import { BaseConfigEntity } from './BaseConfigEntity'
-import { DidAuthConfigEntity } from './DidAuthConfigEntity'
+import { ConnectionType } from '../../types'
 import { IdentityEntity } from './IdentityEntity'
 import { OpenIdConfigEntity } from './OpenIdConfigEntity'
+import { DidAuthConfigEntity } from './DidAuthConfigEntity'
 
 @Entity('Connection')
 export class ConnectionEntity extends BaseEntity {

package/src/entities/contact/ContactMetadataItemEntity.ts

@@ -1,9 +1,10 @@
+import typeorm from 'typeorm'
+const { Entity, Column, PrimaryGeneratedColumn, BaseEntity, ManyToOne, BeforeInsert, BeforeUpdate } = typeorm
+import { IMetadataEntity, ValidationConstraint } from '../../types'
 import { typeOrmDateTime } from '@sphereon/ssi-sdk.agent-config'
-import { IMetadataEntity, ValidationConstraint } from '@sphereon/ssi-sdk.data-store-types'
+import { BaseContactEntity } from './BaseContactEntity'
 import { IsNotEmpty, validate, ValidationError } from 'class-validator'
-import { BaseEntity, BeforeInsert, BeforeUpdate, Column, Entity, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
 import { getConstraint } from '../../utils/ValidatorUtils'
-import { BaseContactEntity } from './BaseContactEntity'
 
 @Entity('ContactMetadata')
 export class ContactMetadataItemEntity extends BaseEntity implements IMetadataEntity {

package/src/entities/contact/CorrelationIdentifierEntity.ts

@@ -1,8 +1,9 @@
-import { CorrelationIdentifierType, ValidationConstraint } from '@sphereon/ssi-sdk.data-store-types'
+import typeorm from 'typeorm'
+const { Entity, Column, PrimaryGeneratedColumn, BaseEntity, OneToOne, JoinColumn, BeforeInsert, BeforeUpdate } = typeorm
+import { CorrelationIdentifierType, ValidationConstraint } from '../../types'
+import { IdentityEntity } from './IdentityEntity'
 import { IsNotEmpty, validate, ValidationError } from 'class-validator'
-import { BaseEntity, BeforeInsert, BeforeUpdate, Column, Entity, JoinColumn, OneToOne, PrimaryGeneratedColumn } from 'typeorm'
 import { getConstraint } from '../../utils/ValidatorUtils'
-import { IdentityEntity } from './IdentityEntity'
 
 @Entity('CorrelationIdentifier')
 export class CorrelationIdentifierEntity extends BaseEntity {

package/src/entities/contact/DidAuthConfigEntity.ts

@@ -1,4 +1,5 @@
-import { ChildEntity, Column } from 'typeorm'
+import typeorm from 'typeorm'
+const { ChildEntity, Column } = typeorm
 import { BaseConfigEntity } from './BaseConfigEntity'
 
 @ChildEntity('DidAuthConfig')