MR-3186: migrate indexhpp resolver

services/app-api/src/domain-models/healthPlanPackage.ts

@@ -72,8 +72,6 @@ function packageSubmitters(pkg: HealthPlanPackageType): string[] {
 function convertContractToUnlockedHealthPlanPackage(
     contract: ContractType
 ): HealthPlanPackageType | Error {
-    console.info('Attempting to convert contract to health plan package')
-
     // Since drafts come in separate on the Contract type, we push it onto the revisions before converting below
     if (contract.draftRevision) {
         contract.revisions.unshift(contract.draftRevision)

services/app-api/src/postgres/contractAndRates/findAllContractsWithHistoryByState.ts

@@ -0,0 +1,49 @@
+import type { PrismaTransactionType } from '../prismaTypes'
+import type { ContractType } from '../../domain-models/contractAndRates'
+import { NotFoundError } from '../storeError'
+import { parseContractWithHistory } from './parseContractWithHistory'
+import { includeFullContract } from './prismaSubmittedContractHelpers'
+
+type ContractOrErrorType = {
+    contractID: string
+    contract: ContractType | Error
+}
+
+type ContractOrErrorArrayType = ContractOrErrorType[]
+
+async function findAllContractsWithHistoryByState(
+    client: PrismaTransactionType,
+    stateCode: string
+): Promise<ContractOrErrorArrayType | NotFoundError | Error> {
+    try {
+        const contracts = await client.contractTable.findMany({
+            where: {
+                stateCode: {
+                    equals: stateCode,
+                },
+            },
+            include: includeFullContract,
+        })
+
+        if (!contracts) {
+            const err = `PRISMA ERROR: Cannot find contracts with state code: ${stateCode}`
+            console.error(err)
+            return new NotFoundError(err)
+        }
+
+        const parsedContractsOrErrors: ContractOrErrorArrayType = contracts.map(
+            (contract) => ({
+                contractID: contract.id,
+                contract: parseContractWithHistory(contract),
+            })
+        )
+
+        return parsedContractsOrErrors
+    } catch (err) {
+        console.error('PRISMA ERROR', err)
+        return err
+    }
+}
+
+export { findAllContractsWithHistoryByState }
+export type { ContractOrErrorArrayType }

services/app-api/src/postgres/contractAndRates/findAllContractsWithHistoryBySubmitInfo.test.ts

@@ -0,0 +1,128 @@
+import { findAllContractsWithHistoryBySubmitInfo } from './findAllContractsWithHistoryBySubmitInfo'
+import { sharedTestPrismaClient } from '../../testHelpers/storeHelpers'
+import { createInsertContractData, must } from '../../testHelpers'
+import { v4 as uuidv4 } from 'uuid'
+import { insertDraftContract } from './insertContract'
+import { submitContract } from './submitContract'
+import { unlockContract } from './unlockContract'
+
+describe('findAllContractsWithHistoryBySubmittedInfo', () => {
+    it('returns only contracts that have been submitted or unlocked', async () => {
+        const client = await sharedTestPrismaClient()
+        const stateUser = await client.user.create({
+            data: {
+                id: uuidv4(),
+                givenName: 'Aang',
+                familyName: 'Avatar',
+                email: 'aang@example.com',
+                role: 'STATE_USER',
+                stateCode: 'NM',
+            },
+        })
+
+        const cmsUser = await client.user.create({
+            data: {
+                id: uuidv4(),
+                givenName: 'Zuko',
+                familyName: 'Hotman',
+                email: 'zuko@example.com',
+                role: 'CMS_USER',
+            },
+        })
+
+        const draftContractData = createInsertContractData({
+            submissionDescription: 'one contract',
+        })
+
+        // make two submitted contracts and submit them
+        const contractOne = must(
+            await insertDraftContract(client, draftContractData)
+        )
+        const contractTwo = must(
+            await insertDraftContract(client, draftContractData)
+        )
+        const submittedContractOne = must(
+            await submitContract(
+                client,
+                contractOne.id,
+                stateUser.id,
+                'contractOne submit'
+            )
+        )
+        const submittedContractTwo = must(
+            await submitContract(
+                client,
+                contractTwo.id,
+                stateUser.id,
+                'contractTwo submit'
+            )
+        )
+
+        // make two draft contracts
+        const draftContractOne = must(
+            await insertDraftContract(client, draftContractData)
+        )
+        const draftContractTwo = must(
+            await insertDraftContract(client, draftContractData)
+        )
+
+        // make one unlocked contract
+        const contractThree = must(
+            await insertDraftContract(client, draftContractData)
+        )
+        must(
+            await submitContract(
+                client,
+                contractThree.id,
+                stateUser.id,
+                'unlockContractOne submit'
+            )
+        )
+        const unlockedContract = must(
+            await unlockContract(
+                client,
+                contractThree.id,
+                cmsUser.id,
+                'unlock unlockContractOne'
+            )
+        )
+
+        // call the find by submit info function
+        const contracts = must(
+            await findAllContractsWithHistoryBySubmitInfo(client)
+        )
+
+        // expect our two submitted contracts
+        expect(contracts).toEqual(
+            expect.arrayContaining([
+                expect.objectContaining({
+                    contractID: submittedContractOne.id,
+                }),
+                expect.objectContaining({
+                    contractID: submittedContractTwo.id,
+                }),
+            ])
+        )
+
+        // expect our one unlocked contract
+        expect(contracts).toEqual(
+            expect.arrayContaining([
+                expect.objectContaining({
+                    contractID: unlockedContract.id,
+                }),
+            ])
+        )
+
+        // expect our two draft contracts to not be in the results
+        expect(contracts).not.toEqual(
+            expect.arrayContaining([
+                expect.objectContaining({
+                    contractID: draftContractOne.id,
+                }),
+                expect.objectContaining({
+                    contractID: draftContractTwo.id,
+                }),
+            ])
+        )
+    })
+})

services/app-api/src/postgres/contractAndRates/findAllContractsWithHistoryBySubmitInfo.ts

@@ -0,0 +1,47 @@
+import type { PrismaTransactionType } from '../prismaTypes'
+import { NotFoundError } from '../storeError'
+import { parseContractWithHistory } from './parseContractWithHistory'
+import { includeFullContract } from './prismaSubmittedContractHelpers'
+import type { ContractOrErrorArrayType } from './findAllContractsWithHistoryByState'
+
+async function findAllContractsWithHistoryBySubmitInfo(
+    client: PrismaTransactionType
+): Promise<ContractOrErrorArrayType | NotFoundError | Error> {
+    try {
+        const contracts = await client.contractTable.findMany({
+            where: {
+                revisions: {
+                    some: {
+                        submitInfo: {
+                            isNot: null,
+                        },
+                    },
+                },
+                stateCode: {
+                    not: 'AS', // exclude test state as per ADR 019
+                },
+            },
+            include: includeFullContract,
+        })
+
+        if (!contracts) {
+            const err = `PRISMA ERROR: Cannot find all contracts by submit info`
+            console.error(err)
+            return new NotFoundError(err)
+        }
+
+        const parsedContracts: ContractOrErrorArrayType = contracts.map(
+            (contract) => ({
+                contractID: contract.id,
+                contract: parseContractWithHistory(contract),
+            })
+        )
+
+        return parsedContracts
+    } catch (err) {
+        console.error('PRISMA ERROR', err)
+        return err
+    }
+}
+
+export { findAllContractsWithHistoryBySubmitInfo }

services/app-api/src/postgres/contractAndRates/findRateWithHistory.test.ts

@@ -459,7 +459,7 @@ describe('findRate', () => {
                     submissionType: 'CONTRACT_AND_RATES',
                     submissionDescription: 'a.1 body',
                     contractType: 'BASE',
-                    programIDs: ['PMAP'],
+                    programIDs: draftContractData.programIDs,
                     populationCovered: 'MEDICAID',
                     riskBasedContract: false,
                 },
@@ -491,7 +491,7 @@ describe('findRate', () => {
                     submissionType: 'CONTRACT_AND_RATES',
                     submissionDescription: 'a.2 body',
                     contractType: 'BASE',
-                    programIDs: ['PMAP'],
+                    programIDs: draftContractData.programIDs,
                     populationCovered: 'MEDICAID',
                     riskBasedContract: false,
                 },
@@ -532,7 +532,7 @@ describe('findRate', () => {
                 submissionType: 'CONTRACT_AND_RATES',
                 submissionDescription: 'one contract',
                 contractType: 'BASE',
-                programIDs: ['PMAP'],
+                programIDs: draftContractData.programIDs,
                 populationCovered: 'MEDICAID',
                 riskBasedContract: false,
             })
@@ -549,7 +549,7 @@ describe('findRate', () => {
                 submissionType: 'CONTRACT_AND_RATES',
                 submissionDescription: 'one contract',
                 contractType: 'BASE',
-                programIDs: ['PMAP'],
+                programIDs: draftContractData.programIDs,
                 populationCovered: 'MEDICAID',
                 riskBasedContract: false,
             })
@@ -567,7 +567,7 @@ describe('findRate', () => {
                 submissionType: 'CONTRACT_AND_RATES',
                 submissionDescription: 'a.1 body',
                 contractType: 'BASE',
-                programIDs: ['PMAP'],
+                programIDs: draftContractData.programIDs,
                 populationCovered: 'MEDICAID',
                 riskBasedContract: false,
             })

services/app-api/src/postgres/contractAndRates/index.ts

@@ -1,5 +1,8 @@
 export type { InsertContractArgsType } from './insertContract'
 export type { UpdateContractArgsType } from './updateDraftContract'
+export type { ContractOrErrorArrayType } from './findAllContractsWithHistoryByState'
 export { insertDraftContract } from './insertContract'
 export { findContractWithHistory } from './findContractWithHistory'
 export { updateDraftContract } from './updateDraftContract'
+export { findAllContractsWithHistoryByState } from './findAllContractsWithHistoryByState'
+export { findAllContractsWithHistoryBySubmitInfo } from './findAllContractsWithHistoryBySubmitInfo'

services/app-api/src/postgres/contractAndRates/insertContract.test.ts

@@ -40,7 +40,7 @@ describe('insertContract', () => {
                         submissionType: 'CONTRACT_AND_RATES',
                         submissionDescription: 'Contract 1.0',
                         contractType: 'BASE',
-                        programIDs: ['PMAP'],
+                        programIDs: draftContractData.programIDs,
                         populationCovered: 'MEDICAID',
                         riskBasedContract: false,
                     }),
@@ -83,6 +83,7 @@ describe('insertContract', () => {
 
         const draftContractData = createInsertContractData({
             stateCode: 'CANADA' as StateCodeType,
+            programIDs: [],
         })
         const draftContract = await insertDraftContract(
             client,

services/app-api/src/postgres/contractAndRates/submitContract.test.ts

@@ -59,7 +59,7 @@ describe('submitContract', () => {
                     submissionType: 'CONTRACT_AND_RATES',
                     submissionDescription: 'one contract',
                     contractType: 'BASE',
-                    programIDs: ['PMAP'],
+                    programIDs: draftContractData.programIDs,
                     populationCovered: 'MEDICAID',
                     riskBasedContract: false,
                 }),
@@ -149,7 +149,7 @@ describe('submitContract', () => {
                             submissionType: 'CONTRACT_AND_RATES',
                             submissionDescription: 'second contract revision',
                             contractType: 'BASE',
-                            programIDs: ['PMAP'],
+                            programIDs: draftContractData.programIDs,
                             populationCovered: 'MEDICAID',
                             riskBasedContract: false,
                         },

services/app-api/src/postgres/postgresStore.ts

@@ -52,10 +52,13 @@ import {
     insertDraftContract,
     findContractWithHistory,
     updateDraftContract,
+    findAllContractsWithHistoryByState,
+    findAllContractsWithHistoryBySubmitInfo,
 } from './contractAndRates'
 import type {
     InsertContractArgsType,
     UpdateContractArgsType,
+    ContractOrErrorArrayType,
 } from './contractAndRates'
 
 type Store = {
@@ -145,6 +148,14 @@ type Store = {
     updateDraftContract: (
         args: UpdateContractArgsType
     ) => Promise<ContractType | Error>
+
+    findAllContractsWithHistoryByState: (
+        stateCode: string
+    ) => Promise<ContractOrErrorArrayType | Error>
+
+    findAllContractsWithHistoryBySubmitInfo: () => Promise<
+        ContractOrErrorArrayType | Error
+    >
 }
 
 function NewPostgresStore(client: PrismaClient): Store {
@@ -206,6 +217,10 @@ function NewPostgresStore(client: PrismaClient): Store {
         findContractWithHistory: (args) =>
             findContractWithHistory(client, args),
         updateDraftContract: (args) => updateDraftContract(client, args),
+        findAllContractsWithHistoryByState: (args) =>
+            findAllContractsWithHistoryByState(client, args),
+        findAllContractsWithHistoryBySubmitInfo: () =>
+            findAllContractsWithHistoryBySubmitInfo(client),
     }
 }
 

services/app-api/src/resolvers/configureResolvers.ts

@@ -42,7 +42,10 @@ export function configureResolvers(
                 store,
                 launchDarkly
             ),
-            indexHealthPlanPackages: indexHealthPlanPackagesResolver(store),
+            indexHealthPlanPackages: indexHealthPlanPackagesResolver(
+                store,
+                launchDarkly
+            ),
             indexUsers: indexUsersResolver(store),
             indexQuestions: indexQuestionsResolver(store),
             fetchEmailSettings: fetchEmailSettingsResolver(