@sphereon/ssi-sdk.data-store 0.11.1-unstable.73 → 0.12.0

package/src/contact/AbstractContactStore.ts

@@ -1,5 +1,6 @@
-import { IContact, IIdentity } from '../types/contact'
 import {
+  IContact,
+  IIdentity,
   IAddIdentityArgs,
   IGetIdentityArgs,
   IGetIdentitiesArgs,
@@ -10,7 +11,7 @@ import {
   IGetContactsArgs,
   IRemoveContactArgs,
   IUpdateContactArgs,
-} from '../types/IAbstractContactStore'
+} from '../types'
 
 export abstract class AbstractContactStore {
   abstract getContact(args: IGetContactArgs): Promise<IContact>

package/src/contact/ContactStore.ts

@@ -1,5 +1,6 @@
 import Debug from 'debug'
 import { OrPromise } from '@sphereon/ssi-types'
+import { AbstractContactStore } from './AbstractContactStore'
 import {
   IAddIdentityArgs,
   IGetIdentityArgs,
@@ -11,9 +12,6 @@ import {
   IAddContactArgs,
   IUpdateContactArgs,
   IRemoveContactArgs,
-} from '../types/IAbstractContactStore'
-import { AbstractContactStore } from './AbstractContactStore'
-import {
   BasicConnectionConfig,
   ConnectionConfig,
   ConnectionTypeEnum,
@@ -25,7 +23,7 @@ import {
   IIdentity,
   IMetadataItem,
   IOpenIdConfig,
-} from '../types/contact'
+} from '../types'
 import { ContactEntity, contactEntityFrom } from '../entities/contact/ContactEntity'
 import { IdentityEntity, identityEntityFrom } from '../entities/contact/IdentityEntity'
 import { IdentityMetadataItemEntity } from '../entities/contact/IdentityMetadataItemEntity'

package/src/entities/contact/ConnectionEntity.ts

@@ -1,6 +1,6 @@
 import { Entity, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn, BaseEntity } from 'typeorm'
 import { BaseConfigEntity } from './BaseConfigEntity'
-import { BasicConnectionConfig, ConnectionTypeEnum, IBasicConnection, IDidAuthConfig, IOpenIdConfig } from '../../types/contact'
+import { BasicConnectionConfig, ConnectionTypeEnum, IBasicConnection, IDidAuthConfig, IOpenIdConfig } from '../../types'
 import { IdentityEntity } from './IdentityEntity'
 import { OpenIdConfigEntity, openIdConfigEntityFrom } from './OpenIdConfigEntity'
 import { DidAuthConfigEntity, didAuthConfigEntityFrom } from './DidAuthConfigEntity'

package/src/entities/contact/ContactEntity.ts

@@ -10,9 +10,9 @@ import {
   PrimaryGeneratedColumn,
   UpdateDateColumn,
 } from 'typeorm'
-import { IBasicContact, IBasicIdentity } from '../../types/contact'
+import { IBasicContact, IBasicIdentity } from '../../types'
 import { IdentityEntity, identityEntityFrom } from './IdentityEntity'
-import { IsNotEmpty, validate } from 'class-validator'
+import { IsNotEmpty, validate, ValidationError } from 'class-validator'
 
 @Entity('Contact')
 export class ContactEntity extends BaseEntity {
@@ -55,9 +55,9 @@ export class ContactEntity extends BaseEntity {
   @BeforeInsert()
   @BeforeUpdate()
   async validate() {
-    const validation = await validate(this)
+    const validation: Array<ValidationError> = await validate(this)
     if (validation.length > 0) {
-      return Promise.reject(Error(validation[0].constraints?.isNotEmpty))
+      return Promise.reject(Error(Object.values(validation[0].constraints!)[0]))
     }
     return
   }
@@ -68,9 +68,7 @@ export const contactEntityFrom = (args: IBasicContact): 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))
-  }
+  contactEntity.identities = args.identities ? args.identities.map((identity: IBasicIdentity) => identityEntityFrom(identity)) : []
 
   return contactEntity
 }

