@sphereon/ssi-sdk.data-store 0.34.1-feature.SSISDK.26.RP.58 → 0.34.1-feature.SSISDK.45.189

package/src/entities/digitalCredential/DigitalCredentialEntity.ts

@@ -1,9 +1,10 @@
 import { typeormDate, typeOrmDateTime } from '@sphereon/ssi-sdk.agent-config'
+import { CredentialRole } from '@sphereon/ssi-types'
 import { BaseEntity, Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
+
 import {
   CredentialCorrelationType,
   CredentialDocumentFormat,
-  CredentialRole,
   CredentialStateType,
   type DigitalCredential,
   DocumentType,

package/src/entities/presentationDefinition/{PresentationDefinitionItemEntity.ts → DcqlQueryItemEntity.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('PresentationDefinitionItem')
+@Entity('DcqlQueryItem')
 @Index(['version'], { unique: false })
-export class PresentationDefinitionItemEntity extends BaseEntity {
+export class DcqlQueryItemEntity extends BaseEntity {
   @PrimaryGeneratedColumn('uuid')
   id!: 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: 'query_id', length: 255, type: 'varchar', nullable: false, unique: false })
+  @IsNotEmpty({ message: 'A blank query id field is not allowed' })
+  queryId!: string
 
   @Column({ name: 'version', length: 255, type: 'varchar', nullable: false, unique: false })
   @IsNotEmpty({ message: 'A blank version field is not allowed' })
@@ -25,13 +25,9 @@ export class PresentationDefinitionItemEntity extends BaseEntity {
   @Column({ name: 'name', length: 255, type: 'varchar', nullable: true, unique: false })
   name?: string
 
-  @Column({ name: 'definition_payload', type: 'text', nullable: false, unique: false }) // TODO should this become nullable now we have dcqlPayload?
-  @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
+  @Column({ name: 'query', type: 'text', nullable: false, unique: false })
+  @IsNotEmpty({ message: 'A blank dcql query payload field is not allowed' })
+  query!: 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 { PresentationDefinitionItemEntity } from './entities/presentationDefinition/PresentationDefinitionItemEntity'
+import { DcqlQueryItemEntity } from './entities/presentationDefinition/DcqlQueryItemEntity'
 import { ContactMetadataItemEntity } from './entities/contact/ContactMetadataItemEntity'
 import { CredentialClaimsEntity } from './entities/issuanceBranding/CredentialClaimsEntity'
 
@@ -99,7 +99,7 @@ export const DataStoreIssuanceBrandingEntities = [
   CredentialClaimsEntity,
 ]
 
-export const DataStorePresentationDefinitionEntities = [PresentationDefinitionItemEntity]
+export const DataStorePresentationDefinitionEntities = [DcqlQueryItemEntity]
 
 export const DataStoreStatusListEntities = [
   StatusListEntity,
@@ -158,7 +158,7 @@ export {
   AuditEventEntity,
   DigitalCredentialEntity,
   MachineStateInfoEntity,
-  PresentationDefinitionItemEntity,
+  DcqlQueryItemEntity,
   ContactMetadataItemEntity,
   CredentialClaimsEntity,
   Oid4vcStateEntity,

package/src/migrations/generic/12-CreateBitstringStatusList.ts

@@ -1,10 +1,40 @@
-import { DatabaseType, MigrationInterface, QueryRunner } from 'typeorm'
 import Debug from 'debug'
-import { CreateBitstringStatusListPG1741895823000 } from '../postgres/1741895823000-CreateBitstringStatusList'
+import { DatabaseType, MigrationInterface, QueryRunner } from 'typeorm'
+
+import {
+  AddBitstringStatusListEnumPG1741895823000,
+  CreateBitstringStatusListPG1741895823000,
+} from '../postgres/1741895823000-CreateBitstringStatusList'
 import { CreateBitstringStatusListSqlite1741895823001 } from '../sqlite/1741895823001-CreateBitstringStatusList'
 
 const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:migrations')
 
+export class AddBitstringStatusListEnum1741895823000 implements MigrationInterface {
+  name = 'AddBitstringStatusListEnum1741895823000'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    debug('migration: creating bitstring status list tables')
+    const dbType: DatabaseType = queryRunner.connection.driver.options.type
+    switch (dbType) {
+      case 'postgres': {
+        const mig = new AddBitstringStatusListEnumPG1741895823000()
+        await mig.up(queryRunner)
+        return
+      }
+      case 'sqlite':
+      case 'expo':
+      case 'react-native': {
+        return
+      }
+      default:
+        return Promise.reject(`Migrations only supported for sqlite and postgres. Was ${dbType}`)
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async down(queryRunner: QueryRunner): Promise<void> {}
+}
+
 export class CreateBitstringStatusList1741895823000 implements MigrationInterface {
   name = 'CreateBitstringStatusList1741895823000'
 

package/src/migrations/generic/13-CreateDcqlQueryItem.ts

@@ -0,0 +1,67 @@
+import Debug from 'debug'
+import { DatabaseType, MigrationInterface, QueryRunner } from 'typeorm'
+
+import { CreateDcqlQueryItemPG1726588800000 } from '../postgres/1726588800000-CreateDcqlQueryItem'
+import { CreateDcqlQueryItemSQlite1726617600000 } from '../sqlite/1726617600000-CreateDcqlQueryItem'
+
+const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:migrations')
+
+export class CreateDcqlQueryItem1726617600000 implements MigrationInterface {
+  name = 'CreateDcqlQueryItem1726617600000'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    debug('migration: updating presentation definition item nullable fields')
+    const dbType: DatabaseType = queryRunner.connection.driver.options.type
+
+    switch (dbType) {
+      case 'postgres': {
+        debug('using postgres migration file')
+        const mig: CreateDcqlQueryItemPG1726588800000 = new CreateDcqlQueryItemPG1726588800000()
+        await mig.up(queryRunner)
+        debug('Migration statements executed')
+        return
+      }
+      case 'sqlite':
+      case 'expo':
+      case 'react-native': {
+        debug('using sqlite/react-native migration file')
+        const mig: CreateDcqlQueryItemSQlite1726617600000 = new CreateDcqlQueryItemSQlite1726617600000()
+        await mig.up(queryRunner)
+        debug('Migration statements executed')
+        return
+      }
+      default:
+        return Promise.reject(
+          `Migrations are currently only supported for sqlite, react-native, expo and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`,
+        )
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    debug('migration: reverting presentation definition item nullable fields')
+    const dbType: DatabaseType = queryRunner.connection.driver.options.type
+
+    switch (dbType) {
+      case 'postgres': {
+        debug('using postgres migration file')
+        const mig: CreateDcqlQueryItemPG1726588800000 = new CreateDcqlQueryItemPG1726588800000()
+        await mig.down(queryRunner)
+        debug('Migration statements executed')
+        return
+      }
+      case 'sqlite':
+      case 'expo':
+      case 'react-native': {
+        debug('using sqlite/react-native migration file')
+        const mig: CreateDcqlQueryItemSQlite1726617600000 = new CreateDcqlQueryItemSQlite1726617600000()
+        await mig.down(queryRunner)
+        debug('Migration statements executed')
+        return
+      }
+      default:
+        return Promise.reject(
+          `Migrations are currently only supported for sqlite, react-native, expo and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`,
+        )
+    }
+  }
+}

package/src/migrations/generic/index.ts

@@ -1,4 +1,8 @@
 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 { CreateIssuanceBranding1659463079429 } from './2-CreateIssuanceBranding'
 import { CreateContacts1690925872318 } from './3-CreateContacts'
 import { CreateStatusList1693866470000 } from './4-CreateStatusList'
@@ -7,9 +11,6 @@ import { CreateDigitalCredential1708525189000 } from './6-CreateDigitalCredentia
 import { CreateMachineStateStore1708098041262 } from './7-CreateMachineStateStore'
 import { CreateContacts1708525189000 } from './8-CreateContacts'
 import { CreateContacts1715761125000 } from './9-CreateContacts'
-import { CreatePresentationDefinitions1716533767523 } from './10-CreatePresentationDefinitions'
-import { FixCredentialClaimsReferencesUuid1741895822987 } from './11-FixCredentialClaimsReferenceUuid'
-import { CreateBitstringStatusList1741895823000 } from './12-CreateBitstringStatusList'
 
 /**
  * The migrations array that SHOULD be used when initializing a TypeORM database connection.
@@ -27,11 +28,15 @@ export const DataStoreContactMigrations = [
   CreateContacts1715761125000,
 ]
 export const DataStoreIssuanceBrandingMigrations = [CreateIssuanceBranding1659463079429, FixCredentialClaimsReferencesUuid1741895822987]
-export const DataStoreStatusListMigrations = [CreateStatusList1693866470000, CreateBitstringStatusList1741895823000]
+export const DataStoreStatusListMigrations = [
+  CreateStatusList1693866470000,
+  AddBitstringStatusListEnum1741895823000,
+  CreateBitstringStatusList1741895823000,
+]
 export const DataStoreEventLoggerMigrations = [CreateAuditEvents1701635835330]
 export const DataStoreDigitalCredentialMigrations = [CreateDigitalCredential1708525189000]
 export const DataStoreMachineStateMigrations = [CreateMachineStateStore1708098041262]
-export const DataStorePresentationDefinitionMigrations = [CreatePresentationDefinitions1716533767523]
+export const DataStorePresentationDefinitionMigrations = [CreatePresentationDefinitions1716533767523, CreateDcqlQueryItem1726617600000]
 
 // 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, 
-    "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

@@ -0,0 +1,25 @@
+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/postgres/1737110469001-UpdateStatusList.ts

@@ -10,7 +10,7 @@ export class UpdateStatusList1737110469001 implements MigrationInterface {
     // Make columns nullable and add new columns
     await queryRunner.query(`ALTER TABLE "StatusList" ALTER COLUMN "indexingDirection" DROP NOT NULL`)
     await queryRunner.query(`ALTER TABLE "StatusList" ALTER COLUMN "statusPurpose" DROP NOT NULL`)
-    await queryRunner.query(`ALTER TABLE "StatusList" ADD "bitsPerStatus" integer`)
+    await queryRunner.query(`ALTER TABLE "StatusList" ADD "bitsPerStatus" integer DEFAULT 1`)
     await queryRunner.query(`ALTER TABLE "StatusList" ADD "expiresAt" timestamp with time zone`)
   }
 

package/src/migrations/postgres/1741895823000-CreateBitstringStatusList.ts

@@ -1,11 +1,25 @@
 import { MigrationInterface, QueryRunner } from 'typeorm'
 
+export class AddBitstringStatusListEnumPG1741895823000 implements MigrationInterface {
+  name = 'AddBitstringStatusListEnum1741895823000'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.startTransaction()
+    await queryRunner.query(`ALTER TYPE "StatusList_type_enum" ADD VALUE 'BitstringStatusList'`)
+    await queryRunner.commitTransaction()
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    // Note: Cannot remove enum value in Postgres without recreating the type
+  }
+}
+
 export class CreateBitstringStatusListPG1741895823000 implements MigrationInterface {
   name = 'CreateBitstringStatusList1741895823000'
 
   public async up(queryRunner: QueryRunner): Promise<void> {
     // Add BitstringStatusList columns to StatusList table
-    await queryRunner.query(`ALTER TABLE "StatusList" ADD COLUMN "bitsPerStatus" integer DEFAULT 1`)
     await queryRunner.query(`ALTER TABLE "StatusList" ADD COLUMN "ttl" integer`)
     await queryRunner.query(`ALTER TABLE "StatusList" ADD COLUMN "validFrom" TIMESTAMP`)
     await queryRunner.query(`ALTER TABLE "StatusList" ADD COLUMN "validUntil" TIMESTAMP`)
@@ -21,7 +35,6 @@ export class CreateBitstringStatusListPG1741895823000 implements MigrationInterf
 
     // Add BitstringStatusListEntry specific columns to StatusListEntry table
     await queryRunner.query(`ALTER TABLE "StatusListEntry" ADD COLUMN "statusPurpose" character varying`)
-    await queryRunner.query(`ALTER TABLE "StatusListEntry" ADD COLUMN "bitsPerStatus" integer DEFAULT 1`)
     await queryRunner.query(`ALTER TABLE "StatusListEntry" ADD COLUMN "statusMessage" text`)
     await queryRunner.query(`ALTER TABLE "StatusListEntry" ADD COLUMN "statusReference" text`)
 

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

@@ -0,0 +1,24 @@
+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"`)
+  }
+}

package/src/presentationDefinition/AbstractPDStore.ts

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

package/src/types/contact/contact.ts

@@ -1,7 +1,7 @@
 import { ManagedIdentifierOptsOrResult } from '@sphereon/ssi-sdk-ext.identifier-resolution'
 import { IIdentifier } from '@veramo/core'
 import { IIssuerLocaleBranding } from '../issuanceBranding/issuanceBranding'
-import { CredentialRole } from '../digitalCredential'
+import { CredentialRole } from '@sphereon/ssi-types'
 
 export type MetadataTypes = string | number | Date | boolean | undefined
 

package/src/types/digitalCredential/IAbstractDigitalCredentialStore.ts

@@ -2,7 +2,8 @@ import { HasherSync } from '@sphereon/ssi-types'
 import { FindOptionsOrder } from 'typeorm'
 import { DigitalCredentialEntity } from '../../entities/digitalCredential/DigitalCredentialEntity'
 import { DigitalCredential } from './types'
-import { CredentialCorrelationType, CredentialRole, CredentialStateType, RegulationType } from './enums'
+import { CredentialCorrelationType, CredentialStateType, RegulationType } from './enums'
+import { CredentialRole } from '@sphereon/ssi-types'
 
 export type GetCredentialArgs = { id: string } | { hash: string }
 

package/src/types/digitalCredential/enums.ts

@@ -56,13 +56,6 @@ export enum CredentialCorrelationType {
   URL = 'URL',
 }
 
-export enum CredentialRole {
-  ISSUER = 'ISSUER',
-  VERIFIER = 'VERIFIER',
-  HOLDER = 'HOLDER',
-  FEDERATION_TRUST_ANCHOR = 'FEDERATION_TRUST_ANCHOR',
-}
-
 export enum CredentialStateType {
   REVOKED = 'REVOKED',
   VERIFIED = 'VERIFIED',

package/src/types/digitalCredential/types.ts

@@ -1,4 +1,5 @@
-import { CredentialCorrelationType, CredentialDocumentFormat, CredentialRole, CredentialStateType, DocumentType, RegulationType } from './enums'
+import { CredentialCorrelationType, CredentialDocumentFormat, CredentialStateType, DocumentType, RegulationType } from './enums'
+import { CredentialRole } from '@sphereon/ssi-types'
 
 /**
  * DigitalCredential

package/src/types/presentationDefinition/IAbstractPDStore.ts

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