feat(auth-api-lib): Use db to look up delegation types and providers when validating

apps/services/auth/delegation-api/src/app/delegations/test/delegation-index/delegation-index.controller.spec.ts

@@ -7,7 +7,11 @@ import {
   createNationalId,
 } from '@island.is/testing/fixtures'
 import { AuthScope } from '@island.is/auth/scopes'
-import { DelegationIndex } from '@island.is/auth-api-lib'
+import {
+  DelegationIndex,
+  DelegationProviderModel,
+  DelegationTypeModel,
+} from '@island.is/auth-api-lib'
 import {
   AuthDelegationProvider,
   AuthDelegationType,
@@ -70,7 +74,29 @@ const invalidDelegationTypeAndProviderMapTestcases: Record<
   ],
 }
 
+const DELEGATION_PROVIDERS = [
+  {
+    provider: AuthDelegationProvider.NationalRegistry,
+    type: AuthDelegationType.LegalGuardian,
+  },
+  {
+    provider: AuthDelegationProvider.Custom,
+    type: AuthDelegationType.Custom,
+  },
+  {
+    provider: AuthDelegationProvider.PersonalRepresentativeRegistry,
+    type: AuthDelegationType.PersonalRepresentativePostbox,
+  },
+  {
+    provider: AuthDelegationProvider.CompanyRegistry,
+    type: AuthDelegationType.ProcurationHolder,
+  },
+]
+
 describe('DelegationIndexController', () => {
+  let delegationTypeModel: typeof DelegationTypeModel
+  let delegationProviderModel: typeof DelegationProviderModel
+
   describe('Without valid scope', () => {
     let app: TestApp
     let server: request.SuperTest<request.Test>
@@ -85,6 +111,8 @@ describe('DelegationIndexController', () => {
       })
 
       server = request(app.getHttpServer())
+      ;({ delegationProviderModel, delegationTypeModel } =
+        await setupDelegationModels(app))
     })
 
     afterAll(async () => {
@@ -143,6 +171,8 @@ describe('DelegationIndexController', () => {
           })
 
           server = request(app.getHttpServer())
+          ;({ delegationProviderModel, delegationTypeModel } =
+            await setupDelegationModels(app))
         })
 
         afterAll(async () => {
@@ -207,6 +237,8 @@ describe('DelegationIndexController', () => {
       })
 
       server = request(app.getHttpServer())
+      ;({ delegationProviderModel, delegationTypeModel } =
+        await setupDelegationModels(app))
     })
 
     afterAll(async () => {
@@ -265,6 +297,8 @@ describe('DelegationIndexController', () => {
       server = request(app.getHttpServer())
 
       delegationIndexModel = app.get(getModelToken(DelegationIndex))
+      ;({ delegationProviderModel, delegationTypeModel } =
+        await setupDelegationModels(app))
     })
 
     afterAll(async () => {
@@ -414,3 +448,43 @@ describe('DelegationIndexController', () => {
     })
   })
 })
+
+async function setupDelegationModels(app: TestApp) {
+  const delegationProviderModel = app.get(
+    getModelToken(DelegationProviderModel),
+  )
+  const delegationTypeModel = app.get(getModelToken(DelegationTypeModel))
+
+  await createDelegationProvidersAndTypes(
+    delegationProviderModel,
+    delegationTypeModel,
+  )
+
+  return { delegationProviderModel, delegationTypeModel }
+}
+
+async function createDelegationProvidersAndTypes(
+  delegationProviderModel: typeof DelegationProviderModel,
+  delegationTypeModel: typeof DelegationTypeModel,
+) {
+  for (const { provider, type } of DELEGATION_PROVIDERS) {
+    const [providerInstance] = await delegationProviderModel.findOrCreate({
+      where: { id: provider },
+      defaults: {
+        id: provider,
+        name: type,
+        description: 'Testing',
+      },
+    })
+
+    await delegationTypeModel.findOrCreate({
+      where: { id: type },
+      defaults: {
+        id: type,
+        name: type,
+        description: 'Testing',
+        providerId: providerInstance.id,
+      },
+    })
+  }
+}

libs/auth-api-lib/src/lib/delegations/delegations-index.service.ts

@@ -28,14 +28,14 @@ import {
 import { DelegationDTO } from './dto/delegation.dto'
 import { DelegationIndexMeta } from './models/delegation-index-meta.model'
 import { DelegationIndex } from './models/delegation-index.model'
+import { DelegationTypeModel } from './models/delegation-type.model'
 import { DelegationDirection } from './types/delegationDirection'
 import {
   DelegationRecordType,
   PersonalRepresentativeDelegationType,
 } from './types/delegationRecord'
 import {
   delegationProviderTypeMap,
-  validateDelegationTypeAndProvider,
   validateToAndFromNationalId,
 } from './utils/delegations'
 
@@ -90,25 +90,6 @@ const getTimeUntilEighteen = (nationalId: string) => {
   return timeUntilEighteen > 0 ? new Date(timeUntilEighteen) : null
 }
 
-const validateCrudParams = (delegation: DelegationRecordInputDTO) => {
-  if (!validateDelegationTypeAndProvider(delegation)) {
-    throw new BadRequestException(
-      'Invalid delegation type and provider combination',
-    )
-  }
-
-  if (!validateToAndFromNationalId(delegation)) {
-    throw new BadRequestException('Invalid national ids')
-  }
-
-  if (
-    delegation.validTo &&
-    new Date(delegation.validTo).getTime() <= new Date().getTime()
-  ) {
-    throw new BadRequestException('Invalid validTo')
-  }
-}
-
 const hasAllSameScopes = (
   a: string[] | undefined,
   b: string[] | undefined,
@@ -151,6 +132,8 @@ export class DelegationsIndexService {
     private apiScopeModel: typeof ApiScope,
     @InjectModel(DelegationIndex)
     private delegationIndexModel: typeof DelegationIndex,
+    @InjectModel(DelegationTypeModel)
+    private delegationTypeModel: typeof DelegationTypeModel,
     @InjectModel(DelegationIndexMeta)
     private delegationIndexMetaModel: typeof DelegationIndexMeta,
     private delegationsIncomingCustomService: DelegationsIncomingCustomService,
@@ -280,7 +263,7 @@ export class DelegationsIndexService {
 
   /* Add item to index */
   async createOrUpdateDelegationRecord(delegation: DelegationRecordInputDTO) {
-    validateCrudParams(delegation)
+    await this.validateCrudParams(delegation)
 
     const [updatedDelegation] = await this.delegationIndexModel.upsert(
       delegation,
@@ -291,7 +274,7 @@ export class DelegationsIndexService {
 
   /* Delete record from index */
   async removeDelegationRecord(delegation: DelegationRecordInputDTO) {
-    validateCrudParams(delegation)
+    await this.validateCrudParams(delegation)
 
     await this.delegationIndexModel.destroy({
       where: {
@@ -659,4 +642,43 @@ export class DelegationsIndexService {
       })
       .then((d) => d.map((d) => d.toDTO()))
   }
+
+  private async validateDelegationTypeAndProvider(
+    delegation: DelegationRecordInputDTO,
+  ) {
+    const { type, provider } = delegation
+
+    const validTypes = await this.delegationTypeModel
+      .findAll({
+        where: {
+          provider,
+        },
+      })
+      .then((d) => d.map((d) => d.name))
+
+    return validTypes.includes(type)
+  }
+
+  private async validateCrudParams(delegation: DelegationRecordInputDTO) {
+    const isValidDelegationType = await this.validateDelegationTypeAndProvider(
+      delegation,
+    )
+
+    if (!isValidDelegationType) {
+      throw new BadRequestException(
+        'Invalid delegation type and provider combination',
+      )
+    }
+
+    if (!validateToAndFromNationalId(delegation)) {
+      throw new BadRequestException('Invalid national ids')
+    }
+
+    if (
+      delegation.validTo &&
+      new Date(delegation.validTo).getTime() <= new Date().getTime()
+    ) {
+      throw new BadRequestException('Invalid validTo')
+    }
+  }
 }

libs/auth-api-lib/src/lib/delegations/utils/delegations.ts

@@ -37,22 +37,6 @@ export const getDelegationNoActorWhereClause = (user: User): WhereOptions => {
   return {}
 }
 
-export const validateDelegationTypeAndProvider = ({
-  type,
-  provider,
-}: {
-  type: DelegationRecordType
-  provider: AuthDelegationProvider
-}) => {
-  const validTypes = delegationProviderTypeMap[provider]
-
-  if (!validTypes) {
-    return false
-  }
-
-  return validTypes.includes(type)
-}
-
 export const validateToAndFromNationalId = ({
   fromNationalId,
   toNationalId,

libs/shared/types/src/lib/delegation.ts

@@ -3,6 +3,7 @@ export enum AuthDelegationType {
   LegalGuardian = 'LegalGuardian',
   Custom = 'Custom',
   PersonalRepresentative = 'PersonalRepresentative',
+  PersonalRepresentativePostbox = 'PersonalRepresentative:postholf',
   LegalRepresentative = 'LegalRepresentative',
   GeneralMandate = 'GeneralMandate',
 }