@sphereon/ssi-sdk.data-store 0.23.5-unstable.88 → 0.24.0

package/src/digitalCredential/AbstractDigitalCredentialStore.ts

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

package/src/digitalCredential/DigitalCredentialStore.ts

@@ -1,127 +1,127 @@
-import { AbstractDigitalCredentialStore } from './AbstractDigitalCredentialStore'
-import {
-  AddCredentialArgs,
-  GetCredentialArgs,
-  GetCredentialsArgs,
-  GetCredentialsResponse,
-  RemoveCredentialArgs,
-  UpdateCredentialStateArgs,
-} from '../types/digitalCredential/IAbstractDigitalCredentialStore'
-import { OrPromise } from '@sphereon/ssi-types'
-import { DataSource, FindOptionsOrder, 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'
-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>
-
-  constructor(dbConnection: OrPromise<DataSource>) {
-    super()
-    this.dbConnection = dbConnection
-  }
-
-  addCredential = async (args: AddCredentialArgs): 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)
-  }
-
-  getCredential = async (args: GetCredentialArgs): 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
-  }
-
-  getCredentials = async (args?: GetCredentialsArgs): Promise<GetCredentialsResponse> => {
-    const { filter = {}, offset, limit, order = 'id.asc' } = args ?? {}
-    const sortOptions: FindOptionsOrder<DigitalCredentialEntity> =
-      order && typeof order === 'string'
-        ? parseAndValidateOrderOptions<DigitalCredentialEntity>(order)
-        : <FindOptionsOrder<DigitalCredentialEntity>>order
-    const [result, total] = await (await this.dbConnection).getRepository(DigitalCredentialEntity).findAndCount({
-      where: filter,
-      skip: offset,
-      take: limit,
-      order: sortOptions,
-    })
-    return {
-      data: 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 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
-    }
-  }
-
-  updateCredentialState = async (args: UpdateCredentialStateArgs): Promise<DigitalCredentialEntity> => {
-    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: ${whereClause}`))
-    }
-    const updatedCredential: DigitalCredential = {
-      ...credential,
-      ...(args.verifiedState !== CredentialStateType.REVOKED && { verifiedAt: args.verifiedAt }),
-      ...(args.verifiedState === CredentialStateType.REVOKED && { revokedAt: args.revokedAt }),
-      lastUpdatedAt: new Date(),
-      verifiedState: args.verifiedState,
-    }
-    debug('Updating credential', credential)
-    const updatedResult: DigitalCredentialEntity = await credentialRepository.save(updatedCredential, { transaction: true })
-    return updatedResult
-  }
-}
+import { AbstractDigitalCredentialStore } from './AbstractDigitalCredentialStore'
+import {
+  AddCredentialArgs,
+  GetCredentialArgs,
+  GetCredentialsArgs,
+  GetCredentialsResponse,
+  RemoveCredentialArgs,
+  UpdateCredentialStateArgs,
+} from '../types/digitalCredential/IAbstractDigitalCredentialStore'
+import { OrPromise } from '@sphereon/ssi-types'
+import { DataSource, FindOptionsOrder, 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'
+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>
+
+  constructor(dbConnection: OrPromise<DataSource>) {
+    super()
+    this.dbConnection = dbConnection
+  }
+
+  addCredential = async (args: AddCredentialArgs): 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)
+  }
+
+  getCredential = async (args: GetCredentialArgs): 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
+  }
+
+  getCredentials = async (args?: GetCredentialsArgs): Promise<GetCredentialsResponse> => {
+    const { filter = {}, offset, limit, order = 'id.asc' } = args ?? {}
+    const sortOptions: FindOptionsOrder<DigitalCredentialEntity> =
+      order && typeof order === 'string'
+        ? parseAndValidateOrderOptions<DigitalCredentialEntity>(order)
+        : <FindOptionsOrder<DigitalCredentialEntity>>order
+    const [result, total] = await (await this.dbConnection).getRepository(DigitalCredentialEntity).findAndCount({
+      where: filter,
+      skip: offset,
+      take: limit,
+      order: sortOptions,
+    })
+    return {
+      data: 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 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
+    }
+  }
+
+  updateCredentialState = async (args: UpdateCredentialStateArgs): Promise<DigitalCredentialEntity> => {
+    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: ${whereClause}`))
+    }
+    const updatedCredential: DigitalCredential = {
+      ...credential,
+      ...(args.verifiedState !== CredentialStateType.REVOKED && { verifiedAt: args.verifiedAt }),
+      ...(args.verifiedState === CredentialStateType.REVOKED && { revokedAt: args.revokedAt }),
+      lastUpdatedAt: new Date(),
+      verifiedState: args.verifiedState,
+    }
+    debug('Updating credential', credential)
+    const updatedResult: DigitalCredentialEntity = await credentialRepository.save(updatedCredential, { transaction: true })
+    return updatedResult
+  }
+}

package/src/entities/contact/BaseContactEntity.ts

