@sphereon/ssi-sdk.data-store 0.24.1-next.42 → 0.24.1-next.98

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

@@ -0,0 +1,191 @@
+import { DataSource } from 'typeorm'
+import { DataStorePresentationDefinitionEntities, DataStorePresentationDefinitionMigrations, PDStore } from '../index'
+import { GetDefinitionsArgs, NonPersistedPresentationDefinitionItem, PresentationDefinitionItem } from '../types'
+
+describe('PDStore tests', (): void => {
+  let dbConnection: DataSource
+  let pdStore: PDStore
+
+  beforeEach(async (): Promise<void> => {
+    dbConnection = await new DataSource({
+      type: 'sqlite',
+      database: ':memory:',
+      logging: ['info'],
+      synchronize: false,
+      migrationsRun: false,
+      migrations: DataStorePresentationDefinitionMigrations,
+      entities: DataStorePresentationDefinitionEntities,
+    }).initialize()
+    await dbConnection.runMigrations()
+    expect(await dbConnection.showMigrations()).toBeFalsy()
+    pdStore = new PDStore(dbConnection)
+  })
+
+  afterEach(async (): Promise<void> => {
+    await dbConnection.destroy()
+  })
+
+  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 definitions', async (): Promise<void> => {
+    const definition1: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
+      version: '1.0',
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
+    }
+    const savedDefinition1: PresentationDefinitionItem = await pdStore.addDefinition(definition1)
+    expect(savedDefinition1).toBeDefined()
+
+    const definition2: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition2',
+      version: '1.0',
+      definitionPayload: { id: 'definition2', input_descriptors: [] },
+    }
+    const savedDefinition2: PresentationDefinitionItem = await pdStore.addDefinition(definition2)
+    expect(savedDefinition2).toBeDefined()
+
+    const result: Array<PresentationDefinitionItem> = await pdStore.getDefinitions({})
+
+    expect(result).toBeDefined()
+    expect(result.length).toEqual(2)
+  })
+
+  it('should get definitions 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 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 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 delete 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()
+
+    await pdStore.deleteDefinition({ itemId: savedDefinition.id })
+
+    await expect(pdStore.getDefinition({ itemId: savedDefinition.id })).rejects.toThrow(
+      `No presentation definition item found for id: ${savedDefinition.id}`,
+    )
+  })
+
+  it('should delete definitions by filter', async (): Promise<void> => {
+    const definition1: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
+      version: '1.0',
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
+    }
+    const savedDefinition1: PresentationDefinitionItem = await pdStore.addDefinition(definition1)
+    expect(savedDefinition1).toBeDefined()
+
+    const definition2: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition2',
+      version: '1.0',
+      definitionPayload: { id: 'definition2', input_descriptors: [] },
+    }
+    const savedDefinition2: PresentationDefinitionItem = await pdStore.addDefinition(definition2)
+    expect(savedDefinition2).toBeDefined()
+
+    const filter = { filter: [{ definitionId: 'definition1' }] }
+    await pdStore.deleteDefinitions(filter)
+
+    const remainingDefinitions: Array<PresentationDefinitionItem> = await pdStore.getDefinitions({})
+    expect(remainingDefinitions.length).toEqual(1)
+    expect(remainingDefinitions[0].definitionId).toEqual('definition2')
+  })
+})

package/src/entities/presentationDefinition/PresentationDefinitionItemEntity.ts

