@sphereon/ssi-sdk.data-store 0.11.1-unstable.64

package/src/entities/contact/IdentityEntity.ts

@@ -0,0 +1,106 @@
+import {
+  BaseEntity,
+  CreateDateColumn,
+  Entity,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+  OneToOne,
+  JoinColumn,
+  ManyToOne,
+  Column,
+  OneToMany,
+  BeforeInsert,
+  BeforeUpdate,
+} from 'typeorm'
+import { correlationIdentifierEntityFrom, CorrelationIdentifierEntity } from './CorrelationIdentifierEntity'
+import { ConnectionEntity, connectionEntityFrom } from './ConnectionEntity'
+import { BasicMetadataItem, IBasicIdentity, IdentityRoleEnum } from '../../types/contact'
+import { ContactEntity } from './ContactEntity'
+import { IdentityMetadataItemEntity, metadataItemEntityFrom } from './IdentityMetadataItemEntity'
+import { IsNotEmpty, validate } from 'class-validator'
+
+@Entity('Identity')
+export class IdentityEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({
+    name: 'alias',
+    length: 255,
+    nullable: false,
+    unique: true,
+  })
+  @IsNotEmpty({ message: 'Blank aliases are not allowed' })
+  alias!: string
+
+  @Column('simple-array', { name: 'roles', nullable: false })
+  roles!: Array<IdentityRoleEnum>
+
+  @OneToOne(() => CorrelationIdentifierEntity, (identifier: CorrelationIdentifierEntity) => identifier.identity, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: false,
+  })
+  identifier!: CorrelationIdentifierEntity
+
+  @OneToOne(() => ConnectionEntity, (connection: ConnectionEntity) => connection.identity, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+  })
+  connection?: ConnectionEntity
+
+  @OneToMany(() => IdentityMetadataItemEntity, (metadata: IdentityMetadataItemEntity) => metadata.identity, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: false,
+  })
+  @JoinColumn({ name: 'metadataId' })
+  metadata!: Array<IdentityMetadataItemEntity>
+
+  @CreateDateColumn({ name: 'created_at', nullable: false })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
+  lastUpdatedAt!: Date
+
+  @ManyToOne(() => ContactEntity, (contact: ContactEntity) => contact.identities, {
+    onDelete: 'CASCADE',
+  })
+  contact!: ContactEntity
+
+  @Column({ name: 'contactId', nullable: true })
+  contactId!: string
+
+  // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
+  @BeforeInsert()
+  @BeforeUpdate()
+  updateUpdatedDate() {
+    this.lastUpdatedAt = new Date()
+  }
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  async validate() {
+    const validation = await validate(this)
+    if (validation.length > 0) {
+      return Promise.reject(Error(validation[0].constraints?.isNotEmpty))
+    }
+    return
+  }
+}
+
+export const identityEntityFrom = (args: IBasicIdentity): IdentityEntity => {
+  const identityEntity = new IdentityEntity()
+  identityEntity.alias = args.alias
+  identityEntity.roles = args.roles
+  identityEntity.identifier = correlationIdentifierEntityFrom(args.identifier)
+  if (args.connection) {
+    identityEntity.connection = connectionEntityFrom(args.connection)
+  }
+  identityEntity.metadata = args.metadata ? args.metadata.map((item: BasicMetadataItem) => metadataItemEntityFrom(item)) : []
+
+  return identityEntity
+}

package/src/entities/contact/IdentityMetadataItemEntity.ts