@@ -1,39 +1,39 @@
-import {
-  BaseEntity,
-  BeforeInsert,
-  BeforeUpdate,
-  CreateDateColumn,
-  Entity,
-  JoinColumn,
-  OneToOne,
-  PrimaryGeneratedColumn,
-  TableInheritance,
-  UpdateDateColumn,
-} from 'typeorm'
-import { PartyEntity } from './PartyEntity'
-
-@Entity('BaseContact')
-@TableInheritance({ column: { type: 'varchar', name: 'type' } })
-export abstract class BaseContactEntity extends BaseEntity {
-  @PrimaryGeneratedColumn('uuid')
-  id!: string
-
-  @CreateDateColumn({ name: 'created_at', nullable: false })
-  createdAt!: Date
-
-  @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
-  lastUpdatedAt!: Date
-
-  @OneToOne(() => PartyEntity, (party: PartyEntity) => party.contact, {
-    onDelete: 'CASCADE',
-  })
-  @JoinColumn({ name: 'party_id' })
-  party!: PartyEntity
-
-  // 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,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  TableInheritance,
+  UpdateDateColumn,
+} from 'typeorm'
+import { PartyEntity } from './PartyEntity'
+
+@Entity('BaseContact')
+@TableInheritance({ column: { type: 'varchar', name: 'type' } })
+export abstract class BaseContactEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @CreateDateColumn({ name: 'created_at', nullable: false })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
+  lastUpdatedAt!: Date
+
+  @OneToOne(() => PartyEntity, (party: PartyEntity) => party.contact, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'party_id' })
+  party!: PartyEntity
+
+  // 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,29 +1,29 @@
-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
-
-  @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
+
+  @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
+}

package/src/entities/contact/CorrelationIdentifierEntity.ts

@@ -1,37 +1,37 @@
-import { Entity, Column, PrimaryGeneratedColumn, BaseEntity, OneToOne, JoinColumn, BeforeInsert, BeforeUpdate } from 'typeorm'
-import { CorrelationIdentifierType, ValidationConstraint } from '../../types'
-import { IdentityEntity } from './IdentityEntity'
-import { IsNotEmpty, validate, ValidationError } from 'class-validator'
-import { getConstraint } from '../../utils/ValidatorUtils'
-
-@Entity('CorrelationIdentifier')
-export class CorrelationIdentifierEntity extends BaseEntity {
-  @PrimaryGeneratedColumn('uuid')
-  id!: string
-
-  @Column('simple-enum', { name: 'type', enum: CorrelationIdentifierType, nullable: false })
-  type!: CorrelationIdentifierType
-
-  @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: 'identity_id' })
-  identity!: IdentityEntity
-
-  @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))
-      }
-    }
-  }
-}
+import { Entity, Column, PrimaryGeneratedColumn, BaseEntity, OneToOne, JoinColumn, BeforeInsert, BeforeUpdate } from 'typeorm'
+import { CorrelationIdentifierType, ValidationConstraint } from '../../types'
+import { IdentityEntity } from './IdentityEntity'
+import { IsNotEmpty, validate, ValidationError } from 'class-validator'
+import { getConstraint } from '../../utils/ValidatorUtils'
+
+@Entity('CorrelationIdentifier')
+export class CorrelationIdentifierEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column('simple-enum', { name: 'type', enum: CorrelationIdentifierType, nullable: false })
+  type!: CorrelationIdentifierType
+
+  @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: 'identity_id' })
+  identity!: IdentityEntity
+
+  @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/contact/DidAuthConfigEntity.ts

@@ -1,14 +1,14 @@
-import { ChildEntity, Column } from 'typeorm'
-import { BaseConfigEntity } from './BaseConfigEntity'
-
-@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
-}
+import { ChildEntity, Column } from 'typeorm'
+import { BaseConfigEntity } from './BaseConfigEntity'
+
+@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
+}

package/src/entities/contact/ElectronicAddressEntity.ts

@@ -1,63 +1,63 @@
-import { IsNotEmpty, validate, ValidationError } from 'class-validator'
-import {
-  Entity,
-  Column,
-  PrimaryGeneratedColumn,
-  BaseEntity,
-  ManyToOne,
-  BeforeInsert,
-  BeforeUpdate,
-  CreateDateColumn,
-  UpdateDateColumn,
-} from 'typeorm'
-import { PartyEntity } from './PartyEntity'
-import { getConstraint } from '../../utils/ValidatorUtils'
-import { ElectronicAddressType, ValidationConstraint } from '../../types'
-
-@Entity('ElectronicAddress')
-export class ElectronicAddressEntity extends BaseEntity {
-  @PrimaryGeneratedColumn('uuid')
-  id!: string
-
-  @Column({ name: 'type', length: 255, nullable: false })
-  @IsNotEmpty({ message: 'Blank electronic address types are not allowed' })
-  type!: ElectronicAddressType
-
-  @Column({ name: 'electronic_address', length: 255, nullable: false })
-  @IsNotEmpty({ message: 'Blank electronic addresses are not allowed' })
-  electronicAddress!: string
-
-  @ManyToOne(() => PartyEntity, (party: PartyEntity) => party.electronicAddresses, {
-    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))
-      }
-    }
-  }
-}
+import { IsNotEmpty, validate, ValidationError } from 'class-validator'
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  BaseEntity,
+  ManyToOne,
+  BeforeInsert,
+  BeforeUpdate,
+  CreateDateColumn,
+  UpdateDateColumn,
+} from 'typeorm'
+import { PartyEntity } from './PartyEntity'
+import { getConstraint } from '../../utils/ValidatorUtils'
+import { ElectronicAddressType, ValidationConstraint } from '../../types'
+
+@Entity('ElectronicAddress')
+export class ElectronicAddressEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'type', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank electronic address types are not allowed' })
+  type!: ElectronicAddressType
+
+  @Column({ name: 'electronic_address', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank electronic addresses are not allowed' })
+  electronicAddress!: string
+
+  @ManyToOne(() => PartyEntity, (party: PartyEntity) => party.electronicAddresses, {
+    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))
+      }
+    }
+  }
+}