@sphereon/ssi-sdk.data-store 0.30.1-unstable.4 → 0.30.1

package/src/digitalCredential/AbstractDigitalCredentialStore.ts

@@ -1,21 +1,21 @@
-import {
-  AddCredentialArgs,
-  DigitalCredential,
-  GetCredentialArgs,
-  GetCredentialsArgs,
-  GetCredentialsResponse,
-  RemoveCredentialArgs,
-  UpdateCredentialStateArgs,
-} from '../types'
-
-export abstract class AbstractDigitalCredentialStore {
-  abstract getCredential(args: GetCredentialArgs): Promise<DigitalCredential>
-
-  abstract getCredentials(args?: GetCredentialsArgs): Promise<GetCredentialsResponse>
-
-  abstract addCredential(args: AddCredentialArgs): Promise<DigitalCredential>
-
-  abstract updateCredentialState(args: UpdateCredentialStateArgs): Promise<DigitalCredential>
-
-  abstract removeCredential(args: RemoveCredentialArgs): Promise<boolean>
-}
+import {
+  AddCredentialArgs,
+  DigitalCredential,
+  GetCredentialArgs,
+  GetCredentialsArgs,
+  GetCredentialsResponse,
+  RemoveCredentialArgs,
+  UpdateCredentialStateArgs,
+} from '../types'
+
+export abstract class AbstractDigitalCredentialStore {
+  abstract getCredential(args: GetCredentialArgs): Promise<DigitalCredential>
+
+  abstract getCredentials(args?: GetCredentialsArgs): Promise<GetCredentialsResponse>
+
+  abstract addCredential(args: AddCredentialArgs): Promise<DigitalCredential>
+
+  abstract updateCredentialState(args: UpdateCredentialStateArgs): Promise<DigitalCredential>
+
+  abstract removeCredential(args: RemoveCredentialArgs): Promise<boolean>
+}

package/src/digitalCredential/DigitalCredentialStore.ts

