@sphereon/ssi-sdk.data-store 0.11.1-next.65

package/src/contact/AbstractContactStore.ts

@@ -0,0 +1,26 @@
+import { IContact, IIdentity } from '../types/contact'
+import {
+  IAddIdentityArgs,
+  IGetIdentityArgs,
+  IGetIdentitiesArgs,
+  IGetContactArgs,
+  IRemoveIdentityArgs,
+  IUpdateIdentityArgs,
+  IAddContactArgs,
+  IGetContactsArgs,
+  IRemoveContactArgs,
+  IUpdateContactArgs,
+} from '../types/IAbstractContactStore'
+
+export abstract class AbstractContactStore {
+  abstract getContact(args: IGetContactArgs): Promise<IContact>
+  abstract getContacts(args?: IGetContactsArgs): Promise<Array<IContact>>
+  abstract addContact(args: IAddContactArgs): Promise<IContact>
+  abstract updateContact(args: IUpdateContactArgs): Promise<IContact>
+  abstract removeContact(args: IRemoveContactArgs): Promise<void>
+  abstract getIdentity(args: IGetIdentityArgs): Promise<IIdentity>
+  abstract getIdentities(args: IGetIdentitiesArgs): Promise<Array<IIdentity>>
+  abstract addIdentity(args: IAddIdentityArgs): Promise<IIdentity>
+  abstract updateIdentity(args: IUpdateIdentityArgs): Promise<IIdentity>
+  abstract removeIdentity(args: IRemoveIdentityArgs): Promise<void>
+}

package/src/contact/ContactStore.ts

