@sphereon/ssi-sdk.data-store 0.18.2-unstable.8 → 0.18.2-unstable.85

package/src/digitalCredential/AbstractDigitalCredentialStore.ts

@@ -0,0 +1,16 @@
+import {
+  AddDigitalCredentialArgs,
+  GetDigitalCredentialArgs,
+  GetDigitalCredentialsArgs,
+  RemoveDigitalCredentialArgs,
+  UpdateDigitalCredentialStateArgs,
+} from '../types/digitalCredential/IAbstractDigitalCredentialStore'
+import { DigitalCredentialEntity } from '../entities/digitalCredential/DigitalCredentialEntity'
+
+export abstract class AbstractDigitalCredentialStore {
+  abstract getDigitalCredential(args: GetDigitalCredentialArgs): Promise<DigitalCredentialEntity>
+  abstract getDigitalCredentials(args?: GetDigitalCredentialsArgs): Promise<Array<DigitalCredentialEntity>>
+  abstract addDigitalCredential(args: AddDigitalCredentialArgs): Promise<DigitalCredentialEntity>
+  abstract updateDigitalCredentialState(args: UpdateDigitalCredentialStateArgs): Promise<DigitalCredentialEntity>
+  abstract removeDigitalCredential(args: RemoveDigitalCredentialArgs): Promise<boolean>
+}

package/src/digitalCredential/DigitalCredentialStore.ts

@@ -0,0 +1,107 @@
+import { AbstractDigitalCredentialStore } from './AbstractDigitalCredentialStore'
+import {
+  AddDigitalCredentialArgs,
+  GetDigitalCredentialArgs,
+  GetDigitalCredentialsArgs,
+  RemoveDigitalCredentialArgs,
+  UpdateDigitalCredentialStateArgs,
+} from '../types/digitalCredential/IAbstractDigitalCredentialStore'
+import { OrPromise } from '@sphereon/ssi-types'
+import { DataSource, Repository } from 'typeorm'
+import Debug from 'debug'
+import { DigitalCredentialEntity } from '../entities/digitalCredential/DigitalCredentialEntity'
+import { nonPersistedDigitalCredentialEntityFromAddArgs } from '../utils/digitalCredential/MappingUtils'
+import { FindOptionsWhere } from 'typeorm/find-options/FindOptionsWhere'
+import { CredentialStateType, DigitalCredential, NonPersistedDigitalCredential } from '../types/digitalCredential/digitalCredential'
+
+const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:credential-store')
+
+export class DigitalCredentialStore extends AbstractDigitalCredentialStore {
+  private readonly dbConnection: OrPromise<DataSource>
+
+  constructor(dbConnection: OrPromise<DataSource>) {
+    super()
+    this.dbConnection = dbConnection
+  }
+
+  addDigitalCredential = async (args: AddDigitalCredentialArgs): Promise<DigitalCredentialEntity> => {
+    debug('Adding credential', args)
+    const digitalCredentialEntityRepository: Repository<DigitalCredentialEntity> = (await this.dbConnection).getRepository(DigitalCredentialEntity)
+    const credentialEntity: NonPersistedDigitalCredential = nonPersistedDigitalCredentialEntityFromAddArgs(args)
+    const createdResult: DigitalCredentialEntity = await digitalCredentialEntityRepository.save(credentialEntity)
+    return Promise.resolve(createdResult)
+  }
+
+  getDigitalCredential = async (args: GetDigitalCredentialArgs): Promise<DigitalCredentialEntity> => {
+    const result: DigitalCredentialEntity | null = await (await this.dbConnection).getRepository(DigitalCredentialEntity).findOne({
+      where: args,
+    })
+
+    if (!result) {
+      return Promise.reject(Error(`No credential found for arg: ${args.toString()}`))
+    }
+    return result
+  }
+
+  getDigitalCredentials = async (args?: GetDigitalCredentialsArgs): Promise<Array<DigitalCredentialEntity>> => {
+    const result: Array<DigitalCredentialEntity> = await (await this.dbConnection).getRepository(DigitalCredentialEntity).find({
+      ...(args?.filter && { where: args?.filter }),
+    })
+    if (!result) {
+      return Promise.reject(Error(`No credential found for arg: ${args?.toString()}`))
+    }
+    return result
+  }
+
+  removeDigitalCredential = async (args: RemoveDigitalCredentialArgs): Promise<boolean> => {
+    if (!args) {
+      return false
+    }
+
+    let query: FindOptionsWhere<DigitalCredentialEntity> = {}
+
+    if ('id' in args) {
+      query.id = args.id
+    } else if ('hash' in args) {
+      query.hash = args.hash
+    } else {
+      return false
+    }
+    try {
+      const connection = await this.dbConnection
+      const result = await connection.getRepository(DigitalCredentialEntity).delete(query)
+      return result.affected === 1
+    } catch (error) {
+      console.error('Error removing digital credential:', error)
+      return false
+    }
+  }
+
+  updateDigitalCredentialState = async (args: UpdateDigitalCredentialStateArgs): Promise<DigitalCredentialEntity> => {
+    const credentialRepository: Repository<DigitalCredentialEntity> = (await this.dbConnection).getRepository(DigitalCredentialEntity)
+    const whereClause: Record<string, any> = {}
+    if ('id' in args) {
+      whereClause.id = args.id
+    }
+    if ('hash' in args) {
+      whereClause.hash = args.hash
+    }
+    const credential: DigitalCredentialEntity | null = await credentialRepository.findOne({
+      where: whereClause,
+    })
+
+    if (!credential) {
+      return Promise.reject(Error(`No credential found for args: ${whereClause}`))
+    }
+    const updatedCredential: DigitalCredential = {
+      ...credential,
+      verificationDate: args.verificationDate ?? new Date(),
+      lastUpdatedAt: new Date(),
+      ...(args.verifiedState === CredentialStateType.REVOKED && { revocationDate: args.verificationDate ?? new Date() }),
+      verifiedState: args.verifiedState,
+    }
+    debug('Updating credential', credential)
+    const updatedResult: DigitalCredentialEntity = await credentialRepository.save(updatedCredential, { transaction: true })
+    return updatedResult
+  }
+}