@@ -0,0 +1,43 @@
+import { BaseEntity, BeforeInsert, BeforeUpdate, Column, CreateDateColumn, Entity, Index, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
+import { IsNotEmpty } from 'class-validator'
+
+@Entity('PresentationDefinitionItem')
+@Index(['version'], { unique: false })
+export class PresentationDefinitionItemEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'definition_id', length: 255, nullable: false, unique: false })
+  @IsNotEmpty({ message: 'A blank definition id field is not allowed' })
+  definitionId!: string
+
+  @Column({ name: 'version', length: 255, nullable: false, unique: false })
+  @IsNotEmpty({ message: 'A blank version field is not allowed' })
+  version!: string
+
+  @Column({ name: 'tenant_id', length: 255, nullable: true, unique: false })
+  tenantId?: string
+
+  @Column({ name: 'purpose', length: 255, nullable: true, unique: false })
+  purpose?: string
+
+  @Column({ name: 'name', length: 255, nullable: true, unique: false })
+  name?: string
+
+  @Column({ name: 'definition_payload', type: 'text', nullable: false, unique: false })
+  @IsNotEmpty({ message: 'A blank definition payload field is not allowed' })
+  definitionPayload!: string
+
+  @CreateDateColumn({ name: 'created_at', nullable: false })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
+  lastUpdatedAt!: Date
+
+  // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
+  @BeforeInsert()
+  @BeforeUpdate()
+  updateUpdatedDate(): void {
+    this.lastUpdatedAt = new Date()
+  }
+}

package/src/index.ts

@@ -34,11 +34,15 @@ export { StatusListStore } from './statusList/StatusListStore'
 import { AuditEventEntity, auditEventEntityFrom } from './entities/eventLogger/AuditEventEntity'
 import { DigitalCredentialEntity } from './entities/digitalCredential/DigitalCredentialEntity'
 import { digitalCredentialFrom, digitalCredentialsFrom, nonPersistedDigitalCredentialEntityFromAddArgs } from './utils/digitalCredential/MappingUtils'
+import { isPresentationDefinitionEqual } from './utils/presentationDefinition/MappingUtils'
+import { PresentationDefinitionItemEntity } from './entities/presentationDefinition/PresentationDefinitionItemEntity'
 import { ContactMetadataItemEntity } from './entities/contact/ContactMetadataItemEntity'
 export { AbstractEventLoggerStore } from './eventLogger/AbstractEventLoggerStore'
 export { EventLoggerStore } from './eventLogger/EventLoggerStore'
 export { IAbstractMachineStateStore } from './machineState/IAbstractMachineStateStore'
 export { MachineStateStore } from './machineState/MachineStateStore'
