@sphereon/ssi-sdk.data-store 0.34.1-feature.SSISDK.26.RP.58 → 0.34.1-feature.SSISDK.45.189

package/src/types/presentationDefinition/presentationDefinition.ts

@@ -1,19 +1,18 @@
-import { IPresentationDefinition } from '@sphereon/pex'
-import { DcqlQueryREST } from '@sphereon/ssi-types'
+import { DcqlQuery } from 'dcql'
 
-export type PresentationDefinitionItem = {
+export type DcqlQueryItem = {
   id: string
-  definitionId: string
+  queryId: string
   tenantId?: string
   version: string
   name?: string
   purpose?: string
-  definitionPayload: IPresentationDefinition
-  dcqlPayload?: DcqlQueryREST
+  query: DcqlQuery
   createdAt: Date
   lastUpdatedAt: Date
 }
 
-export type NonPersistedPresentationDefinitionItem = Omit<PresentationDefinitionItem, 'id' | 'createdAt' | 'lastUpdatedAt'>
-export type PartialPresentationDefinitionItem = Partial<PresentationDefinitionItem>
-export type PresentationDefinitionItemFilter = Partial<Omit<PresentationDefinitionItem, 'definitionPayload' | 'dcqlPayload'>>
+export type ImportDcqlQueryItem = Omit<DcqlQueryItem, 'id' | 'tenantId' | 'version' | 'createdAt' | 'lastUpdatedAt'>
+export type NonPersistedDcqlQueryItem = Omit<DcqlQueryItem, 'id' | 'createdAt' | 'lastUpdatedAt'>
+export type PartialDcqlQueryItem = Partial<DcqlQueryItem>
+export type DcqlQueryItemFilter = Partial<Omit<DcqlQueryItem, 'query'>>

package/src/utils/presentationDefinition/MappingUtils.ts

@@ -1,58 +1,67 @@
-import { PresentationDefinitionItemEntity } from '../../entities/presentationDefinition/PresentationDefinitionItemEntity'
 import type { IPresentationDefinition } from '@sphereon/pex'
-import type { NonPersistedPresentationDefinitionItem, PartialPresentationDefinitionItem, PresentationDefinitionItem } from '../../types'
 import * as blakepkg from 'blakejs'
+import { DcqlQuery } from 'dcql'
+import { DcqlQueryItemEntity } from '../../entities/presentationDefinition/DcqlQueryItemEntity'
+import type { NonPersistedDcqlQueryItem, PartialDcqlQueryItem, DcqlQueryItem } from '../../types'
 import { replaceNullWithUndefined } from '../FormattingUtils'
-import type { DcqlQueryREST } from '@sphereon/ssi-types'
 
-export const presentationDefinitionItemFrom = (entity: PresentationDefinitionItemEntity): PresentationDefinitionItem => {
-  const result: PresentationDefinitionItem = {
+export const dcqlQueryItemFrom = (entity: DcqlQueryItemEntity): DcqlQueryItem => {
+  const result: DcqlQueryItem = {
     id: entity.id,
     tenantId: entity.tenantId,
-    definitionId: entity.definitionId,
+    queryId: entity.queryId,
     version: entity.version,
     name: entity.name,
     purpose: entity.purpose,
-    definitionPayload: JSON.parse(entity.definitionPayload) as IPresentationDefinition,
-    dcqlPayload: JSON.parse(entity.dcqlPayload) as DcqlQueryREST,
+    query: DcqlQuery.parse(JSON.parse(entity.query)),
     createdAt: entity.createdAt,
     lastUpdatedAt: entity.lastUpdatedAt,
   }
 
+  if (result.query) {
+    DcqlQuery.validate(result.query)
+  }
   return replaceNullWithUndefined(result)
 }
 
-export const presentationDefinitionEntityItemFrom = (item: NonPersistedPresentationDefinitionItem): PresentationDefinitionItemEntity => {
-  const entity = new PresentationDefinitionItemEntity()
+export const dcqlQueryEntityItemFrom = (item: NonPersistedDcqlQueryItem): DcqlQueryItemEntity => {
+  const entity = new DcqlQueryItemEntity()
 
   entity.tenantId = item.tenantId
-  entity.definitionId = item.definitionId!
+  entity.queryId = item.queryId!
   entity.version = item.version
   entity.name = item.name
   entity.purpose = item.purpose
-  entity.definitionPayload = JSON.stringify(item.definitionPayload!)
-  entity.dcqlPayload = JSON.stringify(item.dcqlPayload!)
+  if (item.query) {
+    const dcqlQuery = DcqlQuery.parse(item.query)
+    DcqlQuery.validate(dcqlQuery)
+    entity.query = JSON.stringify(item.query)
+  }
   return entity
 }
 
-function hashPayload(payload: IPresentationDefinition): string {
+function hashPayload(payload: IPresentationDefinition | DcqlQuery): string {
   return blakepkg.blake2bHex(JSON.stringify(payload))
 }
 
-export function isPresentationDefinitionEqual(base: PartialPresentationDefinitionItem, compare: PartialPresentationDefinitionItem): boolean {
+export function isPresentationDefinitionEqual(base: PartialDcqlQueryItem, compare: PartialDcqlQueryItem): boolean {
   if (
-    base.definitionId !== compare.definitionId ||
-    base.tenantId != compare.tenantId ||
+    base.queryId !== compare.queryId ||
+    base.tenantId !== compare.tenantId ||
     base.version !== compare.version ||
-    base.name != compare.name ||
-    base.purpose != compare.purpose
+    base.name !== compare.name ||
+    base.purpose !== compare.purpose
   ) {
     return false
   }
 
-  if (base.definitionPayload && compare.definitionPayload) {
-    return hashPayload(base.definitionPayload) === hashPayload(compare.definitionPayload)
+  if (base.query && compare.query) {
+    if (hashPayload(base.query) !== hashPayload(compare.query)) {
+      return false
+    }
+  } else if (base.query || compare.query) {
+    return false
   }
 
-  return false
+  return true
 }