@@ -1,189 +1,189 @@
-import { AbstractDigitalCredentialStore } from './AbstractDigitalCredentialStore'
-import {
-  AddCredentialArgs,
-  CredentialRole,
-  CredentialStateType,
-  DigitalCredential,
-  GetCredentialArgs,
-  GetCredentialsArgs,
-  GetCredentialsResponse,
-  NonPersistedDigitalCredential,
-  RemoveCredentialArgs,
-  UpdateCredentialStateArgs,
-} from '../types'
-import { OrPromise } from '@sphereon/ssi-types'
-import { DataSource, FindOptionsOrder, Repository } from 'typeorm'
-import Debug from 'debug'
-import { DigitalCredentialEntity } from '../entities/digitalCredential/DigitalCredentialEntity'
-import {
-  digitalCredentialFrom,
-  digitalCredentialsFrom,
-  nonPersistedDigitalCredentialEntityFromAddArgs,
-} from '../utils/digitalCredential/MappingUtils'
-import { FindOptionsWhere } from 'typeorm/find-options/FindOptionsWhere'
-import { parseAndValidateOrderOptions } from '../utils/SortingUtils'
-
-const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:credential-store')
-
-export class DigitalCredentialStore extends AbstractDigitalCredentialStore {
-  private readonly dbConnection: OrPromise<DataSource>
-  private dcRepo: Repository<DigitalCredentialEntity> | undefined
-
-  constructor(dbConnection: OrPromise<DataSource>) {
-    super()
-    this.dbConnection = dbConnection
-  }
-
-  addCredential = async (args: AddCredentialArgs): Promise<DigitalCredential> => {
-    debug('Adding credential', args)
-    const credentialEntity: NonPersistedDigitalCredential = nonPersistedDigitalCredentialEntityFromAddArgs(args)
-    const validationError = this.assertValidDigitalCredential(credentialEntity)
-    if (validationError) {
-      return Promise.reject(validationError)
-    }
-    const dcRepo = await this.getRepository()
-    const createdResult: DigitalCredentialEntity = await dcRepo.save(credentialEntity)
-    return Promise.resolve(digitalCredentialFrom(createdResult))
-  }
-
-  getCredential = async (args: GetCredentialArgs): Promise<DigitalCredential> => {
-    const dcRepo = await this.getRepository()
-    const result: DigitalCredentialEntity | null = await dcRepo.findOne({
-      where: args,
-    })
-
-    if (!result) {
-      return Promise.reject(Error(`No credential found for arg: ${JSON.stringify(args)}`))
-    }
-    return digitalCredentialFrom(result)
-  }
-
-  getCredentials = async (args?: GetCredentialsArgs): Promise<GetCredentialsResponse> => {
-    const { filter = {}, offset, limit, order = 'createdAt.asc' } = args ?? {}
-    const sortOptions: FindOptionsOrder<DigitalCredentialEntity> =
-      order && typeof order === 'string'
-        ? parseAndValidateOrderOptions<DigitalCredentialEntity>(order)
-        : <FindOptionsOrder<DigitalCredentialEntity>>order
-    const dcRepo = await this.getRepository()
-    const [result, total] = await dcRepo.findAndCount({
-      where: filter,
-      skip: offset,
-      take: limit,
-      order: sortOptions,
-    })
-    return {
-      data: digitalCredentialsFrom(result),
-      total,
-    }
-  }
-
-  removeCredential = async (args: RemoveCredentialArgs): 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 dcRepo = await this.getRepository()
-      // TODO create a flag whether we want to delete recursively or return an error when there are child credentials?
-      const affected = await this.deleteTree(dcRepo, query)
-      return affected > 0
-    } catch (error) {
-      console.error('Error removing digital credential:', error)
-      return false
-    }
-  }
-
-  private async deleteTree(dcRepo: Repository<DigitalCredentialEntity>, query: FindOptionsWhere<DigitalCredentialEntity>): Promise<number> {
-    let affected: number = 0
-    const findResult = await dcRepo.findBy(query)
-    for (const dc of findResult) {
-      if (dc.parentId !== null && dc.parentId !== undefined) {
-        affected += await this.deleteTree(dcRepo, { id: dc.parentId })
-      }
-      const result = await dcRepo.delete(dc.id)
-      if (result.affected) {
-        affected += result.affected
-      }
-    }
-    return affected
-  }
-
-  private async getRepository(): Promise<Repository<DigitalCredentialEntity>> {
-    if (this.dcRepo !== undefined) {
-      return Promise.resolve(this.dcRepo)
-    }
-    this.dcRepo = (await this.dbConnection).getRepository(DigitalCredentialEntity)
-    if (this.dcRepo === undefined) {
-      return Promise.reject(Error('Could not get DigitalCredentialEntity repository'))
-    }
-    return this.dcRepo
-  }
-
-  updateCredentialState = async (args: UpdateCredentialStateArgs): Promise<DigitalCredential> => {
-    const credentialRepository: Repository<DigitalCredentialEntity> = (await this.dbConnection).getRepository(DigitalCredentialEntity)
-    const whereClause: Record<string, any> = {}
-    if ('id' in args) {
-      whereClause.id = args.id
-    } else if ('hash' in args) {
-      whereClause.hash = args.hash
-    } else {
-      throw new Error('No id or hash param is provided.')
-    }
-    if (!args.verifiedState) {
-      throw new Error('No verifiedState param is provided.')
-    }
-    if (args.verifiedState === CredentialStateType.REVOKED && !args.revokedAt) {
-      throw new Error('No revokedAt param is provided.')
-    }
-    if (args.verifiedState !== CredentialStateType.REVOKED && !args.verifiedAt) {
-      throw new Error('No verifiedAt param is provided.')
-    }
-    const credential: DigitalCredentialEntity | null = await credentialRepository.findOne({
-      where: whereClause,
-    })
-
-    if (!credential) {
-      return Promise.reject(Error(`No credential found for args: ${JSON.stringify(whereClause)}`))
-    }
-    const updatedCredential: DigitalCredential = {
-      ...credential,
-      ...(args.verifiedState !== CredentialStateType.REVOKED && { verifiedAt: args.verifiedAt }),
-      ...(args.verifiedState === CredentialStateType.REVOKED && { revokedAt: args.revokedAt }),
-      identifierMethod: credential.identifierMethod,
-      lastUpdatedAt: new Date(),
-      verifiedState: args.verifiedState,
-    }
-    debug('Updating credential', credential)
-    const updatedResult: DigitalCredentialEntity = await credentialRepository.save(updatedCredential, { transaction: true })
-    return digitalCredentialFrom(updatedResult)
-  }
-
-  private assertValidDigitalCredential(credentialEntity: NonPersistedDigitalCredential): Error | undefined {
-    const { kmsKeyRef, identifierMethod, credentialRole, isIssuerSigned } = credentialEntity
-
-    const isRoleInvalid = credentialRole === CredentialRole.ISSUER || (credentialRole === CredentialRole.HOLDER && !isIssuerSigned)
-
-    if (isRoleInvalid && (!kmsKeyRef || !identifierMethod)) {
-      const missingFields = []
-
-      if (!kmsKeyRef) missingFields.push('kmsKeyRef')
-      if (!identifierMethod) missingFields.push('identifierMethod')
-
-      const fields = missingFields.join(' and ')
-      return new Error(
-        `DigitalCredential field(s) ${fields} is/are required for credential role ${credentialRole} with isIssuerSigned=${isIssuerSigned}.`,
-      )
-    }
-
-    return undefined
-  }
-}
+import { AbstractDigitalCredentialStore } from './AbstractDigitalCredentialStore'
+import {
+  AddCredentialArgs,
+  CredentialRole,
+  CredentialStateType,
+  DigitalCredential,
+  GetCredentialArgs,
+  GetCredentialsArgs,
+  GetCredentialsResponse,
+  NonPersistedDigitalCredential,
+  RemoveCredentialArgs,
+  UpdateCredentialStateArgs,
+} from '../types'
+import { OrPromise } from '@sphereon/ssi-types'
+import { DataSource, FindOptionsOrder, Repository } from 'typeorm'
+import Debug from 'debug'
+import { DigitalCredentialEntity } from '../entities/digitalCredential/DigitalCredentialEntity'
+import {
+  digitalCredentialFrom,
+  digitalCredentialsFrom,
+  nonPersistedDigitalCredentialEntityFromAddArgs,
+} from '../utils/digitalCredential/MappingUtils'
+import { FindOptionsWhere } from 'typeorm/find-options/FindOptionsWhere'
+import { parseAndValidateOrderOptions } from '../utils/SortingUtils'
+
+const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:credential-store')
+
+export class DigitalCredentialStore extends AbstractDigitalCredentialStore {
+  private readonly dbConnection: OrPromise<DataSource>
+  private dcRepo: Repository<DigitalCredentialEntity> | undefined
+
+  constructor(dbConnection: OrPromise<DataSource>) {
+    super()
+    this.dbConnection = dbConnection
+  }
+
+  addCredential = async (args: AddCredentialArgs): Promise<DigitalCredential> => {
+    debug('Adding credential', args)
+    const credentialEntity: NonPersistedDigitalCredential = nonPersistedDigitalCredentialEntityFromAddArgs(args)
+    const validationError = this.assertValidDigitalCredential(credentialEntity)
+    if (validationError) {
+      return Promise.reject(validationError)
+    }
+    const dcRepo = await this.getRepository()
+    const createdResult: DigitalCredentialEntity = await dcRepo.save(credentialEntity)
+    return Promise.resolve(digitalCredentialFrom(createdResult))
+  }
+
+  getCredential = async (args: GetCredentialArgs): Promise<DigitalCredential> => {
+    const dcRepo = await this.getRepository()
+    const result: DigitalCredentialEntity | null = await dcRepo.findOne({
+      where: args,
+    })
+
+    if (!result) {
+      return Promise.reject(Error(`No credential found for arg: ${JSON.stringify(args)}`))
+    }
+    return digitalCredentialFrom(result)
+  }
+
+  getCredentials = async (args?: GetCredentialsArgs): Promise<GetCredentialsResponse> => {
+    const { filter = {}, offset, limit, order = 'createdAt.asc' } = args ?? {}
+    const sortOptions: FindOptionsOrder<DigitalCredentialEntity> =
+      order && typeof order === 'string'
+        ? parseAndValidateOrderOptions<DigitalCredentialEntity>(order)
+        : <FindOptionsOrder<DigitalCredentialEntity>>order
+    const dcRepo = await this.getRepository()
+    const [result, total] = await dcRepo.findAndCount({
+      where: filter,
+      skip: offset,
+      take: limit,
+      order: sortOptions,
+    })
+    return {
+      data: digitalCredentialsFrom(result),
+      total,
+    }
+  }
+
+  removeCredential = async (args: RemoveCredentialArgs): 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 dcRepo = await this.getRepository()
+      // TODO create a flag whether we want to delete recursively or return an error when there are child credentials?
+      const affected = await this.deleteTree(dcRepo, query)
+      return affected > 0
+    } catch (error) {
+      console.error('Error removing digital credential:', error)
+      return false
+    }
+  }
+
+  private async deleteTree(dcRepo: Repository<DigitalCredentialEntity>, query: FindOptionsWhere<DigitalCredentialEntity>): Promise<number> {
+    let affected: number = 0
+    const findResult = await dcRepo.findBy(query)
+    for (const dc of findResult) {
+      if (dc.parentId !== null && dc.parentId !== undefined) {
+        affected += await this.deleteTree(dcRepo, { id: dc.parentId })
+      }
+      const result = await dcRepo.delete(dc.id)
+      if (result.affected) {
+        affected += result.affected
+      }
+    }
+    return affected
+  }
+
+  private async getRepository(): Promise<Repository<DigitalCredentialEntity>> {
+    if (this.dcRepo !== undefined) {
+      return Promise.resolve(this.dcRepo)
+    }
+    this.dcRepo = (await this.dbConnection).getRepository(DigitalCredentialEntity)
+    if (this.dcRepo === undefined) {
+      return Promise.reject(Error('Could not get DigitalCredentialEntity repository'))
+    }
+    return this.dcRepo
+  }
+
+  updateCredentialState = async (args: UpdateCredentialStateArgs): Promise<DigitalCredential> => {
+    const credentialRepository: Repository<DigitalCredentialEntity> = (await this.dbConnection).getRepository(DigitalCredentialEntity)
+    const whereClause: Record<string, any> = {}
+    if ('id' in args) {
+      whereClause.id = args.id
+    } else if ('hash' in args) {
+      whereClause.hash = args.hash
+    } else {
+      throw new Error('No id or hash param is provided.')
+    }
+    if (!args.verifiedState) {
+      throw new Error('No verifiedState param is provided.')
+    }
+    if (args.verifiedState === CredentialStateType.REVOKED && !args.revokedAt) {
+      throw new Error('No revokedAt param is provided.')
+    }
+    if (args.verifiedState !== CredentialStateType.REVOKED && !args.verifiedAt) {
+      throw new Error('No verifiedAt param is provided.')
+    }
+    const credential: DigitalCredentialEntity | null = await credentialRepository.findOne({
+      where: whereClause,
+    })
+
+    if (!credential) {
+      return Promise.reject(Error(`No credential found for args: ${JSON.stringify(whereClause)}`))
+    }
+    const updatedCredential: DigitalCredential = {
+      ...credential,
+      ...(args.verifiedState !== CredentialStateType.REVOKED && { verifiedAt: args.verifiedAt }),
+      ...(args.verifiedState === CredentialStateType.REVOKED && { revokedAt: args.revokedAt }),
+      identifierMethod: credential.identifierMethod,
+      lastUpdatedAt: new Date(),
+      verifiedState: args.verifiedState,
+    }
+    debug('Updating credential', credential)
+    const updatedResult: DigitalCredentialEntity = await credentialRepository.save(updatedCredential, { transaction: true })
+    return digitalCredentialFrom(updatedResult)
+  }
+
+  private assertValidDigitalCredential(credentialEntity: NonPersistedDigitalCredential): Error | undefined {
+    const { kmsKeyRef, identifierMethod, credentialRole, isIssuerSigned } = credentialEntity
+
+    const isRoleInvalid = credentialRole === CredentialRole.ISSUER || (credentialRole === CredentialRole.HOLDER && !isIssuerSigned)
+
+    if (isRoleInvalid && (!kmsKeyRef || !identifierMethod)) {
+      const missingFields = []
+
+      if (!kmsKeyRef) missingFields.push('kmsKeyRef')
+      if (!identifierMethod) missingFields.push('identifierMethod')
+
+      const fields = missingFields.join(' and ')
+      return new Error(
+        `DigitalCredential field(s) ${fields} is/are required for credential role ${credentialRole} with isIssuerSigned=${isIssuerSigned}.`,
+      )
+    }
+
+    return undefined
+  }
+}