+export { AbstractPDStore } from './presentationDefinition/AbstractPDStore'
+export { PDStore } from './presentationDefinition/PDStore'
 
 export {
   DataStoreMigrations,
@@ -47,6 +51,7 @@ export {
   DataStoreIssuanceBrandingMigrations,
   DataStoreStatusListMigrations,
   DataStoreMachineStateMigrations,
+  DataStorePresentationDefinitionMigrations,
 } from './migrations'
 export * from './types'
 export * from './utils/contact/MappingUtils'
@@ -82,6 +87,8 @@ export const DataStoreIssuanceBrandingEntities = [
   IssuerLocaleBrandingEntity,
 ]
 
+export const DataStorePresentationDefinitionEntities = [PresentationDefinitionItemEntity]
+
 export const DataStoreStatusListEntities = [StatusListEntity, StatusListEntryEntity]
 
 export const DataStoreEventLoggerEntities = [AuditEventEntity]
@@ -98,6 +105,7 @@ export const DataStoreEntities = [
   ...DataStoreEventLoggerEntities,
   ...DataStoreDigitalCredentialEntities,
   ...DataStoreMachineStateEntities,
+  ...DataStorePresentationDefinitionEntities,
 ]
 
 export {
@@ -140,5 +148,7 @@ export {
   digitalCredentialsFrom,
   nonPersistedDigitalCredentialEntityFromAddArgs,
   MachineStateInfoEntity,
+  PresentationDefinitionItemEntity,
+  isPresentationDefinitionEqual,
   ContactMetadataItemEntity,
 }

package/src/migrations/generic/10-CreatePresentationDefinitions.ts

@@ -0,0 +1,66 @@
+import { DatabaseType, MigrationInterface, QueryRunner } from 'typeorm'
+import Debug from 'debug'
+import { CreatePresentationDefinitions1716475165345 } from '../postgres/1716475165345-CreatePresentationDefinitions'
+import { CreatePresentationDefinitions1716475165344 } from '../sqlite/1716475165344-CreatePresentationDefinitions'
+
+const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:migrations')
+
+export class CreatePresentationDefinitions1716533767523 implements MigrationInterface {
+  name = 'CreatePresentationDefinitionItems1716533767523'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    debug('migration: creating machine state tables')
+    const dbType: DatabaseType = queryRunner.connection.driver.options.type
+
+    switch (dbType) {
+      case 'postgres': {
+        debug('using postgres migration file')
+        const mig: CreatePresentationDefinitions1716475165345 = new CreatePresentationDefinitions1716475165345()
+        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: CreatePresentationDefinitions1716475165344 = new CreatePresentationDefinitions1716475165344()
+        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 machine state tables')
+    const dbType: DatabaseType = queryRunner.connection.driver.options.type
+
+    switch (dbType) {
+      case 'postgres': {
+        debug('using postgres migration file')
+        const mig: CreatePresentationDefinitions1716475165345 = new CreatePresentationDefinitions1716475165345()
+        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: CreatePresentationDefinitions1716475165344 = new CreatePresentationDefinitions1716475165344()
+        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

@@ -7,6 +7,7 @@ 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'
 
 /**
  * The migrations array that SHOULD be used when initializing a TypeORM database connection.
@@ -28,6 +29,7 @@ export const DataStoreStatusListMigrations = [CreateStatusList1693866470000]
 export const DataStoreEventLoggerMigrations = [CreateAuditEvents1701635835330]
 export const DataStoreDigitalCredentialMigrations = [CreateDigitalCredential1708525189000]
 export const DataStoreMachineStateMigrations = [CreateMachineStateStore1708098041262]
+export const DataStorePresentationDefinitionMigrations = [CreatePresentationDefinitions1716533767523]
 
 // All migrations together
 export const DataStoreMigrations = [
@@ -37,4 +39,5 @@ export const DataStoreMigrations = [
   ...DataStoreEventLoggerMigrations,
   ...DataStoreDigitalCredentialMigrations,
   ...DataStoreMachineStateMigrations,
+  ...DataStorePresentationDefinitionMigrations,
 ]

package/src/migrations/index.ts

@@ -6,4 +6,5 @@ export {
   DataStoreStatusListMigrations,
   DataStoreDigitalCredentialMigrations,
   DataStoreMachineStateMigrations,
+  DataStorePresentationDefinitionMigrations,
 } from './generic'

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

@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class CreatePresentationDefinitions1716475165345 implements MigrationInterface {
+  name = 'CreatePresentationDefinitions1716475165345'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+CREATE TABLE "PresentationDefinitionItem" (
+    "id" uuid NOT NULL DEFAULT uuid_generate_v4(), 
+    "tenant_id" TEXT, 
+    "definition_id" TEXT NOT NULL,
+    "name" TEXT,
+    "version" TEXT NOT NULL, 
+    "purpose" TEXT, 
+    "definition_payload" TEXT NOT NULL, 
+    "created_at" TIMESTAMP NOT NULL DEFAULT now(), 
+    "last_updated_at" TIMESTAMP NOT NULL DEFAULT now(), 
+    CONSTRAINT "PK_PresentationDefinitionItem_id" PRIMARY KEY ("id"))
+                                          `)
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "PresentationDefinitionItem"`)
+  }
+}

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

@@ -0,0 +1,24 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class CreatePresentationDefinitions1716475165344 implements MigrationInterface {
+  name = 'CreatePresentationDefinitions1716475165344'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "PresentationDefinitionItem" (
+    "id" varchar PRIMARY KEY NOT NULL, 
+    "tenant_id" varchar,
+    "definition_id" varchar NOT NULL,
+    "name" varchar,
+    "version" varchar NOT NULL,
+    "purpose" varchar,
+    "definition_payload" 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 "PresentationDefinitionItem"`)
+  }
+}

package/src/presentationDefinition/AbstractPDStore.ts

@@ -0,0 +1,20 @@
+import {
+  GetDefinitionArgs,
+  GetDefinitionsArgs,
+  DeleteDefinitionArgs,
+  PresentationDefinitionItem,
+  AddDefinitionArgs,
+  UpdateDefinitionArgs,
+  DeleteDefinitionsArgs,
+} from '../types'
+
+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 deleteDefinition(args: DeleteDefinitionArgs): Promise<void>
+  abstract deleteDefinitions(args: DeleteDefinitionsArgs): Promise<number>
+}

package/src/presentationDefinition/PDStore.ts

@@ -0,0 +1,185 @@
+import { OrPromise } from '@sphereon/ssi-types'
+import { DataSource, In, Repository } from 'typeorm'
+import { AbstractPDStore } from './AbstractPDStore'
+import Debug from 'debug'
+import {
+  DeleteDefinitionArgs,
+  DeleteDefinitionsArgs,
+  GetDefinitionArgs,
+  GetDefinitionsArgs,
+  HasDefinitionArgs,
+  HasDefinitionsArgs,
+  NonPersistedPresentationDefinitionItem,
+  PresentationDefinitionItem,
+  PresentationDefinitionItemFilter,
+} from '../types'
+import { PresentationDefinitionItemEntity } from '../entities/presentationDefinition/PresentationDefinitionItemEntity'
+import { presentationDefinitionEntityItemFrom, presentationDefinitionItemFrom } from '../utils/presentationDefinition/MappingUtils'
+
+const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:pd-store')
+
+export class PDStore extends AbstractPDStore {
+  private readonly dbConnection: OrPromise<DataSource>
+
+  constructor(dbConnection: OrPromise<DataSource>) {
+    super()
+    this.dbConnection = dbConnection
+  }
+
+  getDefinition = async (args: GetDefinitionArgs): Promise<PresentationDefinitionItem> => {
+    const { itemId } = args ?? {}
+    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 presentationDefinitionItemFrom(result)
+  }
+
+  hasDefinition = async (args: HasDefinitionArgs): Promise<boolean> => {
+    const { itemId } = args ?? {}
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
+
+    const resultCount: number = await pdRepository.count({
+      where: { id: itemId },
+    })
+
+    return resultCount > 0
+  }
+
+  hasDefinitions = async (args: HasDefinitionsArgs): Promise<boolean> => {
+    const { filter } = args
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
+
+    const resultCount: number = await pdRepository.count({
+      ...(filter && { where: cleanFilter(filter) }),
+    })
+    return resultCount > 0
+  }
+
+  getDefinitions = async (args: GetDefinitionsArgs): Promise<Array<PresentationDefinitionItem>> => {
+    const { filter } = args
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
+    const initialResult = await this.findIds(pdRepository, filter)
+    const result: Array<PresentationDefinitionItemEntity> = await pdRepository.find({
+      where: {
+        id: In(initialResult.map((entity: PresentationDefinitionItemEntity) => entity.id)),
+      },
+      order: {
+        version: 'DESC',
+      },
+    })
+
+    return result.map((entity: PresentationDefinitionItemEntity) => presentationDefinitionItemFrom(entity))
+  }
+
+  addDefinition = async (item: NonPersistedPresentationDefinitionItem): Promise<PresentationDefinitionItem> => {
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
+
+    const entity: PresentationDefinitionItemEntity = presentationDefinitionEntityItemFrom(item)
+    debug('Adding presentation definition entity', item)
+    const result: PresentationDefinitionItemEntity = await pdRepository.save(entity, {
+      transaction: true,
+    })
+
+    return presentationDefinitionItemFrom(result)
+  }
+
+  updateDefinition = async (item: PresentationDefinitionItem): Promise<PresentationDefinitionItem> => {
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
+
+    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<PresentationDefinitionItemEntity> = {
+      ...result,
+    }
+    updatedEntity.tenantId = item.tenantId
+    updatedEntity.definitionId = item.definitionId!
+    updatedEntity.version = item.version
+    updatedEntity.name = item.name
+    updatedEntity.purpose = item.purpose
+    updatedEntity.definitionPayload = JSON.stringify(item.definitionPayload!)
+
+    debug('Updating presentation definition entity', updatedEntity)
+    const updateResult: PresentationDefinitionItemEntity = await pdRepository.save(updatedEntity, {
+      transaction: true,
+    })
+
+    return presentationDefinitionItemFrom(updateResult)
+  }
+
+  deleteDefinition = async (args: DeleteDefinitionArgs): Promise<void> => {
+    const { itemId } = args
+
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
+    const entity: PresentationDefinitionItemEntity | null = await pdRepository.findOne({
+      where: { id: itemId },
+    })
+
+    if (!entity) {
+      return Promise.reject(Error(`No presentation definition found with id: ${itemId}`))
+    }
+
+    debug('Deleting presentation definition entity', entity)
+    await pdRepository.delete(entity.id)
+  }
+
+  deleteDefinitions = async (args: DeleteDefinitionsArgs): Promise<number> => {
+    const { filter } = args
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
+    const initialResult = await this.findIds(pdRepository, filter)
+
+    const result: Array<PresentationDefinitionItemEntity> = await pdRepository.find({
+      where: {
+        id: In(initialResult.map((entity: PresentationDefinitionItemEntity) => entity.id)),
+      },
+    })
+
+    for (const entity of result) {
+      debug('Deleting presentation definition entity', entity.id)
+      await pdRepository.delete(entity.id)
+    }
+    return result.length
+  }
+
+  findIds = async (
+    pdRepository: Repository<PresentationDefinitionItemEntity>,
+    filter: Array<PresentationDefinitionItemFilter> | undefined,
+  ): Promise<Array<PresentationDefinitionItemEntity>> => {
+    const idFilter = filter?.find((f) => f.id !== undefined && f.id !== null)
+    if (idFilter) {
+      return await pdRepository.find({
+        where: { id: idFilter.id },
+      })
+    } else {
+      return await pdRepository.find({
+        ...(filter && { where: cleanFilter(filter) }),
+      })
+    }
+  }
+}
+
+const cleanFilter = (filter: Array<PresentationDefinitionItemFilter> | undefined): Array<PresentationDefinitionItemFilter> | undefined => {
+  if (filter === undefined) {
+    return undefined
+  }
+
+  return filter.map((item) => {
+    const cleanedItem: PresentationDefinitionItemFilter = {}
+    for (const key in item) {
+      const value = item[key as keyof PresentationDefinitionItemFilter]
+      if (value !== undefined) {
+        ;(cleanedItem as any)[key] = value
+      }
+    }
+    return cleanedItem
+  })
+}

package/src/types/index.ts

@@ -1,6 +1,8 @@
 export * from './issuanceBranding/issuanceBranding'
 export * from './issuanceBranding/IAbstractIssuanceBrandingStore'
 export * from './contact/contact'
+export * from './presentationDefinition/presentationDefinition'
+export * from './presentationDefinition/IAbstractPDStore'
 export * from './contact/IAbstractContactStore'
 export * from './validation/validation'
 export * from './statusList/statusList'

package/src/types/presentationDefinition/IAbstractPDStore.ts

@@ -0,0 +1,25 @@
+import { NonPersistedPresentationDefinitionItem, PresentationDefinitionItem, PresentationDefinitionItemFilter } from './presentationDefinition'
+
+export type FindDefinitionArgs = Array<PresentationDefinitionItemFilter>
+
+export type GetDefinitionArgs = {
+  itemId: string
+}
+
+export type HasDefinitionArgs = GetDefinitionArgs
+
+export type GetDefinitionsArgs = {
+  filter?: FindDefinitionArgs
+}
+
+export type HasDefinitionsArgs = GetDefinitionsArgs
+
+export type AddDefinitionArgs = NonPersistedPresentationDefinitionItem
+
+export type UpdateDefinitionArgs = PresentationDefinitionItem
+
+export type DeleteDefinitionArgs = {
+  itemId: string
+}
+
+export type DeleteDefinitionsArgs = GetDefinitionsArgs