@sphereon/ssi-sdk.data-store 0.24.1-unstable.9 → 0.25.0

package/src/migrations/sqlite/1690925872693-CreateContacts.ts

@@ -12,6 +12,7 @@ export class CreateContacts1690925872693 implements MigrationInterface {
     )
     await queryRunner.query(`DROP TABLE "CorrelationIdentifier"`)
     await queryRunner.query(`ALTER TABLE "temporary_CorrelationIdentifier" RENAME TO "CorrelationIdentifier"`)
+    // roles not null
     await queryRunner.query(
       `CREATE TABLE "temporary_Identity" ("id" varchar PRIMARY KEY NOT NULL, "alias" varchar(255) NOT NULL, "roles" text NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "contactId" varchar, CONSTRAINT "UQ_Identity_alias" UNIQUE ("alias"))`,
     )
@@ -34,6 +35,7 @@ export class CreateContacts1690925872693 implements MigrationInterface {
     )
     await queryRunner.query(`DROP TABLE "CorrelationIdentifier"`)
     await queryRunner.query(`ALTER TABLE "temporary_CorrelationIdentifier" RENAME TO "CorrelationIdentifier"`)
+    // contactId -> partyId
     await queryRunner.query(
       `CREATE TABLE "temporary_Identity" ("id" varchar PRIMARY KEY NOT NULL, "alias" varchar(255) NOT NULL, "roles" text NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "partyId" varchar, CONSTRAINT "UQ_Identity_alias" UNIQUE ("alias"))`,
     )
