@sphereon/ssi-sdk.pd-manager 0.34.1-feature.FIDES.1.274 → 0.34.1-feature.IDK.11.48

package/src/agent/PDManager.ts

@@ -1,18 +1,22 @@
 import { IAgentPlugin } from '@veramo/core'
 import {
-  DeleteDcqlQueryItemArgs,
-  DeleteDcqlQueryItemsArgs,
-  GetDcqlQueryItemArgs,
-  GetDcqlQueryItemsArgs,
+  DeleteDefinitionItemArgs,
+  DeleteDefinitionItemsArgs,
+  GetDefinitionItemArgs,
+  GetDefinitionItemsArgs,
   HasDefinitionItemArgs,
-  HasDcqlQueryItemsArgs,
+  HasDefinitionItemsArgs,
   IPDManager,
-  PersistDcqlQueryArgs,
+  PersistDefinitionArgs,
   schema,
 } from '../index'
-import { AbstractPDStore, NonPersistedDcqlQueryItem, DcqlQueryItem, AddDefinitionArgs } from '@sphereon/ssi-sdk.data-store-types'
-import { isPresentationDefinitionEqual } from '@sphereon/ssi-sdk.data-store'
-import semver from 'semver/preload.js'
+import {
+  AbstractPDStore,
+  isPresentationDefinitionEqual,
+  NonPersistedPresentationDefinitionItem,
+  PresentationDefinitionItem,
+} from '@sphereon/ssi-sdk.data-store'
+import semver from 'semver/preload'
 import { ReleaseType } from 'semver'
 
 // Exposing the methods here for any REST implementation
@@ -54,32 +58,32 @@ export class PDManager implements IAgentPlugin {
   }
 
   /** {@inheritDoc IPDManager.pdmHasDefinitions} */