@@ -0,0 +1,373 @@
+import Debug from 'debug'
+import { OrPromise } from '@sphereon/ssi-types'
+import {
+  IAddIdentityArgs,
+  IGetIdentityArgs,
+  IGetIdentitiesArgs,
+  IGetContactArgs,
+  IRemoveIdentityArgs,
+  IUpdateIdentityArgs,
+  IGetContactsArgs,
+  IAddContactArgs,
+  IUpdateContactArgs,
+  IRemoveContactArgs,
+} from '../types/IAbstractContactStore'
+import { AbstractContactStore } from './AbstractContactStore'
+import {
+  BasicConnectionConfig,
+  ConnectionConfig,
+  ConnectionTypeEnum,
+  CorrelationIdentifierEnum,
+  IConnection,
+  IContact,
+  ICorrelationIdentifier,
+  IDidAuthConfig,
+  IIdentity,
+  IMetadataItem,
+  IOpenIdConfig,
+} from '../types/contact'
+import { ContactEntity, contactEntityFrom } from '../entities/contact/ContactEntity'
+import { IdentityEntity, identityEntityFrom } from '../entities/contact/IdentityEntity'
+import { IdentityMetadataItemEntity } from '../entities/contact/IdentityMetadataItemEntity'
+import { CorrelationIdentifierEntity } from '../entities/contact/CorrelationIdentifierEntity'
+import { ConnectionEntity } from '../entities/contact/ConnectionEntity'
+import { BaseConfigEntity } from '../entities/contact/BaseConfigEntity'
+import { OpenIdConfigEntity } from '../entities/contact/OpenIdConfigEntity'
+import { DidAuthConfigEntity } from '../entities/contact/DidAuthConfigEntity'
+import { DataSource, In } from 'typeorm'
+
+const debug = Debug('sphereon:ssi-sdk:contact-store')
+
+export class ContactStore extends AbstractContactStore {
+  private readonly dbConnection: OrPromise<DataSource>
+
+  constructor(dbConnection: OrPromise<DataSource>) {
+    super()
+    this.dbConnection = dbConnection
+  }
+
+  getContact = async ({ contactId }: IGetContactArgs): Promise<IContact> => {
+    const result = await (await this.dbConnection).getRepository(ContactEntity).findOne({
+      where: { id: contactId },
+    })
+
+    if (!result) {
+      return Promise.reject(Error(`No contact found for id: ${contactId}`))
+    }
+
+    return this.contactFrom(result)
+  }
+
+  getContacts = async (args?: IGetContactsArgs): Promise<Array<IContact>> => {
+    const initialResult = await (await this.dbConnection).getRepository(ContactEntity).find({
+      ...(args?.filter && { where: args?.filter }),
+    })
+
+    const result = await (await this.dbConnection).getRepository(ContactEntity).find({
+      where: {
+        id: In(initialResult.map((contact: ContactEntity) => contact.id)),
+      },
+    })
+
+    return result.map((contact: ContactEntity) => this.contactFrom(contact))
+  }
+
+  addContact = async (args: IAddContactArgs): Promise<IContact> => {
+    const { name, alias, uri, identities } = args
+
+    const result = await (await this.dbConnection).getRepository(ContactEntity).findOne({
+      where: [{ name }, { alias }],
+    })
+
+    if (result) {
+      return Promise.reject(Error(`Duplicate names or aliases are not allowed. Name: ${name}, Alias: ${alias}`))
+    }
+
+    for (const identity of identities ?? []) {
+      if (identity.identifier.type === CorrelationIdentifierEnum.URL) {
+        if (!identity.connection) {
+          return Promise.reject(Error(`Identity with correlation type ${CorrelationIdentifierEnum.URL} should contain a connection`))
+        }
+
+        if (!this.hasCorrectConfig(identity.connection.type, identity.connection.config)) {
+          return Promise.reject(Error(`Connection type ${identity.connection.type}, does not match for provided config`))
+        }
+      }
+    }
+
+    const contactEntity = contactEntityFrom({ name, alias, uri, identities })
+    debug('Adding contact', name)
+    const createdResult = await (await this.dbConnection).getRepository(ContactEntity).save(contactEntity)
+
+    return this.contactFrom(createdResult)
+  }
+
+  updateContact = async ({ contact }: IUpdateContactArgs): Promise<IContact> => {
+    const result = await (await this.dbConnection).getRepository(ContactEntity).findOne({
+      where: { id: contact.id },
+    })
+
+    if (!result) {
+      return Promise.reject(Error(`No contact found for id: ${contact.id}`))
+    }
+
+    const updatedContact = {
+      ...contact,
+      identities: result.identities,
+    }
+
+    debug('Updating contact', contact)
+    const updatedResult = await (await this.dbConnection).getRepository(ContactEntity).save(updatedContact, { transaction: true })
+
+    return this.contactFrom(updatedResult)
+  }
+
+  removeContact = async ({ contactId }: IRemoveContactArgs): Promise<void> => {
+    debug('Removing contact', contactId)
+    ;(await this.dbConnection)
+      .getRepository(ContactEntity)
+      .findOneById(contactId)
+      .then(async (contact: ContactEntity | null) => {
+        if (!contact) {
+          await Promise.reject(Error(`Unable to find the contact with id to remove: ${contactId}`))
+        } else {
+          await this.deleteIdentities(contact.identities)
+
+          await (
+            await this.dbConnection
+          )
+            .getRepository(ContactEntity)
+            .delete({ id: contactId })
+            .catch((error) => Promise.reject(Error(`Unable to remove contact with id: ${contactId}. ${error}`)))
+        }
+      })
+      .catch((error) => Promise.reject(Error(`Unable to remove contact with id: ${contactId}. ${error}`)))
+  }
+
+  private async deleteIdentities(identities: Array<IdentityEntity>): Promise<void> {
+    debug('Removing identities', identities)
+
+    identities.map(async (identity: IdentityEntity) => {
+      await (
+        await this.dbConnection
+      )
+        .getRepository(CorrelationIdentifierEntity)
+        .delete(identity.identifier.id)
+        .catch((error) => Promise.reject(Error(`Unable to remove identity.identifier with id: ${identity.identifier.id}. ${error}`)))
+
+      if (identity.connection) {
+        await (await this.dbConnection).getRepository(BaseConfigEntity).delete(identity.connection.config.id)
+
+        await (
+          await this.dbConnection
+        )
+          .getRepository(ConnectionEntity)
+          .delete(identity.connection.id)
+          .catch((error) => Promise.reject(Error(`Unable to remove identity.connection with id. ${error}`)))
+      }
+
+      if (identity.metadata) {
+        identity.metadata.map(async (metadataItem: IdentityMetadataItemEntity) => {
+          await (
+            await this.dbConnection
+          )
+            .getRepository(IdentityMetadataItemEntity)
+            .delete(metadataItem.id)
+            .catch((error) => Promise.reject(Error(`Unable to remove metadataItem.id with id ${metadataItem.id}. ${error}`)))
+        })
+      }
+
+      ;(await this.dbConnection)
+        .getRepository(IdentityEntity)
+        .delete(identity.id)
+        .catch((error) => Promise.reject(Error(`Unable to remove metadataItem.id with id ${identity.id}. ${error}`)))
+    })
+  }
+
+  getIdentity = async ({ identityId }: IGetIdentityArgs): Promise<IIdentity> => {
+    const result = await (await this.dbConnection).getRepository(IdentityEntity).findOne({
+      where: { id: identityId },
+    })
+
+    if (!result) {
+      return Promise.reject(Error(`No identity found for id: ${identityId}`))
+    }
+
+    return this.identityFrom(result)
+  }
+
+  getIdentities = async (args?: IGetIdentitiesArgs): Promise<Array<IIdentity>> => {
+    const initialResult = await (await this.dbConnection).getRepository(IdentityEntity).find({
+      ...(args?.filter && { where: args?.filter }),
+    })
+
+    const result = await (await this.dbConnection).getRepository(IdentityEntity).find({
+      where: {
+        id: In(initialResult.map((identity: IdentityEntity) => identity.id)),
+      },
+    })
+
+    return result.map((identity: IdentityEntity) => this.identityFrom(identity))
+  }
+
+  addIdentity = async ({ identity, contactId }: IAddIdentityArgs): Promise<IIdentity> => {
+    const contact = await (await this.dbConnection).getRepository(ContactEntity).findOne({
+      where: { id: contactId },
+    })
+
+    if (!contact) {
+      return Promise.reject(Error(`No contact found for id: ${contactId}`))
+    }
+
+    if (identity.identifier.type === CorrelationIdentifierEnum.URL) {
+      if (!identity.connection) {
+        return Promise.reject(Error(`Identity with correlation type ${CorrelationIdentifierEnum.URL} should contain a connection`))
+      }
+
+      if (!this.hasCorrectConfig(identity.connection.type, identity.connection.config)) {
+        return Promise.reject(Error(`Connection type ${identity.connection.type}, does not match for provided config`))
+      }
+    }
+
+    const identityEntity = identityEntityFrom(identity)
+    identityEntity.contact = contact
+    debug('Adding identity', identity)
+    const result = await (await this.dbConnection).getRepository(IdentityEntity).save(identityEntity, {
+      transaction: true,
+    })
+
+    return this.identityFrom(result)
+  }
+
+  updateIdentity = async ({ identity }: IUpdateIdentityArgs): Promise<IIdentity> => {
+    const result = await (await this.dbConnection).getRepository(IdentityEntity).findOne({
+      where: { id: identity.id },
+    })
+
+    if (!result) {
+      return Promise.reject(Error(`No identity found for id: ${identity.id}`))
+    }
+
+    if (identity.identifier.type === CorrelationIdentifierEnum.URL) {
+      if (!identity.connection) {
+        return Promise.reject(Error(`Identity with correlation type ${CorrelationIdentifierEnum.URL} should contain a connection`))
+      }
+
+      if (!this.hasCorrectConfig(identity.connection.type, identity.connection.config)) {
+        return Promise.reject(Error(`Connection type ${identity.connection.type}, does not match for provided config`))
+      }
+    }
+
+    debug('Updating identity', identity)
+    const updatedResult = await (await this.dbConnection).getRepository(IdentityEntity).save(identity, { transaction: true })
+
+    return this.identityFrom(updatedResult)
+  }
+
+  removeIdentity = async ({ identityId }: IRemoveIdentityArgs): Promise<void> => {
+    const identity = await (await this.dbConnection).getRepository(IdentityEntity).findOne({
+      where: { id: identityId },
+    })
+
+    if (!identity) {
+      return Promise.reject(Error(`No identity found for id: ${identityId}`))
+    }
+
+    debug('Removing identity', identityId)
+
+    await this.deleteIdentities([identity])
+  }
+
+  private contactFrom = (contact: ContactEntity): IContact => {
+    return {
+      id: contact.id,
+      name: contact.name,
+      alias: contact.alias,
+      uri: contact.uri,
+      roles: [...new Set(contact.identities?.flatMap((identity) => identity.roles))] ?? [],
+      identities: contact.identities ? contact.identities.map((identity: IdentityEntity) => this.identityFrom(identity)) : [],
+      createdAt: contact.createdAt,
+      lastUpdatedAt: contact.lastUpdatedAt,
+    }
+  }
+
+  private identityFrom = (identity: IdentityEntity): IIdentity => {
+    return {
+      id: identity.id,
+      alias: identity.alias,
+      roles: identity.roles,
+      identifier: this.correlationIdentifierFrom(identity.identifier),
+      ...(identity.connection && { connection: this.connectionFrom(identity.connection) }),
+      metadata: identity.metadata ? identity.metadata.map((item: IdentityMetadataItemEntity) => this.metadataItemFrom(item)) : [],
+      createdAt: identity.createdAt,
+      lastUpdatedAt: identity.createdAt,
+    }
+  }
+
+  private correlationIdentifierFrom = (identifier: CorrelationIdentifierEntity): ICorrelationIdentifier => {
+    return {
+      id: identifier.id,
+      type: identifier.type,
+      correlationId: identifier.correlationId,
+    }
+  }
+
+  private metadataItemFrom = (item: IdentityMetadataItemEntity): IMetadataItem => {
+    return {
+      id: item.id,
+      label: item.label,
+      value: item.value,
+    }
+  }
+
+  private connectionFrom = (connection: ConnectionEntity): IConnection => {
+    return {
+      id: connection.id,
+      type: connection.type,
+      config: this.configFrom(connection.type, connection.config),
+    }
+  }
+
+  private configFrom = (type: ConnectionTypeEnum, config: BaseConfigEntity): ConnectionConfig => {
+    switch (type) {
+      case ConnectionTypeEnum.OPENID_CONNECT:
+        return {
+          id: (config as OpenIdConfigEntity).id,
+          clientId: (config as OpenIdConfigEntity).clientId,
+          clientSecret: (config as OpenIdConfigEntity).clientSecret,
+          scopes: (config as OpenIdConfigEntity).scopes,
+          issuer: (config as OpenIdConfigEntity).issuer!, // TODO fixme
+          redirectUrl: (config as OpenIdConfigEntity).redirectUrl,
+          dangerouslyAllowInsecureHttpRequests: (config as OpenIdConfigEntity).dangerouslyAllowInsecureHttpRequests,
+          clientAuthMethod: (config as OpenIdConfigEntity).clientAuthMethod,
+        }
+      case ConnectionTypeEnum.SIOPv2:
+        return {
+          id: (config as DidAuthConfigEntity).id,
+          identifier: { did: (config as DidAuthConfigEntity).identifier, provider: '', keys: [], services: [] },
+          stateId: '',
+          redirectUrl: (config as DidAuthConfigEntity).redirectUrl,
+          sessionId: (config as DidAuthConfigEntity).sessionId,
+        }
+      default:
+        throw new Error('Connection type not supported')
+    }
+  }
+
+  private hasCorrectConfig(type: ConnectionTypeEnum, config: BasicConnectionConfig): boolean {
+    switch (type) {
+      case ConnectionTypeEnum.OPENID_CONNECT:
+        return this.isOpenIdConfig(config)
+      case ConnectionTypeEnum.SIOPv2:
+        return this.isDidAuthConfig(config)
+      default:
+        throw new Error('Connection type not supported')
+    }
+  }
+
+  private isOpenIdConfig = (config: BasicConnectionConfig): config is IOpenIdConfig =>
+    'clientSecret' in config && 'issuer' in config && 'redirectUrl' in config
+
+  private isDidAuthConfig = (config: BasicConnectionConfig): config is IDidAuthConfig =>
+    'identifier' in config && 'redirectUrl' in config && 'sessionId' in config
+}