@@ -49,7 +51,7 @@ export class CreateContacts1690925872693 implements MigrationInterface {
     await queryRunner.query(`DROP TABLE "Connection"`)
     await queryRunner.query(`ALTER TABLE "temporary_Connection" RENAME TO "Connection"`)
     await queryRunner.query(
-      `CREATE TABLE "PartyType" ("id" varchar PRIMARY KEY NOT NULL, "type" varchar CHECK( "type" IN ('naturalPerson','organization') ) NOT NULL, "origin" varchar CHECK( "origin" IN ('INTERNAL', 'EXTERNAL') ) NOT NULL DEFAULT 'EXTERNAL', "name" varchar(255) NOT NULL, "description" varchar(255), "tenant_id" varchar(255) NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), CONSTRAINT "UQ_PartyType_name" UNIQUE ("name"))`,
+      `CREATE TABLE "PartyType" ("id" varchar PRIMARY KEY NOT NULL, "type" varchar CHECK( "type" IN ('naturalPerson','organization') ) NOT NULL, "origin" varchar CHECK( "origin" IN ('INTERNAL', 'EXTERNAL') ) NOT NULL, "name" varchar(255) NOT NULL, "description" varchar(255), "tenant_id" varchar(255) NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), CONSTRAINT "UQ_PartyType_name" UNIQUE ("name"))`,
     )
     await queryRunner.query(`CREATE UNIQUE INDEX "IDX_PartyType_type_tenant_id" ON "PartyType" ("type", "tenant_id")`)
     await queryRunner.query(
@@ -109,6 +111,7 @@ export class CreateContacts1690925872693 implements MigrationInterface {
     )
     await queryRunner.query(`DROP TABLE "Party"`)
     await queryRunner.query(`ALTER TABLE "temporary_Party" RENAME TO "Party"`)
+    // Restore lost FK_Identity_partyId
     await queryRunner.query(
       `CREATE TABLE "temporary_Identity" ("id" varchar PRIMARY KEY NOT NULL, "alias" varchar(255) NOT NULL, "roles" text NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "partyId" varchar, CONSTRAINT "UQ_Identity_alias" UNIQUE ("alias"), CONSTRAINT "FK_Identity_partyId" FOREIGN KEY ("partyId") REFERENCES "Party" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`,
     )
@@ -155,7 +158,71 @@ export class CreateContacts1690925872693 implements MigrationInterface {
   }
 
   public async down(queryRunner: QueryRunner): Promise<void> {
-    // TODO DPP-27 implement downgrade
-    return Promise.reject(Error(`Downgrade is not yet implemented for ${this.name}`))
+    await queryRunner.query(
+      `CREATE TABLE "Contact" ("id" varchar PRIMARY KEY NOT NULL, "uri" varchar(255), "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "name" varchar(255), "alias" varchar(255))`,
+    )
+    await queryRunner.query(
+      `INSERT INTO "Contact"(id, uri, created_at, last_updated_at, name, alias) SELECT id, uri, created_at, last_updated_at, (SELECT legal_name FROM "BaseContact" WHERE "BaseContact"."party_id" = "Party"."id"), (SELECT display_name FROM "BaseContact" WHERE "BaseContact"."party_id" = "Party"."id") FROM "Party" WHERE party_type_id = '3875c12e-fdaa-4ef6-a340-c936e054b627'`,
+    )
+    await queryRunner.query(`DROP TABLE "BaseContact"`)
+    await queryRunner.query(`DROP TABLE "Party"`)
+
+    await queryRunner.query(
+      `CREATE TABLE "BaseConfigEntity" ("id" varchar PRIMARY KEY NOT NULL, "identifier" varchar(255), "redirect_url" varchar(255), "session_id" varchar(255), "client_id" varchar(255), "client_secret" varchar(255), "scopes" text, "issuer" varchar(255), "dangerously_allow_insecure_http_requests" boolean, "client_auth_method" text, "type" varchar NOT NULL, "connectionId" varchar)`,
+    )
+    await queryRunner.query(
+      `INSERT INTO "BaseConfigEntity"("id", "identifier", "redirect_url", "session_id", "client_id", "client_secret", "scopes", "issuer", "dangerously_allow_insecure_http_requests", "client_auth_method", "type", "connectionId") SELECT "id", "identifier", "redirect_url", "session_id", "client_id", "client_secret", "scopes", "issuer", "dangerously_allow_insecure_http_requests", "client_auth_method", "type", "connection_id" FROM "BaseConfig"`,
+    )
+    await queryRunner.query(`DROP TABLE "BaseConfig"`)
+
+    await queryRunner.query(
+      `CREATE TABLE "temporary_Party" ("id" varchar PRIMARY KEY NOT NULL, "uri" varchar(255), "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "party_type_id" varchar NOT NULL, CONSTRAINT "FK_Party_party_type_id" FOREIGN KEY ("party_type_id") REFERENCES "PartyType" ("id") ON DELETE NO ACTION ON UPDATE NO ACTION)`,
+    )
+    await queryRunner.query(
+      `INSERT INTO "temporary_Party"("id", "uri", "created_at", "last_updated_at", "party_type_id") SELECT "id", "uri", "created_at", "last_updated_at", "party_type_id" FROM "Party"`,
+    )
+    await queryRunner.query(`DROP TABLE "Party"`)
+    await queryRunner.query(`ALTER TABLE "temporary_Party" RENAME TO "Party"`)
+
+    await queryRunner.query(`DROP INDEX "IDX_PartyRelationship_left_right"`)
+    await queryRunner.query(
+      `CREATE TABLE "temporary_PartyRelationship" ("id" varchar PRIMARY KEY NOT NULL, "left_id" varchar NOT NULL, "right_id" varchar NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), CONSTRAINT "FK_PartyRelationship_left_id" FOREIGN KEY ("left_id") REFERENCES "Party" ("id") ON DELETE CASCADE ON UPDATE NO ACTION, CONSTRAINT "FK_PartyRelationship_right_id" FOREIGN KEY ("right_id") REFERENCES "Party" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`,
+    )
+    await queryRunner.query(
+      `INSERT INTO "temporary_PartyRelationship"("id", "left_id", "right_id", "created_at", "last_updated_at") SELECT "id", "left_id", "right_id", "created_at", "last_updated_at" FROM "PartyRelationship"`,
+    )
+    await queryRunner.query(`DROP TABLE "PartyRelationship"`)
+    await queryRunner.query(`ALTER TABLE "temporary_PartyRelationship" RENAME TO "PartyRelationship"`)
+    await queryRunner.query(`CREATE UNIQUE INDEX "IDX_PartyRelationship_left_right" ON "PartyRelationship" ("left_id", "right_id")`)
+
+    await queryRunner.query(`DROP INDEX "IDX_BaseContact_type"`)
+    await queryRunner.query(
+      `CREATE TABLE "temporary_BaseContact" ("id" varchar PRIMARY KEY NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "legal_name" varchar(255), "display_name" varchar(255), "first_name" varchar(255), "middle_name" varchar(255), "last_name" varchar(255), "type" varchar NOT NULL, "party_id" varchar, CONSTRAINT "UQ_BaseContact_legal_name" UNIQUE ("legal_name"), CONSTRAINT "REL_BaseContact_party_id" UNIQUE ("party_id"), CONSTRAINT "FK_BaseContact_party_id" FOREIGN KEY ("party_id") REFERENCES "Party" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`,
+    )
+    await queryRunner.query(
+      `INSERT INTO "temporary_BaseContact"("id", "created_at", "last_updated_at", "legal_name", "display_name", "first_name", "middle_name", "last_name", "type", "party_id") SELECT "id", "created_at", "last_updated_at", "legal_name", "display_name", "first_name", "middle_name", "last_name", "type", "party_id" FROM "BaseContact"`,
+    )
+    await queryRunner.query(`DROP TABLE "BaseContact"`)
+    await queryRunner.query(`ALTER TABLE "temporary_BaseContact" RENAME TO "BaseContact"`)
+    await queryRunner.query(`CREATE INDEX "IDX_BaseContact_type" ON "BaseContact" ("type")`)
+
+    await queryRunner.query(`DROP INDEX "IDX_BaseConfig_type"`)
+    await queryRunner.query(
+      `CREATE TABLE "temporary_BaseConfig" ("id" varchar PRIMARY KEY NOT NULL, "identifier" varchar(255), "redirect_url" varchar(255), "session_id" varchar(255), "client_id" varchar(255), "client_secret" varchar(255), "scopes" text, "issuer" varchar(255), "dangerously_allow_insecure_http_requests" boolean, "client_auth_method" text, "type" varchar NOT NULL, "connection_id" varchar, CONSTRAINT "REL_BaseConfig_connection_id" UNIQUE ("connection_id"), CONSTRAINT "FK_BaseConfig_connection_id" FOREIGN KEY ("connection_id") REFERENCES "Connection" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`,
+    )
+    await queryRunner.query(
+      `INSERT INTO "temporary_BaseConfig"("id", "identifier", "redirect_url", "session_id", "client_id", "client_secret", "scopes", "issuer", "dangerously_allow_insecure_http_requests", "client_auth_method", "type", "connection_id") SELECT "id", "identifier", "redirect_url", "session_id", "client_id", "client_secret", "scopes", "issuer", "dangerously_allow_insecure_http_requests", "client_auth_method", "type", "connection_id" FROM "BaseConfig"`,
+    )
+    await queryRunner.query(`DROP TABLE "BaseConfig"`)
+    await queryRunner.query(`ALTER TABLE "temporary_BaseConfig" RENAME TO "BaseConfig"`)
+    await queryRunner.query(`CREATE INDEX "IDX_BaseConfig_type" ON "BaseConfig" ("type")`)
+
+    await queryRunner.query(`DROP INDEX "IDX_PartyType_type_tenant_id"`)
+    await queryRunner.query(`DROP TABLE "PartyType"`)
+    await queryRunner.query(`DROP TABLE "Connection"`)
+    await queryRunner.query(`DROP TABLE "Identity"`)
+    await queryRunner.query(`DROP TABLE "CorrelationIdentifier"`)
+    await queryRunner.query(`DROP TABLE "ElectronicAddress"`)
+    await queryRunner.query(`DROP TABLE "PhysicalAddress"`)
   }
 }

package/src/migrations/sqlite/1710438363002-CreateContacts.ts

@@ -0,0 +1,83 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class CreateContacts1710438363002 implements MigrationInterface {
+  name = 'CreateContacts1710438363002'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "Party" ADD COLUMN "owner_id" text`)
+    await queryRunner.query(`ALTER TABLE "Party" ADD COLUMN "tenant_id" text`)
+
+    // Add owner_id, tenant_id & origin
+    await queryRunner.query(
+      `CREATE TABLE "temporary_Identity" (
+                                             "id" varchar PRIMARY KEY NOT NULL,
+                                             "alias" varchar(255) NOT NULL,
+                                             "roles" text NOT NULL,
+                                             "origin" text NOT NULL,
+                                             "created_at" datetime NOT NULL DEFAULT (datetime('now')),
+                                             "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')),
+                                             "partyId" varchar,
+                                             "owner_id" text,
+                                             "tenant_id" text,
+                                             CONSTRAINT "UQ_Identity_alias" UNIQUE ("alias"),
+                                             CONSTRAINT "FK_Identity_partyId" FOREIGN KEY ("partyId") REFERENCES "Party" ("id") ON DELETE CASCADE ON UPDATE NO ACTION
+         )`,
+    )
+    await queryRunner.query(
+      `INSERT INTO "temporary_Identity"("id", "alias", "roles", "created_at", "last_updated_at", "partyId", "owner_id", "tenant_id", "origin")
+         SELECT "id", "alias", "roles", 'EXTERNAL' as "origin", "created_at", "last_updated_at", "partyId", NULL as "owner_id", NULL as "tenant_id" FROM "Identity"`,
+    )
+    await queryRunner.query(`DROP TABLE "Identity"`)
+    await queryRunner.query(`ALTER TABLE "temporary_Identity" RENAME TO "Identity"`)
+
+    await queryRunner.query(`ALTER TABLE "CorrelationIdentifier" ADD COLUMN "owner_id" text`)
+    await queryRunner.query(`ALTER TABLE "CorrelationIdentifier" ADD COLUMN "tenant_id" text`)
+
+    await queryRunner.query(`ALTER TABLE "Connection" ADD COLUMN "owner_id" text`)
+    await queryRunner.query(`ALTER TABLE "Connection" ADD COLUMN "tenant_id" text`)
+
+    await queryRunner.query(`ALTER TABLE "BaseConfig" ADD COLUMN "owner_id" text`)
+    await queryRunner.query(`ALTER TABLE "BaseConfig" ADD COLUMN "tenant_id" text`)
+
+    await queryRunner.query(`ALTER TABLE "BaseContact" ADD COLUMN "owner_id" text`)
+    await queryRunner.query(`ALTER TABLE "BaseContact" ADD COLUMN "tenant_id" text`)
+
+    await queryRunner.query(`ALTER TABLE "PartyRelationship" ADD COLUMN "owner_id" text`)
+    await queryRunner.query(`ALTER TABLE "PartyRelationship" ADD COLUMN "tenant_id" text`)
+
+    await queryRunner.query(`ALTER TABLE "ElectronicAddress" ADD COLUMN "owner_id" text`)
+    await queryRunner.query(`ALTER TABLE "ElectronicAddress" ADD COLUMN "tenant_id" text`)
+
+    await queryRunner.query(`ALTER TABLE "PhysicalAddress" ADD COLUMN "owner_id" text`)
+    await queryRunner.query(`ALTER TABLE "PhysicalAddress" ADD COLUMN "tenant_id" text`)
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "PhysicalAddress" DROP COLUMN "tenant_id"`)
+    await queryRunner.query(`ALTER TABLE "PhysicalAddress" DROP COLUMN "owner_id"`)
+
+    await queryRunner.query(`ALTER TABLE "ElectronicAddress" DROP COLUMN "tenant_id"`)
+    await queryRunner.query(`ALTER TABLE "ElectronicAddress" DROP COLUMN "owner_id"`)
+
+    await queryRunner.query(`ALTER TABLE "PartyRelationship" DROP COLUMN "tenant_id"`)
+    await queryRunner.query(`ALTER TABLE "PartyRelationship" DROP COLUMN "owner_id"`)
+
+    await queryRunner.query(`ALTER TABLE "BaseContact" DROP COLUMN "tenant_id"`)
+    await queryRunner.query(`ALTER TABLE "BaseContact" DROP COLUMN "owner_id"`)
+
+    await queryRunner.query(`ALTER TABLE "BaseConfig" DROP COLUMN "tenant_id"`)
+    await queryRunner.query(`ALTER TABLE "BaseConfig" DROP COLUMN "owner_id"`)
+
+    await queryRunner.query(`ALTER TABLE "Connection" DROP COLUMN "tenant_id"`)
+    await queryRunner.query(`ALTER TABLE "Connection" DROP COLUMN "owner_id"`)
+
+    await queryRunner.query(`ALTER TABLE "CorrelationIdentifier" DROP COLUMN "tenant_id"`)
+    await queryRunner.query(`ALTER TABLE "CorrelationIdentifier" DROP COLUMN "owner_id"`)
+
+    await queryRunner.query(`ALTER TABLE "Identity" DROP COLUMN "tenant_id"`)
+    await queryRunner.query(`ALTER TABLE "Identity" DROP COLUMN "owner_id"`)
+
+    await queryRunner.query(`ALTER TABLE "Party" DROP COLUMN "tenant_id"`)
+    await queryRunner.query(`ALTER TABLE "Party" DROP COLUMN "owner_id"`)
+  }
+}

