@sphereon/ssi-sdk.data-store 0.34.1-next.3 → 0.34.1-next.323

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

@@ -13,7 +13,7 @@ export class CreatePresentationDefinitions1716475165344 implements MigrationInte
     "version" varchar NOT NULL,
     "purpose" varchar,
     "definition_payload" varchar NOT NULL,
-    "dcql_payload" varchar,
+    "query" varchar,
     "created_at" datetime NOT NULL DEFAULT (datetime('now')),
     "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')))`,
     )

package/src/migrations/sqlite/1726617600000-CreateDcqlQueryItem.ts

@@ -0,0 +1,24 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class CreateDcqlQueryItemSQlite1726617600000 implements MigrationInterface {
+  name = 'CreateDcqlQueryItemSQlite1726617600000'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "DcqlQueryItem" (
+                                      "id" varchar PRIMARY KEY NOT NULL,
+                                      "tenant_id" varchar,
+                                      "query_id" varchar NOT NULL,
+                                      "name" varchar,
+                                      "version" varchar NOT NULL,
+                                      "purpose" varchar,
+                                      "query" varchar NOT NULL,
+                                      "created_at" datetime NOT NULL DEFAULT (datetime('now')),
+                                      "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')))`,
+    )
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "DcqlQueryItem"`)
+  }
+}

package/src/migrations/sqlite/1741895823001-CreateBitstringStatusList.ts

@@ -0,0 +1,145 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class CreateBitstringStatusListSqlite1741895823001 implements MigrationInterface {
+  name = 'CreateBitstringStatusList1741895823000'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // Update StatusList table to include BitstringStatusList type and columns
+    await queryRunner.query(`
+      CREATE TABLE "temporary_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', 'OAuthStatusList', 'BitstringStatusList') ) 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', 'vc+jwt') ) NOT NULL DEFAULT ('lds'),
+        "indexingDirection" varchar CHECK( "indexingDirection" IN ('rightToLeft') ),
+        "statusPurpose" varchar,
+        "statusListCredential" text,
+        "expiresAt" datetime,
+        "bitsPerStatus" integer DEFAULT (1),
+        "ttl" integer,
+        "validFrom" datetime,
+        "validUntil" datetime,
+        CONSTRAINT "UQ_correlationId" UNIQUE ("correlationId")
+      )
+    `)
+
+    await queryRunner.query(`
+      INSERT INTO "temporary_StatusList"(
+        "id", "correlationId", "length", "issuer", "type", "driverType",
+        "credentialIdMode", "proofFormat", "indexingDirection", "statusPurpose",
+        "statusListCredential", "bitsPerStatus", "expiresAt"
+      )
+      SELECT 
+        "id", "correlationId", "length", "issuer", "type", "driverType",
+        "credentialIdMode", "proofFormat", "indexingDirection", "statusPurpose",
+        "statusListCredential", "bitsPerStatus", "expiresAt"
+      FROM "StatusList"
+    `)
+
+    await queryRunner.query(`DROP TABLE "StatusList"`)
+    await queryRunner.query(`ALTER TABLE "temporary_StatusList" RENAME TO "StatusList"`)
+
+    // Update StatusListEntry table with inheritance and bitstring columns
+    await queryRunner.query(`
+      CREATE TABLE "temporary_StatusListEntry" (
+        "statusListId" varchar NOT NULL,
+        "statusListIndex" integer NOT NULL,
+        "credentialId" text,
+        "credentialHash" varchar(128),
+        "correlationId" varchar(255),
+        "value" varchar(50),
+        "type" varchar CHECK( "type" IN ('StatusListEntryEntity', 'bitstring') ) NOT NULL DEFAULT ('StatusListEntryEntity'),
+        "statusPurpose" varchar,
+        "bitsPerStatus" integer DEFAULT (1),
+        "statusMessage" text,
+        "statusReference" text,
+        PRIMARY KEY ("statusListId", "statusListIndex")
+      )
+    `)
+
+    await queryRunner.query(`
+      INSERT INTO "temporary_StatusListEntry"(
+        "statusListId", "statusListIndex", "credentialId", "credentialHash", 
+        "correlationId", "value", "type"
+      )
+      SELECT 
+        "statusListId", "statusListIndex", "credentialId", "credentialHash",
+        "correlationId", "value", 'StatusListEntryEntity'
+      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> {
+    // Revert StatusListEntry table changes
+    await queryRunner.query(`
+      CREATE TABLE "temporary_StatusListEntry" (
+        "statusListId" varchar NOT NULL,
+        "statusListIndex" integer NOT NULL,
+        "credentialId" text,
+        "credentialHash" varchar(128),
+        "correlationId" varchar(255),
+        "value" varchar(50),
+        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"
+      WHERE "type" = 'StatusListEntryEntity'
+    `)
+
+    await queryRunner.query(`DROP TABLE "StatusListEntry"`)
+    await queryRunner.query(`ALTER TABLE "temporary_StatusListEntry" RENAME TO "StatusListEntry"`)
+
+    // Revert StatusList table changes
+    await queryRunner.query(`
+      CREATE TABLE "temporary_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', 'OAuthStatusList') ) 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', 'vc+jwt') ) NOT NULL DEFAULT ('lds'),
+        "indexingDirection" varchar CHECK( "indexingDirection" IN ('rightToLeft') ),
+        "statusPurpose" varchar,
+        "statusListCredential" text,
+        "bitsPerStatus" integer,
+        "expiresAt" datetime,
+        CONSTRAINT "UQ_correlationId" UNIQUE ("correlationId")
+      )
+    `)
+
+    await queryRunner.query(`
+      INSERT INTO "temporary_StatusList"(
+        "id", "correlationId", "length", "issuer", "type", "driverType",
+        "credentialIdMode", "proofFormat", "indexingDirection", "statusPurpose",
+        "statusListCredential", "bitsPerStatus", "expiresAt"
+      )
+      SELECT 
+        "id", "correlationId", "length", "issuer", 
+        CASE WHEN "type" = 'BitstringStatusList' THEN 'StatusList2021' ELSE "type" END,
+        "driverType", "credentialIdMode", "proofFormat", "indexingDirection",
+        "statusPurpose", "statusListCredential", "bitsPerStatus", "expiresAt"
+      FROM "StatusList"
+    `)
+
+    await queryRunner.query(`DROP TABLE "StatusList"`)
+    await queryRunner.query(`ALTER TABLE "temporary_StatusList" RENAME TO "StatusList"`)
+  }
+}

package/src/presentationDefinition/PDStore.ts

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

package/src/statusList/IStatusListStore.ts

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