@sphereon/ssi-sdk.data-store 0.15.2-next.6 → 0.15.2-next.77

package/src/migrations/postgres/1685628974232-CreateIssuanceBranding.ts

@@ -1,9 +1,11 @@
 import { MigrationInterface, QueryRunner } from 'typeorm'
+import { enableUuidv4 } from './uuid'
 
 export class CreateIssuanceBranding1685628974232 implements MigrationInterface {
   name = 'CreateIssuanceBranding1685628974232'
 
   public async up(queryRunner: QueryRunner): Promise<void> {
+    await enableUuidv4(queryRunner)
     await queryRunner.query(
       `CREATE TABLE "ImageDimensions" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "width" integer NOT NULL, "height" integer NOT NULL, CONSTRAINT "PK_ImageDimensions_id" PRIMARY KEY ("id"))`
     )

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

@@ -0,0 +1,94 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+import { enableUuidv4 } from './uuid'
+
+export class CreateContacts1690925872592 implements MigrationInterface {
+  name = 'CreateContacts1690925872592'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await enableUuidv4(queryRunner)
+    await queryRunner.query(`ALTER TABLE "CorrelationIdentifier" DROP CONSTRAINT "FK_CorrelationIdentifier_identityId"`)
+    await queryRunner.query(`ALTER TABLE "IdentityMetadata" DROP CONSTRAINT "FK_IdentityMetadata_identityId"`)
+    await queryRunner.query(`ALTER TABLE "Identity" DROP CONSTRAINT "FK_Identity_contactId"`)
+    await queryRunner.query(`ALTER TABLE "Connection" DROP CONSTRAINT "FK_Connection_identityId"`)
+    await queryRunner.query(`ALTER TABLE "CorrelationIdentifier" RENAME COLUMN "identityId" TO "identity_id"`)
+    await queryRunner.query(`ALTER TABLE "Connection" RENAME COLUMN "identityId" TO "identity_id"`)
+    await queryRunner.query(`CREATE TYPE "public"."PartyType_type_enum" AS ENUM('naturalPerson', 'organization')`)
+    await queryRunner.query(
+      `CREATE TABLE "PartyType" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "type" "public"."PartyType_type_enum" NOT NULL, "name" character varying(255) NOT NULL, "description" character varying(255), "tenant_id" character varying(255) NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "last_updated_at" TIMESTAMP NOT NULL DEFAULT now(), CONSTRAINT "UQ_PartyType_name" UNIQUE ("name"), CONSTRAINT "PK_PartyType_id" PRIMARY KEY ("id"))`
+    )
+    await queryRunner.query(`CREATE UNIQUE INDEX "IDX_PartyType_type_tenant_id" ON "PartyType" ("type", "tenant_id")`)
+    await queryRunner.query(
+      `CREATE TABLE "BaseContact" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "created_at" TIMESTAMP NOT NULL DEFAULT now(), "last_updated_at" TIMESTAMP NOT NULL DEFAULT now(), "legal_name" character varying(255), "display_name" character varying(255), "first_name" character varying(255), "middle_name" character varying(255), "last_name" character varying(255), "type" character varying NOT NULL, "party_id" uuid, CONSTRAINT "UQ_BaseContact_legal_name" UNIQUE ("legal_name"), CONSTRAINT "REL_BaseContact_party_id" UNIQUE ("party_id"), CONSTRAINT "PK_BaseContact_id" PRIMARY KEY ("id"))`
+    )
+    await queryRunner.query(`CREATE INDEX "IDX_BaseContact_type" ON "BaseContact" ("type")`)
+    await queryRunner.query(
+      `CREATE TABLE "PartyRelationship" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "left_id" uuid NOT NULL, "right_id" uuid NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "last_updated_at" TIMESTAMP NOT NULL DEFAULT now(), CONSTRAINT "PK_PartyRelationship_id" PRIMARY KEY ("id"))`
+    )
+    await queryRunner.query(`CREATE UNIQUE INDEX "IDX_PartyRelationship_left_right" ON "PartyRelationship" ("left_id", "right_id")`)
+    await queryRunner.query(
+      `CREATE TABLE "ElectronicAddress" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "type" character varying(255) NOT NULL, "electronic_address" character varying(255) NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "last_updated_at" TIMESTAMP NOT NULL DEFAULT now(), "partyId" uuid, CONSTRAINT "PK_ElectronicAddress_id" PRIMARY KEY ("id"))`
+    )
+    await queryRunner.query(
+      `CREATE TABLE "Party" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "uri" character varying(255) NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "last_updated_at" TIMESTAMP NOT NULL DEFAULT now(), "party_type_id" uuid NOT NULL, CONSTRAINT "PK_Party_id" PRIMARY KEY ("id"))`
+    )
+    await queryRunner.query(
+      `CREATE TABLE "BaseConfig" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "identifier" character varying(255), "redirect_url" character varying(255), "session_id" character varying(255), "client_id" character varying(255), "client_secret" character varying(255), "scopes" text, "issuer" character varying(255), "dangerously_allow_insecure_http_requests" boolean, "client_auth_method" text, "type" character varying NOT NULL, "connection_id" uuid, CONSTRAINT "REL_BaseConfig_connection_id" UNIQUE ("connection_id"), CONSTRAINT "PK_BaseConfig_id" PRIMARY KEY ("id"))`
+    )
+    await queryRunner.query(`CREATE INDEX "IDX_BaseConfig_type" ON "BaseConfig" ("type")`)
+    await queryRunner.query(`ALTER TABLE "Identity" RENAME COLUMN "contactId" TO "partyId"`)
+    await queryRunner.query(`ALTER TABLE "Identity" ALTER COLUMN "roles" SET NOT NULL`)
+    await queryRunner.query(
+      `ALTER TABLE "CorrelationIdentifier" ADD CONSTRAINT "FK_CorrelationIdentifier_identity_id" FOREIGN KEY ("identity_id") 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 "BaseContact" ADD CONSTRAINT "FK_BaseContact_party_id" FOREIGN KEY ("party_id") REFERENCES "Party"("id") ON DELETE CASCADE ON UPDATE NO ACTION`
+    )
+    await queryRunner.query(
+      `ALTER TABLE "PartyRelationship" ADD CONSTRAINT "FK_PartyRelationship_left_id" FOREIGN KEY ("left_id") REFERENCES "Party"("id") ON DELETE CASCADE ON UPDATE NO ACTION`
+    )
+    await queryRunner.query(
+      `ALTER TABLE "PartyRelationship" ADD CONSTRAINT "FK_PartyRelationship_right_id" FOREIGN KEY ("right_id") REFERENCES "Party"("id") ON DELETE CASCADE ON UPDATE NO ACTION`
+    )
+    await queryRunner.query(
+      `ALTER TABLE "ElectronicAddress" ADD CONSTRAINT "FK_ElectronicAddress_partyId" FOREIGN KEY ("partyId") REFERENCES "Party"("id") ON DELETE CASCADE ON UPDATE NO ACTION`
+    )
+    await queryRunner.query(
+      `ALTER TABLE "Party" ADD 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(
+      `ALTER TABLE "Identity" ADD CONSTRAINT "FK_Identity_partyId" FOREIGN KEY ("partyId") REFERENCES "Party"("id") ON DELETE CASCADE ON UPDATE NO ACTION`
+    )
+    await queryRunner.query(
+      `ALTER TABLE "Connection" ADD CONSTRAINT "FK_Connection_identity_id" FOREIGN KEY ("identity_id") REFERENCES "Identity"("id") ON DELETE CASCADE ON UPDATE NO ACTION`
+    )
+    await queryRunner.query(
+      `ALTER TABLE "BaseConfig" ADD CONSTRAINT "FK_BaseConfig_connection_id" FOREIGN KEY ("connection_id") REFERENCES "Connection"("id") ON DELETE CASCADE ON UPDATE NO ACTION`
+    )
+
+    // migrate existing data
+    await queryRunner.query(`ALTER TABLE "CorrelationIdentifier" RENAME CONSTRAINT "UQ_Correlation_id" TO "UQ_CorrelationIdentifier_correlation_id"`)
+    await queryRunner.query(`ALTER TABLE "Identity" RENAME CONSTRAINT "UQ_Identity_Alias" TO "UQ_Identity_alias"`)
+    await queryRunner.query(
+      `INSERT INTO "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", "connectionId" FROM "BaseConfigEntity"`
+    )
+    await queryRunner.query(`DROP TABLE "BaseConfigEntity"`)
+    await queryRunner.query(
+      `INSERT INTO "PartyType"(id, type, name, description, tenant_id, created_at, last_updated_at) VALUES ('3875c12e-fdaa-4ef6-a340-c936e054b627', 'organization', 'Sphereon_default_type', 'sphereon_default_organization', '95e09cfc-c974-4174-86aa-7bf1d5251fb4', now(), now())`
+    )
+    await queryRunner.query(
+      `INSERT INTO "Party"(id, uri, created_at, last_updated_at, party_type_id) SELECT id, uri, created_at, last_updated_at, '3875c12e-fdaa-4ef6-a340-c936e054b627' FROM "Contact"`
+    )
+    await queryRunner.query(
+      `INSERT INTO "BaseContact"(id, legal_name, display_name, party_id, created_at, last_updated_at, type) SELECT id, name, alias, id, created_at, last_updated_at, 'Organization' FROM "Contact"`
+    )
+    await queryRunner.query(`DROP TABLE "Contact"`)
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    // TODO DPP-27 implement downgrade
+    return Promise.reject(Error(`Downgrade is not yet implemented for ${this.name}`))
+  }
+}

package/src/migrations/postgres/CreateStatusList1693866470001-CreateStatusList.ts

@@ -0,0 +1,24 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class CreateStatusList1693866470001 implements MigrationInterface {
+  name = 'CreateStatusList1693866470001'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "StatusListEntry" ("statusListId" character varying NOT NULL, "statusListIndex" integer NOT NULL, "credentialId" character varying, "credentialHash" character varying(128), "correlationId" character varying(255), "value" character varying(50), CONSTRAINT "PK_68704d2d13857360c6b44a3d1d0" PRIMARY KEY ("statusListId", "statusListIndex"))`
+    )
+    await queryRunner.query(`CREATE TYPE "public"."StatusList_type_enum" AS ENUM('StatusList2021')`)
+    await queryRunner.query(
+      `CREATE TYPE "public"."StatusList_drivertype_enum" AS ENUM('agent_typeorm', 'agent_kv_store', 'github', 'agent_filesystem')`
+    )
+    await queryRunner.query(`CREATE TYPE "public"."StatusList_credentialidmode_enum" AS ENUM('ISSUANCE', 'PERSISTENCE', 'NEVER')`)
+    await queryRunner.query(
+      `CREATE TABLE "StatusList" ("id" character varying NOT NULL, "correlationId" character varying NOT NULL, "length" integer NOT NULL, "issuer" text NOT NULL, "type" "public"."StatusList_type_enum" NOT NULL DEFAULT 'StatusList2021', "driverType" "public"."StatusList_drivertype_enum" NOT NULL DEFAULT 'agent_typeorm', "credentialIdMode" "public"."StatusList_credentialidmode_enum" NOT NULL DEFAULT 'ISSUANCE', "proofFormat" character varying NOT NULL DEFAULT 'lds', "indexingDirection" character varying NOT NULL DEFAULT 'rightToLeft', "statusPurpose" character varying NOT NULL DEFAULT 'revocation', "statusListCredential" text, CONSTRAINT "UQ_correlationId" UNIQUE ("correlationId"), CONSTRAINT "PK_StatusList_Id" PRIMARY KEY ("id"))`
+    )
+    await queryRunner.query(
+      `ALTER TABLE "StatusListEntry" ADD CONSTRAINT "FK_statusListEntry_statusListId" FOREIGN KEY ("statusListId") REFERENCES "StatusList"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`
+    )
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {}
+}

package/src/migrations/postgres/uuid.ts

@@ -0,0 +1,12 @@
+import { QueryRunner } from 'typeorm'
+
+export async function enableUuidv4(queryRunner: QueryRunner) {
+  try {
+    await queryRunner.query(`CREATE EXTENSION IF NOT EXISTS "uuid-ossp";`)
+  } catch (error) {
+    console.log(
+      `Please enable the uuid-ossp.control extension in your postgresql installation. It enables generating V4 UUID and can be found in the postgresql-contrib package`
+    )
+    throw error
+  }
+}

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

@@ -0,0 +1,163 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class CreateContacts1690925872693 implements MigrationInterface {
+  name = 'CreateContacts1690925872693'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    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 "REL_CorrelationIdentifier_identityId" UNIQUE ("identityId"), CONSTRAINT "UQ_CorrelationIdentifier_correlation_id" UNIQUE ("correlation_id"))`
+    )
+    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_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"))`
+    )
+    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"))`
+    )
+    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"`)
+    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, "identity_id" varchar, CONSTRAINT "REL_CorrelationIdentifier_identityId" UNIQUE ("identity_id"), CONSTRAINT "UQ_CorrelationIdentifier_correlation_id" UNIQUE ("correlation_id"))`
+    )
+    await queryRunner.query(
+      `INSERT INTO "temporary_CorrelationIdentifier"("id", "type", "correlation_id", "identity_id") 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_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"))`
+    )
+    await queryRunner.query(
+      `INSERT INTO "temporary_Identity"("id", "alias", "roles", "created_at", "last_updated_at", "partyId") 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, "identity_id" varchar, CONSTRAINT "REL_Connection_identityId" UNIQUE ("identity_id"))`
+    )
+    await queryRunner.query(`INSERT INTO "temporary_Connection"("id", "type", "identity_id") SELECT "id", "type", "identityId" FROM "Connection"`)
+    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, "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(
+      `CREATE TABLE "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"))`
+    )
+    await queryRunner.query(`CREATE INDEX "IDX_BaseContact_type" ON "BaseContact" ("type")`)
+    await queryRunner.query(
+      `CREATE TABLE "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')))`
+    )
+    await queryRunner.query(`CREATE UNIQUE INDEX "IDX_PartyRelationship_left_right" ON "PartyRelationship" ("left_id", "right_id")`)
+    await queryRunner.query(
+      `CREATE TABLE "ElectronicAddress" ("id" varchar PRIMARY KEY NOT NULL, "type" varchar(255) NOT NULL, "electronic_address" varchar(255) NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "partyId" varchar)`
+    )
+    await queryRunner.query(
+      `CREATE TABLE "Party" ("id" varchar PRIMARY KEY NOT NULL, "uri" varchar(255) NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "party_type_id" varchar NOT NULL)`
+    )
+    await queryRunner.query(
+      `CREATE TABLE "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"))`
+    )
+    await queryRunner.query(`CREATE INDEX "IDX_BaseConfig_type" ON "BaseConfig" ("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, "identity_id" varchar, CONSTRAINT "REL_CorrelationIdentifier_identity_id" UNIQUE ("identity_id"), CONSTRAINT "UQ_CorrelationIdentifier_correlation_id" UNIQUE ("correlation_id"), CONSTRAINT "FK_CorrelationIdentifier_identity_id" FOREIGN KEY ("identity_id") REFERENCES "Identity" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`
+    )
+    await queryRunner.query(
+      `INSERT INTO "temporary_CorrelationIdentifier"("id", "type", "correlation_id", "identity_id") SELECT "id", "type", "correlation_id", "identity_id" FROM "CorrelationIdentifier"`
+    )
+    await queryRunner.query(`DROP TABLE "CorrelationIdentifier"`)
+    await queryRunner.query(`ALTER TABLE "temporary_CorrelationIdentifier" RENAME TO "CorrelationIdentifier"`)
+    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_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(
+      `CREATE TABLE "temporary_ElectronicAddress" ("id" varchar PRIMARY KEY NOT NULL, "type" varchar(255) NOT NULL, "electronic_address" varchar(255) NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "partyId" varchar, CONSTRAINT "FK_ElectronicAddress_partyId" FOREIGN KEY ("partyId") REFERENCES "Party" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`
+    )
+    await queryRunner.query(
+      `INSERT INTO "temporary_ElectronicAddress"("id", "type", "electronic_address", "created_at", "last_updated_at", "partyId") SELECT "id", "type", "electronic_address", "created_at", "last_updated_at", "partyId" FROM "ElectronicAddress"`
+    )
+    await queryRunner.query(`DROP TABLE "ElectronicAddress"`)
+    await queryRunner.query(`ALTER TABLE "temporary_ElectronicAddress" RENAME TO "ElectronicAddress"`)
+    await queryRunner.query(
+      `CREATE TABLE "temporary_Party" ("id" varchar PRIMARY KEY NOT NULL, "uri" varchar(255) NOT NULL, "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(
+      `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)`
+    )
+    await queryRunner.query(
+      `INSERT INTO "temporary_Identity"("id", "alias", "roles", "created_at", "last_updated_at", "partyId") SELECT "id", "alias", "roles", "created_at", "last_updated_at", "partyId" 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, "identity_id" varchar, CONSTRAINT "REL_Connection_identity_id" UNIQUE ("identity_id"), CONSTRAINT "FK_Connection_identity_id" FOREIGN KEY ("identity_id") REFERENCES "Identity" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`
+    )
+    await queryRunner.query(`INSERT INTO "temporary_Connection"("id", "type", "identity_id") SELECT "id", "type", "identity_id" FROM "Connection"`)
+    await queryRunner.query(`DROP TABLE "Connection"`)
+    await queryRunner.query(`ALTER TABLE "temporary_Connection" RENAME TO "Connection"`)
+    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")`)
+
+    // migrate existing data
+    await queryRunner.query(
+      `INSERT INTO "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 "BaseConfigEntity"`
+    )
+    await queryRunner.query(`DROP TABLE "BaseConfigEntity"`)
+    await queryRunner.query(
+      `INSERT INTO "PartyType"(id, type, name, description, tenant_id, created_at, last_updated_at) VALUES ('3875c12e-fdaa-4ef6-a340-c936e054b627', 'organization', 'Sphereon_default_type', 'sphereon_default_organization', '95e09cfc-c974-4174-86aa-7bf1d5251fb4', datetime('now'), datetime('now'))`
+    )
+    await queryRunner.query(
+      `INSERT INTO "Party"(id, uri, created_at, last_updated_at, party_type_id) SELECT id, uri, created_at, last_updated_at, '3875c12e-fdaa-4ef6-a340-c936e054b627' FROM "Contact"`
+    )
+    await queryRunner.query(
+      `INSERT INTO "BaseContact"(id, legal_name, display_name, party_id, created_at, last_updated_at, type) SELECT id, name, alias, id, created_at, last_updated_at, 'Organization' FROM "Contact"`
+    )
+    await queryRunner.query(`DROP TABLE "Contact"`)
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    // TODO DPP-27 implement downgrade
+    return Promise.reject(Error(`Downgrade is not yet implemented for ${this.name}`))
+  }
+}