package/src/entities/contact/CorrelationIdentifierEntity.ts

@@ -1,7 +1,7 @@
 import { Entity, Column, PrimaryGeneratedColumn, BaseEntity, OneToOne, JoinColumn, BeforeInsert, BeforeUpdate } from 'typeorm'
-import { CorrelationIdentifierEnum, BasicCorrelationIdentifier } from '../../types/contact'
+import { CorrelationIdentifierEnum, BasicCorrelationIdentifier } from '../../types'
 import { IdentityEntity } from './IdentityEntity'
-import { IsNotEmpty, validate } from 'class-validator'
+import { IsNotEmpty, validate, ValidationError } from 'class-validator'
 
 @Entity('CorrelationIdentifier')
 export class CorrelationIdentifierEntity extends BaseEntity {
@@ -24,9 +24,9 @@ export class CorrelationIdentifierEntity extends BaseEntity {
   @BeforeInsert()
   @BeforeUpdate()
   async validate() {
-    const validation = await validate(this)
+    const validation: Array<ValidationError> = await validate(this)
     if (validation.length > 0) {
-      return Promise.reject(Error(validation[0].constraints?.isNotEmpty))
+      return Promise.reject(Error(Object.values(validation[0].constraints!)[0]))
     }
     return
   }

package/src/entities/contact/DidAuthConfigEntity.ts

@@ -1,6 +1,6 @@
 import { ChildEntity, Column, JoinColumn, OneToOne } from 'typeorm'
 import { BaseConfigEntity } from './BaseConfigEntity'
-import { BasicDidAuthConfig } from '../../types/contact'
+import { BasicDidAuthConfig } from '../../types'
 import { ConnectionEntity } from './ConnectionEntity'
 
 @ChildEntity('DidAuthConfig')

package/src/entities/contact/IdentityEntity.ts

@@ -12,12 +12,12 @@ import {
   BeforeInsert,
   BeforeUpdate,
 } from 'typeorm'
+import { IsNotEmpty, validate, ValidationError } from 'class-validator'
 import { correlationIdentifierEntityFrom, CorrelationIdentifierEntity } from './CorrelationIdentifierEntity'
 import { ConnectionEntity, connectionEntityFrom } from './ConnectionEntity'
-import { BasicMetadataItem, IBasicIdentity, IdentityRoleEnum } from '../../types/contact'
-import { ContactEntity } from './ContactEntity'
 import { IdentityMetadataItemEntity, metadataItemEntityFrom } from './IdentityMetadataItemEntity'
-import { IsNotEmpty, validate } from 'class-validator'
+import { BasicMetadataItem, IBasicIdentity, IdentityRoleEnum } from '../../types'
+import { ContactEntity } from './ContactEntity'
 
 @Entity('Identity')
 export class IdentityEntity extends BaseEntity {
@@ -84,9 +84,9 @@ export class IdentityEntity extends BaseEntity {
   @BeforeInsert()
   @BeforeUpdate()
   async validate() {
-    const validation = await validate(this)
+    const validation: Array<ValidationError> = await validate(this)
     if (validation.length > 0) {
-      return Promise.reject(Error(validation[0].constraints?.isNotEmpty))
+      return Promise.reject(Error(Object.values(validation[0].constraints!)[0]))
     }
     return
   }
@@ -97,9 +97,7 @@ export const identityEntityFrom = (args: IBasicIdentity): IdentityEntity => {
   identityEntity.alias = args.alias
   identityEntity.roles = args.roles
   identityEntity.identifier = correlationIdentifierEntityFrom(args.identifier)
-  if (args.connection) {
-    identityEntity.connection = connectionEntityFrom(args.connection)
-  }
+  identityEntity.connection = args.connection ? connectionEntityFrom(args.connection) : undefined
   identityEntity.metadata = args.metadata ? args.metadata.map((item: BasicMetadataItem) => metadataItemEntityFrom(item)) : []
 
   return identityEntity

package/src/entities/contact/IdentityMetadataItemEntity.ts

@@ -1,7 +1,7 @@
 import { Entity, Column, PrimaryGeneratedColumn, BaseEntity, ManyToOne, BeforeInsert, BeforeUpdate } from 'typeorm'
-import { BasicMetadataItem } from '../../types/contact'
+import { BasicMetadataItem } from '../../types'
 import { IdentityEntity } from './IdentityEntity'
-import { IsNotEmpty, validate } from 'class-validator'
+import { IsNotEmpty, validate, ValidationError } from 'class-validator'
 
 @Entity('IdentityMetadata')
 export class IdentityMetadataItemEntity extends BaseEntity {
@@ -22,9 +22,9 @@ export class IdentityMetadataItemEntity extends BaseEntity {
   @BeforeInsert()
   @BeforeUpdate()
   async validate() {
-    const validation = await validate(this)
+    const validation: Array<ValidationError> = await validate(this)
     if (validation.length > 0) {
-      return Promise.reject(Error(validation[0].constraints?.isNotEmpty))
+      return Promise.reject(Error(Object.values(validation[0].constraints!)[0]))
     }
     return
   }

package/src/entities/contact/OpenIdConfigEntity.ts

@@ -1,6 +1,6 @@
 import { ChildEntity, Column, JoinColumn, OneToOne } from 'typeorm'
 import { BaseConfigEntity } from './BaseConfigEntity'
-import { BasicOpenIdConfig } from '../../types/contact'
+import { BasicOpenIdConfig } from '../../types'
 import { ConnectionEntity } from './ConnectionEntity'
 
 @ChildEntity('OpenIdConfig')

package/src/entities/issuanceBranding/BackgroundAttributesEntity.ts

@@ -0,0 +1,42 @@
+import { BaseEntity, BeforeInsert, BeforeUpdate, Column, Entity, JoinColumn, OneToOne, PrimaryGeneratedColumn } from 'typeorm'
+import { IBasicBackgroundAttributes } from '../../types'
+import { ImageAttributesEntity, imageAttributesEntityFrom } from './ImageAttributesEntity'
+import { validate, Validate, ValidationError } from 'class-validator'
+import { isEmptyString, IsNonEmptyStringConstraint } from '../validators'
+
+@Entity('BackgroundAttributes')
+export class BackgroundAttributesEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'color', length: 255, nullable: true, unique: false })
+  @Validate(IsNonEmptyStringConstraint, { message: 'Blank background colors are not allowed' })
+  color?: string
+
+  @OneToOne(() => ImageAttributesEntity, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: true,
+  })
+  @JoinColumn({ name: 'imageId' })
+  image?: ImageAttributesEntity
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  async validate(): Promise<undefined> {
+    const validation: Array<ValidationError> = await validate(this)
+    if (validation.length > 0) {
+      return Promise.reject(Error(Object.values(validation[0].constraints!)[0]))
+    }
+    return
+  }
+}
+
+export const backgroundAttributesEntityFrom = (args: IBasicBackgroundAttributes): BackgroundAttributesEntity => {
+  const backgroundAttributesEntity: BackgroundAttributesEntity = new BackgroundAttributesEntity()
+  backgroundAttributesEntity.color = isEmptyString(args.color) ? undefined : args.color
+  backgroundAttributesEntity.image = args.image ? imageAttributesEntityFrom(args.image) : undefined
+
+  return backgroundAttributesEntity
+}

package/src/entities/issuanceBranding/BaseLocaleBrandingEntity.ts

@@ -0,0 +1,86 @@
+import {
+  BaseEntity,
+  BeforeInsert,
+  BeforeUpdate,
+  Column,
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  TableInheritance,
+  UpdateDateColumn,
+} from 'typeorm'
+import { ImageAttributesEntity } from './ImageAttributesEntity'
+import { BackgroundAttributesEntity } from './BackgroundAttributesEntity'
+import { TextAttributesEntity } from './TextAttributesEntity'
+import { validate, Validate, ValidationError } from 'class-validator'
+import { IsNonEmptyStringConstraint } from '../validators'
+
+@Entity('BaseLocaleBranding')
+@TableInheritance({ column: { type: 'varchar', name: 'type' } })
+export class BaseLocaleBrandingEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'alias', length: 255, nullable: true, unique: false })
+  @Validate(IsNonEmptyStringConstraint, { message: 'Blank aliases are not allowed' })
+  alias?: string
+
+  @Column({ name: 'locale', length: 255, nullable: false, unique: false })
+  locale?: string
+
+  @OneToOne(() => ImageAttributesEntity, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: true,
+  })
+  @JoinColumn({ name: 'logoId' })
+  logo?: ImageAttributesEntity
+
+  @Column({ name: 'description', length: 255, nullable: true, unique: false })
+  @Validate(IsNonEmptyStringConstraint, { message: 'Blank descriptions are not allowed' })
+  description?: string
+
+  @OneToOne(() => BackgroundAttributesEntity, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: true,
+  })
+  @JoinColumn({ name: 'backgroundId' })
+  background?: BackgroundAttributesEntity
+
+  @OneToOne(() => TextAttributesEntity, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: true,
+  })
+  @JoinColumn({ name: 'textId' })
+  text?: TextAttributesEntity
+
+  @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<undefined> {
+    const validation: Array<ValidationError> = await validate(this)
+    if (validation.length > 0) {
+      return Promise.reject(Error(Object.values(validation[0].constraints!)[0]))
+    }
+    return
+  }
+}