package/src/entities/contact/BaseConfigEntity.ts

@@ -0,0 +1,8 @@
+import { BaseEntity, Entity, PrimaryGeneratedColumn, TableInheritance } from 'typeorm'
+
+@Entity('BaseConfigEntity') // FIXME rename it to 'BaseConfig'
+@TableInheritance({ column: { type: 'varchar', name: 'type' } })
+export abstract class BaseConfigEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+}

package/src/entities/contact/ConnectionEntity.ts

@@ -0,0 +1,48 @@
+import { Entity, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn, BaseEntity } from 'typeorm'
+import { BaseConfigEntity } from './BaseConfigEntity'
+import { BasicConnectionConfig, ConnectionTypeEnum, IBasicConnection, IDidAuthConfig, IOpenIdConfig } from '../../types/contact'
+import { IdentityEntity } from './IdentityEntity'
+import { OpenIdConfigEntity, openIdConfigEntityFrom } from './OpenIdConfigEntity'
+import { DidAuthConfigEntity, didAuthConfigEntityFrom } from './DidAuthConfigEntity'
+
+@Entity('Connection')
+export class ConnectionEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column('simple-enum', { name: 'type', enum: ConnectionTypeEnum, nullable: false })
+  type!: ConnectionTypeEnum
+
+  @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: 'identityId' })
+  identity!: IdentityEntity
+}
+
+export const connectionEntityFrom = (connection: IBasicConnection): ConnectionEntity => {
+  const connectionEntity = new ConnectionEntity()
+  connectionEntity.type = connection.type
+  connectionEntity.config = configEntityFrom(connection.type, connection.config)
+
+  return connectionEntity
+}
+
+const configEntityFrom = (type: ConnectionTypeEnum, config: BasicConnectionConfig): BaseConfigEntity => {
+  switch (type) {
+    case ConnectionTypeEnum.OPENID_CONNECT:
+      return openIdConfigEntityFrom(config as IOpenIdConfig)
+    case ConnectionTypeEnum.SIOPv2:
+      return didAuthConfigEntityFrom(config as IDidAuthConfig)
+    default:
+      throw new Error('Connection type not supported')
+  }
+}