package/src/migrations/sqlite/1693866470000-CreateStatusList.ts

@@ -0,0 +1,24 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class CreateStatusList1693866470002 implements MigrationInterface {
+  name = 'CreateStatusList1693866470002'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "StatusListEntry" ("statusListId" varchar NOT NULL, "statusListIndex" integer NOT NULL, "credentialId" varchar, "credentialHash" varchar(128), "correlationId" varchar(255), "value" varchar(50), PRIMARY KEY ("statusListId", "statusListIndex"))`
+    )
+    await queryRunner.query(
+      `CREATE TABLE "StatusList" ("id" varchar PRIMARY KEY NOT NULL, "correlationId" varchar NOT NULL, "length" integer NOT NULL, "issuer" text NOT NULL, "type" varchar CHECK( "type" IN ('StatusList2021') ) NOT NULL DEFAULT ('StatusList2021'), "driverType" varchar CHECK( "driverType" IN ('agent_typeorm','agent_kv_store','github','agent_filesystem') ) NOT NULL DEFAULT ('agent_typeorm'), "credentialIdMode" varchar CHECK( "credentialIdMode" IN ('ISSUANCE','PERSISTENCE','NEVER') ) NOT NULL DEFAULT ('ISSUANCE'), "proofFormat" varchar CHECK( "proofFormat" IN ('lds','jwt') ) NOT NULL DEFAULT ('lds'), "indexingDirection" varchar CHECK( "indexingDirection" IN ('rightToLeft') ) NOT NULL DEFAULT ('rightToLeft'), "statusPurpose" varchar NOT NULL DEFAULT ('revocation'), "statusListCredential" text, CONSTRAINT "UQ_correlationId" UNIQUE ("correlationId"))`
+    )
+    await queryRunner.query(
+      `CREATE TABLE "temporary_StatusListEntry" ("statusListId" varchar NOT NULL, "statusListIndex" integer NOT NULL, "credentialId" varchar, "credentialHash" varchar(128), "correlationId" varchar(255), "value" varchar(50), CONSTRAINT "FK_statusListEntry_statusListId" FOREIGN KEY ("statusListId") REFERENCES "StatusList" ("id") ON DELETE NO ACTION ON UPDATE NO ACTION, PRIMARY KEY ("statusListId", "statusListIndex"))`
+    )
+    await queryRunner.query(
+      `INSERT INTO "temporary_StatusListEntry"("statusListId", "statusListIndex", "credentialId", "credentialHash", "correlationId", "value") SELECT "statusListId", "statusListIndex", "credentialId", "credentialHash", "correlationId", "value" FROM "StatusListEntry"`
+    )
+    await queryRunner.query(`DROP TABLE "StatusListEntry"`)
+    await queryRunner.query(`ALTER TABLE "temporary_StatusListEntry" RENAME TO "StatusListEntry"`)
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {}
+}

package/src/statusList/IStatusListStore.ts

@@ -0,0 +1,44 @@
+import { StatusListEntryEntity } from '../entities/statusList2021/StatusList2021EntryEntity'
+import {
+  IAddStatusListArgs,
+  IAddStatusListEntryArgs,
+  IGetStatusListArgs,
+  IGetStatusListEntriesArgs,
+  IGetStatusListEntryByCredentialIdArgs,
+  IGetStatusListEntryByIndexArgs,
+  IGetStatusListsArgs,
+  IRemoveStatusListArgs,
+  IStatusListEntryAvailableArgs,
+  IUpdateStatusListIndexArgs,
+} from '../types/statusList/IAbstractStatusListStore'
+import { IStatusListEntity, IStatusListEntryEntity } from '../types/statusList/statusList'
+
+export interface IStatusListStore {
+  getStatusList(args: IGetStatusListArgs): Promise<IStatusListEntity>
+
+  getStatusLists(args: IGetStatusListsArgs): Promise<Array<IStatusListEntity>>
+
+  removeStatusList(args: IRemoveStatusListArgs): Promise<void>
+
+  addStatusList(args: IAddStatusListArgs): Promise<IStatusListEntity>
+
+  updateStatusList(args: IUpdateStatusListIndexArgs): Promise<IStatusListEntity>
+
+  availableStatusListEntries(args: IStatusListEntryAvailableArgs): Promise<number[]>
+
+  addStatusListEntry(args: IAddStatusListEntryArgs): Promise<IStatusListEntryEntity>
+
+  updateStatusListEntry(args: IAddStatusListEntryArgs): Promise<IStatusListEntryEntity>
+
+  getStatusListEntryByIndex(args: IGetStatusListEntryByIndexArgs): Promise<StatusListEntryEntity | undefined>
+
+  getStatusListEntryByCredentialId(args: IGetStatusListEntryByCredentialIdArgs): Promise<StatusListEntryEntity | undefined>
+
+  removeStatusListEntryByIndex(args: IGetStatusListEntryByIndexArgs): Promise<boolean>
+
+  removeStatusListEntryByCredentialId(args: IGetStatusListEntryByCredentialIdArgs): Promise<boolean>
+
+  getStatusListEntries(args: IGetStatusListEntriesArgs): Promise<IStatusListEntryEntity[]>
+
+  getStatusList(args: IGetStatusListArgs): Promise<IStatusListEntity>
+}

package/src/statusList/StatusListStore.ts

@@ -0,0 +1,237 @@
+import { OrPromise } from '@sphereon/ssi-types'
+import Debug from 'debug'
+import { DataSource, In, Repository } from 'typeorm'
+import { StatusListEntity } from '../entities/statusList2021/StatusList2021Entity'
+import { StatusListEntryEntity } from '../entities/statusList2021/StatusList2021EntryEntity'
+import {
+  IAddStatusListArgs,
+  IAddStatusListEntryArgs,
+  IGetStatusListArgs,
+  IGetStatusListEntriesArgs,
+  IGetStatusListEntryByCredentialIdArgs,
+  IGetStatusListEntryByIndexArgs,
+  IGetStatusListsArgs,
+  IRemoveStatusListArgs,
+  IStatusListEntryAvailableArgs,
+  IUpdateStatusListIndexArgs,
+  IStatusListEntity,
+  IStatusListEntryEntity,
+} from '../types'
+import { IStatusListStore } from './IStatusListStore'
+
+const debug = Debug('sphereon:ssi-sdk:data-store:status-list')
+
+export class StatusListStore implements IStatusListStore {
+  private readonly _dbConnection: OrPromise<DataSource>
+
+  constructor(dbConnection: OrPromise<DataSource>) {
+    this._dbConnection = dbConnection
+  }
+
+  /**
+   * Get's the available status list indices from the provided indices. Meaning it will filter out any index that is already known.
+   *
+   * The idea is that the caller provides a set of random status list indices. We can relatively easy check against the DB in an optimized way.
+   * If the status list is large it is probably best ot also provide at least a good number of indices. So something like 10 or 20 values.
+   * Callers are also expected to call this function multiple times if it does not yield results
+   *
+   * @param args
+   */
+  async availableStatusListEntries(args: IStatusListEntryAvailableArgs): Promise<number[]> {
+    const statusListIndex = Array.isArray(args.statusListIndex) ? args.statusListIndex : [args.statusListIndex]
+    const statusList = await this.getStatusList({ ...args, id: args.statusListId })
+    const repo = await this.getStatusListEntryRepo()
+    const results = (
+      await repo.find({
+        where: {
+          statusList,
+          statusListIndex: In(statusListIndex),
+        },
+      })
+    ).map((index) => index.statusListIndex)
+    return statusListIndex.filter((index) => !results.includes(index))
+  }
+
+  async addStatusListEntry(args: IAddStatusListEntryArgs): Promise<IStatusListEntryEntity> {
+    return (await this.getStatusListEntryRepo()).save(args)
+  }
+
+  async updateStatusListEntry(args: IAddStatusListEntryArgs): Promise<IStatusListEntryEntity> {
+    const statusListId = typeof args.statusList === 'string' ? args.statusList : args.statusList.id
+    const result = await this.getStatusListEntryByIndex({ ...args, statusListId, errorOnNotFound: false })
+    const updatedEntry: Partial<IStatusListEntryEntity> = {
+      value: args.value,
+      correlationId: args.correlationId,
+      credentialHash: args.credentialHash,
+      credentialId: args.credentialId,
+    }
+
+    const updateResult = await (
+      await this.getStatusListEntryRepo()
+    ).upsert(
+      { ...(result ?? { statusList: args.statusList, statusListIndex: args.statusListIndex }), ...updatedEntry },
+      { conflictPaths: ['statusList', 'statusListIndex'] }
+    )
+    console.log(updateResult)
+    return (await this.getStatusListEntryByIndex({ ...args, statusListId, errorOnNotFound: true })) as IStatusListEntryEntity
+  }
+
+  async getStatusListEntryByIndex(args: IGetStatusListEntryByIndexArgs): Promise<StatusListEntryEntity | undefined> {
+    if (!args.statusListId && !args.correlationId) {
+      throw Error(`Cannot get statusList entry if not either a statusList id or correlationId is provided`)
+    }
+    const result = await (
+      await this.getStatusListEntryRepo()
+    ).findOne({
+      where: {
+        ...(args.statusListId && { statusList: args.statusListId }),
+        ...(args.correlationId && { correlationId: args.correlationId }),
+        statusListIndex: args.statusListIndex,
+      },
+    })
+
+    if (!result && args.errorOnNotFound) {
+      throw Error(`Could not find status list index ${args.statusListIndex} for status list id ${args.statusListId}`)
+    }
+    return result ?? undefined
+  }
+
+  async removeStatusListEntryByIndex(args: IGetStatusListEntryByIndexArgs): Promise<boolean> {
+    let error = false
+    try {
+      await this.getStatusListEntryByIndex(args) // only used to check it exists
+    } catch (error) {
+      error = true
+    }
+    if (error) {
+      console.log(`Could not delete statusList ${args.statusListId} entry by index ${args.statusListIndex}`)
+    } else {
+      const result = await (
+        await this.getStatusListEntryRepo()
+      ).delete({
+        ...(args.statusListId && { statusList: args.statusListId }),
+        ...(args.correlationId && { correlationId: args.correlationId }),
+        statusListIndex: args.statusListIndex,
+      })
+      error = !result.affected || result.affected !== 1
+    }
+    return !error
+  }
+
+  async getStatusListEntryByCredentialId(args: IGetStatusListEntryByCredentialIdArgs): Promise<StatusListEntryEntity | undefined> {
+    const credentialId = args.credentialId
+    if (!credentialId) {
+      throw Error('Can only get a credential by credentialId when a credentialId is supplied')
+    }
+    const statusList = await this.getStatusList({ id: args.statusListId, correlationId: args.statusListCorrelationId })
+    const where = {
+      statusList: statusList.id,
+      ...(args.entryCorrelationId && { correlationId: args.entryCorrelationId }),
+      credentialId,
+    }
+    console.log(`Entries: ${JSON.stringify(await (await this.getStatusListEntryRepo()).find(), null, 2)}`)
+    const result = await (await this.getStatusListEntryRepo()).findOne({ where })
+
+    if (!result && args.errorOnNotFound) {
+      throw Error(`Could not find status list credential id ${credentialId} for status list id ${statusList.id}`)
+    }
+    return result ?? undefined
+  }
+
+  async removeStatusListEntryByCredentialId(args: IGetStatusListEntryByCredentialIdArgs): Promise<boolean> {
+    let error = false
+    try {
+      await this.getStatusListEntryByCredentialId(args) // only used to check it exists
+    } catch (error) {
+      error = true
+    }
+    if (!error) {
+      const result = await (
+        await this.getStatusListEntryRepo()
+      ).delete({
+        ...(args.statusListId && { statusList: args.statusListId }),
+        ...(args.entryCorrelationId && { correlationId: args.entryCorrelationId }),
+        credentialId: args.credentialId,
+      })
+      error = !result.affected || result.affected !== 1
+    }
+    return !error
+  }
+
+  async getStatusListEntries(args: IGetStatusListEntriesArgs): Promise<StatusListEntryEntity[]> {
+    return (await this.getStatusListEntryRepo()).find({ where: { ...args?.filter, statusList: args.statusListId } })
+  }
+
+  async getStatusList(args: IGetStatusListArgs): Promise<IStatusListEntity> {
+    if (!args.id && !args.correlationId) {
+      throw Error(`At least and 'id' or 'correlationId' needs to be provided to lookup a status list`)
+    }
+    const where = []
+    if (args.id) {
+      where.push({ id: args.id })
+    }
+    if (args.correlationId) {
+      where.push({ correlationId: args.correlationId })
+    }
+    const result = await (await this.getStatusListRepo()).findOne({ where })
+    if (!result) {
+      throw Error(`No status list found for id ${args.id}`)
+    }
+    return result
+  }
+
+  async getStatusLists(args: IGetStatusListsArgs): Promise<Array<IStatusListEntity>> {
+    const result = await (
+      await this.getStatusListRepo()
+    ).find({
+      where: args.filter,
+    })
+
+    if (!result) {
+      return []
+    }
+    return result
+  }
+
+  async addStatusList(args: IAddStatusListArgs): Promise<IStatusListEntity> {
+    const { id, correlationId } = args
+
+    const result = await (
+      await this.getStatusListRepo()
+    ).findOne({
+      where: [{ id }, { correlationId }],
+    })
+    if (result) {
+      throw Error(`Status list for id ${id}, correlationId ${correlationId} already exists`)
+    }
+
+    debug('Adding status list ', id)
+    const createdResult = await (await this.getStatusListRepo()).save(args)
+
+    return createdResult
+  }
+
+  async updateStatusList(args: IUpdateStatusListIndexArgs): Promise<IStatusListEntity> {
+    const result = await this.getStatusList(args)
+    debug('Updating status list', result)
+    const updatedResult = await (await this.getStatusListRepo()).save(args, { transaction: true })
+    return updatedResult
+  }
+
+  async removeStatusList(args: IRemoveStatusListArgs): Promise<void> {
+    const result = await this.getStatusList(args)
+    await (await this.getStatusListRepo()).delete(result)
+  }
+
+  private async getDS(): Promise<DataSource> {
+    return await this._dbConnection
+  }
+
+  async getStatusListRepo(): Promise<Repository<StatusListEntity>> {
+    return (await this.getDS()).getRepository(StatusListEntity)
+  }
+
+  async getStatusListEntryRepo(): Promise<Repository<StatusListEntryEntity>> {
+    return (await this.getDS()).getRepository(StatusListEntryEntity)
+  }
+}