package/src/migrations/sqlite/1715761125002-CreateContacts.ts

@@ -0,0 +1,59 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class CreateContacts1715761125002 implements MigrationInterface {
+  name = 'CreateContacts1715761125002'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // Upgrade IdentityMetadata table
+    await queryRunner.query(`ALTER TABLE "IdentityMetadata" RENAME TO "temporary_IdentityMetadata"`)
+    await queryRunner.query(`CREATE TABLE "IdentityMetadata"
+                             (
+                                 "id"          varchar PRIMARY KEY NOT NULL,
+                                 "label"       varchar(255)        NOT NULL,
+                                 "valueType"   varchar             NOT NULL,
+                                 "stringValue" varchar(255),
+                                 "numberValue" double,
+                                 "dateValue"   datetime,
+                                 "boolValue"   boolean,
+                                 "identityId"  varchar,
+                                 FOREIGN KEY ("identityId") REFERENCES "Identity" ("id") ON DELETE CASCADE)`)
+    await queryRunner.query(`INSERT INTO "IdentityMetadata" ("id", "label", "valueType", "stringValue", "identityId")
+                                 SELECT "id", "label", 'string', "value", "identityId"
+                                 FROM "temporary_IdentityMetadata"
+        `)
+    await queryRunner.query(`DROP TABLE "temporary_IdentityMetadata"`)
+
+    // Create new ContactMetadata table
+    await queryRunner.query(`CREATE TABLE "ContactMetadata"
+                                 (
+                                     "id"          varchar PRIMARY KEY NOT NULL,
+                                     "label"       varchar(255)        NOT NULL,
+                                     "valueType"   varchar             NOT NULL,
+                                     "stringValue" text,
+                                     "numberValue" double,
+                                     "dateValue"   datetime,
+                                     "boolValue"   boolean,
+                                     "contactId"   varchar,
+                                     FOREIGN KEY ("contactId") REFERENCES "BaseContact" ("id") ON DELETE CASCADE)`)
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    // Drop the ContactMetadata table
+    await queryRunner.query(`DROP TABLE "ContactMetadata"`)
+
+    // Restore the IdentityMetadata table
+    await queryRunner.query(`ALTER TABLE "IdentityMetadata" RENAME TO "temporary_IdentityMetadata"`)
+    await queryRunner.query(`CREATE TABLE "IdentityMetadata"
+                                 (
+                                     "id"         varchar PRIMARY KEY NOT NULL,
+                                     "label"      varchar(255)        NOT NULL,
+                                     "value"      varchar(255)        NOT NULL,
+                                     "identityId" varchar,
+                                     FOREIGN KEY ("identityId") REFERENCES "Identity" ("id") ON DELETE CASCADE
+                                 )`)
+    await queryRunner.query(`INSERT INTO "IdentityMetadata" ("id", "label", "value", "identityId")
+                                 SELECT "id", "label", "stringValue", "identityId"
+                                 FROM "temporary_IdentityMetadata"`)
+    await queryRunner.query(`DROP TABLE "temporary_IdentityMetadata"`)
+  }
+}

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 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({
+        where: { id: In(idFilters) },
+      })
+    } else {
+      return await pdRepository.find({
+        ...(filter && { where: cleanFilter(filter) }), // TODO test how mixing filters work
+      })
+    }
+  }
+}
+
+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/contact/contact.ts