package/src/entities/issuanceBranding/CredentialBrandingEntity.ts

@@ -0,0 +1,78 @@
+import {
+  BaseEntity,
+  BeforeInsert,
+  BeforeUpdate,
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm'
+import { ArrayMinSize, IsNotEmpty, validate, ValidationError } from 'class-validator'
+import { CredentialLocaleBrandingEntity, credentialLocaleBrandingEntityFrom } from './CredentialLocaleBrandingEntity'
+import { IBasicCredentialBranding, IBasicCredentialLocaleBranding } from '../../types'
+
+@Entity('CredentialBranding')
+@Index('IDX_CredentialBrandingEntity_vcHash', ['vcHash'])
+@Index('IDX_CredentialBrandingEntity_issuerCorrelationId', ['issuerCorrelationId'])
+export class CredentialBrandingEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'vcHash', length: 255, nullable: false, unique: true })
+  @IsNotEmpty({ message: 'Blank vcHashes are not allowed' })
+  vcHash!: string
+
+  @Column({ name: 'issuerCorrelationId', length: 255, nullable: false, unique: false })
+  @IsNotEmpty({ message: 'Blank issuerCorrelationIds are not allowed' })
+  issuerCorrelationId!: string
+
+  @OneToMany(
+    () => CredentialLocaleBrandingEntity,
+    (credentialLocaleBrandingEntity: CredentialLocaleBrandingEntity) => credentialLocaleBrandingEntity.credentialBranding,
+    {
+      cascade: true,
+      onDelete: 'CASCADE',
+      eager: true,
+      nullable: false,
+    }
+  )
+  @ArrayMinSize(1, { message: 'localeBranding cannot be empty' })
+  localeBranding!: Array<CredentialLocaleBrandingEntity>
+
+  @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<undefined> {
+    const validation: Array<ValidationError> = await validate(this)
+    if (validation.length > 0) {
+      return Promise.reject(Error(Object.values(validation[0].constraints!)[0]))
+    }
+    return
+  }
+}
+
+export const credentialBrandingEntityFrom = (args: IBasicCredentialBranding): CredentialBrandingEntity => {
+  const credentialBrandingEntity: CredentialBrandingEntity = new CredentialBrandingEntity()
+  credentialBrandingEntity.issuerCorrelationId = args.issuerCorrelationId
+  credentialBrandingEntity.vcHash = args.vcHash
+  credentialBrandingEntity.localeBranding = args.localeBranding.map((localeBranding: IBasicCredentialLocaleBranding) =>
+    credentialLocaleBrandingEntityFrom(localeBranding)
+  )
+
+  return credentialBrandingEntity
+}