package/src/entities/contact/ContactEntity.ts

@@ -0,0 +1,76 @@
+import {
+  BaseEntity,
+  BeforeInsert,
+  BeforeUpdate,
+  Column,
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm'
+import { IBasicContact, IBasicIdentity } from '../../types/contact'
+import { IdentityEntity, identityEntityFrom } from './IdentityEntity'
+import { IsNotEmpty, validate } from 'class-validator'
+
+@Entity('Contact')
+export class ContactEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'name', length: 255, nullable: false, unique: true })
+  @IsNotEmpty({ message: 'Blank names are not allowed' })
+  name!: string
+
+  @Column({ name: 'alias', length: 255, nullable: false, unique: true })
+  @IsNotEmpty({ message: 'Blank aliases are not allowed' })
+  alias!: string
+
+  @Column({ name: 'uri', length: 255 })
+  uri?: string
+
+  @OneToMany(() => IdentityEntity, (identity: IdentityEntity) => identity.contact, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: false,
+  })
+  @JoinColumn({ name: 'identityId' })
+  identities!: Array<IdentityEntity>
+
+  @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() {
+    this.lastUpdatedAt = new Date()
+  }
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  async validate() {
+    const validation = await validate(this)
+    if (validation.length > 0) {
+      return Promise.reject(Error(validation[0].constraints?.isNotEmpty))
+    }
+    return
+  }
+}
+
+export const contactEntityFrom = (args: IBasicContact): ContactEntity => {
+  const contactEntity = new ContactEntity()
+  contactEntity.name = args.name
+  contactEntity.alias = args.alias
+  contactEntity.uri = args.uri
+  if (args.identities) {
+    contactEntity.identities = args.identities.map((identity: IBasicIdentity) => identityEntityFrom(identity))
+  }
+
+  return contactEntity
+}