package/src/entities/contact/BaseContactEntity.ts

@@ -1,51 +1,51 @@
-import {
-  BaseEntity,
-  BeforeInsert,
-  BeforeUpdate,
-  CreateDateColumn,
-  Entity,
-  JoinColumn,
-  OneToMany,
-  OneToOne,
-  PrimaryGeneratedColumn,
-  TableInheritance,
-  UpdateDateColumn,
-} from 'typeorm'
-import { typeOrmDateTime } from '@sphereon/ssi-sdk.agent-config'
-import { PartyEntity } from './PartyEntity'
-import { ContactMetadataItemEntity } from './ContactMetadataItemEntity'
-
-@Entity('BaseContact')
-@TableInheritance({ column: { type: 'varchar', name: 'type' } })
-export abstract class BaseContactEntity extends BaseEntity {
-  @PrimaryGeneratedColumn('uuid')
-  id!: string
-
-  @CreateDateColumn({ name: 'created_at', nullable: false, type: typeOrmDateTime() })
-  createdAt!: Date
-
-  @UpdateDateColumn({ name: 'last_updated_at', nullable: false, type: typeOrmDateTime() })
-  lastUpdatedAt!: Date
-
-  @OneToOne(() => PartyEntity, (party: PartyEntity) => party.contact, {
-    onDelete: 'CASCADE',
-  })
-  @JoinColumn({ name: 'party_id' })
-  party!: PartyEntity
-
-  @OneToMany(() => ContactMetadataItemEntity, (metadata: ContactMetadataItemEntity) => metadata.contact, {
-    cascade: true,
-    onDelete: 'CASCADE',
-    eager: true,
-    nullable: false,
-  })
-  @JoinColumn({ name: 'metadata_id' })
-  metadata!: Array<ContactMetadataItemEntity>
-
-  // 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()
-  }
-}
+import {
+  BaseEntity,
+  BeforeInsert,
+  BeforeUpdate,
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  OneToMany,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  TableInheritance,
+  UpdateDateColumn,
+} from 'typeorm'
+import { typeOrmDateTime } from '@sphereon/ssi-sdk.agent-config'
+import { PartyEntity } from './PartyEntity'
+import { ContactMetadataItemEntity } from './ContactMetadataItemEntity'
+
+@Entity('BaseContact')
+@TableInheritance({ column: { type: 'varchar', name: 'type' } })
+export abstract class BaseContactEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @CreateDateColumn({ name: 'created_at', nullable: false, type: typeOrmDateTime() })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'last_updated_at', nullable: false, type: typeOrmDateTime() })
+  lastUpdatedAt!: Date
+
+  @OneToOne(() => PartyEntity, (party: PartyEntity) => party.contact, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'party_id' })
+  party!: PartyEntity
+
+  @OneToMany(() => ContactMetadataItemEntity, (metadata: ContactMetadataItemEntity) => metadata.contact, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: false,
+  })
+  @JoinColumn({ name: 'metadata_id' })
+  metadata!: Array<ContactMetadataItemEntity>
+
+  // 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()
+  }
+}