package/src/entities/issuanceBranding/CredentialLocaleBrandingEntity.ts

@@ -0,0 +1,33 @@
+import { ChildEntity, Column, JoinColumn, ManyToOne, Index } from 'typeorm'
+import { IBasicCredentialLocaleBranding } from '../../types'
+import { backgroundAttributesEntityFrom } from './BackgroundAttributesEntity'
+import { CredentialBrandingEntity } from './CredentialBrandingEntity'
+import { imageAttributesEntityFrom } from './ImageAttributesEntity'
+import { BaseLocaleBrandingEntity } from './BaseLocaleBrandingEntity'
+import { textAttributesEntityFrom } from './TextAttributesEntity'
+import { isEmptyString } from '../validators'
+
+@ChildEntity('CredentialLocaleBranding')
+@Index('IDX_CredentialLocaleBrandingEntity_credentialBranding_locale', ['credentialBranding', 'locale'], { unique: true })
+export class CredentialLocaleBrandingEntity extends BaseLocaleBrandingEntity {
+  @ManyToOne(() => CredentialBrandingEntity, (credentialBranding: CredentialBrandingEntity) => credentialBranding.localeBranding, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'credentialBrandingId' })
+  credentialBranding!: CredentialBrandingEntity
+
+  @Column({ name: 'credentialBrandingId', nullable: false })
+  credentialBrandingId!: string
+}
+
+export const credentialLocaleBrandingEntityFrom = (args: IBasicCredentialLocaleBranding): CredentialLocaleBrandingEntity => {
+  const credentialLocaleBrandingEntity: CredentialLocaleBrandingEntity = new CredentialLocaleBrandingEntity()
+  credentialLocaleBrandingEntity.alias = isEmptyString(args.alias) ? undefined : args.alias
+  credentialLocaleBrandingEntity.locale = args.locale ? args.locale : ''
+  credentialLocaleBrandingEntity.logo = args.logo ? imageAttributesEntityFrom(args.logo) : undefined
+  credentialLocaleBrandingEntity.description = isEmptyString(args.description) ? undefined : args.description
+  credentialLocaleBrandingEntity.background = args.background ? backgroundAttributesEntityFrom(args.background) : undefined
+  credentialLocaleBrandingEntity.text = args.text ? textAttributesEntityFrom(args.text) : undefined
+
+  return credentialLocaleBrandingEntity
+}

