@sphereon/ssi-sdk.pd-manager 0.34.1-feature.SSISDK.57.uni.client.206 → 0.34.1-feature.SSISDK.58.host.nonce.endpoint.145

package/src/agent/PDManager.ts

@@ -1,21 +1,20 @@
 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,
   isPresentationDefinitionEqual,
-  NonPersistedDcqlQueryItem,
-  DcqlQueryItem,
-  AddDefinitionArgs,
+  NonPersistedPresentationDefinitionItem,
+  PresentationDefinitionItem,
 } from '@sphereon/ssi-sdk.data-store'
 import semver from 'semver/preload'
 import { ReleaseType } from 'semver'
@@ -59,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) => {
@@ -100,41 +99,41 @@ 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> {
+  private async pdmPersistDefinition(args: PersistDefinitionArgs): Promise<PresentationDefinitionItem> {
     const { definitionItem, opts } = args
     const { versionControlMode, versionIncrementReleaseType } = opts ?? { versionControlMode: 'AutoIncrement' }
     const { version, tenantId } = definitionItem
-    const definitionId = definitionItem.queryId
+    const definitionId = definitionItem.definitionId
 
     let { id } = definitionItem
     if (id !== undefined && versionControlMode !== 'Overwrite') {
       id = undefined
     }
 
-    const nonPersistedDefinitionItem: NonPersistedDcqlQueryItem = {
+    const nonPersistedDefinitionItem: NonPersistedPresentationDefinitionItem = {
       ...definitionItem,
       version: version ?? '1',
     }
 
-    const existing = await this.store.getDefinitions({ filter: [{ id, queryId: definitionId, tenantId, version }] })
+    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 }] })
+    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
@@ -160,58 +159,64 @@ export class PDManager implements IAgentPlugin {
   }
 
   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.dcqlPayload?.name ?? definitionItem.definitionPayload?.name ?? definitionItem.name
+      existingItem.purpose = definitionItem.dcqlPayload?.defaultPurpose ?? definitionItem.definitionPayload?.purpose ?? definitionItem.purpose
+      existingItem.dcqlPayload = definitionItem.dcqlPayload
+      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
+        name: definitionItem.name ?? definitionItem.dcqlPayload?.name ?? definitionItem.definitionPayload?.name,
+        purpose: definitionItem.purpose ?? definitionItem.dcqlPayload?.defaultPurpose ?? definitionItem.definitionPayload?.purpose,
+      }
       return await this.store.addDefinition(newDefinitionItem)
     }
   }
 
   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.name = definitionItem.dcqlPayload?.name ?? definitionItem.definitionPayload?.name ?? definitionItem.name
+      latestVersionItem.purpose = definitionItem.dcqlPayload?.defaultPurpose ?? definitionItem.definitionPayload?.purpose ?? definitionItem.purpose
+      latestVersionItem.definitionPayload = definitionItem.definitionPayload
+      latestVersionItem.dcqlPayload = definitionItem.dcqlPayload
 
       return await this.store.updateDefinition(latestVersionItem)
     } else {
       // Apply the same field extraction logic for new items
       const newDefinitionItem = {
         ...definitionItem,
-      } satisfies AddDefinitionArgs
+        name: definitionItem.name ?? definitionItem.dcqlPayload?.name ?? definitionItem.definitionPayload?.name,
+        purpose: definitionItem.purpose ?? definitionItem.dcqlPayload?.defaultPurpose ?? definitionItem.definitionPayload?.purpose,
+      }
       return await this.store.addDefinition(newDefinitionItem)
     }
   }
 
   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 +224,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
@@ -260,7 +265,9 @@ export class PDManager implements IAgentPlugin {
     const newDefinitionItem = {
       ...definitionItem,
       version: resultVersion,
-    } satisfies AddDefinitionArgs
+      name: definitionItem.name ?? definitionItem.dcqlPayload?.name ?? definitionItem.definitionPayload?.name,
+      purpose: definitionItem.purpose ?? definitionItem.dcqlPayload?.defaultPurpose ?? definitionItem.definitionPayload?.purpose,
+    }
 
     return await this.store.addDefinition(newDefinitionItem)
   }

package/src/index.ts

@@ -1,10 +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'

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'
+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,54 +25,54 @@ 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, 'version'> & {
   id?: string
   version?: string
 }
@@ -82,8 +82,8 @@ export type PersistOptions = {
   versionIncrementReleaseType?: ReleaseType
 }
 
-export type PersistDcqlQueryArgs = {
-  definitionItem: PersistDcqlQueryItem
+export type PersistDefinitionArgs = {
+  definitionItem: PersistPresentationDefinitionItem
   opts?: PersistOptions
 }