@sphereon/ssi-sdk.data-store 0.34.1-feature.SSISDK.57.uni.client.169 → 0.34.1-feature.SSISDK.57.uni.client.203

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sphereon/ssi-sdk.data-store",
-  "version": "0.34.1-feature.SSISDK.57.uni.client.169+6401d3e9",
+  "version": "0.34.1-feature.SSISDK.57.uni.client.203+70e8e76c",
   "source": "src/index.ts",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -28,11 +28,11 @@
   "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.57.uni.client.169+6401d3e9",
-    "@sphereon/ssi-sdk-ext.identifier-resolution": "0.34.1-feature.SSISDK.57.uni.client.169+6401d3e9",
-    "@sphereon/ssi-sdk.agent-config": "0.34.1-feature.SSISDK.57.uni.client.169+6401d3e9",
-    "@sphereon/ssi-sdk.core": "0.34.1-feature.SSISDK.57.uni.client.169+6401d3e9",
-    "@sphereon/ssi-types": "0.34.1-feature.SSISDK.57.uni.client.169+6401d3e9",
+    "@sphereon/ssi-sdk-ext.did-utils": "0.34.1-feature.SSISDK.57.uni.client.203+70e8e76c",
+    "@sphereon/ssi-sdk-ext.identifier-resolution": "0.34.1-feature.SSISDK.57.uni.client.203+70e8e76c",
+    "@sphereon/ssi-sdk.agent-config": "0.34.1-feature.SSISDK.57.uni.client.203+70e8e76c",
+    "@sphereon/ssi-sdk.core": "0.34.1-feature.SSISDK.57.uni.client.203+70e8e76c",
+    "@sphereon/ssi-types": "0.34.1-feature.SSISDK.57.uni.client.203+70e8e76c",
     "@veramo/core": "4.2.0",
     "@veramo/utils": "4.2.0",
     "blakejs": "^1.2.1",
@@ -65,5 +65,5 @@
     "PostgreSQL",
     "Contact Store"
   ],
-  "gitHead": "6401d3e9674ee70ca653677f51449e75b1dde671"
+  "gitHead": "70e8e76c1e91a68a49f9251002a11ad861c9f72f"
 }

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

@@ -6,7 +6,7 @@ import { DataStorePresentationDefinitionEntities } from '../index'
 import { DataStorePresentationDefinitionMigrations } from '../migrations'
 import { SAMPLE_DCQL_QUERY_IMPORT } from './pd-manager.store.test'
 