package/src/entities/issuanceBranding/ImageAttributesEntity.ts

@@ -0,0 +1,57 @@
+import { BaseEntity, BeforeInsert, BeforeUpdate, Column, Entity, JoinColumn, OneToOne, PrimaryGeneratedColumn } from 'typeorm'
+import { IBasicImageAttributes } from '../../types'
+import { ImageDimensionsEntity, imageDimensionsEntityFrom } from './ImageDimensionsEntity'
+import { validate, Validate, ValidationError } from 'class-validator'
+import { isEmptyString, IsNonEmptyStringConstraint } from '../validators'
+
+@Entity('ImageAttributes')
+export class ImageAttributesEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'uri', length: 255, nullable: true, unique: false })
+  @Validate(IsNonEmptyStringConstraint, { message: 'Blank image uri are not allowed' })
+  uri?: string
+
+  @Column({ name: 'dataUri', length: 255, nullable: true, unique: false })
+  @Validate(IsNonEmptyStringConstraint, { message: 'Blank image data uri are not allowed' })
+  dataUri?: string
+
+  @Column({ name: 'mediaType', length: 255, nullable: true, unique: false })
+  @Validate(IsNonEmptyStringConstraint, { message: 'Blank image types are not allowed' })
+  mediaType?: string
+
+  @Column({ name: 'alt', length: 255, nullable: true, unique: false })
+  @Validate(IsNonEmptyStringConstraint, { message: 'Blank image alts are not allowed' })
+  alt?: string
+
+  @OneToOne(() => ImageDimensionsEntity, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: true,
+  })
+  @JoinColumn({ name: 'dimensionsId' })
+  dimensions?: ImageDimensionsEntity
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  async validate(): Promise<undefined> {
+    const validation: Array<ValidationError> = await validate(this)
+    if (validation.length > 0) {
+      return Promise.reject(Error(Object.values(validation[0].constraints!)[0]))
+    }
+    return
+  }
+}
+
+export const imageAttributesEntityFrom = (args: IBasicImageAttributes): ImageAttributesEntity => {
+  const imageAttributesEntity: ImageAttributesEntity = new ImageAttributesEntity()
+  imageAttributesEntity.uri = isEmptyString(args.uri) ? undefined : args.uri
+  imageAttributesEntity.dataUri = isEmptyString(args.dataUri) ? undefined : args.dataUri
+  imageAttributesEntity.mediaType = isEmptyString(args.mediaType) ? undefined : args.mediaType
+  imageAttributesEntity.alt = isEmptyString(args.alt) ? undefined : args.alt
+  imageAttributesEntity.dimensions = args.dimensions ? imageDimensionsEntityFrom(args.dimensions) : undefined
+
+  return imageAttributesEntity
+}