package/src/entities/contact/CorrelationIdentifierEntity.ts

@@ -0,0 +1,41 @@
+import { Entity, Column, PrimaryGeneratedColumn, BaseEntity, OneToOne, JoinColumn, BeforeInsert, BeforeUpdate } from 'typeorm'
+import { CorrelationIdentifierEnum, BasicCorrelationIdentifier } from '../../types/contact'
+import { IdentityEntity } from './IdentityEntity'
+import { IsNotEmpty, validate } from 'class-validator'
+
+@Entity('CorrelationIdentifier')
+export class CorrelationIdentifierEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column('simple-enum', { name: 'type', enum: CorrelationIdentifierEnum, nullable: false })
+  type!: CorrelationIdentifierEnum
+
+  @Column('text', { name: 'correlation_id', nullable: false, unique: true })
+  @IsNotEmpty({ message: 'Blank correlation ids are not allowed' })
+  correlationId!: string
+
+  @OneToOne(() => IdentityEntity, (identity: IdentityEntity) => identity.identifier, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'identityId' })
+  identity!: IdentityEntity
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  async validate() {
+    const validation = await validate(this)
+    if (validation.length > 0) {
+      return Promise.reject(Error(validation[0].constraints?.isNotEmpty))
+    }
+    return
+  }
+}
+
+export const correlationIdentifierEntityFrom = (identifier: BasicCorrelationIdentifier): CorrelationIdentifierEntity => {
+  const identifierEntity = new CorrelationIdentifierEntity()
+  identifierEntity.type = identifier.type
+  identifierEntity.correlationId = identifier.correlationId
+
+  return identifierEntity
+}

