@sphereon/ssi-sdk.data-store 0.34.1-feature.SSISDK.57.uni.client.206 → 0.34.1-feature.SSISDK.58.host.nonce.endpoint.145

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sphereon/ssi-sdk.data-store",
-  "version": "0.34.1-feature.SSISDK.57.uni.client.206+c30b7b42",
+  "version": "0.34.1-feature.SSISDK.58.host.nonce.endpoint.145+5bfc0b12",
   "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.206+c30b7b42",
-    "@sphereon/ssi-sdk-ext.identifier-resolution": "0.34.1-feature.SSISDK.57.uni.client.206+c30b7b42",
-    "@sphereon/ssi-sdk.agent-config": "0.34.1-feature.SSISDK.57.uni.client.206+c30b7b42",
-    "@sphereon/ssi-sdk.core": "0.34.1-feature.SSISDK.57.uni.client.206+c30b7b42",
-    "@sphereon/ssi-types": "0.34.1-feature.SSISDK.57.uni.client.206+c30b7b42",
+    "@sphereon/ssi-sdk-ext.did-utils": "0.34.1-feature.SSISDK.58.host.nonce.endpoint.145+5bfc0b12",
+    "@sphereon/ssi-sdk-ext.identifier-resolution": "0.34.1-feature.SSISDK.58.host.nonce.endpoint.145+5bfc0b12",
+    "@sphereon/ssi-sdk.agent-config": "0.34.1-feature.SSISDK.58.host.nonce.endpoint.145+5bfc0b12",
+    "@sphereon/ssi-sdk.core": "0.34.1-feature.SSISDK.58.host.nonce.endpoint.145+5bfc0b12",
+    "@sphereon/ssi-types": "0.34.1-feature.SSISDK.58.host.nonce.endpoint.145+5bfc0b12",
     "@veramo/core": "4.2.0",
     "@veramo/utils": "4.2.0",
     "blakejs": "^1.2.1",
@@ -65,5 +65,5 @@
     "PostgreSQL",
     "Contact Store"
   ],
-  "gitHead": "c30b7b42dfbd1ea969234fe7a4a5813c5fddef3b"
+  "gitHead": "5bfc0b1229134b5d80279a3baf1fc64c9c6e755e"
 }

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

@@ -1,12 +1,13 @@
 import { DataSources } from '@sphereon/ssi-sdk.agent-config'
+import { DcqlQuery } from 'dcql'
 import { DataSource } from 'typeorm'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-import { DcqlQueryItemEntity } from '../entities/presentationDefinition/DcqlQueryItemEntity'
-import { DataStorePresentationDefinitionEntities } from '../index'
+import { PresentationDefinitionItemEntity } from '../entities/presentationDefinition/PresentationDefinitionItemEntity'
 import { DataStorePresentationDefinitionMigrations } from '../migrations'
-import { SAMPLE_DCQL_QUERY_IMPORT } from './pd-manager.store.test'
+import { DataStorePresentationDefinitionEntities } from '../index'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { SAMPLE_DCQL_QUERY_PAYLOAD } from './pd-manager.store.test'
 