package/src/entities/issuanceBranding/ImageDimensionsEntity.ts

@@ -0,0 +1,22 @@
+import { BaseEntity, Column, Entity, PrimaryGeneratedColumn } from 'typeorm'
+import { IBasicImageDimensions } from '../../types'
+
+@Entity('ImageDimensions')
+export class ImageDimensionsEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'width', nullable: false, unique: false })
+  width!: number
+
+  @Column({ name: 'height', nullable: false, unique: false })
+  height!: number
+}
+
+export const imageDimensionsEntityFrom = (args: IBasicImageDimensions): ImageDimensionsEntity => {
+  const imageDimensionsEntity: ImageDimensionsEntity = new ImageDimensionsEntity()
+  imageDimensionsEntity.width = args.width
+  imageDimensionsEntity.height = args.height
+
+  return imageDimensionsEntity
+}

package/src/entities/issuanceBranding/IssuerBrandingEntity.ts

@@ -0,0 +1,72 @@
+import {
+  BaseEntity,
+  BeforeInsert,
+  BeforeUpdate,
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm'
+import { ArrayMinSize, IsNotEmpty, validate, ValidationError } from 'class-validator'
+import { IssuerLocaleBrandingEntity, issuerLocaleBrandingEntityFrom } from './IssuerLocaleBrandingEntity'
+import { IBasicIssuerBranding, IBasicIssuerLocaleBranding } from '../../types'
+
+@Entity('IssuerBranding')
+@Index('IDX_IssuerBrandingEntity_issuerCorrelationId', ['issuerCorrelationId'])
+export class IssuerBrandingEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'issuerCorrelationId', length: 255, nullable: false, unique: true })
+  @IsNotEmpty({ message: 'Blank issuerCorrelationIds are not allowed' })
+  issuerCorrelationId!: string
+
+  @OneToMany(
+    () => IssuerLocaleBrandingEntity,
+    (issuerLocaleBrandingEntity: IssuerLocaleBrandingEntity) => issuerLocaleBrandingEntity.issuerBranding,
+    {
+      cascade: true,
+      onDelete: 'CASCADE',
+      eager: true,
+      nullable: false,
+    }
+  )
+  @ArrayMinSize(1, { message: 'localeBranding cannot be empty' })
+  localeBranding!: Array<IssuerLocaleBrandingEntity>
+
+  @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<undefined> {
+    const validation: Array<ValidationError> = await validate(this)
+    if (validation.length > 0) {
+      return Promise.reject(Error(Object.values(validation[0].constraints!)[0]))
+    }
+    return
+  }
+}
+
+export const issuerBrandingEntityFrom = (args: IBasicIssuerBranding): IssuerBrandingEntity => {
+  const issuerBrandingEntity: IssuerBrandingEntity = new IssuerBrandingEntity()
+  issuerBrandingEntity.issuerCorrelationId = args.issuerCorrelationId
+  issuerBrandingEntity.localeBranding = args.localeBranding.map((localeBranding: IBasicIssuerLocaleBranding) =>
+    issuerLocaleBrandingEntityFrom(localeBranding)
+  )
+
+  return issuerBrandingEntity
+}