-describe('PresentationDefinitionItemEntity tests', (): void => {
+describe('DcqlQueryItemEntity tests', (): void => {
   let dbConnection: DataSource
 
   beforeEach(async (): Promise<void> => {
@@ -26,34 +26,34 @@ describe('PresentationDefinitionItemEntity tests', (): void => {
     await dbConnection.destroy()
   })
 
-  it('should create and retrieve PresentationDefinitionItemEntity with dcqlPayload', async (): Promise<void> => {
+  it('should create and retrieve DcqlQueryItemEntity', async (): Promise<void> => {
     const repository = dbConnection.getRepository(DcqlQueryItemEntity)
     const entity = new DcqlQueryItemEntity()
     entity.queryId = 'ajax-club'
     entity.version = '1.0'
-    entity.dcqlPayload = JSON.stringify(SAMPLE_DCQL_QUERY_IMPORT.dcqlQuery)
+    entity.query = JSON.stringify(SAMPLE_DCQL_QUERY_IMPORT.query)
 
     const savedEntity = await repository.save(entity)
     expect(savedEntity).toBeDefined()
     expect(savedEntity.id).toBeDefined()
-    expect(savedEntity.dcqlPayload).toBeDefined()
+    expect(savedEntity.query).toBeDefined()
 
     const retrievedEntity = await repository.findOneBy({ id: savedEntity.id })
     expect(retrievedEntity).toBeDefined()
-    expect(retrievedEntity!.dcqlPayload).toBeDefined()
-    const parsedDcql = JSON.parse(retrievedEntity!.dcqlPayload)
+    expect(retrievedEntity!.query).toBeDefined()
+    const parsedDcql = JSON.parse(retrievedEntity!.query)
     expect(parsedDcql.credentials[0].id).toEqual('clubcard-v1')
     expect(parsedDcql.credentials[0].format).toEqual('dc+sd-jwt')
     expect(parsedDcql.credentials[0].meta.vct_values).toContain('clubcard-v1')
     expect(parsedDcql.credentials[0].claims).toHaveLength(4)
   })
 
-  it('should update PresentationDefinitionItemEntity dcqlPayload', async (): Promise<void> => {
+  it('should update DcqlQueryItemEntity dcql query', async (): Promise<void> => {
     const repository = dbConnection.getRepository(DcqlQueryItemEntity)
     const entity = new DcqlQueryItemEntity()
     entity.queryId = 'ajax-club'
     entity.version = '1.0'
-    entity.dcqlPayload = JSON.stringify(SAMPLE_DCQL_QUERY_IMPORT.dcqlQuery)
+    entity.query = JSON.stringify(SAMPLE_DCQL_QUERY_IMPORT.query)
 
     const savedEntity = await repository.save(entity)
     expect(savedEntity).toBeDefined()
@@ -71,10 +71,10 @@ describe('PresentationDefinitionItemEntity tests', (): void => {
         },
       ],
     }
-    savedEntity.dcqlPayload = JSON.stringify(updatedDcql)
+    savedEntity.query = JSON.stringify(updatedDcql)
     const updatedEntity = await repository.save(savedEntity)
     expect(updatedEntity).toBeDefined()
-    expect(JSON.parse(updatedEntity.dcqlPayload).credentials[0].id).toEqual('updated-clubcard')
-    expect(JSON.parse(updatedEntity.dcqlPayload).credentials[0].format).toEqual('jwt_vc')
+    expect(JSON.parse(updatedEntity.query).credentials[0].id).toEqual('updated-clubcard')
+    expect(JSON.parse(updatedEntity.query).credentials[0].format).toEqual('jwt_vc')
   })
 })

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

@@ -13,7 +13,7 @@ import { DcqlQueryItem, GetDefinitionsArgs, NonPersistedDcqlQueryItem } from '..
 
 export const SAMPLE_DCQL_QUERY_IMPORT: ImportDcqlQueryItem = {
   queryId: 'ajax-club',
-  dcqlQuery: {
+  query: {
     credentials: [
       {
         id: 'clubcard-v1',
@@ -66,17 +66,68 @@ describe('PDStore tests', (): void => {
     await dbConnection.destroy()
   })
 
-  it('should throw error when getting definition with unknown id', async (): Promise<void> => {
+  it('should throw error when getting query 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 update definition with dcqlPayload', async (): Promise<void> => {
+  it('should get all queries', async (): Promise<void> => {
+    const definition1: NonPersistedDcqlQueryItem = {
+      queryId: 'definition1',
+      version: '1.0',
+      query: {
+        credentials: [
+          {
+            id: 'id-card-v1',
+            format: 'dc+sd-jwt',
+            require_cryptographic_holder_binding: true,
+            multiple: false,
+            claims: [
+              {
+                path: ['name'],
+              },
+            ],
+          },
+        ],
+      },
+    }
+    const savedDefinition1: DcqlQueryItem = await pdStore.addDefinition(definition1)
+    expect(savedDefinition1).toBeDefined()
+
+    const definition2: NonPersistedDcqlQueryItem = {
+      queryId: 'definition2',
+      version: '1.0',
+      query: {
+        credentials: [
+          {
+            id: 'driver-license-v1',
+            format: 'dc+sd-jwt',
+            require_cryptographic_holder_binding: true,
+            multiple: false,
+            claims: [
+              {
+                path: ['dateOfBirth'],
+              },
+            ],
+          },
+        ],
+      },
+    }
+    const savedDefinition2: DcqlQueryItem = await pdStore.addDefinition(definition2)
+    expect(savedDefinition2).toBeDefined()
+
+    const result: Array<DcqlQueryItem> = 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,
       version: '1.0',
-      dcqlQuery: SAMPLE_DCQL_QUERY_IMPORT.dcqlQuery,
+      query: SAMPLE_DCQL_QUERY_IMPORT.query,
     }
     const savedDefinition: DcqlQueryItem = await pdStore.addDefinition(definition)
     expect(savedDefinition).toBeDefined()
@@ -98,7 +149,7 @@ describe('PDStore tests', (): void => {
     const updatedDefinition: DcqlQueryItem = {
       ...savedDefinition,
       version: '1.1',
-      dcqlQuery: updatedDcqlQuery,
+      query: updatedDcqlQuery,
     }
 
     await pdStore.updateDefinition(updatedDefinition)
@@ -106,15 +157,15 @@ describe('PDStore tests', (): void => {
 
     expect(result).toBeDefined()
     expect(result.version).toEqual('1.1')
-    expect(result.dcqlQuery?.credentials[0].id).toEqual('updated-clubcard')
-    expect(result.dcqlQuery?.credentials[0].format).toEqual('dc+sd-jwt')
+    expect(result.query?.credentials[0].id).toEqual('updated-clubcard')
+    expect(result.query?.credentials[0].format).toEqual('dc+sd-jwt')
   })
 
-  it('should get definition with dcqlPayload by id', async (): Promise<void> => {
+  it('should get dcql queries by id', async (): Promise<void> => {
     const definition: NonPersistedDcqlQueryItem = {
       queryId: SAMPLE_DCQL_QUERY_IMPORT.queryId,
       version: '1.0',
-      dcqlQuery: SAMPLE_DCQL_QUERY_IMPORT.dcqlQuery,
+      query: SAMPLE_DCQL_QUERY_IMPORT.query,
     }
 
     const savedDefinition: DcqlQueryItem = await pdStore.addDefinition(definition)
@@ -123,19 +174,19 @@ describe('PDStore tests', (): void => {
     const result: DcqlQueryItem = await pdStore.getDefinition({ itemId: savedDefinition.id })
 
     expect(result).toBeDefined()
-    expect(result.dcqlQuery).toBeDefined()
-    expect(result.dcqlQuery.credentials[0].format).toBe('dc+sd-jwt')
-    if (result.dcqlQuery.credentials[0].format === 'dc+sd-jwt') {
-      expect(result.dcqlQuery.credentials[0].meta?.vct_values).toContain('clubcard-v1')
+    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.dcqlQuery.credentials[0].claims).toHaveLength(4)
+    expect(result.query.credentials[0].claims).toHaveLength(4)
   })
 
-  it('should get definitions with dcqlPayload by filter', async (): Promise<void> => {
+  it('should get dcql queries by filter', async (): Promise<void> => {
     const definition: NonPersistedDcqlQueryItem = {
       queryId: SAMPLE_DCQL_QUERY_IMPORT.queryId,
       version: '1.0',
-      dcqlQuery: SAMPLE_DCQL_QUERY_IMPORT.dcqlQuery,
+      query: SAMPLE_DCQL_QUERY_IMPORT.query,
     }
     const savedDefinition: DcqlQueryItem = await pdStore.addDefinition(definition)
     expect(savedDefinition).toBeDefined()
@@ -146,15 +197,15 @@ describe('PDStore tests', (): void => {
     const result: Array<DcqlQueryItem> = await pdStore.getDefinitions(args)
 
     expect(result.length).toEqual(1)
-    expect(result[0].dcqlQuery).toBeDefined()
-    expect(result[0].dcqlQuery.credentials[0].id).toEqual('clubcard-v1')
+    expect(result[0].query).toBeDefined()
+    expect(result[0].query.credentials[0].id).toEqual('clubcard-v1')
   })
 
-  it('should delete query', async (): Promise<void> => {
+  it('should delete dcql query', async (): Promise<void> => {
     const definition: NonPersistedDcqlQueryItem = {
       queryId: 'definition1',
       version: '1.0',
-      dcqlQuery: SAMPLE_DCQL_QUERY_IMPORT.dcqlQuery,
+      query: SAMPLE_DCQL_QUERY_IMPORT.query,
     }
     const savedDefinition: DcqlQueryItem = await pdStore.addDefinition(definition)
     expect(savedDefinition).toBeDefined()
@@ -166,11 +217,11 @@ describe('PDStore tests', (): void => {
     )
   })
 
-  it('should delete queries by filter', async (): Promise<void> => {
+  it('should delete dcql queries by filter', async (): Promise<void> => {
     const definition1: NonPersistedDcqlQueryItem = {
       queryId: 'definition1',
       version: '1.0',
-      dcqlQuery: SAMPLE_DCQL_QUERY_IMPORT.dcqlQuery,
+      query: SAMPLE_DCQL_QUERY_IMPORT.query,
     }
     const savedDefinition1: DcqlQueryItem = await pdStore.addDefinition(definition1)
     expect(savedDefinition1).toBeDefined()
@@ -178,7 +229,7 @@ describe('PDStore tests', (): void => {
     const definition2: NonPersistedDcqlQueryItem = {
       queryId: 'definition2',
       version: '1.0',
-      dcqlQuery: SAMPLE_DCQL_QUERY_IMPORT.dcqlQuery,
+      query: SAMPLE_DCQL_QUERY_IMPORT.query,
     }
     const savedDefinition2: DcqlQueryItem = await pdStore.addDefinition(definition2)
     expect(savedDefinition2).toBeDefined()

package/src/entities/presentationDefinition/DcqlQueryItemEntity.ts

@@ -25,9 +25,9 @@ export class DcqlQueryItemEntity extends BaseEntity {
   @Column({ name: 'name', length: 255, type: 'varchar', nullable: true, unique: false })
   name?: string
 
-  @Column({ name: 'dcql_payload', type: 'text', nullable: false, unique: false })
+  @Column({ name: 'query', type: 'text', nullable: false, unique: false })
   @IsNotEmpty({ message: 'A blank dcql query payload field is not allowed' })
-  dcqlPayload!: string
+  query!: string
 
   @CreateDateColumn({ name: 'created_at', nullable: false, type: typeOrmDateTime() })
   createdAt!: Date

package/src/migrations/postgres/1716475165345-CreatePresentationDefinitions.ts

@@ -13,7 +13,7 @@ CREATE TABLE "PresentationDefinitionItem" (
     "version" TEXT NOT NULL, 
     "purpose" TEXT, 
     "definition_payload" TEXT NOT NULL, 
-    "dcql_payload" TEXT, 
+    "query" TEXT, 
     "created_at" TIMESTAMP NOT NULL DEFAULT now(), 
     "last_updated_at" TIMESTAMP NOT NULL DEFAULT now(), 
     CONSTRAINT "PK_PresentationDefinitionItem_id" PRIMARY KEY ("id"))

package/src/migrations/postgres/1726588800000-CreateDcqlQueryItem.ts

@@ -12,7 +12,7 @@ export class CreateDcqlQueryItemPG1726588800000 implements MigrationInterface {
                                      "name" TEXT,
                                      "version" TEXT NOT NULL,
                                      "purpose" TEXT,
-                                     "dcql_payload" TEXT NOT NULL,
+                                     "query" TEXT NOT NULL,
                                      "created_at" TIMESTAMP NOT NULL DEFAULT now(),
                                      "last_updated_at" TIMESTAMP NOT NULL DEFAULT now(),
                                      CONSTRAINT "PK_DcqlQueryItem_id" PRIMARY KEY ("id"))

package/src/migrations/sqlite/1716475165344-CreatePresentationDefinitions.ts

@@ -13,7 +13,7 @@ export class CreatePresentationDefinitions1716475165344 implements MigrationInte
     "version" varchar NOT NULL,
     "purpose" varchar,
     "definition_payload" varchar NOT NULL,
-    "dcql_payload" varchar,
+    "query" varchar,
     "created_at" datetime NOT NULL DEFAULT (datetime('now')),
     "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')))`,
     )

package/src/migrations/sqlite/1726617600000-CreateDcqlQueryItem.ts

@@ -12,7 +12,7 @@ export class CreateDcqlQueryItemSQlite1726617600000 implements MigrationInterfac
                                       "name" varchar,
                                       "version" varchar NOT NULL,
                                       "purpose" varchar,
-                                      "dcql_payload" varchar NOT NULL,
+                                      "query" varchar NOT NULL,
                                       "created_at" datetime NOT NULL DEFAULT (datetime('now')),
                                       "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')))`,
     )

package/src/presentationDefinition/PDStore.ts

@@ -14,7 +14,7 @@ import type {
   DcqlQueryItemFilter,
 } from '../types'
 import { DcqlQueryItemEntity } from '../entities/presentationDefinition/DcqlQueryItemEntity'
-import { presentationDefinitionEntityItemFrom, presentationDefinitionItemFrom } from '../utils/presentationDefinition/MappingUtils'
+import { dcqlQueryEntityItemFrom, dcqlQueryItemFrom } from '../utils/presentationDefinition/MappingUtils'
 
 const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:pd-store')
 
@@ -36,7 +36,7 @@ export class PDStore extends AbstractPDStore {
       return Promise.reject(Error(`No presentation definition item found for id: ${itemId}`))
     }
 
-    return presentationDefinitionItemFrom(result)
+    return dcqlQueryItemFrom(result)
   }
 
   hasDefinition = async (args: HasDefinitionArgs): Promise<boolean> => {
@@ -73,19 +73,19 @@ export class PDStore extends AbstractPDStore {
       },
     })
 
-    return result.map((entity: DcqlQueryItemEntity) => presentationDefinitionItemFrom(entity))
+    return result.map((entity: DcqlQueryItemEntity) => dcqlQueryItemFrom(entity))
   }
 
   addDefinition = async (item: NonPersistedDcqlQueryItem): Promise<DcqlQueryItem> => {
     const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
 
-    const entity: DcqlQueryItemEntity = presentationDefinitionEntityItemFrom(item)
+    const entity: DcqlQueryItemEntity = dcqlQueryEntityItemFrom(item)
     debug('Adding presentation definition entity', item)
     const result: DcqlQueryItemEntity = await pdRepository.save(entity, {
       transaction: true,
     })
 
-    return presentationDefinitionItemFrom(result)
+    return dcqlQueryItemFrom(result)
   }
 
   updateDefinition = async (item: DcqlQueryItem): Promise<DcqlQueryItem> => {
@@ -106,14 +106,14 @@ export class PDStore extends AbstractPDStore {
     updatedEntity.version = item.version
     updatedEntity.name = item.name
     updatedEntity.purpose = item.purpose
-    updatedEntity.dcqlPayload = JSON.stringify(item.dcqlQuery)
+    updatedEntity.query = JSON.stringify(item.query)
 
     debug('Updating presentation definition entity', updatedEntity)
     const updateResult: DcqlQueryItemEntity = await pdRepository.save(updatedEntity, {
       transaction: true,
     })
 
-    return presentationDefinitionItemFrom(updateResult)
+    return dcqlQueryItemFrom(updateResult)
   }
 
   deleteDefinition = async (args: DeleteDefinitionArgs): Promise<void> => {

package/src/types/presentationDefinition/presentationDefinition.ts

@@ -7,7 +7,7 @@ export type DcqlQueryItem = {
   version: string
   name?: string
   purpose?: string
-  dcqlQuery: DcqlQuery
+  query: DcqlQuery
   createdAt: Date
   lastUpdatedAt: Date
 }
@@ -15,4 +15,4 @@ export type DcqlQueryItem = {
 export type ImportDcqlQueryItem = Omit<DcqlQueryItem, 'id' | 'tenantId' | 'version' | 'createdAt' | 'lastUpdatedAt'>
 export type NonPersistedDcqlQueryItem = Omit<DcqlQueryItem, 'id' | 'createdAt' | 'lastUpdatedAt'>
 export type PartialDcqlQueryItem = Partial<DcqlQueryItem>
-export type DcqlQueryItemFilter = Partial<Omit<DcqlQueryItem, 'dcqlQuery'>>
+export type DcqlQueryItemFilter = Partial<Omit<DcqlQueryItem, 'query'>>

package/src/utils/presentationDefinition/MappingUtils.ts

@@ -5,7 +5,7 @@ import { DcqlQueryItemEntity } from '../../entities/presentationDefinition/DcqlQ
 import type { NonPersistedDcqlQueryItem, PartialDcqlQueryItem, DcqlQueryItem } from '../../types'
 import { replaceNullWithUndefined } from '../FormattingUtils'
 
-export const presentationDefinitionItemFrom = (entity: DcqlQueryItemEntity): DcqlQueryItem => {
+export const dcqlQueryItemFrom = (entity: DcqlQueryItemEntity): DcqlQueryItem => {
   const result: DcqlQueryItem = {
     id: entity.id,
     tenantId: entity.tenantId,
@@ -13,18 +13,18 @@ export const presentationDefinitionItemFrom = (entity: DcqlQueryItemEntity): Dcq
     version: entity.version,
     name: entity.name,
     purpose: entity.purpose,
-    dcqlQuery: DcqlQuery.parse(JSON.parse(entity.dcqlPayload)),
+    query: DcqlQuery.parse(JSON.parse(entity.query)),
     createdAt: entity.createdAt,
     lastUpdatedAt: entity.lastUpdatedAt,
   }
 
-  if (result.dcqlQuery) {
-    DcqlQuery.validate(result.dcqlQuery)
+  if (result.query) {
+    DcqlQuery.validate(result.query)
   }
   return replaceNullWithUndefined(result)
 }
 
-export const presentationDefinitionEntityItemFrom = (item: NonPersistedDcqlQueryItem): DcqlQueryItemEntity => {
+export const dcqlQueryEntityItemFrom = (item: NonPersistedDcqlQueryItem): DcqlQueryItemEntity => {
   const entity = new DcqlQueryItemEntity()
 
   entity.tenantId = item.tenantId
@@ -32,10 +32,10 @@ export const presentationDefinitionEntityItemFrom = (item: NonPersistedDcqlQuery
   entity.version = item.version
   entity.name = item.name
   entity.purpose = item.purpose
-  if (item.dcqlQuery) {
-    const dcqlQuery = DcqlQuery.parse(item.dcqlQuery)
+  if (item.query) {
+    const dcqlQuery = DcqlQuery.parse(item.query)
     DcqlQuery.validate(dcqlQuery)
-    entity.dcqlPayload = JSON.stringify(item.dcqlQuery)
+    entity.query = JSON.stringify(item.query)
   }
   return entity
 }
@@ -55,11 +55,11 @@ export function isPresentationDefinitionEqual(base: PartialDcqlQueryItem, compar
     return false
   }
 
-  if (base.dcqlQuery && compare.dcqlQuery) {
-    if (hashPayload(base.dcqlQuery) !== hashPayload(compare.dcqlQuery)) {
+  if (base.query && compare.query) {
+    if (hashPayload(base.query) !== hashPayload(compare.query)) {
       return false
     }
-  } else if (base.dcqlQuery || compare.dcqlQuery) {
+  } else if (base.query || compare.query) {
     return false
   }