@sphereon/ssi-sdk.data-store 0.18.2-next.9 → 0.18.2-next.92

package/src/entities/contact/PhysicalAddressEntity.ts

@@ -0,0 +1,87 @@
+import { IsNotEmpty, validate, ValidationError } from 'class-validator'
+import {
+  BaseEntity,
+  BeforeInsert,
+  BeforeUpdate,
+  Column,
+  CreateDateColumn,
+  Entity,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm'
+import { getConstraint } from '../../utils/ValidatorUtils'
+import { PhysicalAddressType, ValidationConstraint } from '../../types'
+import { PartyEntity } from './PartyEntity'
+
+@Entity('PhysicalAddress')
+export class PhysicalAddressEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'type', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank physical address types are not allowed' })
+  type!: PhysicalAddressType
+
+  @Column({ name: 'street_name', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank street names are not allowed' })
+  streetName!: string
+
+  @Column({ name: 'street_number', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank street numbers are not allowed' })
+  streetNumber!: string
+
+  @Column({ name: 'postal_code', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank postal codes are not allowed' })
+  postalCode!: string
+
+  @Column({ name: 'city_name', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank city names are not allowed' })
+  cityName!: string
+
+  @Column({ name: 'province_name', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank province names are not allowed' })
+  provinceName!: string
+
+  @Column({ name: 'country_code', length: 2, nullable: false })
+  @IsNotEmpty({ message: 'Blank country codes are not allowed' })
+  countryCode!: string
+
+  @Column({ name: 'building_name', length: 255, nullable: true })
+  @IsNotEmpty({ message: 'Blank building names are not allowed' })
+  buildingName?: string
+
+  @ManyToOne(() => PartyEntity, (party: PartyEntity) => party.physicalAddresses, {
+    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))
+      }
+    }
+  }
+}

package/src/index.ts

@@ -24,6 +24,7 @@ import { PartyTypeEntity } from './entities/contact/PartyTypeEntity'
 import { OrganizationEntity } from './entities/contact/OrganizationEntity'
 import { NaturalPersonEntity } from './entities/contact/NaturalPersonEntity'
 import { ElectronicAddressEntity } from './entities/contact/ElectronicAddressEntity'
+import { PhysicalAddressEntity } from './entities/contact/PhysicalAddressEntity'
 export { ContactStore } from './contact/ContactStore'
 export { AbstractContactStore } from './contact/AbstractContactStore'
 export { AbstractIssuanceBrandingStore } from './issuanceBranding/AbstractIssuanceBrandingStore'
@@ -57,6 +58,7 @@ export const DataStoreContactEntities = [
   OrganizationEntity,
   NaturalPersonEntity,
   ElectronicAddressEntity,
+  PhysicalAddressEntity,
 ]
 
 export const DataStoreIssuanceBrandingEntities = [
@@ -102,6 +104,7 @@ export {
   CredentialLocaleBrandingEntity,
   IssuerLocaleBrandingEntity,
   ElectronicAddressEntity,
+  PhysicalAddressEntity,
   backgroundAttributesEntityFrom,
   credentialBrandingEntityFrom,
   imageAttributesEntityFrom,

package/src/issuanceBranding/IssuanceBrandingStore.ts

@@ -53,16 +53,17 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
   }
 
   public addCredentialBranding = async (args: IAddCredentialBrandingArgs): Promise<ICredentialBranding> => {
+    const { localeBranding, vcHash } = args
     const repository: Repository<CredentialBrandingEntity> = (await this.dbConnection).getRepository(CredentialBrandingEntity)
     const result: CredentialBrandingEntity | null = await repository.findOne({
-      where: [{ vcHash: args.vcHash }],
+      where: [{ vcHash }],
     })
 
     if (result) {
-      return Promise.reject(Error(`Credential branding already present for vc with hash: ${args.vcHash}`))
+      return Promise.reject(Error(`Credential branding already present for vc with hash: ${vcHash}`))
     }
 
-    if (await this.hasDuplicateLocales(args.localeBranding)) {
+    if (await this.hasDuplicateLocales(localeBranding)) {
       return Promise.reject(Error(`Credential branding contains duplicate locales`))
     }
 
@@ -74,8 +75,9 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
   }
 
   public getCredentialBranding = async (args?: IGetCredentialBrandingArgs): Promise<Array<ICredentialBranding>> => {
-    if (args?.filter) {
-      args?.filter.forEach((filter: IPartialCredentialBranding): void => {
+    const { filter } = args ?? {}
+    if (filter) {
+      filter.forEach((filter: IPartialCredentialBranding): void => {
         if (filter.localeBranding && 'locale' in filter.localeBranding && filter.localeBranding.locale === undefined) {
           filter.localeBranding.locale = ''
         }
@@ -84,16 +86,17 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
 
     debug('Getting credential branding', args)
     const result: Array<CredentialBrandingEntity> = await (await this.dbConnection).getRepository(CredentialBrandingEntity).find({
-      ...(args?.filter && { where: args?.filter }),
+      ...(filter && { where: filter }),
     })
 
     return result.map((credentialBranding: CredentialBrandingEntity) => this.credentialBrandingFrom(credentialBranding))
   }
 
   public removeCredentialBranding = async (args: IRemoveCredentialBrandingArgs): Promise<void> => {
+    const { filter } = args
     const repository: Repository<CredentialBrandingEntity> = (await this.dbConnection).getRepository(CredentialBrandingEntity)
     const credentialBranding: Array<CredentialBrandingEntity> = await repository.find({
-      where: args.filter,
+      where: filter,
     })
 
     debug('Removing credential locale branding', args)
@@ -105,49 +108,51 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
     await Promise.all(localeBrandingDeletions)
 
     debug('Removing credential branding', args)
-    const credentialBrandingDeletions: Array<Promise<DeleteResult>> = args.filter.map(
+    const credentialBrandingDeletions: Array<Promise<DeleteResult>> = filter.map(
       async (filter: ICredentialBrandingFilter): Promise<DeleteResult> => await repository.delete(filter)
     )
     await Promise.all(credentialBrandingDeletions)
   }
 
   public updateCredentialBranding = async (args: IUpdateCredentialBrandingArgs): Promise<ICredentialBranding> => {
+    const { credentialBranding } = args
     const repository: Repository<CredentialBrandingEntity> = (await this.dbConnection).getRepository(CredentialBrandingEntity)
     const credentialBrandingEntity: CredentialBrandingEntity | null = await repository.findOne({
-      where: { id: args.credentialBranding.id },
+      where: { id: credentialBranding.id },
     })
 
     if (!credentialBrandingEntity) {
-      return Promise.reject(Error(`No credential branding found for id: ${args.credentialBranding.id}`))
+      return Promise.reject(Error(`No credential branding found for id: ${credentialBranding.id}`))
     }
 
-    const credentialBranding: Omit<ICredentialBranding, 'createdAt' | 'lastUpdatedAt'> = {
-      ...args.credentialBranding,
+    const branding: Omit<ICredentialBranding, 'createdAt' | 'lastUpdatedAt'> = {
+      ...credentialBranding,
       localeBranding: credentialBrandingEntity.localeBranding,
     }
 
-    debug('Updating credential branding', credentialBranding)
-    const result: CredentialBrandingEntity = await repository.save(credentialBranding, { transaction: true })
+    debug('Updating credential branding', branding)
+    const result: CredentialBrandingEntity = await repository.save(branding, { transaction: true })
 
     return this.credentialBrandingFrom(result)
   }
 
   public addCredentialLocaleBranding = async (args: IAddCredentialLocaleBrandingArgs): Promise<ICredentialBranding> => {
+    const { credentialBrandingId, localeBranding } = args
     const credentialBrandingRepository: Repository<CredentialBrandingEntity> = (await this.dbConnection).getRepository(CredentialBrandingEntity)
     const credentialBranding: CredentialBrandingEntity | null = await credentialBrandingRepository.findOne({
-      where: { id: args.credentialBrandingId },
+      where: { id: credentialBrandingId },
     })
 
     if (!credentialBranding) {
-      return Promise.reject(Error(`No credential branding found for id: ${args.credentialBrandingId}`))
+      return Promise.reject(Error(`No credential branding found for id: ${credentialBrandingId}`))
     }
 
     const locales: Array<CredentialLocaleBrandingEntity> | null = await (await this.dbConnection).getRepository(CredentialLocaleBrandingEntity).find({
       where: {
         credentialBranding: {
-          id: args.credentialBrandingId,
+          id: credentialBrandingId,
         },
-        locale: In(args.localeBranding.map((localeBranding: IBasicCredentialLocaleBranding) => localeBranding.locale)),
+        locale: In(localeBranding.map((localeBranding: IBasicCredentialLocaleBranding) => localeBranding.locale)),
       },
     })
 
@@ -164,7 +169,7 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
     const credentialLocaleBrandingRepository: Repository<CredentialLocaleBrandingEntity> = (await this.dbConnection).getRepository(
       CredentialLocaleBrandingEntity
     )
-    const addCredentialLocaleBranding: Array<Promise<void>> = args.localeBranding.map(
+    const addCredentialLocaleBranding: Array<Promise<void>> = localeBranding.map(
       async (localeBranding: IBasicCredentialLocaleBranding): Promise<void> => {
         const credentialLocaleBrandingEntity: CredentialLocaleBrandingEntity = credentialLocaleBrandingEntityFrom(localeBranding)
         debug('Adding credential locale branding', credentialLocaleBrandingEntity)
@@ -176,7 +181,7 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
     await Promise.all(addCredentialLocaleBranding)
 
     const result: CredentialBrandingEntity | null = await credentialBrandingRepository.findOne({
-      where: { id: args.credentialBrandingId },
+      where: { id: credentialBrandingId },
     })
 
     if (!result) {
@@ -187,8 +192,9 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
   }
 
   public getCredentialLocaleBranding = async (args?: IGetCredentialLocaleBrandingArgs): Promise<Array<ICredentialLocaleBranding>> => {
-    if (args?.filter) {
-      args?.filter.forEach((filter: ICredentialLocaleBrandingFilter): void => {
+    const { filter } = args ?? {}
+    if (filter) {
+      filter.forEach((filter: ICredentialLocaleBrandingFilter): void => {
         if ('locale' in filter && filter.locale === undefined) {
           filter.locale = ''
         }
@@ -199,7 +205,7 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
     const credentialBrandingLocale: Array<CredentialLocaleBrandingEntity> | null = await (await this.dbConnection)
       .getRepository(CredentialLocaleBrandingEntity)
       .find({
-        ...(args?.filter && { where: args?.filter }),
+        ...(filter && { where: filter }),
       })
 
     return credentialBrandingLocale
@@ -210,10 +216,11 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
   }
 
   public removeCredentialLocaleBranding = async (args: IRemoveCredentialLocaleBrandingArgs): Promise<void> => {
+    const { filter } = args
     const credentialLocaleBranding: Array<CredentialLocaleBrandingEntity> = await (await this.dbConnection)
       .getRepository(CredentialLocaleBrandingEntity)
       .find({
-        where: args.filter,
+        where: filter,
       })
 
     debug('Removing credential locale branding', args)
@@ -224,13 +231,14 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
   }
 
   public updateCredentialLocaleBranding = async (args: IUpdateCredentialLocaleBrandingArgs): Promise<ICredentialLocaleBranding> => {
+    const { localeBranding } = args
     const repository: Repository<CredentialLocaleBrandingEntity> = (await this.dbConnection).getRepository(CredentialLocaleBrandingEntity)
     const result: CredentialLocaleBrandingEntity | null = await repository.findOne({
-      where: { id: args.localeBranding.id },
+      where: { id: localeBranding.id },
     })
 
     if (!result) {
-      return Promise.reject(Error(`No credential locale branding found for id: ${args.localeBranding.id}`))
+      return Promise.reject(Error(`No credential locale branding found for id: ${localeBranding.id}`))
     }
 
     const locales: Array<CredentialLocaleBrandingEntity> | null = await repository.find({
@@ -238,32 +246,33 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
         credentialBranding: {
           id: result.credentialBrandingId,
         },
-        id: Not(In([args.localeBranding.id])),
-        locale: args.localeBranding.locale,
+        id: Not(In([localeBranding.id])),
+        locale: localeBranding.locale,
       },
     })
 
     if (locales && locales.length > 0) {
-      return Promise.reject(Error(`Credential branding: ${result.credentialBrandingId} already contains locale: ${args.localeBranding.locale}`))
+      return Promise.reject(Error(`Credential branding: ${result.credentialBrandingId} already contains locale: ${localeBranding.locale}`))
     }
 
-    debug('Updating credential locale branding', args.localeBranding)
-    const updatedResult: CredentialLocaleBrandingEntity = await repository.save(args.localeBranding, { transaction: true })
+    debug('Updating credential locale branding', localeBranding)
+    const updatedResult: CredentialLocaleBrandingEntity = await repository.save(localeBranding, { transaction: true })
 
     return this.localeBrandingFrom(updatedResult) as ICredentialLocaleBranding
   }
 
   public addIssuerBranding = async (args: IAddIssuerBrandingArgs): Promise<IIssuerBranding> => {
+    const { localeBranding, issuerCorrelationId } = args
     const repository: Repository<IssuerBrandingEntity> = (await this.dbConnection).getRepository(IssuerBrandingEntity)
     const result: IssuerBrandingEntity | null = await repository.findOne({
-      where: [{ issuerCorrelationId: args.issuerCorrelationId }],
+      where: [{ issuerCorrelationId }],
     })
 
     if (result) {
-      return Promise.reject(Error(`Issuer branding already present for issuer with correlation id: ${args.issuerCorrelationId}`))
+      return Promise.reject(Error(`Issuer branding already present for issuer with correlation id: ${issuerCorrelationId}`))
     }
 
-    if (await this.hasDuplicateLocales(args.localeBranding)) {
+    if (await this.hasDuplicateLocales(localeBranding)) {
       return Promise.reject(Error(`Issuer branding contains duplicate locales`))
     }
 
@@ -275,8 +284,9 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
   }
 
   public getIssuerBranding = async (args?: IGetIssuerBrandingArgs): Promise<Array<IIssuerBranding>> => {
-    if (args?.filter) {
-      args?.filter.forEach((filter: IIssuerBrandingFilter): void => {
+    const { filter } = args ?? {}
+    if (filter) {
+      filter.forEach((filter: IIssuerBrandingFilter): void => {
         if (filter.localeBranding && 'locale' in filter.localeBranding && filter.localeBranding.locale === undefined) {
           filter.localeBranding.locale = ''
         }
@@ -285,16 +295,17 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
 
     debug('Getting issuer branding', args)
     const result: Array<IssuerBrandingEntity> = await (await this.dbConnection).getRepository(IssuerBrandingEntity).find({
-      ...(args?.filter && { where: args?.filter }),
+      ...(filter && { where: filter }),
     })
 
     return result.map((issuerBranding: IssuerBrandingEntity) => this.issuerBrandingFrom(issuerBranding))
   }
 
   public removeIssuerBranding = async (args: IRemoveIssuerBrandingArgs): Promise<void> => {
+    const { filter } = args
     const repository: Repository<IssuerBrandingEntity> = (await this.dbConnection).getRepository(IssuerBrandingEntity)
     const issuerBranding: Array<IssuerBrandingEntity> = await repository.find({
-      where: args.filter,
+      where: filter,
     })
 
     debug('Removing issuer locale branding', args)
@@ -306,49 +317,51 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
     await Promise.all(localeBrandingDeletions)
 
     debug('Removing issuer branding', args)
-    const issuerBrandingDeletions: Array<Promise<DeleteResult>> = args.filter.map(
+    const issuerBrandingDeletions: Array<Promise<DeleteResult>> = filter.map(
       async (filter: IIssuerBrandingFilter): Promise<DeleteResult> => await repository.delete(filter)
     )
     await Promise.all(issuerBrandingDeletions)
   }
 
   public updateIssuerBranding = async (args: IUpdateIssuerBrandingArgs): Promise<IIssuerBranding> => {
+    const { issuerBranding } = args
     const repository: Repository<IssuerBrandingEntity> = (await this.dbConnection).getRepository(IssuerBrandingEntity)
     const issuerBrandingEntity: IssuerBrandingEntity | null = await repository.findOne({
-      where: { id: args.issuerBranding.id },
+      where: { id: issuerBranding.id },
     })
 
     if (!issuerBrandingEntity) {
-      return Promise.reject(Error(`No issuer branding found for id: ${args.issuerBranding.id}`))
+      return Promise.reject(Error(`No issuer branding found for id: ${issuerBranding.id}`))
     }
 
-    const issuerBranding: Omit<IIssuerBranding, 'createdAt' | 'lastUpdatedAt'> = {
-      ...args.issuerBranding,
+    const branding: Omit<IIssuerBranding, 'createdAt' | 'lastUpdatedAt'> = {
+      ...issuerBranding,
       localeBranding: issuerBrandingEntity.localeBranding,
     }
 
-    debug('Updating issuer branding', issuerBranding)
-    const result: IssuerBrandingEntity = await repository.save(issuerBranding, { transaction: true })
+    debug('Updating issuer branding', branding)
+    const result: IssuerBrandingEntity = await repository.save(branding, { transaction: true })
 
     return this.issuerBrandingFrom(result)
   }
 
   public addIssuerLocaleBranding = async (args: IAddIssuerLocaleBrandingArgs): Promise<IIssuerBranding> => {
+    const { localeBranding, issuerBrandingId } = args
     const issuerBrandingRepository: Repository<IssuerBrandingEntity> = (await this.dbConnection).getRepository(IssuerBrandingEntity)
     const issuerBranding: IssuerBrandingEntity | null = await issuerBrandingRepository.findOne({
-      where: { id: args.issuerBrandingId },
+      where: { id: issuerBrandingId },
     })
 
     if (!issuerBranding) {
-      return Promise.reject(Error(`No issuer branding found for id: ${args.issuerBrandingId}`))
+      return Promise.reject(Error(`No issuer branding found for id: ${issuerBrandingId}`))
     }
 
     const locales: Array<IssuerLocaleBrandingEntity> | null = await (await this.dbConnection).getRepository(IssuerLocaleBrandingEntity).find({
       where: {
         issuerBranding: {
-          id: args.issuerBrandingId,
+          id: issuerBrandingId,
         },
-        locale: In(args.localeBranding.map((localeBranding: IBasicIssuerLocaleBranding) => localeBranding.locale)),
+        locale: In(localeBranding.map((localeBranding: IBasicIssuerLocaleBranding) => localeBranding.locale)),
       },
     })
 
@@ -363,19 +376,17 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
     }
 
     const issuerLocaleBrandingRepository: Repository<IssuerLocaleBrandingEntity> = (await this.dbConnection).getRepository(IssuerLocaleBrandingEntity)
-    const addIssuerLocaleBranding: Array<Promise<void>> = args.localeBranding.map(
-      async (localeBranding: IBasicIssuerLocaleBranding): Promise<void> => {
-        const issuerLocaleBrandingEntity: IssuerLocaleBrandingEntity = issuerLocaleBrandingEntityFrom(localeBranding)
-        debug('Adding issuer locale branding', issuerLocaleBrandingEntity)
-        issuerLocaleBrandingEntity.issuerBranding = issuerBranding
-        await issuerLocaleBrandingRepository.save(issuerLocaleBrandingEntity, { transaction: true })
-      }
-    )
+    const addIssuerLocaleBranding: Array<Promise<void>> = localeBranding.map(async (localeBranding: IBasicIssuerLocaleBranding): Promise<void> => {
+      const issuerLocaleBrandingEntity: IssuerLocaleBrandingEntity = issuerLocaleBrandingEntityFrom(localeBranding)
+      debug('Adding issuer locale branding', issuerLocaleBrandingEntity)
+      issuerLocaleBrandingEntity.issuerBranding = issuerBranding
+      await issuerLocaleBrandingRepository.save(issuerLocaleBrandingEntity, { transaction: true })
+    })
 
     await Promise.all(addIssuerLocaleBranding)
 
     const result: IssuerBrandingEntity | null = await issuerBrandingRepository.findOne({
-      where: { id: args.issuerBrandingId },
+      where: { id: issuerBrandingId },
     })
 
     if (!result) {
@@ -386,8 +397,9 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
   }
 
   public getIssuerLocaleBranding = async (args?: IGetIssuerLocaleBrandingArgs): Promise<Array<IIssuerLocaleBranding>> => {
-    if (args?.filter) {
-      args?.filter.forEach((filter: IIssuerLocaleBrandingFilter): void => {
+    const { filter } = args ?? {}
+    if (filter) {
+      filter.forEach((filter: IIssuerLocaleBrandingFilter): void => {
         if ('locale' in filter && filter.locale === undefined) {
           filter.locale = ''
         }
@@ -398,7 +410,7 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
     const issuerLocaleBranding: Array<IssuerLocaleBrandingEntity> | null = await (await this.dbConnection)
       .getRepository(IssuerLocaleBrandingEntity)
       .find({
-        ...(args?.filter && { where: args?.filter }),
+        ...(filter && { where: filter }),
       })
 
     return issuerLocaleBranding
@@ -409,8 +421,9 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
   }
 
   public removeIssuerLocaleBranding = async (args: IRemoveIssuerLocaleBrandingArgs): Promise<void> => {
+    const { filter } = args
     const issuerLocaleBranding: Array<IssuerLocaleBrandingEntity> = await (await this.dbConnection).getRepository(IssuerLocaleBrandingEntity).find({
-      where: args.filter,
+      where: filter,
     })
 
     debug('Removing credential locale branding', args)
@@ -421,13 +434,14 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
   }
 
   public updateIssuerLocaleBranding = async (args: IUpdateIssuerLocaleBrandingArgs): Promise<IIssuerLocaleBranding> => {
+    const { localeBranding } = args
     const repository: Repository<IssuerLocaleBrandingEntity> = (await this.dbConnection).getRepository(IssuerLocaleBrandingEntity)
     const result: IssuerLocaleBrandingEntity | null = await repository.findOne({
-      where: { id: args.localeBranding.id },
+      where: { id: localeBranding.id },
     })
 
     if (!result) {
-      return Promise.reject(Error(`No issuer locale branding found for id: ${args.localeBranding.id}`))
+      return Promise.reject(Error(`No issuer locale branding found for id: ${localeBranding.id}`))
     }
 
     const locales: Array<IssuerLocaleBrandingEntity> | null = await repository.find({
@@ -435,17 +449,17 @@ export class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
         issuerBranding: {
           id: result.issuerBrandingId,
         },
-        id: Not(In([args.localeBranding.id])),
-        locale: args.localeBranding.locale,
+        id: Not(In([localeBranding.id])),
+        locale: localeBranding.locale,
       },
     })
 
     if (locales && locales.length > 0) {
-      return Promise.reject(Error(`Issuer branding: ${result.issuerBrandingId} already contains locale: ${args.localeBranding.locale}`))
+      return Promise.reject(Error(`Issuer branding: ${result.issuerBrandingId} already contains locale: ${localeBranding.locale}`))
     }
 
-    debug('Updating issuer locale branding', args.localeBranding)
-    const updatedResult: IssuerLocaleBrandingEntity = await repository.save(args.localeBranding, { transaction: true })
+    debug('Updating issuer locale branding', localeBranding)
+    const updatedResult: IssuerLocaleBrandingEntity = await repository.save(localeBranding, { transaction: true })
 
     return this.localeBrandingFrom(updatedResult) as IIssuerLocaleBranding
   }

package/src/migrations/sqlite/1690925872693-CreateContacts.ts

@@ -60,9 +60,6 @@ export class CreateContacts1690925872693 implements MigrationInterface {
       `CREATE TABLE "PartyRelationship" ("id" varchar PRIMARY KEY NOT NULL, "left_id" varchar NOT NULL, "right_id" varchar NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')))`
     )
     await queryRunner.query(`CREATE UNIQUE INDEX "IDX_PartyRelationship_left_right" ON "PartyRelationship" ("left_id", "right_id")`)
-    await queryRunner.query(
-      `CREATE TABLE "ElectronicAddress" ("id" varchar PRIMARY KEY NOT NULL, "type" varchar(255) NOT NULL, "electronic_address" varchar(255) NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "partyId" varchar)`
-    )
     await queryRunner.query(
       `CREATE TABLE "Party" ("id" varchar PRIMARY KEY NOT NULL, "uri" varchar(255) NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "party_type_id" varchar NOT NULL)`
     )
@@ -99,15 +96,13 @@ export class CreateContacts1690925872693 implements MigrationInterface {
     await queryRunner.query(`ALTER TABLE "temporary_PartyRelationship" RENAME TO "PartyRelationship"`)
     await queryRunner.query(`CREATE UNIQUE INDEX "IDX_PartyRelationship_left_right" ON "PartyRelationship" ("left_id", "right_id")`)
     await queryRunner.query(
-      `CREATE TABLE "temporary_ElectronicAddress" ("id" varchar PRIMARY KEY NOT NULL, "type" varchar(255) NOT NULL, "electronic_address" varchar(255) NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "partyId" varchar, CONSTRAINT "FK_ElectronicAddress_partyId" FOREIGN KEY ("partyId") REFERENCES "Party" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`
+      `CREATE TABLE "ElectronicAddress" ("id" varchar PRIMARY KEY NOT NULL, "type" varchar(255) NOT NULL, "electronic_address" varchar(255) NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "partyId" varchar, CONSTRAINT "FK_ElectronicAddress_partyId" FOREIGN KEY ("partyId") REFERENCES "Party" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`
     )
     await queryRunner.query(
-      `INSERT INTO "temporary_ElectronicAddress"("id", "type", "electronic_address", "created_at", "last_updated_at", "partyId") SELECT "id", "type", "electronic_address", "created_at", "last_updated_at", "partyId" FROM "ElectronicAddress"`
+      `CREATE TABLE "PhysicalAddress" ("id" varchar PRIMARY KEY NOT NULL, "type" varchar(255) NOT NULL, "street_name" varchar(255) NOT NULL, "street_number" varchar(255) NOT NULL, "postal_code" varchar(255) NOT NULL, "city_name" varchar(255) NOT NULL, "province_name" varchar(255) NOT NULL, "country_code" varchar(2) NOT NULL, "building_name" varchar(255), "partyId" varchar, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), CONSTRAINT "FK_PhysicalAddressEntity_partyId" FOREIGN KEY ("partyId") REFERENCES "Party" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`
     )
-    await queryRunner.query(`DROP TABLE "ElectronicAddress"`)
-    await queryRunner.query(`ALTER TABLE "temporary_ElectronicAddress" RENAME TO "ElectronicAddress"`)
     await queryRunner.query(
-      `CREATE TABLE "temporary_Party" ("id" varchar PRIMARY KEY NOT NULL, "uri" varchar(255) NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "party_type_id" varchar NOT NULL, CONSTRAINT "FK_Party_party_type_id" FOREIGN KEY ("party_type_id") REFERENCES "PartyType" ("id") ON DELETE NO ACTION ON UPDATE NO ACTION)`
+      `CREATE TABLE "temporary_Party" ("id" varchar PRIMARY KEY NOT NULL, "uri" varchar(255), "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')), "party_type_id" varchar NOT NULL, CONSTRAINT "FK_Party_party_type_id" FOREIGN KEY ("party_type_id") REFERENCES "PartyType" ("id") ON DELETE NO ACTION ON UPDATE NO ACTION)`
     )
     await queryRunner.query(
       `INSERT INTO "temporary_Party"("id", "uri", "created_at", "last_updated_at", "party_type_id") SELECT "id", "uri", "created_at", "last_updated_at", "party_type_id" FROM "Party"`

package/src/types/contact/IAbstractContactStore.ts

@@ -1,23 +1,30 @@
 import {
-  NonPersistedPartyType,
+  ElectronicAddress,
+  Identity,
   NonPersistedContact,
+  NonPersistedElectronicAddress,
   NonPersistedIdentity,
-  Party,
-  Identity,
-  PartialParty,
+  NonPersistedPartyType,
+  NonPersistedPhysicalAddress,
+  PartialElectronicAddress,
   PartialIdentity,
-  PartyTypeEnum,
-  PartyType,
-  PartyRelationship,
+  PartialParty,
   PartialPartyRelationship,
   PartialPartyType,
-  NonPersistedElectronicAddress,
+  PartialPhysicalAddress,
+  Party,
+  PartyRelationship,
+  PartyType,
+  PartyTypeEnum,
+  PhysicalAddress,
 } from './contact'
 
 export type FindPartyArgs = Array<PartialParty>
 export type FindIdentityArgs = Array<PartialIdentity>
 export type FindPartyTypeArgs = Array<PartialPartyType>
 export type FindRelationshipArgs = Array<PartialPartyRelationship>
+export type FindElectronicAddressArgs = Array<PartialElectronicAddress>
+export type FindPhysicalAddressArgs = Array<PartialPhysicalAddress>
 
 export type GetPartyArgs = {
   partyId: string
@@ -33,6 +40,7 @@ export type AddPartyArgs = {
   contact: NonPersistedContact
   identities?: Array<NonPersistedIdentity>
   electronicAddresses?: Array<NonPersistedElectronicAddress>
+  physicalAddresses?: Array<NonPersistedPhysicalAddress>
 }
 
 export type UpdatePartyArgs = {
@@ -107,3 +115,45 @@ export type UpdatePartyTypeArgs = {
 export type RemovePartyTypeArgs = {
   partyTypeId: string
 }
+
+export type GetElectronicAddressArgs = {
+  electronicAddressId: string
+}
+
+export type GetElectronicAddressesArgs = {
+  filter?: FindElectronicAddressArgs
+}
+
+export type AddElectronicAddressArgs = {
+  partyId: string
+  electronicAddress: NonPersistedElectronicAddress
+}
+
+export type UpdateElectronicAddressArgs = {
+  electronicAddress: ElectronicAddress
+}
+
+export type RemoveElectronicAddressArgs = {
+  electronicAddressId: string
+}
+
+export type GetPhysicalAddressArgs = {
+  physicalAddressId: string
+}
+
+export type GetPhysicalAddressesArgs = {
+  filter?: FindPhysicalAddressArgs
+}
+
+export type AddPhysicalAddressArgs = {
+  partyId: string
+  physicalAddress: NonPersistedPhysicalAddress
+}
+
+export type UpdatePhysicalAddressArgs = {
+  physicalAddress: PhysicalAddress
+}
+
+export type RemovePhysicalAddressArgs = {
+  physicalAddressId: string
+}