package/src/entities/contact/ElectronicAddressEntity.ts

@@ -32,6 +32,9 @@ export class ElectronicAddressEntity extends BaseEntity {
   })
   party!: PartyEntity
 
+  @Column({ name: 'partyId', nullable: true })
+  partyId?: string
+
   @CreateDateColumn({ name: 'created_at', nullable: false })
   createdAt!: Date
 

package/src/entities/contact/IdentityEntity.ts

@@ -73,7 +73,7 @@ export class IdentityEntity extends BaseEntity {
   party!: PartyEntity
 
   @Column({ name: 'partyId', nullable: true })
-  partyId!: string
+  partyId?: string
 
   // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
   @BeforeInsert()

package/src/entities/contact/PartyEntity.ts

@@ -20,13 +20,14 @@ import { BaseContactEntity } from './BaseContactEntity'
 import { PartyRelationshipEntity } from './PartyRelationshipEntity'
 import { getConstraint } from '../../utils/ValidatorUtils'
 import { ElectronicAddressEntity } from './ElectronicAddressEntity'
+import { PhysicalAddressEntity } from './PhysicalAddressEntity'
 
 @Entity('Party')
 export class PartyEntity extends BaseEntity {
   @PrimaryGeneratedColumn('uuid')
   id!: string
 
-  @Column({ name: 'uri', length: 255 })
+  @Column({ name: 'uri', length: 255, nullable: true })
   uri?: string
 
   @OneToMany(() => IdentityEntity, (identity: IdentityEntity) => identity.party, {
@@ -47,6 +48,15 @@ export class PartyEntity extends BaseEntity {
   @JoinColumn({ name: 'electronic_address_id' })
   electronicAddresses!: Array<ElectronicAddressEntity>
 
+  @OneToMany(() => PhysicalAddressEntity, (physicalAddress: PhysicalAddressEntity) => physicalAddress.party, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: false,
+  })
+  @JoinColumn({ name: 'physical_address_id' })
+  physicalAddresses!: Array<PhysicalAddressEntity>
+
   @ManyToOne(() => PartyTypeEntity, (contactType: PartyTypeEntity) => contactType.parties, {
     cascade: true,
     nullable: false,

package/src/entities/contact/PhysicalAddressEntity.ts

@@ -0,0 +1,87 @@
+import { IsNotEmpty, validate, ValidationError } from 'class-validator'
+import {
+  BaseEntity,
+  BeforeInsert,
+  BeforeUpdate,
+  Column,
+  CreateDateColumn,
+  Entity,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn
+} from 'typeorm'
+import { getConstraint } from '../../utils/ValidatorUtils'
+import { PhysicalAddressType, ValidationConstraint } from '../../types'
+import { PartyEntity } from './PartyEntity'
+
+@Entity('PhysicalAddress')
+export class PhysicalAddressEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'type', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank physical address types are not allowed' })
+  type!: PhysicalAddressType
+
+  @Column({ name: 'street_name', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank street names are not allowed' })
+  streetName!: string
+
+  @Column({ name: 'street_number', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank street numbers are not allowed' })
+  streetNumber!: string
+
+  @Column({ name: 'postal_code', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank postal codes are not allowed' })
+  postalCode!: string
+
+  @Column({ name: 'city_name', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank city names are not allowed' })
+  cityName!: string
+
+  @Column({ name: 'province_name', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank province names are not allowed' })
+  provinceName!: string
+
+  @Column({ name: 'country_code', length: 2, nullable: false })
+  @IsNotEmpty({ message: 'Blank country codes are not allowed' })
+  countryCode!: string
+
+  @Column({ name: 'building_name', length: 255, nullable: true })
+  @IsNotEmpty({ message: 'Blank building names are not allowed' })
+  buildingName?: string
+
+  @ManyToOne(() => PartyEntity, (party: PartyEntity) => party.physicalAddresses, {
+    onDelete: 'CASCADE',
+  })
+  party!: PartyEntity
+
+  @Column({ name: 'partyId', nullable: true })
+  partyId?: string
+
+  @CreateDateColumn({ name: 'created_at', nullable: false })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
+  lastUpdatedAt!: Date
+
+  // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
+  @BeforeInsert()
+  @BeforeUpdate()
+  updateUpdatedDate(): void {
+    this.lastUpdatedAt = new Date()
+  }
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  async validate(): Promise<void> {
+    const validation: Array<ValidationError> = await validate(this)
+    if (validation.length > 0) {
+      const constraint: ValidationConstraint | undefined = getConstraint(validation[0])
+      if (constraint) {
+        const message: string = Object.values(constraint!)[0]
+        return Promise.reject(Error(message))
+      }
+    }
+  }
+}

package/src/entities/digitalCredential/DigitalCredentialEntity.ts

@@ -0,0 +1,64 @@
+import { BaseEntity, Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
+import {
+  CredentialCorrelationType,
+  CredentialDocumentFormat,
+  CredentialStateType,
+  CredentialType,
+} from '../../types/digitalCredential/digitalCredential'
+
+@Entity('DigitalCredential')
+export class DigitalCredentialEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column('simple-enum', { name: 'credential_type', enum: CredentialType, nullable: false })
+  credentialType!: CredentialType
+
+  @Column('simple-enum', { name: 'document_format', enum: CredentialDocumentFormat, nullable: false })
+  documentFormat!: CredentialDocumentFormat
+
+  @Column('text', { name: 'raw', nullable: false })
+  raw!: string
+
+  @Column('text', { name: 'uniform_document', nullable: false })
+  uniformDocument!: string
+
+  @Column('text', { name: 'hash', nullable: false, unique: true })
+  hash!: string
+
+  @Column('simple-enum', { name: 'issuer_correlation_type', enum: CredentialCorrelationType, nullable: false })
+  issuerCorrelationType!: CredentialCorrelationType
+
+  @Column('simple-enum', { name: 'subject_correlation_type', enum: CredentialCorrelationType, nullable: true })
+  subjectCorrelationType?: CredentialCorrelationType
+
+  @Column('text', { name: 'issuer_correlation_id', nullable: false })
+  issuerCorrelationId!: string
+
+  @Column('text', { name: 'subject_correlation_id', nullable: true })
+  subjectCorrelationId?: string
+
+  @Column('simple-enum', { name: 'verified_state', enum: CredentialStateType, nullable: true })
+  verifiedState?: CredentialStateType
+
+  @Column('text', { name: 'tenant_id', nullable: true })
+  tenantId?: string
+
+  @CreateDateColumn({ name: 'created_at', nullable: false })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
+  lastUpdatedAt!: Date
+
+  @Column('date', { name: 'expires_at', nullable: true })
+  expiresAt?: Date
+
+  @Column('date', { name: 'issued_at', nullable: true })
+  issuedAt?: Date
+
+  @Column('date', { name: 'verification_date', nullable: true })
+  verificationDate?: Date
+
+  @Column('date', { name: 'revocation_date', nullable: true })
+  revocationDate?: Date
+}

package/src/entities/eventLogger/AuditEventEntity.ts

@@ -1,99 +1,99 @@
-import { BaseEntity, Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
-import {
-  ActionType,
-  InitiatorType,
-  LogLevel,
-  PartyCorrelationType,
-  SubSystem,
-  System,
-  SystemCorrelationIdType,
-  ActionSubType,
-} from '@sphereon/ssi-sdk.core'
-import { NonPersistedAuditLoggingEvent } from '../../types'
-
-@Entity('AuditEvents')
-export class AuditEventEntity extends BaseEntity {
-  @PrimaryGeneratedColumn('uuid')
-  id!: string
-
-  @Column({ name: 'timestamp', nullable: false, unique: false })
-  timestamp!: Date
-
-  @Column('simple-enum', { name: 'level', enum: LogLevel, nullable: false, unique: false })
-  level!: LogLevel
-
-  @Column({ name: 'correlationId', nullable: false, unique: false })
-  correlationId!: string
-
-  @Column('simple-enum', { name: 'system', enum: System, nullable: false, unique: false })
-  system!: System
-
-  @Column('simple-enum', { name: 'subSystemType', enum: SubSystem, nullable: false, unique: false })
-  subSystemType!: SubSystem
-
-  @Column('simple-enum', { name: 'actionType', enum: ActionType, nullable: false, unique: false })
-  actionType!: ActionType
-
-  @Column({ name: 'actionSubType', nullable: false, unique: false })
-  actionSubType!: ActionSubType
-
-  @Column('simple-enum', { name: 'initiatorType', enum: InitiatorType, nullable: false, unique: false })
-  initiatorType!: InitiatorType
-
-  @Column('simple-enum', { name: 'systemCorrelationIdType', enum: SystemCorrelationIdType, nullable: true, unique: false })
-  systemCorrelationIdType?: SystemCorrelationIdType
-
-  @Column({ name: 'systemCorrelationId', nullable: true, unique: false })
-  systemCorrelationId?: string
-
-  @Column({ name: 'systemAlias', nullable: false, unique: false })
-  systemAlias?: string
-
-  @Column('simple-enum', { name: 'partyCorrelationType', enum: PartyCorrelationType, nullable: true, unique: false })
-  partyCorrelationType?: PartyCorrelationType
-
-  @Column({ name: 'partyCorrelationId', nullable: true, unique: false })
-  partyCorrelationId?: string
-
-  @Column({ name: 'partyAlias', nullable: true, unique: false })
-  partyAlias?: string
-
-  @Column({ name: 'description', nullable: false, unique: false })
-  description!: string
-
-  @Column({ name: 'data', nullable: true, unique: false })
-  data?: string
-
-  @Column({ name: 'diagnosticData', nullable: true, unique: false })
-  diagnosticData?: string
-
-  @CreateDateColumn({ name: 'created_at', nullable: false })
-  createdAt!: Date
-
-  @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
-  lastUpdatedAt!: Date
-}
-
-export const auditEventEntityFrom = (args: NonPersistedAuditLoggingEvent): AuditEventEntity => {
-  const auditEventEntity: AuditEventEntity = new AuditEventEntity()
-  auditEventEntity.timestamp = args.timestamp
-  auditEventEntity.level = args.level
-  auditEventEntity.correlationId = args.correlationId
-  auditEventEntity.system = args.system
-  auditEventEntity.subSystemType = args.subSystemType
-  auditEventEntity.actionType = args.actionType
-  auditEventEntity.actionSubType = args.actionSubType
-  auditEventEntity.initiatorType = args.initiatorType
-  auditEventEntity.systemCorrelationIdType = args.systemCorrelationIdType
-  auditEventEntity.systemCorrelationId = args.systemCorrelationId
-  auditEventEntity.systemAlias = args.systemAlias
-  auditEventEntity.partyCorrelationType = args.partyCorrelationType
-  auditEventEntity.partyCorrelationId = args.partyCorrelationId
-  auditEventEntity.partyAlias = args.partyAlias
-  auditEventEntity.description = args.description
-  auditEventEntity.partyCorrelationType = args.partyCorrelationType
-  auditEventEntity.data = JSON.stringify(args.data)
-  auditEventEntity.diagnosticData = JSON.stringify(args.diagnosticData)
-
-  return auditEventEntity
-}
+import { BaseEntity, Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
+import {
+  ActionType,
+  InitiatorType,
+  LogLevel,
+  PartyCorrelationType,
+  SubSystem,
+  System,
+  SystemCorrelationIdType,
+  ActionSubType,
+} from '@sphereon/ssi-sdk.core'
+import { NonPersistedAuditLoggingEvent } from '../../types'
+
+@Entity('AuditEvents')
+export class AuditEventEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'timestamp', nullable: false, unique: false })
+  timestamp!: Date
+
+  @Column('simple-enum', { name: 'level', enum: LogLevel, nullable: false, unique: false })
+  level!: LogLevel
+
+  @Column({ name: 'correlationId', nullable: false, unique: false })
+  correlationId!: string
+
+  @Column('simple-enum', { name: 'system', enum: System, nullable: false, unique: false })
+  system!: System
+
+  @Column('simple-enum', { name: 'subSystemType', enum: SubSystem, nullable: false, unique: false })
+  subSystemType!: SubSystem
+
+  @Column('simple-enum', { name: 'actionType', enum: ActionType, nullable: false, unique: false })
+  actionType!: ActionType
+
+  @Column({ name: 'actionSubType', nullable: false, unique: false })
+  actionSubType!: ActionSubType
+
+  @Column('simple-enum', { name: 'initiatorType', enum: InitiatorType, nullable: false, unique: false })
+  initiatorType!: InitiatorType
+
+  @Column('simple-enum', { name: 'systemCorrelationIdType', enum: SystemCorrelationIdType, nullable: true, unique: false })
+  systemCorrelationIdType?: SystemCorrelationIdType
+
+  @Column({ name: 'systemCorrelationId', nullable: true, unique: false })
+  systemCorrelationId?: string
+
+  @Column({ name: 'systemAlias', nullable: true, unique: false })
+  systemAlias?: string
+
+  @Column('simple-enum', { name: 'partyCorrelationType', enum: PartyCorrelationType, nullable: true, unique: false })
+  partyCorrelationType?: PartyCorrelationType
+
+  @Column({ name: 'partyCorrelationId', nullable: true, unique: false })
+  partyCorrelationId?: string
+
+  @Column({ name: 'partyAlias', nullable: true, unique: false })
+  partyAlias?: string
+
+  @Column({ name: 'description', nullable: false, unique: false })
+  description!: string
+
+  @Column({ name: 'data', nullable: true, unique: false })
+  data?: string
+
+  @Column({ name: 'diagnosticData', nullable: true, unique: false })
+  diagnosticData?: string
+
+  @CreateDateColumn({ name: 'created_at', nullable: false })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
+  lastUpdatedAt!: Date
+}
+
+export const auditEventEntityFrom = (args: NonPersistedAuditLoggingEvent): AuditEventEntity => {
+  const auditEventEntity: AuditEventEntity = new AuditEventEntity()
+  auditEventEntity.timestamp = args.timestamp
+  auditEventEntity.level = args.level
+  auditEventEntity.correlationId = args.correlationId
+  auditEventEntity.system = args.system
+  auditEventEntity.subSystemType = args.subSystemType
+  auditEventEntity.actionType = args.actionType
+  auditEventEntity.actionSubType = args.actionSubType
+  auditEventEntity.initiatorType = args.initiatorType
+  auditEventEntity.systemCorrelationIdType = args.systemCorrelationIdType
+  auditEventEntity.systemCorrelationId = args.systemCorrelationId
+  auditEventEntity.systemAlias = args.systemAlias
+  auditEventEntity.partyCorrelationType = args.partyCorrelationType
+  auditEventEntity.partyCorrelationId = args.partyCorrelationId
+  auditEventEntity.partyAlias = args.partyAlias
+  auditEventEntity.description = args.description
+  auditEventEntity.partyCorrelationType = args.partyCorrelationType
+  auditEventEntity.data = JSON.stringify(args.data)
+  auditEventEntity.diagnosticData = JSON.stringify(args.diagnosticData)
+
+  return auditEventEntity
+}