@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/src/migrations/generic/{13-CreateDcqlQueryItem.ts → 13-UpdatePresentationDefinitionItemNullable.ts}

@@ -1,13 +1,13 @@
 import Debug from 'debug'
 import { DatabaseType, MigrationInterface, QueryRunner } from 'typeorm'
 
-import { CreateDcqlQueryItemPG1726588800000 } from '../postgres/1726588800000-CreateDcqlQueryItem'
-import { CreateDcqlQueryItemSQlite1726617600000 } from '../sqlite/1726617600000-CreateDcqlQueryItem'
+import { UpdatePresentationDefinitionItemNullablePG1741895824000 } from '../postgres/1756975509000-UpdatePresentationDefinitionItemNullable'
+import { UpdatePresentationDefinitionItemNullableSqlite1756975340000 } from '../sqlite/1756975340000-UpdatePresentationDefinitionItemNullable'
 
 const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:migrations')
 
-export class CreateDcqlQueryItem1726617600000 implements MigrationInterface {
-  name = 'CreateDcqlQueryItem1726617600000'
+export class UpdatePresentationDefinitionItemNullable1741895824000 implements MigrationInterface {
+  name = 'UpdatePresentationDefinitionItemNullable1741895824000'
 
   public async up(queryRunner: QueryRunner): Promise<void> {
     debug('migration: updating presentation definition item nullable fields')
@@ -16,7 +16,7 @@ export class CreateDcqlQueryItem1726617600000 implements MigrationInterface {
     switch (dbType) {
       case 'postgres': {
         debug('using postgres migration file')
-        const mig: CreateDcqlQueryItemPG1726588800000 = new CreateDcqlQueryItemPG1726588800000()
+        const mig: UpdatePresentationDefinitionItemNullablePG1741895824000 = new UpdatePresentationDefinitionItemNullablePG1741895824000()
         await mig.up(queryRunner)
         debug('Migration statements executed')
         return
@@ -25,7 +25,7 @@ export class CreateDcqlQueryItem1726617600000 implements MigrationInterface {
       case 'expo':
       case 'react-native': {
         debug('using sqlite/react-native migration file')
-        const mig: CreateDcqlQueryItemSQlite1726617600000 = new CreateDcqlQueryItemSQlite1726617600000()
+        const mig: UpdatePresentationDefinitionItemNullableSqlite1756975340000 = new UpdatePresentationDefinitionItemNullableSqlite1756975340000()
         await mig.up(queryRunner)
         debug('Migration statements executed')
         return
@@ -44,7 +44,7 @@ export class CreateDcqlQueryItem1726617600000 implements MigrationInterface {
     switch (dbType) {
       case 'postgres': {
         debug('using postgres migration file')
-        const mig: CreateDcqlQueryItemPG1726588800000 = new CreateDcqlQueryItemPG1726588800000()
+        const mig: UpdatePresentationDefinitionItemNullablePG1741895824000 = new UpdatePresentationDefinitionItemNullablePG1741895824000()
         await mig.down(queryRunner)
         debug('Migration statements executed')
         return
@@ -53,7 +53,7 @@ export class CreateDcqlQueryItem1726617600000 implements MigrationInterface {
       case 'expo':
       case 'react-native': {
         debug('using sqlite/react-native migration file')
-        const mig: CreateDcqlQueryItemSQlite1726617600000 = new CreateDcqlQueryItemSQlite1726617600000()
+        const mig: UpdatePresentationDefinitionItemNullableSqlite1756975340000 = new UpdatePresentationDefinitionItemNullableSqlite1756975340000()
         await mig.down(queryRunner)
         debug('Migration statements executed')
         return

package/src/migrations/generic/index.ts

@@ -2,7 +2,7 @@ import { CreateContacts1659463079429 } from './1-CreateContacts'
 import { CreatePresentationDefinitions1716533767523 } from './10-CreatePresentationDefinitions'
 import { FixCredentialClaimsReferencesUuid1741895822987 } from './11-FixCredentialClaimsReferenceUuid'
 import { AddBitstringStatusListEnum1741895823000, CreateBitstringStatusList1741895823000 } from './12-CreateBitstringStatusList'
-import { CreateDcqlQueryItem1726617600000 } from './13-CreateDcqlQueryItem'
+import { UpdatePresentationDefinitionItemNullable1741895824000 } from './13-UpdatePresentationDefinitionItemNullable'
 import { CreateIssuanceBranding1659463079429 } from './2-CreateIssuanceBranding'
 import { CreateContacts1690925872318 } from './3-CreateContacts'
 import { CreateStatusList1693866470000 } from './4-CreateStatusList'
@@ -36,7 +36,10 @@ export const DataStoreStatusListMigrations = [
 export const DataStoreEventLoggerMigrations = [CreateAuditEvents1701635835330]
 export const DataStoreDigitalCredentialMigrations = [CreateDigitalCredential1708525189000]
 export const DataStoreMachineStateMigrations = [CreateMachineStateStore1708098041262]
-export const DataStorePresentationDefinitionMigrations = [CreatePresentationDefinitions1716533767523, CreateDcqlQueryItem1726617600000]
+export const DataStorePresentationDefinitionMigrations = [
+  CreatePresentationDefinitions1716533767523,
+  UpdatePresentationDefinitionItemNullable1741895824000,
+]
 
 // All migrations together
 export const DataStoreMigrations = [

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, 
-    "query" TEXT, 
+    "dcql_payload" 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/1756975509000-UpdatePresentationDefinitionItemNullable.ts

@@ -0,0 +1,15 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class UpdatePresentationDefinitionItemNullablePG1741895824000 implements MigrationInterface {
+  name = 'UpdatePresentationDefinitionItemNullable1741895824000'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // Make definition_payload nullable
+    await queryRunner.query(`ALTER TABLE "PresentationDefinitionItem" ALTER COLUMN "definition_payload" DROP NOT NULL`)
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    // Make definition_payload NOT NULL again
+    await queryRunner.query(`ALTER TABLE "PresentationDefinitionItem" ALTER COLUMN "definition_payload" SET NOT NULL`)
+  }
+}

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,
-    "query" varchar,
+    "dcql_payload" varchar,
     "created_at" datetime NOT NULL DEFAULT (datetime('now')),
     "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')))`,
     )

package/src/migrations/sqlite/1756975340000-UpdatePresentationDefinitionItemNullable.ts

@@ -0,0 +1,77 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class UpdatePresentationDefinitionItemNullableSqlite1756975340000 implements MigrationInterface {
+  name = 'UpdatePresentationDefinitionItemNullable1756975340000'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // Create temporary table with updated schema (definition_payload nullable)
+    await queryRunner.query(`
+      CREATE TABLE "temporary_PresentationDefinitionItem" (
+                                                            "id" varchar PRIMARY KEY NOT NULL,
+                                                            "definition_id" varchar(255) NOT NULL,
+                                                            "version" varchar(255) NOT NULL,
+                                                            "tenant_id" varchar(255),
+                                                            "purpose" varchar(255),
+                                                            "name" varchar(255),
+                                                            "definition_payload" text,
+                                                            "dcql_payload" text,
+                                                            "created_at" datetime NOT NULL DEFAULT (datetime('now')),
+                                                            "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')),
+                                                            CONSTRAINT "UQ_PresentationDefinitionItem_definition_id_version" UNIQUE ("definition_id", "version")
+      )
+    `)
+
+    // Copy data from old table
+    await queryRunner.query(`
+      INSERT INTO "temporary_PresentationDefinitionItem"(
+        "id", "definition_id", "version", "tenant_id", "purpose", "name",
+        "definition_payload", "dcql_payload", "created_at", "last_updated_at"
+      )
+      SELECT
+        "id", "definition_id", "version", "tenant_id", "purpose", "name",
+        "definition_payload", "dcql_payload", "created_at", "last_updated_at"
+      FROM "PresentationDefinitionItem"
+    `)
+
+    // Drop old table and rename
+    await queryRunner.query(`DROP TABLE "PresentationDefinitionItem"`)
+    await queryRunner.query(`ALTER TABLE "temporary_PresentationDefinitionItem" RENAME TO "PresentationDefinitionItem"`)
+
+    // Recreate index
+    await queryRunner.query(`CREATE INDEX "IDX_PresentationDefinitionItem_version" ON "PresentationDefinitionItem" ("version")`)
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    // Revert to original schema (definition_payload NOT NULL, dcql_payload nullable)
+    await queryRunner.query(`
+      CREATE TABLE "temporary_PresentationDefinitionItem" (
+                                                            "id" varchar PRIMARY KEY NOT NULL,
+                                                            "definition_id" varchar(255) NOT NULL,
+                                                            "version" varchar(255) NOT NULL,
+                                                            "tenant_id" varchar(255),
+                                                            "purpose" varchar(255),
+                                                            "name" varchar(255),
+                                                            "definition_payload" text NOT NULL,
+                                                            "dcql_payload" text,
+                                                            "created_at" datetime NOT NULL DEFAULT (datetime('now')),
+                                                            "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')),
+                                                            CONSTRAINT "UQ_PresentationDefinitionItem_definition_id_version" UNIQUE ("definition_id", "version")
+      )
+    `)
+
+    await queryRunner.query(`
+      INSERT INTO "temporary_PresentationDefinitionItem"(
+        "id", "definition_id", "version", "tenant_id", "purpose", "name",
+        "definition_payload", "dcql_payload", "created_at", "last_updated_at"
+      )
+      SELECT
+        "id", "definition_id", "version", "tenant_id", "purpose", "name",
+        "definition_payload", "dcql_payload", "created_at", "last_updated_at"
+      FROM "PresentationDefinitionItem"
+    `)
+
+    await queryRunner.query(`DROP TABLE "PresentationDefinitionItem"`)
+    await queryRunner.query(`ALTER TABLE "temporary_PresentationDefinitionItem" RENAME TO "PresentationDefinitionItem"`)
+    await queryRunner.query(`CREATE INDEX "IDX_PresentationDefinitionItem_version" ON "PresentationDefinitionItem" ("version")`)
+  }
+}

package/src/presentationDefinition/AbstractPDStore.ts

@@ -2,7 +2,7 @@ import type {
   GetDefinitionArgs,
   GetDefinitionsArgs,
   DeleteDefinitionArgs,
-  DcqlQueryItem,
+  PresentationDefinitionItem,
   AddDefinitionArgs,
   UpdateDefinitionArgs,
   DeleteDefinitionsArgs,
@@ -11,10 +11,10 @@ import type {
 export abstract class AbstractPDStore {
   abstract hasDefinition(args: GetDefinitionArgs): Promise<boolean>
   abstract hasDefinitions(args: GetDefinitionsArgs): Promise<boolean>
-  abstract getDefinition(args: GetDefinitionArgs): Promise<DcqlQueryItem>
-  abstract getDefinitions(args: GetDefinitionsArgs): Promise<Array<DcqlQueryItem>>
-  abstract addDefinition(args: AddDefinitionArgs): Promise<DcqlQueryItem>
-  abstract updateDefinition(args: UpdateDefinitionArgs): Promise<DcqlQueryItem>
+  abstract getDefinition(args: GetDefinitionArgs): Promise<PresentationDefinitionItem>
+  abstract getDefinitions(args: GetDefinitionsArgs): Promise<Array<PresentationDefinitionItem>>
+  abstract addDefinition(args: AddDefinitionArgs): Promise<PresentationDefinitionItem>
+  abstract updateDefinition(args: UpdateDefinitionArgs): Promise<PresentationDefinitionItem>
   abstract deleteDefinition(args: DeleteDefinitionArgs): Promise<void>
   abstract deleteDefinitions(args: DeleteDefinitionsArgs): Promise<number>
 }

package/src/presentationDefinition/PDStore.ts

@@ -9,12 +9,12 @@ import type {
   GetDefinitionsArgs,
   HasDefinitionArgs,
   HasDefinitionsArgs,
-  NonPersistedDcqlQueryItem,
-  DcqlQueryItem,
-  DcqlQueryItemFilter,
+  NonPersistedPresentationDefinitionItem,
+  PresentationDefinitionItem,
+  PresentationDefinitionItemFilter,
 } from '../types'
-import { DcqlQueryItemEntity } from '../entities/presentationDefinition/DcqlQueryItemEntity'
-import { dcqlQueryEntityItemFrom, dcqlQueryItemFrom } from '../utils/presentationDefinition/MappingUtils'
+import { PresentationDefinitionItemEntity } from '../entities/presentationDefinition/PresentationDefinitionItemEntity'
+import { presentationDefinitionEntityItemFrom, presentationDefinitionItemFrom } from '../utils/presentationDefinition/MappingUtils'
 
 const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:pd-store')
 
@@ -26,22 +26,22 @@ export class PDStore extends AbstractPDStore {
     this.dbConnection = dbConnection
   }
 
-  getDefinition = async (args: GetDefinitionArgs): Promise<DcqlQueryItem> => {
+  getDefinition = async (args: GetDefinitionArgs): Promise<PresentationDefinitionItem> => {
     const { itemId } = args ?? {}
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
-    const result: DcqlQueryItemEntity | null = await pdRepository.findOne({
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
+    const result: PresentationDefinitionItemEntity | null = await pdRepository.findOne({
       where: { id: itemId },
     })
     if (!result) {
       return Promise.reject(Error(`No presentation definition item found for id: ${itemId}`))
     }
 
-    return dcqlQueryItemFrom(result)
+    return presentationDefinitionItemFrom(result)
   }
 
   hasDefinition = async (args: HasDefinitionArgs): Promise<boolean> => {
     const { itemId } = args ?? {}
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
 
     const resultCount: number = await pdRepository.count({
       where: { id: itemId },
@@ -52,7 +52,7 @@ export class PDStore extends AbstractPDStore {
 
   hasDefinitions = async (args: HasDefinitionsArgs): Promise<boolean> => {
     const { filter } = args
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
 
     const resultCount: number = await pdRepository.count({
       ...(filter && { where: cleanFilter(filter) }),
@@ -60,67 +60,72 @@ export class PDStore extends AbstractPDStore {
     return resultCount > 0
   }
 
-  getDefinitions = async (args: GetDefinitionsArgs): Promise<Array<DcqlQueryItem>> => {
+  getDefinitions = async (args: GetDefinitionsArgs): Promise<Array<PresentationDefinitionItem>> => {
     const { filter } = args
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
     const initialResult = await this.findIds(pdRepository, filter)
-    const result: Array<DcqlQueryItemEntity> = await pdRepository.find({
+    const result: Array<PresentationDefinitionItemEntity> = await pdRepository.find({
       where: {
-        id: In(initialResult.map((entity: DcqlQueryItemEntity) => entity.id)),
+        id: In(initialResult.map((entity: PresentationDefinitionItemEntity) => entity.id)),
       },
       order: {
         version: 'DESC',
       },
     })
 
-    return result.map((entity: DcqlQueryItemEntity) => dcqlQueryItemFrom(entity))
+    return result.map((entity: PresentationDefinitionItemEntity) => presentationDefinitionItemFrom(entity))
   }
 
-  addDefinition = async (item: NonPersistedDcqlQueryItem): Promise<DcqlQueryItem> => {
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
+  addDefinition = async (item: NonPersistedPresentationDefinitionItem): Promise<PresentationDefinitionItem> => {
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
 
-    const entity: DcqlQueryItemEntity = dcqlQueryEntityItemFrom(item)
+    const entity: PresentationDefinitionItemEntity = presentationDefinitionEntityItemFrom(item)
     debug('Adding presentation definition entity', item)
-    const result: DcqlQueryItemEntity = await pdRepository.save(entity, {
+    const result: PresentationDefinitionItemEntity = await pdRepository.save(entity, {
       transaction: true,
     })
 
-    return dcqlQueryItemFrom(result)
+    return presentationDefinitionItemFrom(result)
   }
 
-  updateDefinition = async (item: DcqlQueryItem): Promise<DcqlQueryItem> => {
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
+  updateDefinition = async (item: PresentationDefinitionItem): Promise<PresentationDefinitionItem> => {
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
 
-    const result: DcqlQueryItemEntity | null = await pdRepository.findOne({
+    const result: PresentationDefinitionItemEntity | null = await pdRepository.findOne({
       where: { id: item.id },
     })
     if (!result) {
       return Promise.reject(Error(`No presentation definition entity found for id: ${item.id}`))
     }
 
-    const updatedEntity: Partial<DcqlQueryItemEntity> = {
+    const updatedEntity: Partial<PresentationDefinitionItemEntity> = {
       ...result,
     }
     updatedEntity.tenantId = item.tenantId
-    updatedEntity.queryId = item.queryId!
+    updatedEntity.definitionId = item.definitionId!
     updatedEntity.version = item.version
     updatedEntity.name = item.name
     updatedEntity.purpose = item.purpose
-    updatedEntity.query = JSON.stringify(item.query)
+    if (item.definitionPayload) {
+      updatedEntity.definitionPayload = JSON.stringify(item.definitionPayload!)
+    }
+    if (item.dcqlPayload) {
+      updatedEntity.dcqlPayload = JSON.stringify(item.dcqlPayload!.dcqlQuery)
+    }
 
     debug('Updating presentation definition entity', updatedEntity)
-    const updateResult: DcqlQueryItemEntity = await pdRepository.save(updatedEntity, {
+    const updateResult: PresentationDefinitionItemEntity = await pdRepository.save(updatedEntity, {
       transaction: true,
     })
 
-    return dcqlQueryItemFrom(updateResult)
+    return presentationDefinitionItemFrom(updateResult)
   }
 
   deleteDefinition = async (args: DeleteDefinitionArgs): Promise<void> => {
     const { itemId } = args
 
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
-    const entity: DcqlQueryItemEntity | null = await pdRepository.findOne({
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
+    const entity: PresentationDefinitionItemEntity | null = await pdRepository.findOne({
       where: { id: itemId },
     })
 
@@ -134,12 +139,12 @@ export class PDStore extends AbstractPDStore {
 
   deleteDefinitions = async (args: DeleteDefinitionsArgs): Promise<number> => {
     const { filter } = args
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
     const initialResult = await this.findIds(pdRepository, filter)
 
-    const result: Array<DcqlQueryItemEntity> = await pdRepository.find({
+    const result: Array<PresentationDefinitionItemEntity> = await pdRepository.find({
       where: {
-        id: In(initialResult.map((entity: DcqlQueryItemEntity) => entity.id)),
+        id: In(initialResult.map((entity: PresentationDefinitionItemEntity) => entity.id)),
       },
     })
 
@@ -151,9 +156,9 @@ export class PDStore extends AbstractPDStore {
   }
 
   findIds = async (
-    pdRepository: Repository<DcqlQueryItemEntity>,
-    filter: Array<DcqlQueryItemFilter> | undefined,
-  ): Promise<Array<DcqlQueryItemEntity>> => {
+    pdRepository: Repository<PresentationDefinitionItemEntity>,
+    filter: Array<PresentationDefinitionItemFilter> | undefined,
+  ): Promise<Array<PresentationDefinitionItemEntity>> => {
     const idFilters = filter?.map((f) => f.id).filter((id) => id !== undefined && id !== null)
     if (idFilters && idFilters.length > 0 && idFilters.length === filter?.length) {
       return await pdRepository.find({
@@ -167,15 +172,15 @@ export class PDStore extends AbstractPDStore {
   }
 }
 
-const cleanFilter = (filter: Array<DcqlQueryItemFilter> | undefined): Array<DcqlQueryItemFilter> | undefined => {
+const cleanFilter = (filter: Array<PresentationDefinitionItemFilter> | undefined): Array<PresentationDefinitionItemFilter> | undefined => {
   if (filter === undefined) {
     return undefined
   }
 
   return filter.map((item) => {
-    const cleanedItem: DcqlQueryItemFilter = {}
+    const cleanedItem: PresentationDefinitionItemFilter = {}
     for (const key in item) {
-      const value = item[key as keyof DcqlQueryItemFilter]
+      const value = item[key as keyof PresentationDefinitionItemFilter]
       if (value !== undefined) {
         ;(cleanedItem as any)[key] = value
       }

package/src/types/presentationDefinition/IAbstractPDStore.ts

@@ -1,6 +1,6 @@
-import { NonPersistedDcqlQueryItem, DcqlQueryItem, DcqlQueryItemFilter } from './presentationDefinition'
+import { NonPersistedPresentationDefinitionItem, PresentationDefinitionItem, PresentationDefinitionItemFilter } from './presentationDefinition'
 
-export type FindDcqlQueryArgs = Array<DcqlQueryItemFilter>
+export type FindDefinitionArgs = Array<PresentationDefinitionItemFilter>
 
 export type GetDefinitionArgs = {
   itemId: string
@@ -9,14 +9,14 @@ export type GetDefinitionArgs = {
 export type HasDefinitionArgs = GetDefinitionArgs
 
 export type GetDefinitionsArgs = {
-  filter?: FindDcqlQueryArgs
+  filter?: FindDefinitionArgs
 }
 
 export type HasDefinitionsArgs = GetDefinitionsArgs
 
-export type AddDefinitionArgs = NonPersistedDcqlQueryItem
+export type AddDefinitionArgs = NonPersistedPresentationDefinitionItem
 
-export type UpdateDefinitionArgs = DcqlQueryItem
+export type UpdateDefinitionArgs = PresentationDefinitionItem
 
 export type DeleteDefinitionArgs = {
   itemId: string

package/src/types/presentationDefinition/presentationDefinition.ts

@@ -1,18 +1,19 @@
-import { DcqlQuery } from 'dcql'
+import { IPresentationDefinition } from '@sphereon/pex'
+import { DcqlQueryPayload } from '@sphereon/ssi-types'
 
-export type DcqlQueryItem = {
+export type PresentationDefinitionItem = {
   id: string
-  queryId: string
+  definitionId: string
   tenantId?: string
   version: string
   name?: string
   purpose?: string
-  query: DcqlQuery
+  definitionPayload?: IPresentationDefinition
+  dcqlPayload?: DcqlQueryPayload
   createdAt: Date
   lastUpdatedAt: Date
 }
 
-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, 'query'>>
+export type NonPersistedPresentationDefinitionItem = Omit<PresentationDefinitionItem, 'id' | 'createdAt' | 'lastUpdatedAt'>
+export type PartialPresentationDefinitionItem = Partial<PresentationDefinitionItem>
+export type PresentationDefinitionItemFilter = Partial<Omit<PresentationDefinitionItem, 'definitionPayload' | 'dcqlPayload'>>

package/src/utils/presentationDefinition/MappingUtils.ts

@@ -1,52 +1,64 @@
+import { DcqlQueryPayload } from '@sphereon/ssi-types'
+import { DcqlQuery } from 'dcql'
+import { PresentationDefinitionItemEntity } from '../../entities/presentationDefinition/PresentationDefinitionItemEntity'
 import type { IPresentationDefinition } from '@sphereon/pex'
+import type { NonPersistedPresentationDefinitionItem, PartialPresentationDefinitionItem, PresentationDefinitionItem } from '../../types'
 import * as blakepkg from 'blakejs'
-import { DcqlQuery } from 'dcql'
-import { DcqlQueryItemEntity } from '../../entities/presentationDefinition/DcqlQueryItemEntity'
-import type { NonPersistedDcqlQueryItem, PartialDcqlQueryItem, DcqlQueryItem } from '../../types'
 import { replaceNullWithUndefined } from '../FormattingUtils'
 
-export const dcqlQueryItemFrom = (entity: DcqlQueryItemEntity): DcqlQueryItem => {
-  const result: DcqlQueryItem = {
+export const presentationDefinitionItemFrom = (entity: PresentationDefinitionItemEntity): PresentationDefinitionItem => {
+  const result: PresentationDefinitionItem = {
     id: entity.id,
     tenantId: entity.tenantId,
-    queryId: entity.queryId,
+    definitionId: entity.definitionId,
     version: entity.version,
     name: entity.name,
     purpose: entity.purpose,
-    query: DcqlQuery.parse(JSON.parse(entity.query)),
+    definitionPayload: JSON.parse(entity.definitionPayload) as IPresentationDefinition,
+    ...(entity.dcqlPayload && {
+      dcqlPayload: {
+        queryId: entity.definitionId,
+        name: entity.name,
+        defaultPurpose: entity.purpose,
+        dcqlQuery: DcqlQuery.parse(JSON.parse(entity.dcqlPayload)),
+      },
+    }),
     createdAt: entity.createdAt,
     lastUpdatedAt: entity.lastUpdatedAt,
   }
 
-  if (result.query) {
-    DcqlQuery.validate(result.query)
+  if (result.dcqlPayload?.dcqlQuery) {
+    DcqlQuery.validate(result.dcqlPayload?.dcqlQuery)
   }
   return replaceNullWithUndefined(result)
 }
 
-export const dcqlQueryEntityItemFrom = (item: NonPersistedDcqlQueryItem): DcqlQueryItemEntity => {
-  const entity = new DcqlQueryItemEntity()
+export const presentationDefinitionEntityItemFrom = (item: NonPersistedPresentationDefinitionItem): PresentationDefinitionItemEntity => {
+  const entity = new PresentationDefinitionItemEntity()
 
   entity.tenantId = item.tenantId
-  entity.queryId = item.queryId!
+  entity.definitionId = item.definitionId!
   entity.version = item.version
   entity.name = item.name
   entity.purpose = item.purpose
-  if (item.query) {
-    const dcqlQuery = DcqlQuery.parse(item.query)
+  if (item.definitionPayload) {
+    entity.definitionPayload = JSON.stringify(item.definitionPayload)
+  }
+  if (item.dcqlPayload) {
+    const dcqlQuery = DcqlQuery.parse(item.dcqlPayload.dcqlQuery)
     DcqlQuery.validate(dcqlQuery)
-    entity.query = JSON.stringify(item.query)
+    entity.dcqlPayload = JSON.stringify(item.dcqlPayload.dcqlQuery)
   }
   return entity
 }
 
-function hashPayload(payload: IPresentationDefinition | DcqlQuery): string {
+function hashPayload(payload: IPresentationDefinition | DcqlQueryPayload): string {
   return blakepkg.blake2bHex(JSON.stringify(payload))
 }
 
-export function isPresentationDefinitionEqual(base: PartialDcqlQueryItem, compare: PartialDcqlQueryItem): boolean {
+export function isPresentationDefinitionEqual(base: PartialPresentationDefinitionItem, compare: PartialPresentationDefinitionItem): boolean {
   if (
-    base.queryId !== compare.queryId ||
+    base.definitionId !== compare.definitionId ||
     base.tenantId !== compare.tenantId ||
     base.version !== compare.version ||
     base.name !== compare.name ||
@@ -55,11 +67,19 @@ export function isPresentationDefinitionEqual(base: PartialDcqlQueryItem, compar
     return false
   }
 
-  if (base.query && compare.query) {
-    if (hashPayload(base.query) !== hashPayload(compare.query)) {
+  if (base.dcqlPayload && compare.dcqlPayload) {
+    if (hashPayload(base.dcqlPayload) !== hashPayload(compare.dcqlPayload)) {
+      return false
+    }
+  } else if (base.dcqlPayload || compare.dcqlPayload) {
+    return false
+  }
+
+  if (base.definitionPayload && compare.definitionPayload) {
+    if (hashPayload(base.definitionPayload) !== hashPayload(compare.definitionPayload)) {
       return false
     }
-  } else if (base.query || compare.query) {
+  } else if (base.definitionPayload || compare.definitionPayload) {
     return false
   }
 

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

@@ -1,25 +0,0 @@
-import { MigrationInterface, QueryRunner } from 'typeorm'
-
-export class CreateDcqlQueryItemPG1726588800000 implements MigrationInterface {
-  name = 'CreateDcqlQueryItemPG1726588800000'
-
-  public async up(queryRunner: QueryRunner): Promise<void> {
-    await queryRunner.query(`
-      CREATE TABLE "DcqlQueryItem" (
-                                     "id" uuid NOT NULL DEFAULT uuid_generate_v4(),
-                                     "tenant_id" TEXT,
-                                     "query_id" TEXT NOT NULL,
-                                     "name" TEXT,
-                                     "version" TEXT NOT NULL,
-                                     "purpose" TEXT,
-                                     "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"))
-    `)
-  }
-
-  public async down(queryRunner: QueryRunner): Promise<void> {
-    await queryRunner.query(`DROP TABLE "DcqlQueryItem"`)
-  }
-}

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

@@ -1,24 +0,0 @@
-import { MigrationInterface, QueryRunner } from 'typeorm'
-
-export class CreateDcqlQueryItemSQlite1726617600000 implements MigrationInterface {
-  name = 'CreateDcqlQueryItemSQlite1726617600000'
-
-  public async up(queryRunner: QueryRunner): Promise<void> {
-    await queryRunner.query(
-      `CREATE TABLE "DcqlQueryItem" (
-                                      "id" varchar PRIMARY KEY NOT NULL,
-                                      "tenant_id" varchar,
-                                      "query_id" varchar NOT NULL,
-                                      "name" varchar,
-                                      "version" varchar NOT NULL,
-                                      "purpose" varchar,
-                                      "query" varchar NOT NULL,
-                                      "created_at" datetime NOT NULL DEFAULT (datetime('now')),
-                                      "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')))`,
-    )
-  }
-
-  public async down(queryRunner: QueryRunner): Promise<void> {
-    await queryRunner.query(`DROP TABLE "DcqlQueryItem"`)
-  }
-}