@@ -0,0 +1,39 @@
+import { Entity, Column, PrimaryGeneratedColumn, BaseEntity, ManyToOne, BeforeInsert, BeforeUpdate } from 'typeorm'
+import { BasicMetadataItem } from '../../types/contact'
+import { IdentityEntity } from './IdentityEntity'
+import { IsNotEmpty, validate } from 'class-validator'
+
+@Entity('IdentityMetadata')
+export class IdentityMetadataItemEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'label', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank metadata labels are not allowed' })
+  label!: string
+
+  @Column({ name: 'value', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank metadata values are not allowed' })
+  value!: string
+
+  @ManyToOne(() => IdentityEntity, (identity: IdentityEntity) => identity.metadata, { cascade: ['insert', 'update'], onDelete: 'CASCADE' })
+  identity!: IdentityEntity
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  async validate() {
+    const validation = await validate(this)
+    if (validation.length > 0) {
+      return Promise.reject(Error(validation[0].constraints?.isNotEmpty))
+    }
+    return
+  }
+}
+
+export const metadataItemEntityFrom = (item: BasicMetadataItem): IdentityMetadataItemEntity => {
+  const metadataItem = new IdentityMetadataItemEntity()
+  metadataItem.label = item.label
+  metadataItem.value = item.value
+
+  return metadataItem
+}

package/src/entities/contact/OpenIdConfigEntity.ts

@@ -0,0 +1,48 @@
+import { ChildEntity, Column, JoinColumn, OneToOne } from 'typeorm'
+import { BaseConfigEntity } from './BaseConfigEntity'
+import { BasicOpenIdConfig } from '../../types/contact'
+import { ConnectionEntity } from './ConnectionEntity'
+
+@ChildEntity('OpenIdConfig')
+export class OpenIdConfigEntity extends BaseConfigEntity {
+  @Column({ name: 'client_id', length: 255, nullable: false })
+  clientId!: string
+
+  @Column({ name: 'client_secret', length: 255, nullable: false })
+  clientSecret!: string
+
+  @Column('simple-array', { name: 'scopes', nullable: false })
+  scopes!: Array<string>
+
+  @Column({ name: 'issuer', length: 255, nullable: false })
+  issuer!: string
+
+  @Column('text', { name: 'redirect_url', nullable: false })
+  redirectUrl!: string
+
+  @Column('boolean', { name: 'dangerously_allow_insecure_http_requests', nullable: false })
+  dangerouslyAllowInsecureHttpRequests!: boolean
+
+  @Column('text', { name: 'client_auth_method', nullable: false })
+  clientAuthMethod!: 'basic' | 'post' | undefined
+
+  @OneToOne(() => ConnectionEntity, (connection: ConnectionEntity) => connection.config, {
+    cascade: ['insert', 'update'],
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'connectionId' })
+  connection?: ConnectionEntity
+}
+
+export const openIdConfigEntityFrom = (config: BasicOpenIdConfig): OpenIdConfigEntity => {
+  const openIdConfig = new OpenIdConfigEntity()
+  openIdConfig.clientId = config.clientId
+  openIdConfig.clientSecret = config.clientSecret
+  openIdConfig.scopes = config.scopes
+  openIdConfig.issuer = config.issuer
+  openIdConfig.redirectUrl = config.redirectUrl
+  openIdConfig.dangerouslyAllowInsecureHttpRequests = config.dangerouslyAllowInsecureHttpRequests
+  openIdConfig.clientAuthMethod = config.clientAuthMethod
+
+  return openIdConfig
+}

package/src/index.ts

@@ -0,0 +1,45 @@
+import { BaseConfigEntity } from './entities/contact/BaseConfigEntity'
+import { ConnectionEntity, connectionEntityFrom } from './entities/contact/ConnectionEntity'
+import { ContactEntity, contactEntityFrom } from './entities/contact/ContactEntity'
+import { CorrelationIdentifierEntity, correlationIdentifierEntityFrom } from './entities/contact/CorrelationIdentifierEntity'
+import { DidAuthConfigEntity, didAuthConfigEntityFrom } from './entities/contact/DidAuthConfigEntity'
+import { IdentityEntity, identityEntityFrom } from './entities/contact/IdentityEntity'
+import { IdentityMetadataItemEntity, metadataItemEntityFrom } from './entities/contact/IdentityMetadataItemEntity'
+import { OpenIdConfigEntity, openIdConfigEntityFrom } from './entities/contact/OpenIdConfigEntity'
+
+export { ContactStore } from './contact/ContactStore'
+export { AbstractContactStore } from './contact/AbstractContactStore'
+
+export const DataStoreContactEntities = [
+  BaseConfigEntity,
+  ConnectionEntity,
+  ContactEntity,
+  IdentityEntity,
+  IdentityMetadataItemEntity,
+  CorrelationIdentifierEntity,
+  DidAuthConfigEntity,
+  OpenIdConfigEntity,
+]
+
+export {
+  BaseConfigEntity,
+  ConnectionEntity,
+  ContactEntity,
+  CorrelationIdentifierEntity,
+  DidAuthConfigEntity,
+  IdentityEntity,
+  IdentityMetadataItemEntity,
+  OpenIdConfigEntity,
+  metadataItemEntityFrom,
+  connectionEntityFrom,
+  contactEntityFrom,
+  correlationIdentifierEntityFrom,
+  identityEntityFrom,
+  didAuthConfigEntityFrom,
+  openIdConfigEntityFrom,
+}
+
+export * from './types/contact'
+export * from './types/IAbstractContactStore'
+
+export { DataStoreMigrations } from './migrations'

package/src/migrations/generic/1-CreateContacts.ts

@@ -0,0 +1,54 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+import Debug from 'debug'
+import { CreateContacts1659463079428 } from '../postgres/1659463079428-CreateContacts'
+import { CreateContacts1659463069549 } from '../sqlite/1659463069549-CreateContacts'
+
+const debug = Debug('sphereon:ssi-sdk:migrations')
+
+export class CreateContacts1659463079429 implements MigrationInterface {
+  name = 'CreateContacts1659463079429'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    debug('migration: creating contacts tables')
+    const dbType = queryRunner.connection.driver.options.type
+    if (dbType === 'postgres') {
+      debug('using postgres migration file')
+      const mig = new CreateContacts1659463079428()
+      const up = await mig.up(queryRunner)
+      debug('Migration statements executed')
+      return up
+    } else if (dbType === 'sqlite' || 'react-native') {
+      debug('using sqlite/react-native migration file')
+      const mig = new CreateContacts1659463069549()
+      const up = await mig.up(queryRunner)
+      debug('Migration statements executed')
+      return up
+    } else {
+      return Promise.reject(
+        "Migrations are currently only supported for sqlite, react-native and postgres. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now"
+      )
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    debug('reverting contacts tables')
+    const dbType = queryRunner.connection.driver.options.type
+    if (dbType === 'postgres') {
+      debug('using postgres migration file')
+      const mig = new CreateContacts1659463079428()
+      const down = await mig.down(queryRunner)
+      debug('Migration statements executed')
+      return down
+    } else if (dbType === 'sqlite' || 'react-native') {
+      debug('using sqlite/react-native migration file')
+      const mig = new CreateContacts1659463069549()
+      const down = await mig.down(queryRunner)
+      debug('Migration statements executed')
+      return down
+    } else {
+      return Promise.reject(
+        "Migrations are currently only supported for sqlite, react-native and postgres. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now"
+      )
+    }
+  }
+}

package/src/migrations/generic/index.ts

@@ -0,0 +1,10 @@
+import { CreateContacts1659463079429 } from './1-CreateContacts'
+
+/**
+ * The migrations array that SHOULD be used when initializing a TypeORM database connection.
+ *
+ * These ensure the correct creation of tables and the proper migrations of data when tables change between versions.
+ *
+ * @public
+ */
+export const DataStoreMigrations = [CreateContacts1659463079429]

package/src/migrations/index.ts

@@ -0,0 +1 @@
+export { DataStoreMigrations } from './generic'

package/src/migrations/internal-migrations-ormconfig.ts

@@ -0,0 +1,28 @@
+import { ConnectionOptions } from 'typeorm'
+import { DataStoreContactEntities, DataStoreMigrations } from '../index'
+
+/**
+ * Do Not use these connections in production!. They are only here to create/test migration files!
+ */
+export default [
+  {
+    type: 'sqlite',
+    name: 'migration-sqlite',
+    database: 'migration.sqlite',
+    migrationsRun: false,
+    synchronize: false,
+    logging: ['error', 'info', 'warn', 'log'],
+    entities: [...DataStoreContactEntities],
+    migrations: [...DataStoreMigrations],
+  },
+  {
+    type: 'postgres',
+    name: 'migration-postgres',
+    database: 'migration-postgres',
+    migrationsRun: false,
+    synchronize: false,
+    logging: ['error', 'info', 'warn', 'log'],
+    entities: [...DataStoreContactEntities],
+    migrations: [...DataStoreMigrations],
+  },
+] as ConnectionOptions[]

package/src/migrations/postgres/1659463079428-CreateContacts.ts

@@ -0,0 +1,61 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class CreateContacts1659463079428 implements MigrationInterface {
+  name = 'CreateContacts1659463079428'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "BaseConfigEntity" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "client_id" character varying(255), "client_secret" character varying(255), "scopes" text, "issuer" character varying(255), "redirect_url" text, "dangerously_allow_insecure_http_requests" boolean, "client_auth_method" text, "identifier" character varying(255), "session_id" character varying(255), "type" character varying NOT NULL, "connectionId" uuid, CONSTRAINT "REL_BaseConfig_connectionId" UNIQUE ("connectionId"), CONSTRAINT "PK_BaseConfigEntity_id" PRIMARY KEY ("id"))`
+    )
+    await queryRunner.query(`CREATE INDEX "IDX_BaseConfigEntity_type" ON "BaseConfigEntity" ("type")`)
+    await queryRunner.query(`CREATE TYPE "public"."CorrelationIdentifier_type_enum" AS ENUM('did', 'url')`)
+    await queryRunner.query(
+      `CREATE TABLE "CorrelationIdentifier" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "type" "public"."CorrelationIdentifier_type_enum" NOT NULL, "correlation_id" text NOT NULL, "identityId" uuid, CONSTRAINT "UQ_Correlation_id" UNIQUE ("correlation_id"), CONSTRAINT "REL_CorrelationIdentifier_identityId" UNIQUE ("identityId"), CONSTRAINT "PK_CorrelationIdentifier_id" PRIMARY KEY ("id"))`
+    )
+    await queryRunner.query(
+      `CREATE TABLE "Contact" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "name" character varying(255) NOT NULL, "alias" character varying(255) NOT NULL, "uri" character varying(255) NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "last_updated_at" TIMESTAMP NOT NULL DEFAULT now(), CONSTRAINT "UQ_Name" UNIQUE ("name"), CONSTRAINT "UQ_Alias" UNIQUE ("alias"), CONSTRAINT "PK_Contact_id" PRIMARY KEY ("id"))`
+    )
+    await queryRunner.query(
+      `CREATE TABLE "IdentityMetadata" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "label" character varying(255) NOT NULL, "value" character varying(255) NOT NULL, "identityId" uuid, CONSTRAINT "PK_IdentityMetadata_id" PRIMARY KEY ("id"))`
+    )
+    await queryRunner.query(
+      `CREATE TABLE "Identity" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "alias" character varying(255) NOT NULL, "roles" text, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "last_updated_at" TIMESTAMP NOT NULL DEFAULT now(), "contactId" uuid, CONSTRAINT "UQ_Alias" UNIQUE ("alias"), CONSTRAINT "PK_Identity_id" PRIMARY KEY ("id"))`
+    )
+    await queryRunner.query(`CREATE TYPE "public"."Connection_type_enum" AS ENUM('OIDC', 'SIOPv2', 'SIOPv2+OpenID4VP')`)
+    await queryRunner.query(
+      `CREATE TABLE "Connection" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "type" "public"."Connection_type_enum" NOT NULL, "identityId" uuid, CONSTRAINT "REL_Connection_identityId" UNIQUE ("identityId"), CONSTRAINT "PK_Connection_id" PRIMARY KEY ("id"))`
+    )
+    await queryRunner.query(
+      `ALTER TABLE "BaseConfigEntity" ADD CONSTRAINT "FK_BaseConfig_connectionId" FOREIGN KEY ("connectionId") REFERENCES "Connection"("id") ON DELETE CASCADE ON UPDATE NO ACTION`
+    )
+    await queryRunner.query(
+      `ALTER TABLE "CorrelationIdentifier" ADD CONSTRAINT "FK_CorrelationIdentifier_identityId" FOREIGN KEY ("identityId") REFERENCES "Identity"("id") ON DELETE CASCADE ON UPDATE NO ACTION`
+    )
+    await queryRunner.query(
+      `ALTER TABLE "IdentityMetadata" ADD CONSTRAINT "FK_IdentityMetadata_identityId" FOREIGN KEY ("identityId") REFERENCES "Identity"("id") ON DELETE CASCADE ON UPDATE NO ACTION`
+    )
+    await queryRunner.query(
+      `ALTER TABLE "Identity" ADD CONSTRAINT "FK_Identity_contactId" FOREIGN KEY ("contactId") REFERENCES "Contact"("id") ON DELETE CASCADE ON UPDATE NO ACTION`
+    )
+    await queryRunner.query(
+      `ALTER TABLE "Connection" ADD CONSTRAINT "FK_Connection_identityId" FOREIGN KEY ("identityId") REFERENCES "Identity"("id") ON DELETE CASCADE ON UPDATE NO ACTION`
+    )
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "Connection" DROP CONSTRAINT "FK_Connection_identityId"`)
+    await queryRunner.query(`ALTER TABLE "Identity" DROP CONSTRAINT "FK_Identity_contactId"`)
+    await queryRunner.query(`ALTER TABLE "IdentityMetadata" DROP CONSTRAINT "FK_IdentityMetadata_identityId"`)
+    await queryRunner.query(`ALTER TABLE "CorrelationIdentifier" DROP CONSTRAINT "FK_CorrelationIdentifier_identityId"`)
+    await queryRunner.query(`ALTER TABLE "BaseConfigEntity" DROP CONSTRAINT "FK_BaseConfig_connectionId"`)
+    await queryRunner.query(`DROP TABLE "Connection"`)
+    await queryRunner.query(`DROP TYPE "public"."Connection_type_enum"`)
+    await queryRunner.query(`DROP TABLE "Identity"`)
+    await queryRunner.query(`DROP TABLE "IdentityMetadata"`)
+    await queryRunner.query(`DROP TABLE "Contact"`)
+    await queryRunner.query(`DROP TABLE "CorrelationIdentifier"`)
+    await queryRunner.query(`DROP TYPE "public"."CorrelationIdentifier_type_enum"`)
+    await queryRunner.query(`DROP INDEX "public"."IDX_BaseConfigEntity_type"`)
+    await queryRunner.query(`DROP TABLE "BaseConfigEntity"`)
+  }
+}

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