-  private async pdmHasDefinitions(args: HasDcqlQueryItemsArgs): Promise<boolean> {
+  private async pdmHasDefinitions(args: HasDefinitionItemsArgs): Promise<boolean> {
     const { filter } = args
     return this.store.hasDefinitions({ filter })
   }
 
   /** {@inheritDoc IPDManager.pdmGetDefinition} */
-  private async pdmGetDefinition(args: GetDcqlQueryItemArgs): Promise<DcqlQueryItem> {
+  private async pdmGetDefinition(args: GetDefinitionItemArgs): Promise<PresentationDefinitionItem> {
     const { itemId } = args
     return this.store.getDefinition({ itemId })
   }
 
   /** {@inheritDoc IPDManager.pdmGetDefinitions} */
-  private async pdmGetDefinitions(args: GetDcqlQueryItemsArgs): Promise<Array<DcqlQueryItem>> {
+  private async pdmGetDefinitions(args: GetDefinitionItemsArgs): Promise<Array<PresentationDefinitionItem>> {
     const { filter, opts } = args
     const allDefinitions = await this.store.getDefinitions({ filter })
-    let definitions: DcqlQueryItem[] = []
+    let definitions: PresentationDefinitionItem[] = []
     if (opts == undefined || opts.showVersionHistory !== true) {
       const groupedByDefinitionId = allDefinitions.reduce(
         (acc, entity) => {
-          if (!acc[entity.queryId]) {
-            acc[entity.queryId] = []
+          if (!acc[entity.definitionId]) {
+            acc[entity.definitionId] = []
           }
-          acc[entity.queryId].push(entity)
+          acc[entity.definitionId].push(entity)
           return acc
         },
-        {} as Record<string, DcqlQueryItem[]>,
+        {} as Record<string, PresentationDefinitionItem[]>,
       )
       definitions = Object.values(groupedByDefinitionId).map((entities) =>
         entities.reduce((highestVersionItem, baseItem) => {
@@ -95,123 +99,111 @@ export class PDManager implements IAgentPlugin {
   }
 
   /** {@inheritDoc IPDManager.pdmDeleteDefinition} */
-  private async pdmDeleteDefinition(args: DeleteDcqlQueryItemArgs): Promise<boolean> {
+  private async pdmDeleteDefinition(args: DeleteDefinitionItemArgs): Promise<boolean> {
     return this.store.deleteDefinition(args).then((value) => true)
   }
 
   /** {@inheritDoc IPDManager.pdmDeleteDefinitions} */
-  private async pdmDeleteDefinitions(args: DeleteDcqlQueryItemsArgs): Promise<number> {
+  private async pdmDeleteDefinitions(args: DeleteDefinitionItemsArgs): Promise<number> {
     return this.store.deleteDefinitions(args)
   }
 
   /** {@inheritDoc IPDManager.pdmPersistDefinition} */
-  private async pdmPersistDefinition(args: PersistDcqlQueryArgs): Promise<DcqlQueryItem> {
-    try {
-      const { definitionItem, opts } = args
-      const { versionControlMode, versionIncrementReleaseType } = opts ?? { versionControlMode: 'AutoIncrement' }
-      const { version, tenantId } = definitionItem
-      const definitionId = definitionItem.queryId
-
-      let { id } = definitionItem
-      if (id !== undefined && versionControlMode !== 'Overwrite') {
-        id = undefined
-      }
+  private async pdmPersistDefinition(args: PersistDefinitionArgs): Promise<PresentationDefinitionItem> {
+    const { definitionItem, opts } = args
+    const { versionControlMode, versionIncrementReleaseType } = opts ?? { versionControlMode: 'AutoIncrement' }
+    const { version, tenantId } = definitionItem
+    const definitionId = definitionItem.definitionId ?? definitionItem.definitionPayload.id
+
+    let { id } = definitionItem
+    if (id !== undefined && versionControlMode !== 'Overwrite') {
+      id = undefined
+    }
 
-      const nonPersistedDefinitionItem: NonPersistedDcqlQueryItem = {
-        ...definitionItem,
-        version: version ?? '1',
-      }
+    const nonPersistedDefinitionItem: NonPersistedPresentationDefinitionItem = {
+      ...definitionItem,
+      definitionId: definitionId,
+      version: version ?? '1',
+    }
 
-      const existing = await this.store.getDefinitions({ filter: [{ id, queryId: definitionId, tenantId, version }] })
-      const existingItem = existing[0]
+    const existing = await this.store.getDefinitions({ filter: [{ id, definitionId, tenantId, version }] })
+    const existingItem = existing[0]
 
-      // Always fetch all definitions for the definitionId/tenantId and determine the truly latest version
-      const allDefinitions = await this.store.getDefinitions({ filter: [{ queryId: definitionId, tenantId }] })
-      allDefinitions.sort((a, b) => semver.compare(this.normalizeToSemverVersionFormat(a.version), this.normalizeToSemverVersionFormat(b.version)))
-      const trulyLatestVersionItem = allDefinitions[allDefinitions.length - 1]
+    // Always fetch all definitions for the definitionId/tenantId and determine the truly latest version
+    const allDefinitions = await this.store.getDefinitions({ filter: [{ definitionId, tenantId }] })
+    allDefinitions.sort((a, b) => semver.compare(this.normalizeToSemverVersionFormat(a.version), this.normalizeToSemverVersionFormat(b.version)))
+    const trulyLatestVersionItem = allDefinitions[allDefinitions.length - 1]
 
-      let latestVersionItem: DcqlQueryItem | undefined = trulyLatestVersionItem
+    let latestVersionItem: PresentationDefinitionItem | undefined = trulyLatestVersionItem
 
-      // If a specific version exists and matches existingItem, we keep that as a base.
-      // Otherwise we use the trulyLatestVersionItem
-      if (existingItem && version) {
-        latestVersionItem = trulyLatestVersionItem ?? existingItem
-      }
+    // If a specific version exists and matches existingItem, we keep that as a base.
+    // Otherwise we use the trulyLatestVersionItem
+    if (existingItem && version) {
+      latestVersionItem = trulyLatestVersionItem ?? existingItem
+    }
 
-      const isPayloadModified = !existingItem || !isPresentationDefinitionEqual(existingItem, definitionItem)
-      if (!isPayloadModified) return existingItem
-
-      switch (versionControlMode) {
-        case 'Overwrite':
-          return this.handleOverwriteMode(existingItem, nonPersistedDefinitionItem, version)
-        case 'OverwriteLatest':
-          return this.handleOverwriteLatestMode(latestVersionItem, nonPersistedDefinitionItem)
-        case 'Manual':
-          return this.handleManualMode(existingItem, nonPersistedDefinitionItem, tenantId, version)
-        case 'AutoIncrement':
-          return this.handleAutoIncrementMode(latestVersionItem, nonPersistedDefinitionItem, versionIncrementReleaseType ?? 'major')
-        default:
-          throw new Error(`Unknown version control mode: ${versionControlMode}`)
-      }
-    } catch (e) {
-      console.log('pdmPersistDefinition failed', e)
-      throw e
+    const isPayloadModified = !existingItem || !isPresentationDefinitionEqual(existingItem, definitionItem)
+    if (!isPayloadModified) return existingItem
+
+    switch (versionControlMode) {
+      case 'Overwrite':
+        return this.handleOverwriteMode(existingItem, nonPersistedDefinitionItem, version)
+      case 'OverwriteLatest':
+        return this.handleOverwriteLatestMode(latestVersionItem, nonPersistedDefinitionItem)
+      case 'Manual':
+        return this.handleManualMode(existingItem, nonPersistedDefinitionItem, tenantId, version)
+      case 'AutoIncrement':
+        return this.handleAutoIncrementMode(latestVersionItem, nonPersistedDefinitionItem, versionIncrementReleaseType ?? 'major')
+      default:
+        throw new Error(`Unknown version control mode: ${versionControlMode}`)
     }
   }
 
   private async handleOverwriteMode(
-    existingItem: DcqlQueryItem | undefined,
-    definitionItem: NonPersistedDcqlQueryItem,
+    existingItem: PresentationDefinitionItem | undefined,
+    definitionItem: NonPersistedPresentationDefinitionItem,
     version: string | undefined,
-  ): Promise<DcqlQueryItem> {
+  ): Promise<PresentationDefinitionItem> {
     if (existingItem) {
-      existingItem.queryId = definitionItem.queryId
+      existingItem.definitionId = definitionItem.definitionId
       existingItem.version = version ?? existingItem.version ?? '1'
       existingItem.tenantId = definitionItem.tenantId
-      existingItem.name = definitionItem.name
-      existingItem.purpose = definitionItem.purpose
-      existingItem.query = definitionItem.query
+      existingItem.name = definitionItem.definitionPayload.name ?? definitionItem.name
+      existingItem.purpose = definitionItem.definitionPayload.purpose ?? definitionItem.purpose
+      existingItem.definitionPayload = definitionItem.definitionPayload
 
       return await this.store.updateDefinition(existingItem)
     } else {
-      // Apply the same field extraction logic for new items
-      const newDefinitionItem = {
-        ...definitionItem,
-      } satisfies AddDefinitionArgs
-      return await this.store.addDefinition(newDefinitionItem)
+      return await this.store.addDefinition(definitionItem)
     }
   }
 
   private async handleOverwriteLatestMode(
-    latestVersionItem: DcqlQueryItem | undefined,
-    definitionItem: NonPersistedDcqlQueryItem,
-  ): Promise<DcqlQueryItem> {
+    latestVersionItem: PresentationDefinitionItem | undefined,
+    definitionItem: NonPersistedPresentationDefinitionItem,
+  ): Promise<PresentationDefinitionItem> {
     if (latestVersionItem) {
-      latestVersionItem.queryId = definitionItem.queryId
+      latestVersionItem.definitionId = definitionItem.definitionId
       latestVersionItem.tenantId = definitionItem.tenantId
       latestVersionItem.name = definitionItem.name
       latestVersionItem.purpose = definitionItem.purpose
-      latestVersionItem.query = definitionItem.query
+      latestVersionItem.definitionPayload = definitionItem.definitionPayload
 
       return await this.store.updateDefinition(latestVersionItem)
     } else {
-      // Apply the same field extraction logic for new items
-      const newDefinitionItem = {
-        ...definitionItem,
-      } satisfies AddDefinitionArgs
-      return await this.store.addDefinition(newDefinitionItem)
+      return await this.store.addDefinition(definitionItem)
     }
   }
 
   private async handleManualMode(
-    existingItem: DcqlQueryItem | undefined,
-    definitionItem: NonPersistedDcqlQueryItem,
+    existingItem: PresentationDefinitionItem | undefined,
+    definitionItem: NonPersistedPresentationDefinitionItem,
     tenantId: string | undefined,
     version: string | undefined,
-  ): Promise<DcqlQueryItem> {
+  ): Promise<PresentationDefinitionItem> {
     if (existingItem && !isPresentationDefinitionEqual(existingItem, definitionItem)) {
       throw Error(
-        `Cannot update definition ${definitionItem.queryId} for tenant ${tenantId} version ${version} because definition exists and manual version control is enabled.`,
+        `Cannot update definition ${definitionItem.definitionId} for tenant ${tenantId} version ${version} because definition exists and manual version control is enabled.`,
       )
     } else {
       return await this.store.addDefinition(definitionItem)
@@ -219,10 +211,10 @@ export class PDManager implements IAgentPlugin {
   }
 
   private async handleAutoIncrementMode(
-    latestVersionItem: DcqlQueryItem | undefined,
-    definitionItem: NonPersistedDcqlQueryItem,
+    latestVersionItem: PresentationDefinitionItem | undefined,
+    definitionItem: NonPersistedPresentationDefinitionItem,
     releaseType: ReleaseType,
-  ): Promise<DcqlQueryItem> {
+  ): Promise<PresentationDefinitionItem> {
     const defaultVersion = '1'
     let currentVersion = latestVersionItem?.version ?? definitionItem.version ?? defaultVersion
     let resultVersion: string
@@ -238,7 +230,7 @@ export class PDManager implements IAgentPlugin {
       let fullVersionToIncrement = preReleaseIdentifier ? `${normalizedBaseVersion}-${preReleaseSuffix}` : normalizedBaseVersion
 
       // Use semver to increment the version
-      let incrementedVersion = semver.inc(fullVersionToIncrement, releaseType, undefined, preReleaseIdentifier)
+      let incrementedVersion = semver.inc(fullVersionToIncrement, releaseType, preReleaseIdentifier)
       if (!incrementedVersion) {
         throw new Error(`Could not increment ${releaseType} version on ${currentVersion} ${preReleaseSuffix}`)
       }
@@ -256,20 +248,10 @@ export class PDManager implements IAgentPlugin {
       }
     }
 
-    // Apply field extraction logic before adding
-    const newDefinitionItem = {
-      ...definitionItem,
-      version: resultVersion,
-    } satisfies AddDefinitionArgs
-
-    try {
-      const dcqlQueryItem = await this.store.addDefinition(newDefinitionItem)
-      return dcqlQueryItem
-    } catch (e) {
-      console.log(e)
-      throw e
-    }
+    definitionItem.version = resultVersion
+    return await this.store.addDefinition(definitionItem)
   }
+
   private normalizeToSemverVersionFormat(version: string): string {
     const defaultVersion = '1.0.0'
     let [baseVersion, preReleaseSuffix] = version.split(/-(.+)/)

package/src/index.ts

@@ -1,11 +1,9 @@
 /**
  * @public
  */
-import schema from '../plugin.schema.json'
+const schema = require('../plugin.schema.json')
 export { schema }
 export { PDManager, pdManagerMethods } from './agent/PDManager'
 export * from './types/IPDManager'
 
-export type { ReleaseType } from 'semver'
-export type { ImportDcqlQueryItem } from '@sphereon/ssi-sdk.data-store-types'
-export type { DcqlQuery } from 'dcql'
+export { ReleaseType } from 'semver'

package/src/types/IPDManager.ts

@@ -1,5 +1,5 @@
 import { IAgentContext, IPluginMethodMap } from '@veramo/core'
-import { FindDcqlQueryArgs, NonPersistedDcqlQueryItem, DcqlQueryItem } from '@sphereon/ssi-sdk.data-store-types'
+import { FindDefinitionArgs, NonPersistedPresentationDefinitionItem, PresentationDefinitionItem } from '@sphereon/ssi-sdk.data-store'
 import { ReleaseType } from 'semver'
 
 export interface IPDManager extends IPluginMethodMap {
@@ -7,13 +7,13 @@ export interface IPDManager extends IPluginMethodMap {
    * Get a single presentation definition records by primary key
    * @param args
    */
-  pdmGetDefinition(args: GetDcqlQueryItemArgs): Promise<DcqlQueryItem>
+  pdmGetDefinition(args: GetDefinitionItemArgs): Promise<PresentationDefinitionItem>
 
   /**
    * Find one or more presentation definition records using filters
    * @param args
    */
-  pdmGetDefinitions(args: GetDcqlQueryItemsArgs): Promise<Array<DcqlQueryItem>>
+  pdmGetDefinitions(args: GetDefinitionItemsArgs): Promise<Array<PresentationDefinitionItem>>
 
   /**
    * Checks whether a presentation definition record exists by primary key
@@ -25,55 +25,56 @@ export interface IPDManager extends IPluginMethodMap {
    * Checks whether one or more presentation definition records exist using filters
    * @param args
    */
-  pdmHasDefinitions(args: HasDcqlQueryItemsArgs): Promise<boolean>
+  pdmHasDefinitions(args: HasDefinitionItemsArgs): Promise<boolean>
 
   /**
    * Delete a single presentation definition records by primary key
    * @param args
    */
-  pdmDeleteDefinition(args: DeleteDcqlQueryItemArgs): Promise<boolean>
+  pdmDeleteDefinition(args: DeleteDefinitionItemArgs): Promise<boolean>
 
   /**
    * Delete multiple presentation definitions records using filters
    * @param args
    */
-  pdmDeleteDefinitions(args: DeleteDcqlQueryItemsArgs): Promise<number>
+  pdmDeleteDefinitions(args: DeleteDefinitionItemsArgs): Promise<number>
 
   /**
    * Check in a presentation definition.
    * It has version control logic which will add or update presentation definition records and has settings for automatic version numbering.
    * @param args
    */
-  pdmPersistDefinition(args: PersistDcqlQueryArgs): Promise<DcqlQueryItem>
+  pdmPersistDefinition(args: PersistDefinitionArgs): Promise<PresentationDefinitionItem>
 }
 
 export type VersionControlMode = 'AutoIncrement' | 'Manual' | 'Overwrite' | 'OverwriteLatest'
 
-export type GetDcqlQueryItemArgs = {
+export type GetDefinitionItemArgs = {
   itemId: string
 }
 
-export type HasDefinitionItemArgs = GetDcqlQueryItemArgs
+export type HasDefinitionItemArgs = GetDefinitionItemArgs
 
 export type FetchOptions = {
   showVersionHistory?: boolean
 }
 
-export type GetDcqlQueryItemsArgs = {
-  filter?: FindDcqlQueryArgs
+export type GetDefinitionItemsArgs = {
+  filter?: FindDefinitionArgs
   opts?: FetchOptions
 }
 
-export type HasDcqlQueryItemsArgs = GetDcqlQueryItemsArgs
+export type HasDefinitionItemsArgs = GetDefinitionItemsArgs
 
-export type DeleteDcqlQueryItemArgs = {
+export type DeleteDefinitionItemArgs = {
   itemId: string
 }
 
-export type DeleteDcqlQueryItemsArgs = GetDcqlQueryItemsArgs
+export type DeleteDefinitionItemsArgs = GetDefinitionItemsArgs
 
-export type PersistDcqlQueryItem = Omit<NonPersistedDcqlQueryItem, 'version'> & {
+export type PersistPresentationDefinitionItem = Omit<NonPersistedPresentationDefinitionItem, 'definitionId' | 'version'> & {
   id?: string
+  definitionId?: string
   version?: string
 }
 
@@ -82,8 +83,8 @@ export type PersistOptions = {
   versionIncrementReleaseType?: ReleaseType
 }
 
-export type PersistDcqlQueryArgs = {
-  definitionItem: PersistDcqlQueryItem
+export type PersistDefinitionArgs = {
+  definitionItem: PersistPresentationDefinitionItem
   opts?: PersistOptions
 }