-describe('DcqlQueryItemEntity tests', (): void => {
+describe('PresentationDefinitionItemEntity tests', (): void => {
   let dbConnection: DataSource
 
   beforeEach(async (): Promise<void> => {
@@ -26,34 +27,34 @@ describe('DcqlQueryItemEntity tests', (): void => {
     await dbConnection.destroy()
   })
 
-  it('should create and retrieve DcqlQueryItemEntity', async (): Promise<void> => {
-    const repository = dbConnection.getRepository(DcqlQueryItemEntity)
-    const entity = new DcqlQueryItemEntity()
-    entity.queryId = 'ajax-club'
+  it('should create and retrieve PresentationDefinitionItemEntity with dcqlPayload', async (): Promise<void> => {
+    const repository = dbConnection.getRepository(PresentationDefinitionItemEntity)
+    const entity = new PresentationDefinitionItemEntity()
+    entity.definitionId = 'ajax-club'
     entity.version = '1.0'
-    entity.query = JSON.stringify(SAMPLE_DCQL_QUERY_IMPORT.query)
+    entity.dcqlPayload = JSON.stringify(SAMPLE_DCQL_QUERY_PAYLOAD.dcqlQuery)
 
     const savedEntity = await repository.save(entity)
     expect(savedEntity).toBeDefined()
     expect(savedEntity.id).toBeDefined()
-    expect(savedEntity.query).toBeDefined()
+    expect(savedEntity.dcqlPayload).toBeDefined()
 
     const retrievedEntity = await repository.findOneBy({ id: savedEntity.id })
     expect(retrievedEntity).toBeDefined()
-    expect(retrievedEntity!.query).toBeDefined()
-    const parsedDcql = JSON.parse(retrievedEntity!.query)
+    expect(retrievedEntity!.dcqlPayload).toBeDefined()
+    const parsedDcql = JSON.parse(retrievedEntity!.dcqlPayload)
     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 DcqlQueryItemEntity dcql query', async (): Promise<void> => {
-    const repository = dbConnection.getRepository(DcqlQueryItemEntity)
-    const entity = new DcqlQueryItemEntity()
-    entity.queryId = 'ajax-club'
+  it('should update PresentationDefinitionItemEntity dcqlPayload', async (): Promise<void> => {
+    const repository = dbConnection.getRepository(PresentationDefinitionItemEntity)
+    const entity = new PresentationDefinitionItemEntity()
+    entity.definitionId = 'ajax-club'
     entity.version = '1.0'
-    entity.query = JSON.stringify(SAMPLE_DCQL_QUERY_IMPORT.query)
+    entity.dcqlPayload = JSON.stringify(SAMPLE_DCQL_QUERY_PAYLOAD.dcqlQuery)
 
     const savedEntity = await repository.save(entity)
     expect(savedEntity).toBeDefined()
@@ -71,10 +72,57 @@ describe('DcqlQueryItemEntity tests', (): void => {
         },
       ],
     }
-    savedEntity.query = JSON.stringify(updatedDcql)
+    savedEntity.dcqlPayload = JSON.stringify(updatedDcql)
     const updatedEntity = await repository.save(savedEntity)
     expect(updatedEntity).toBeDefined()
-    expect(JSON.parse(updatedEntity.query).credentials[0].id).toEqual('updated-clubcard')
-    expect(JSON.parse(updatedEntity.query).credentials[0].format).toEqual('jwt_vc')
+    expect(JSON.parse(updatedEntity.dcqlPayload).credentials[0].id).toEqual('updated-clubcard')
+    expect(JSON.parse(updatedEntity.dcqlPayload).credentials[0].format).toEqual('jwt_vc')
+  })
+
+  it('should create and retrieve PresentationDefinitionItemEntity', async (): Promise<void> => {
+    const repository = dbConnection.getRepository(PresentationDefinitionItemEntity)
+    const entity = new PresentationDefinitionItemEntity()
+    entity.definitionId = 'definition1'
+    entity.version = '1.0'
+    entity.definitionPayload = JSON.stringify({ id: 'definition1', input_descriptors: [] })
+
+    const savedEntity = await repository.save(entity)
+    expect(savedEntity).toBeDefined()
+    expect(savedEntity.id).toBeDefined()
+
+    const retrievedEntity = await repository.findOneBy({ id: savedEntity.id })
+    expect(retrievedEntity).toBeDefined()
+    expect(retrievedEntity!.definitionId).toEqual('definition1')
+  })
+
+  it('should update PresentationDefinitionItemEntity', async (): Promise<void> => {
+    const repository = dbConnection.getRepository(PresentationDefinitionItemEntity)
+    const entity = new PresentationDefinitionItemEntity()
+    entity.definitionId = 'definition1'
+    entity.version = '1.0'
+    entity.definitionPayload = JSON.stringify({ id: 'definition1', input_descriptors: [] })
+
+    const savedEntity = await repository.save(entity)
+    expect(savedEntity).toBeDefined()
+
+    savedEntity.version = '1.1'
+    const updatedEntity = await repository.save(savedEntity)
+    expect(updatedEntity).toBeDefined()
+    expect(updatedEntity.version).toEqual('1.1')
+  })
+
+  it('should delete PresentationDefinitionItemEntity', async (): Promise<void> => {
+    const repository = dbConnection.getRepository(PresentationDefinitionItemEntity)
+    const entity = new PresentationDefinitionItemEntity()
+    entity.definitionId = 'definition1'
+    entity.version = '1.0'
+    entity.definitionPayload = JSON.stringify({ id: 'definition1', input_descriptors: [] })
+
+    const savedEntity = await repository.save(entity)
+    expect(savedEntity).toBeDefined()
+
+    await repository.delete(savedEntity.id)
+    const retrievedEntity = await repository.findOneBy({ id: savedEntity.id })
+    expect(retrievedEntity).toBeNull()
   })
 })

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

@@ -1,19 +1,13 @@
 import { DataSources } from '@sphereon/ssi-sdk.agent-config'
-import { DcqlQuery } from 'dcql'
+import { DcqlQueryPayload } from '@sphereon/ssi-types'
 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 '../types'
-
-export const SAMPLE_DCQL_QUERY_IMPORT: ImportDcqlQueryItem = {
+
+export const SAMPLE_DCQL_QUERY_PAYLOAD: DcqlQueryPayload = {
   queryId: 'ajax-club',
-  query: {
+  dcqlQuery: {
     credentials: [
       {
         id: 'clubcard-v1',
@@ -66,148 +60,237 @@ 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 args: GetDefinitionsArgs = {
+      filter: [{ definitionId: 'definition1' }],
+    }
+    const result: Array<PresentationDefinitionItem> = await pdStore.getDefinitions(args)
+
+    expect(result.length).toEqual(1)
+  })
+
+  it('should add definition', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
+      version: '1.0',
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
+    }
+
+    const result: PresentationDefinitionItem = await pdStore.addDefinition(definition)
+
+    expect(result).toBeDefined()
+    expect(result.definitionId).toEqual(definition.definitionId)
+  })
+
+  it('should add definition with dcqlPayload', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'ajax-club',
+      version: '1.0',
+      definitionPayload: { id: 'ajax-club', input_descriptors: [] },
+      dcqlPayload: SAMPLE_DCQL_QUERY_PAYLOAD,
+    }
+
+    const result: PresentationDefinitionItem = await pdStore.addDefinition(definition)
+
+    expect(result).toBeDefined()
+    expect(result.definitionId).toEqual(definition.definitionId)
+    expect(result.dcqlPayload).toBeDefined()
+    expect(result.dcqlPayload?.dcqlQuery.credentials[0].id).toEqual('clubcard-v1')
+    expect(result.dcqlPayload?.dcqlQuery.credentials[0].format).toEqual('dc+sd-jwt')
+  })
+
+  it('should update definition', 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 updatedDefinition: PresentationDefinitionItem = {
+      ...savedDefinition,
+      version: '1.1',
+    }
+
+    await pdStore.updateDefinition(updatedDefinition)
+    const result: PresentationDefinitionItem = await pdStore.getDefinition({ itemId: savedDefinition.id })
+
+    expect(result).toBeDefined()
+    expect(result.version).toEqual('1.1')
+  })
+
+  it('should update definition with dcqlPayload', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'ajax-club',
+      version: '1.0',
+      definitionPayload: { id: 'ajax-club', input_descriptors: [] },
+      dcqlPayload: SAMPLE_DCQL_QUERY_PAYLOAD,
+    }
+    const savedDefinition: PresentationDefinitionItem = await pdStore.addDefinition(definition)
+    expect(savedDefinition).toBeDefined()
+
+    const updatedDcqlQueryPayload = {
+      ...SAMPLE_DCQL_QUERY_PAYLOAD,
+      dcqlQuery: {
+        credentials: [
+          {
+            id: 'updated-clubcard',
+            format: 'dc+sd-jwt',
+            claims: [
+              {
+                path: ['name'],
+              },
+            ],
+          },
+        ],
+      },
+    } as unknown as DcqlQueryPayload // FIXME I do not have another solution for this atm, I can do Partial<DcqlQuery> but that does not work for its child entities
 
-    const updatedDefinition: DcqlQueryItem = {
+    const updatedDefinition: PresentationDefinitionItem = {
       ...savedDefinition,
       version: '1.1',
-      query: updatedDcqlQuery,
+      dcqlPayload: updatedDcqlQueryPayload,
     }
 
     await pdStore.updateDefinition(updatedDefinition)
-    const result: DcqlQueryItem = await pdStore.getDefinition({ itemId: savedDefinition.id })
+    const result: PresentationDefinitionItem = 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.dcqlPayload?.dcqlQuery.credentials[0].id).toEqual('updated-clubcard')
+    expect(result.dcqlPayload?.dcqlQuery.credentials[0].format).toEqual('dc+sd-jwt')
   })
 
-  it('should get dcql queries by id', async (): Promise<void> => {
-    const definition: NonPersistedDcqlQueryItem = {
-      queryId: SAMPLE_DCQL_QUERY_IMPORT.queryId,
+  it('should get definition with dcqlPayload by id', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'ajax-club',
       version: '1.0',
-      query: SAMPLE_DCQL_QUERY_IMPORT.query,
+      definitionPayload: { id: 'ajax-club', input_descriptors: [] },
+      dcqlPayload: SAMPLE_DCQL_QUERY_PAYLOAD,
     }
 
-    const savedDefinition: DcqlQueryItem = await pdStore.addDefinition(definition)
+    const savedDefinition: PresentationDefinitionItem = await pdStore.addDefinition(definition)
     expect(savedDefinition).toBeDefined()
 
-    const result: DcqlQueryItem = await pdStore.getDefinition({ itemId: savedDefinition.id })
+    const result: PresentationDefinitionItem = await pdStore.getDefinition({ itemId: savedDefinition.id })
 
     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.dcqlPayload).toBeDefined()
+    expect(result.dcqlPayload?.dcqlQuery.credentials[0].format).toBe('dc+sd-jwt')
+    if (result.dcqlPayload?.dcqlQuery.credentials[0].format === 'dc+sd-jwt') {
+      expect(result.dcqlPayload.dcqlQuery.credentials[0].meta?.vct_values).toContain('clubcard-v1')
     }
-    expect(result.query.credentials[0].claims).toHaveLength(4)
+    expect(result.dcqlPayload?.dcqlQuery.credentials[0].claims).toHaveLength(4)
   })
 
-  it('should get dcql queries by filter', async (): Promise<void> => {
-    const definition: NonPersistedDcqlQueryItem = {
-      queryId: SAMPLE_DCQL_QUERY_IMPORT.queryId,
+  it('should get definitions with dcqlPayload by filter', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'ajax-club',
       version: '1.0',
-      query: SAMPLE_DCQL_QUERY_IMPORT.query,
+      definitionPayload: { id: 'ajax-club', input_descriptors: [] },
+      dcqlPayload: SAMPLE_DCQL_QUERY_PAYLOAD,
     }
-    const savedDefinition: DcqlQueryItem = await pdStore.addDefinition(definition)
+    const savedDefinition: PresentationDefinitionItem = await pdStore.addDefinition(definition)
     expect(savedDefinition).toBeDefined()
 
     const args: GetDefinitionsArgs = {
-      filter: [{ queryId: 'ajax-club' }],
+      filter: [{ definitionId: 'ajax-club' }],
     }
-    const result: Array<DcqlQueryItem> = await pdStore.getDefinitions(args)
+    const result: Array<PresentationDefinitionItem> = await pdStore.getDefinitions(args)
 
     expect(result.length).toEqual(1)
-    expect(result[0].query).toBeDefined()
-    expect(result[0].query.credentials[0].id).toEqual('clubcard-v1')
+    expect(result[0].dcqlPayload).toBeDefined()
+    expect(result[0].dcqlPayload?.dcqlQuery.credentials[0].id).toEqual('clubcard-v1')
   })
 
-  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 +300,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/entities/presentationDefinition/{DcqlQueryItemEntity.ts → PresentationDefinitionItemEntity.ts}

@@ -2,15 +2,15 @@ import { BaseEntity, BeforeInsert, BeforeUpdate, Column, CreateDateColumn, Entit
 import { IsNotEmpty } from 'class-validator'
 import { typeOrmDateTime } from '@sphereon/ssi-sdk.agent-config'
 
-@Entity('DcqlQueryItem')
+@Entity('PresentationDefinitionItem')
 @Index(['version'], { unique: false })
-export class DcqlQueryItemEntity extends BaseEntity {
+export class PresentationDefinitionItemEntity extends BaseEntity {
   @PrimaryGeneratedColumn('uuid')
   id!: string
 
-  @Column({ name: 'query_id', length: 255, type: 'varchar', nullable: false, unique: false })
-  @IsNotEmpty({ message: 'A blank query id field is not allowed' })
-  queryId!: string
+  @Column({ name: 'definition_id', length: 255, type: 'varchar', nullable: false, unique: false })
+  @IsNotEmpty({ message: 'A blank definition id field is not allowed' })
+  definitionId!: string
 
   @Column({ name: 'version', length: 255, type: 'varchar', nullable: false, unique: false })
   @IsNotEmpty({ message: 'A blank version field is not allowed' })
@@ -25,9 +25,13 @@ export class DcqlQueryItemEntity extends BaseEntity {
   @Column({ name: 'name', length: 255, type: 'varchar', nullable: true, unique: false })
   name?: string
 
-  @Column({ name: 'query', type: 'text', nullable: false, unique: false })
-  @IsNotEmpty({ message: 'A blank dcql query payload field is not allowed' })
-  query!: string
+  @Column({ name: 'definition_payload', type: 'text', nullable: true, unique: false })
+  @IsNotEmpty({ message: 'A blank PD definition payload field is not allowed' })
+  definitionPayload!: string
+
+  @Column({ name: 'dcql_payload', type: 'text', nullable: true, unique: false })
+  @IsNotEmpty({ message: 'A blank dcql definition payload field is not allowed' })
+  dcqlPayload!: string
 
   @CreateDateColumn({ name: 'created_at', nullable: false, type: typeOrmDateTime() })
   createdAt!: Date

package/src/index.ts

@@ -29,7 +29,7 @@ import { ElectronicAddressEntity } from './entities/contact/ElectronicAddressEnt
 import { PhysicalAddressEntity } from './entities/contact/PhysicalAddressEntity'
 import { AuditEventEntity } from './entities/eventLogger/AuditEventEntity'
 import { DigitalCredentialEntity } from './entities/digitalCredential/DigitalCredentialEntity'
-import { DcqlQueryItemEntity } from './entities/presentationDefinition/DcqlQueryItemEntity'
+import { PresentationDefinitionItemEntity } from './entities/presentationDefinition/PresentationDefinitionItemEntity'
 import { ContactMetadataItemEntity } from './entities/contact/ContactMetadataItemEntity'
 import { CredentialClaimsEntity } from './entities/issuanceBranding/CredentialClaimsEntity'
 
@@ -99,7 +99,7 @@ export const DataStoreIssuanceBrandingEntities = [
   CredentialClaimsEntity,
 ]
 
-export const DataStorePresentationDefinitionEntities = [DcqlQueryItemEntity]
+export const DataStorePresentationDefinitionEntities = [PresentationDefinitionItemEntity]
 
 export const DataStoreStatusListEntities = [
   StatusListEntity,
@@ -158,7 +158,7 @@ export {
   AuditEventEntity,
   DigitalCredentialEntity,
   MachineStateInfoEntity,
-  DcqlQueryItemEntity,
+  PresentationDefinitionItemEntity,
   ContactMetadataItemEntity,
   CredentialClaimsEntity,
   Oid4vcStateEntity,