@@ -0,0 +1,111 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class CreateContacts1659463069549 implements MigrationInterface {
+  name = 'CreateContacts1659463069549'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "BaseConfigEntity" ("id" varchar PRIMARY KEY NOT NULL, "client_id" varchar(255), "client_secret" varchar(255), "scopes" text, "issuer" varchar(255), "redirect_url" text, "dangerously_allow_insecure_http_requests" boolean, "client_auth_method" text, "identifier" varchar(255), "session_id" varchar(255), "type" varchar NOT NULL, "connectionId" varchar, CONSTRAINT "REL_BaseConfig_connectionId" UNIQUE ("connectionId"))`
+    )
+    await queryRunner.query(`CREATE INDEX "IDX_BaseConfigEntity_type" ON "BaseConfigEntity" ("type")`)
+    await queryRunner.query(
+      `CREATE TABLE "CorrelationIdentifier" ("id" varchar PRIMARY KEY NOT NULL, "type" varchar CHECK( "type" IN ('did','url') ) NOT NULL, "correlation_id" text NOT NULL, "identityId" varchar, CONSTRAINT "UQ_Correlation_id" UNIQUE ("correlation_id"), CONSTRAINT "REL_CorrelationIdentifier_identityId" UNIQUE ("identityId"))`
+    )
+    await queryRunner.query(
+      `CREATE TABLE "Contact" ("id" varchar PRIMARY KEY NOT NULL, "name" varchar(255) NOT NULL, "alias" varchar(255) NOT NULL, "uri" varchar(255) NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), CONSTRAINT "UQ_Name" UNIQUE ("name"), CONSTRAINT "UQ_Alias" UNIQUE ("alias"))`
+    )
+    await queryRunner.query(
+      `CREATE TABLE "IdentityMetadata" ("id" varchar PRIMARY KEY NOT NULL, "label" varchar(255) NOT NULL, "value" varchar(255) NOT NULL, "identityId" varchar)`
+    )
+    await queryRunner.query(
+      `CREATE TABLE "Identity" ("id" varchar PRIMARY KEY NOT NULL, "alias" varchar(255) NOT NULL, "roles" text, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "contactId" varchar, CONSTRAINT "UQ_Alias" UNIQUE ("alias"))`
+    )
+    await queryRunner.query(
+      `CREATE TABLE "Connection" ("id" varchar PRIMARY KEY NOT NULL, "type" varchar CHECK( "type" IN ('OIDC','SIOPv2','SIOPv2+OpenID4VP') ) NOT NULL, "identityId" varchar, CONSTRAINT "REL_Connection_identityId" UNIQUE ("identityId"))`
+    )
+    await queryRunner.query(`DROP INDEX "IDX_BaseConfigEntity_type"`)
+    await queryRunner.query(
+      `CREATE TABLE "temporary_BaseConfigEntity" ("id" varchar PRIMARY KEY NOT NULL, "client_id" varchar(255), "client_secret" varchar(255), "scopes" text, "issuer" varchar(255), "redirect_url" text, "dangerously_allow_insecure_http_requests" boolean, "client_auth_method" text, "identifier" varchar(255), "session_id" varchar(255), "type" varchar NOT NULL, "connectionId" varchar, CONSTRAINT "REL_BaseConfig_connectionId" UNIQUE ("connectionId"), CONSTRAINT "FK_BaseConfig_connectionId" FOREIGN KEY ("connectionId") REFERENCES "Connection" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`
+    )
+    await queryRunner.query(
+      `INSERT INTO "temporary_BaseConfigEntity"("id", "client_id", "client_secret", "scopes", "issuer", "redirect_url", "dangerously_allow_insecure_http_requests", "client_auth_method", "identifier", "session_id", "type", "connectionId") SELECT "id", "client_id", "client_secret", "scopes", "issuer", "redirect_url", "dangerously_allow_insecure_http_requests", "client_auth_method", "identifier", "session_id", "type", "connectionId" FROM "BaseConfigEntity"`
+    )
+    await queryRunner.query(`DROP TABLE "BaseConfigEntity"`)
+    await queryRunner.query(`ALTER TABLE "temporary_BaseConfigEntity" RENAME TO "BaseConfigEntity"`)
+    await queryRunner.query(`CREATE INDEX "IDX_BaseConfigEntity_type" ON "BaseConfigEntity" ("type")`)
+    await queryRunner.query(
+      `CREATE TABLE "temporary_CorrelationIdentifier" ("id" varchar PRIMARY KEY NOT NULL, "type" varchar CHECK( "type" IN ('did','url') ) NOT NULL, "correlation_id" text NOT NULL, "identityId" varchar, CONSTRAINT "UQ_Correlation_id" UNIQUE ("correlation_id"), CONSTRAINT "REL_CorrelationIdentifier_identityId" UNIQUE ("identityId"), CONSTRAINT "FK_CorrelationIdentifier_identityId" FOREIGN KEY ("identityId") REFERENCES "Identity" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`
+    )
+    await queryRunner.query(
+      `INSERT INTO "temporary_CorrelationIdentifier"("id", "type", "correlation_id", "identityId") SELECT "id", "type", "correlation_id", "identityId" FROM "CorrelationIdentifier"`
+    )
+    await queryRunner.query(`DROP TABLE "CorrelationIdentifier"`)
+    await queryRunner.query(`ALTER TABLE "temporary_CorrelationIdentifier" RENAME TO "CorrelationIdentifier"`)
+    await queryRunner.query(
+      `CREATE TABLE "temporary_IdentityMetadata" ("id" varchar PRIMARY KEY NOT NULL, "label" varchar(255) NOT NULL, "value" varchar(255) NOT NULL, "identityId" varchar, CONSTRAINT "FK_IdentityMetadata_identityId" FOREIGN KEY ("identityId") REFERENCES "Identity" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`
+    )
+    await queryRunner.query(
+      `INSERT INTO "temporary_IdentityMetadata"("id", "label", "value", "identityId") SELECT "id", "label", "value", "identityId" FROM "IdentityMetadata"`
+    )
+    await queryRunner.query(`DROP TABLE "IdentityMetadata"`)
+    await queryRunner.query(`ALTER TABLE "temporary_IdentityMetadata" RENAME TO "IdentityMetadata"`)
+    await queryRunner.query(
+      `CREATE TABLE "temporary_Identity" ("id" varchar PRIMARY KEY NOT NULL, "alias" varchar(255) NOT NULL, "roles" text, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "contactId" varchar, CONSTRAINT "UQ_Alias" UNIQUE ("alias"), CONSTRAINT "FK_Identity_contactId" FOREIGN KEY ("contactId") REFERENCES "Contact" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`
+    )
+    await queryRunner.query(
+      `INSERT INTO "temporary_Identity"("id", "alias", "roles", "created_at", "last_updated_at", "contactId") SELECT "id", "alias", "roles", "created_at", "last_updated_at", "contactId" FROM "Identity"`
+    )
+    await queryRunner.query(`DROP TABLE "Identity"`)
+    await queryRunner.query(`ALTER TABLE "temporary_Identity" RENAME TO "Identity"`)
+    await queryRunner.query(
+      `CREATE TABLE "temporary_Connection" ("id" varchar PRIMARY KEY NOT NULL, "type" varchar CHECK( "type" IN ('OIDC','SIOPv2','SIOPv2+OpenID4VP') ) NOT NULL, "identityId" varchar, CONSTRAINT "REL_Connection_identityId" UNIQUE ("identityId"), CONSTRAINT "FK_Connection_identityId" FOREIGN KEY ("identityId") REFERENCES "Identity" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`
+    )
+    await queryRunner.query(`INSERT INTO "temporary_Connection"("id", "type", "identityId") SELECT "id", "type", "identityId" FROM "Connection"`)
+    await queryRunner.query(`DROP TABLE "Connection"`)
+    await queryRunner.query(`ALTER TABLE "temporary_Connection" RENAME TO "Connection"`)
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "Connection" RENAME TO "temporary_Connection"`)
+    await queryRunner.query(
+      `CREATE TABLE "Connection" ("id" varchar PRIMARY KEY NOT NULL, "type" varchar CHECK( "type" IN ('OIDC','SIOPv2','SIOPv2+OpenID4VP') ) NOT NULL, "identityId" varchar, CONSTRAINT "REL_Connection_identityId" UNIQUE ("identityId"))`
+    )
+    await queryRunner.query(`INSERT INTO "Connection"("id", "type", "identityId") SELECT "id", "type", "identityId" FROM "Connection"`)
+    await queryRunner.query(`DROP TABLE "temporary_Connection"`)
+
+    await queryRunner.query(`ALTER TABLE "Identity" RENAME TO "temporary_Identity"`)
+    await queryRunner.query(
+      `CREATE TABLE "Identity" ("id" varchar PRIMARY KEY NOT NULL, "alias" varchar(255) NOT NULL, "roles" text, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "contactId" varchar, CONSTRAINT "UQ_Alias" UNIQUE ("alias"))`
+    )
+    await queryRunner.query(
+      `INSERT INTO "Identity"("id", "alias", "roles","created_at", "last_updated_at", "contactId") SELECT "id", "alias", "roles","created_at", "last_updated_at", "contactId" FROM "Identity"`
+    )
+    await queryRunner.query(`DROP TABLE "temporary_Identity"`)
+
+    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)`
+    )
+    await queryRunner.query(
+      `INSERT INTO "IdentityMetadata"("id", "label", "value", "identityId") SELECT "id", "label", "value", "identityId" FROM "IdentityMetadata"`
+    )
+    await queryRunner.query(`DROP TABLE "temporary_IdentityMetadata"`)
+
+    await queryRunner.query(`ALTER TABLE "CorrelationIdentifier" RENAME TO "temporary_CorrelationIdentifier"`)
+    await queryRunner.query(
+      `CREATE TABLE "CorrelationIdentifier" ("id" varchar PRIMARY KEY NOT NULL, "type" varchar CHECK( "type" IN ('did','url') ) NOT NULL, "correlation_id" text NOT NULL, "identityId" varchar, CONSTRAINT "UQ_Correlation_id" UNIQUE ("correlation_id"), CONSTRAINT "REL_CorrelationIdentifier_identityId" UNIQUE ("identityId"))`
+    )
+    await queryRunner.query(
+      `INSERT INTO "CorrelationIdentifier"("id", "type", "correlation_id", "identityId") SELECT "id", "type", "correlation_id", "identityId" FROM "CorrelationIdentifier"`
+    )
+    await queryRunner.query(`DROP TABLE "temporary_CorrelationIdentifier"`)
+
+    await queryRunner.query(`DROP TABLE "Connection"`)
+    await queryRunner.query(`DROP TABLE "Identity"`)
+    await queryRunner.query(`DROP TABLE "IdentityMetadata"`)
+    await queryRunner.query(`DROP TABLE "Contact"`)
+    await queryRunner.query(`DROP TABLE "CorrelationIdentifier"`)
+    await queryRunner.query(`DROP INDEX "IDX_BaseConfigEntity_type"`)
+    await queryRunner.query(`DROP TABLE "BaseConfigEntity"`)
+  }
+}

package/src/types/IAbstractContactStore.ts

@@ -0,0 +1,51 @@
+import { FindOptionsWhere } from 'typeorm'
+import { ContactEntity } from '../entities/contact/ContactEntity'
+import { IdentityEntity } from '../entities/contact/IdentityEntity'
+import { IBasicIdentity, IContact, IIdentity } from './contact'
+
+export type FindContactArgs = FindOptionsWhere<ContactEntity>[]
+export type FindIdentityArgs = FindOptionsWhere<IdentityEntity>[]
+
+export interface IGetContactArgs {
+  contactId: string
+}
+
+export interface IGetContactsArgs {
+  filter?: FindContactArgs
+}
+
+export interface IAddContactArgs {
+  name: string
+  alias: string
+  uri?: string
+  identities?: Array<IBasicIdentity>
+}
+
+export interface IUpdateContactArgs {
+  contact: Omit<IContact, 'identities' | 'createdAt' | 'lastUpdatedAt'>
+}
+
+export interface IRemoveContactArgs {
+  contactId: string
+}
+
+export interface IGetIdentityArgs {
+  identityId: string
+}
+
+export interface IGetIdentitiesArgs {
+  filter?: FindIdentityArgs
+}
+
+export interface IAddIdentityArgs {
+  contactId: string
+  identity: IBasicIdentity
+}
+
+export interface IUpdateIdentityArgs {
+  identity: IIdentity
+}
+
+export interface IRemoveIdentityArgs {
+  identityId: string
+}