package/src/entities/contact/DidAuthConfigEntity.ts

@@ -0,0 +1,31 @@
+import { ChildEntity, Column, JoinColumn, OneToOne } from 'typeorm'
+import { BaseConfigEntity } from './BaseConfigEntity'
+import { BasicDidAuthConfig } from '../../types/contact'
+import { ConnectionEntity } from './ConnectionEntity'
+
+@ChildEntity('DidAuthConfig')
+export class DidAuthConfigEntity extends BaseConfigEntity {
+  @Column({ name: 'identifier', length: 255, nullable: false })
+  identifier!: string
+
+  @Column({ name: 'redirect_url', length: 255, nullable: false })
+  redirectUrl!: string
+
+  @Column({ name: 'session_id', length: 255, nullable: false })
+  sessionId!: string
+
+  @OneToOne(() => ConnectionEntity, (connection: ConnectionEntity) => connection.config, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'connectionId' })
+  connection?: ConnectionEntity
+}
+
+export const didAuthConfigEntityFrom = (config: BasicDidAuthConfig): DidAuthConfigEntity => {
+  const didAuthConfig = new DidAuthConfigEntity()
+  didAuthConfig.identifier = config.identifier.did
+  didAuthConfig.redirectUrl = config.redirectUrl
+  didAuthConfig.sessionId = config.sessionId
+
+  return didAuthConfig
+}