package/src/entities/issuanceBranding/IssuerLocaleBrandingEntity.ts

@@ -0,0 +1,33 @@
+import { ChildEntity, Column, Index, JoinColumn, ManyToOne } from 'typeorm'
+import { IBasicIssuerLocaleBranding } from '../../types'
+import { backgroundAttributesEntityFrom } from './BackgroundAttributesEntity'
+import { imageAttributesEntityFrom } from './ImageAttributesEntity'
+import { IssuerBrandingEntity } from './IssuerBrandingEntity'
+import { BaseLocaleBrandingEntity } from './BaseLocaleBrandingEntity'
+import { textAttributesEntityFrom } from './TextAttributesEntity'
+import { isEmptyString } from '../validators'
+
+@ChildEntity('IssuerLocaleBranding')
+@Index('IDX_IssuerLocaleBrandingEntity_issuerBranding_locale', ['issuerBranding', 'locale'], { unique: true })
+export class IssuerLocaleBrandingEntity extends BaseLocaleBrandingEntity {
+  @ManyToOne(() => IssuerBrandingEntity, (issuerBranding: IssuerBrandingEntity) => issuerBranding.localeBranding, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'issuerBrandingId' })
+  issuerBranding!: IssuerBrandingEntity
+
+  @Column({ name: 'issuerBrandingId', nullable: false })
+  issuerBrandingId!: string
+}
+
+export const issuerLocaleBrandingEntityFrom = (args: IBasicIssuerLocaleBranding): IssuerLocaleBrandingEntity => {
+  const issuerLocaleBrandingEntity: IssuerLocaleBrandingEntity = new IssuerLocaleBrandingEntity()
+  issuerLocaleBrandingEntity.alias = isEmptyString(args.alias) ? undefined : args.alias
+  issuerLocaleBrandingEntity.locale = args.locale ? args.locale : ''
+  issuerLocaleBrandingEntity.logo = args.logo ? imageAttributesEntityFrom(args.logo) : undefined
+  issuerLocaleBrandingEntity.description = isEmptyString(args.description) ? undefined : args.description
+  issuerLocaleBrandingEntity.background = args.background ? backgroundAttributesEntityFrom(args.background) : undefined
+  issuerLocaleBrandingEntity.text = args.text ? textAttributesEntityFrom(args.text) : undefined
+
+  return issuerLocaleBrandingEntity
+}

package/src/entities/issuanceBranding/TextAttributesEntity.ts

@@ -0,0 +1,31 @@
+import { BaseEntity, BeforeInsert, BeforeUpdate, Column, Entity, PrimaryGeneratedColumn } from 'typeorm'
+import { IBasicTextAttributes } from '../../types'
+import { validate, Validate, ValidationError } from 'class-validator'
+import { isEmptyString, IsNonEmptyStringConstraint } from '../validators'
+
+@Entity('TextAttributes')
+export class TextAttributesEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'color', length: 255, nullable: true, unique: false })
+  @Validate(IsNonEmptyStringConstraint, { message: 'Blank text colors are not allowed' })
+  color?: string
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  async validate(): Promise<undefined> {
+    const validation: Array<ValidationError> = await validate(this)
+    if (validation.length > 0) {
+      return Promise.reject(Error(Object.values(validation[0].constraints!)[0]))
+    }
+    return
+  }
+}
+
+export const textAttributesEntityFrom = (args: IBasicTextAttributes): TextAttributesEntity => {
+  const textAttributesEntity: TextAttributesEntity = new TextAttributesEntity()
+  textAttributesEntity.color = isEmptyString(args.color) ? undefined : args.color
+
+  return textAttributesEntity
+}