package/src/entities/contact/ConnectionEntity.ts

@@ -1,35 +1,35 @@
-import { Entity, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn, BaseEntity } from 'typeorm'
-import { BaseConfigEntity } from './BaseConfigEntity'
-import { ConnectionType } from '../../types'
-import { IdentityEntity } from './IdentityEntity'
-import { OpenIdConfigEntity } from './OpenIdConfigEntity'
-import { DidAuthConfigEntity } from './DidAuthConfigEntity'
-
-@Entity('Connection')
-export class ConnectionEntity extends BaseEntity {
-  @PrimaryGeneratedColumn('uuid')
-  id!: string
-
-  @Column('simple-enum', { name: 'type', enum: ConnectionType, nullable: false })
-  type!: ConnectionType
-
-  @Column('text', { name: 'tenant_id', nullable: true })
-  tenantId?: string
-
-  @Column('text', { name: 'owner_id', nullable: true })
-  ownerId?: string
-
-  @OneToOne(() => BaseConfigEntity, (config: OpenIdConfigEntity | DidAuthConfigEntity) => config.connection, {
-    cascade: true,
-    onDelete: 'CASCADE',
-    eager: true,
-    nullable: false,
-  })
-  config!: BaseConfigEntity
-
-  @OneToOne(() => IdentityEntity, (identity: IdentityEntity) => identity.connection, {
-    onDelete: 'CASCADE',
-  })
-  @JoinColumn({ name: 'identity_id' })
-  identity!: IdentityEntity
-}
+import { Entity, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn, BaseEntity } from 'typeorm'
+import { BaseConfigEntity } from './BaseConfigEntity'
+import { ConnectionType } from '../../types'
+import { IdentityEntity } from './IdentityEntity'
+import { OpenIdConfigEntity } from './OpenIdConfigEntity'
+import { DidAuthConfigEntity } from './DidAuthConfigEntity'
+
+@Entity('Connection')
+export class ConnectionEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column('simple-enum', { name: 'type', enum: ConnectionType, nullable: false })
+  type!: ConnectionType
+
+  @Column('text', { name: 'tenant_id', nullable: true })
+  tenantId?: string
+
+  @Column('text', { name: 'owner_id', nullable: true })
+  ownerId?: string
+
+  @OneToOne(() => BaseConfigEntity, (config: OpenIdConfigEntity | DidAuthConfigEntity) => config.connection, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: false,
+  })
+  config!: BaseConfigEntity
+
+  @OneToOne(() => IdentityEntity, (identity: IdentityEntity) => identity.connection, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'identity_id' })
+  identity!: IdentityEntity
+}