@@ -1,9 +1,13 @@
 import { IIdentifier } from '@veramo/core'
 
+export type MetadataTypes = string | number | Date | boolean | undefined
+
 export type Party = {
   id: string
   uri?: string
-  roles: Array<IdentityRole>
+  roles: Array<CredentialRole>
+  ownerId?: string
+  tenantId?: string
   identities: Array<Identity>
   electronicAddresses: Array<ElectronicAddress>
   physicalAddresses: Array<PhysicalAddress>
@@ -47,36 +51,44 @@ export type PartialParty = Partial<
 export type Identity = {
   id: string
   alias: string
-  roles: Array<IdentityRole>
+  ownerId?: string
+  tenantId?: string
+  origin: IdentityOrigin
+  roles: Array<CredentialRole>
   identifier: CorrelationIdentifier
   connection?: Connection
-  metadata?: Array<MetadataItem>
+  metadata?: Array<MetadataItem<MetadataTypes>>
   createdAt: Date
   lastUpdatedAt: Date
 }
-export type NonPersistedIdentity = Omit<Identity, 'id' | 'identifier' | 'connection' | 'metadata' | 'createdAt' | 'lastUpdatedAt'> & {
+export type NonPersistedIdentity = Omit<Identity, 'id' | 'identifier' | 'connection' | 'metadata' | 'origin' | 'createdAt' | 'lastUpdatedAt'> & {
+  origin: IdentityOrigin
   identifier: NonPersistedCorrelationIdentifier
   connection?: NonPersistedConnection
-  metadata?: Array<NonPersistedMetadataItem>
+  metadata?: Array<NonPersistedMetadataItem<MetadataTypes>>
 }
-export type PartialIdentity = Partial<Omit<Identity, 'identifier' | 'connection' | 'metadata' | 'roles'>> & {
+export type PartialIdentity = Partial<Omit<Identity, 'identifier' | 'connection' | 'metadata' | 'origin' | 'roles'>> & {
   identifier?: PartialCorrelationIdentifier
   connection?: PartialConnection
-  metadata?: PartialMetadataItem
-  roles?: IdentityRole
+  metadata?: PartialMetadataItem<MetadataTypes> // Usage: FindIdentityArgs = Array<PartialIdentity>
+  origin?: IdentityOrigin
+  roles?: CredentialRole
   partyId?: string
 }
 
-export type MetadataItem = {
+export type MetadataItem<T extends MetadataTypes> = {
   id: string
   label: string
-  value: string
+  value: T
 }
-export type NonPersistedMetadataItem = Omit<MetadataItem, 'id'>
-export type PartialMetadataItem = Partial<MetadataItem>
+
+export type NonPersistedMetadataItem<T extends MetadataTypes> = Omit<MetadataItem<T>, 'id'>
+export type PartialMetadataItem<T extends MetadataTypes> = Partial<MetadataItem<T>>
 
 export type CorrelationIdentifier = {
   id: string
+  ownerId?: string
+  tenantId?: string
   type: CorrelationIdentifierType
   correlationId: string
 }
@@ -85,6 +97,8 @@ export type PartialCorrelationIdentifier = Partial<CorrelationIdentifier>
 
 export type Connection = {
   id: string
+  ownerId?: string
+  tenantId?: string
   type: ConnectionType
   config: ConnectionConfig
 }
@@ -99,6 +113,8 @@ export type OpenIdConfig = {
   id: string
   clientId: string
   clientSecret: string
+  ownerId?: string
+  tenantId?: string
   scopes: Array<string>
   issuer: string
   redirectUrl: string
@@ -112,6 +128,8 @@ export type DidAuthConfig = {
   id: string
   identifier: IIdentifier
   stateId: string
+  ownerId?: string
+  tenantId?: string
   redirectUrl: string
   sessionId: string
 }
@@ -130,21 +148,33 @@ export type NaturalPerson = {
   lastName: string
   middleName?: string
   displayName: string
+  metadata?: Array<MetadataItem<MetadataTypes>>
+  ownerId?: string
+  tenantId?: string
   createdAt: Date
   lastUpdatedAt: Date
 }
+
 export type NonPersistedNaturalPerson = Omit<NaturalPerson, 'id' | 'createdAt' | 'lastUpdatedAt'>
-export type PartialNaturalPerson = Partial<NaturalPerson>
+
+export type PartialNaturalPerson = Partial<Omit<NaturalPerson, 'metadata'>> & {
+  metadata?: PartialMetadataItem<MetadataTypes>
+}
 
 export type Organization = {
   id: string
   legalName: string
   displayName: string
+  metadata?: Array<MetadataItem<MetadataTypes>>
+  ownerId?: string
+  tenantId?: string
   createdAt: Date
   lastUpdatedAt: Date
 }
 export type NonPersistedOrganization = Omit<Organization, 'id' | 'createdAt' | 'lastUpdatedAt'>
-export type PartialOrganization = Partial<Organization>
+export type PartialOrganization = Partial<Omit<Organization, 'metadata'>> & {
+  metadata?: PartialMetadataItem<MetadataTypes>
+}
 
 export type Contact = NaturalPerson | Organization
 export type NonPersistedContact = NonPersistedNaturalPerson | NonPersistedOrganization
@@ -169,6 +199,8 @@ export type PartyRelationship = {
   id: string
   leftId: string
   rightId: string
+  ownerId?: string
+  tenantId?: string
   createdAt: Date
   lastUpdatedAt: Date
 }
@@ -179,6 +211,8 @@ export type ElectronicAddress = {
   id: string
   type: ElectronicAddressType
   electronicAddress: string
+  ownerId?: string
+  tenantId?: string
   createdAt: Date
   lastUpdatedAt: Date
 }
@@ -197,6 +231,8 @@ export type PhysicalAddress = {
   provinceName: string
   countryCode: string
   buildingName?: string
+  ownerId?: string
+  tenantId?: string
   createdAt: Date
   lastUpdatedAt: Date
 }
@@ -209,7 +245,7 @@ export type ElectronicAddressType = 'email' | 'phone'
 
 export type PhysicalAddressType = 'home' | 'visit' | 'postal'
 
-export enum IdentityRole {
+export enum CredentialRole {
   ISSUER = 'issuer',
   VERIFIER = 'verifier',
   HOLDER = 'holder',
@@ -235,3 +271,8 @@ export enum PartyOrigin {
   INTERNAL = 'INTERNAL',
   EXTERNAL = 'EXTERNAL',
 }
+
+export enum IdentityOrigin {
+  INTERNAL = 'INTERNAL',
+  EXTERNAL = 'EXTERNAL',
+}