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

package/src/entities/contact/IdentityEntity.ts

@@ -0,0 +1,104 @@
+import {
+  BaseEntity,
+  CreateDateColumn,
+  Entity,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+  OneToOne,
+  JoinColumn,
+  ManyToOne,
+  Column,
+  OneToMany,
+  BeforeInsert,
+  BeforeUpdate,
+} from 'typeorm'
+import { IsNotEmpty, validate, ValidationError } from 'class-validator'
+import { correlationIdentifierEntityFrom, CorrelationIdentifierEntity } from './CorrelationIdentifierEntity'
+import { ConnectionEntity, connectionEntityFrom } from './ConnectionEntity'
+import { IdentityMetadataItemEntity, metadataItemEntityFrom } from './IdentityMetadataItemEntity'
+import { BasicMetadataItem, IBasicIdentity, IdentityRoleEnum } from '../../types'
+import { ContactEntity } from './ContactEntity'
+
+@Entity('Identity')
+export class IdentityEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({
+    name: 'alias',
+    length: 255,
+    nullable: false,
+    unique: true,
+  })
+  @IsNotEmpty({ message: 'Blank aliases are not allowed' })
+  alias!: string
+
+  @Column('simple-array', { name: 'roles', nullable: false })
+  roles!: Array<IdentityRoleEnum>
+
+  @OneToOne(() => CorrelationIdentifierEntity, (identifier: CorrelationIdentifierEntity) => identifier.identity, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: false,
+  })
+  identifier!: CorrelationIdentifierEntity
+
+  @OneToOne(() => ConnectionEntity, (connection: ConnectionEntity) => connection.identity, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+  })
+  connection?: ConnectionEntity
+
+  @OneToMany(() => IdentityMetadataItemEntity, (metadata: IdentityMetadataItemEntity) => metadata.identity, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: false,
+  })
+  @JoinColumn({ name: 'metadataId' })
+  metadata!: Array<IdentityMetadataItemEntity>
+
+  @CreateDateColumn({ name: 'created_at', nullable: false })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
+  lastUpdatedAt!: Date
+
+  @ManyToOne(() => ContactEntity, (contact: ContactEntity) => contact.identities, {
+    onDelete: 'CASCADE',
+  })
+  contact!: ContactEntity
+
+  @Column({ name: 'contactId', nullable: true })
+  contactId!: string
+
+  // 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: Array<ValidationError> = await validate(this)
+    if (validation.length > 0) {
+      return Promise.reject(Error(Object.values(validation[0].constraints!)[0]))
+    }
+    return
+  }
+}
+
+export const identityEntityFrom = (args: IBasicIdentity): IdentityEntity => {
+  const identityEntity = new IdentityEntity()
+  identityEntity.alias = args.alias
+  identityEntity.roles = args.roles
+  identityEntity.identifier = correlationIdentifierEntityFrom(args.identifier)
+  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

@@ -0,0 +1,39 @@
+import { Entity, Column, PrimaryGeneratedColumn, BaseEntity, ManyToOne, BeforeInsert, BeforeUpdate } from 'typeorm'
+import { BasicMetadataItem } from '../../types'
+import { IdentityEntity } from './IdentityEntity'
+import { IsNotEmpty, validate, ValidationError } from 'class-validator'
+
+@Entity('IdentityMetadata')
+export class IdentityMetadataItemEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'label', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank metadata labels are not allowed' })
+  label!: string
+
+  @Column({ name: 'value', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank metadata values are not allowed' })
+  value!: string
+
+  @ManyToOne(() => IdentityEntity, (identity: IdentityEntity) => identity.metadata, { cascade: ['insert', 'update'], onDelete: 'CASCADE' })
+  identity!: IdentityEntity
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  async validate() {
+    const validation: Array<ValidationError> = await validate(this)
+    if (validation.length > 0) {
+      return Promise.reject(Error(Object.values(validation[0].constraints!)[0]))
+    }
+    return
+  }
+}
+
+export const metadataItemEntityFrom = (item: BasicMetadataItem): IdentityMetadataItemEntity => {
+  const metadataItem = new IdentityMetadataItemEntity()
+  metadataItem.label = item.label
+  metadataItem.value = item.value
+
+  return metadataItem
+}

package/src/entities/contact/OpenIdConfigEntity.ts

@@ -0,0 +1,48 @@
+import { ChildEntity, Column, JoinColumn, OneToOne } from 'typeorm'
+import { BaseConfigEntity } from './BaseConfigEntity'
+import { BasicOpenIdConfig } from '../../types'
+import { ConnectionEntity } from './ConnectionEntity'
+
+@ChildEntity('OpenIdConfig')
+export class OpenIdConfigEntity extends BaseConfigEntity {
+  @Column({ name: 'client_id', length: 255, nullable: false })
+  clientId!: string
+
+  @Column({ name: 'client_secret', length: 255, nullable: false })
+  clientSecret!: string
+
+  @Column('simple-array', { name: 'scopes', nullable: false })
+  scopes!: Array<string>
+
+  @Column({ name: 'issuer', length: 255, nullable: false })
+  issuer!: string
+
+  @Column('text', { name: 'redirect_url', nullable: false })
+  redirectUrl!: string
+
+  @Column('boolean', { name: 'dangerously_allow_insecure_http_requests', nullable: false })
+  dangerouslyAllowInsecureHttpRequests!: boolean
+
+  @Column('text', { name: 'client_auth_method', nullable: false })
+  clientAuthMethod!: 'basic' | 'post' | undefined
+
+  @OneToOne(() => ConnectionEntity, (connection: ConnectionEntity) => connection.config, {
+    cascade: ['insert', 'update'],
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'connectionId' })
+  connection?: ConnectionEntity
+}
+
+export const openIdConfigEntityFrom = (config: BasicOpenIdConfig): OpenIdConfigEntity => {
+  const openIdConfig = new OpenIdConfigEntity()
+  openIdConfig.clientId = config.clientId
+  openIdConfig.clientSecret = config.clientSecret
+  openIdConfig.scopes = config.scopes
+  openIdConfig.issuer = config.issuer
+  openIdConfig.redirectUrl = config.redirectUrl
+  openIdConfig.dangerouslyAllowInsecureHttpRequests = config.dangerouslyAllowInsecureHttpRequests
+  openIdConfig.clientAuthMethod = config.clientAuthMethod
+
+  return 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
+}

package/src/entities/validators/index.ts

@@ -0,0 +1,16 @@
+import { ValidationArguments, ValidatorConstraint, ValidatorConstraintInterface } from 'class-validator'
+
+@ValidatorConstraint({ name: 'isNonEmptyString', async: false })
+export class IsNonEmptyStringConstraint implements ValidatorConstraintInterface {
+  validate(value: string, args: ValidationArguments): boolean {
+    return !isEmptyString(value)
+  }
+
+  defaultMessage(args: ValidationArguments): string {
+    return `${args.property} must not be an empty string.`
+  }
+}
+
+export const isEmptyString = (value: any): boolean => {
+  return typeof value === 'string' && value.trim().length === 0
+}