@opencrvs/toolkit 2.0.0-rc.fc7f7fc → 2.0.0-rc.fef9d21

package/dist/cli.js

@@ -91,7 +91,7 @@ function processFile(filePath, project) {
       if (wasRemoved) {
         removedCount++;
         console.log(
-          `  [${import_path.default.relative(getCwd(), filePath)}] Removed 'review' from REGISTER action`
+          `  [${import_path.default.relative(process.cwd(), filePath)}] Removed 'review' from REGISTER action`
         );
       }
     }
@@ -99,7 +99,7 @@ function processFile(filePath, project) {
   return removedCount;
 }
 async function main() {
-  const srcDir = import_path.default.join(getCwd(), "src");
+  const srcDir = import_path.default.join(process.cwd(), "src");
   console.log(`Scanning for defineConfig calls in: ${srcDir}
 `);
   const project = new import_ts_morph.Project({
@@ -135,7 +135,7 @@ Saving ${modifiedFiles.length} modified file(s)...`);
   for (const filePath of modifiedFiles) {
     const sourceFile = project.getSourceFileOrThrow(filePath);
     await sourceFile.save();
-    console.log(`  Saved: ${import_path.default.relative(getCwd(), filePath)}`);
+    console.log(`  Saved: ${import_path.default.relative(process.cwd(), filePath)}`);
   }
   console.log(
     `
@@ -338,7 +338,7 @@ function processFile2(filePath, project) {
     const eventType = resolveEventType(configArg);
     if (!eventType) {
       console.warn(
-        `  [${import_path2.default.relative(getCwd(), configArg.getSourceFile().getFilePath())}] Could not resolve root 'type' from defineConfig \u2014 skipping auditHistoryLabel id generation`
+        `  [${import_path2.default.relative(process.cwd(), configArg.getSourceFile().getFilePath())}] Could not resolve root 'type' from defineConfig \u2014 skipping auditHistoryLabel id generation`
       );
     }
     let fileNeedsImports = false;
@@ -354,7 +354,7 @@ function processFile2(filePath, project) {
         fileNeedsImports = true;
         configHadValidateAction = true;
         console.log(
-          `  [${import_path2.default.relative(getCwd(), filePath)}] Transformed VALIDATE action to CUSTOM with customActionType: '${VALIDATE_DECLARATION_VALUE}'`
+          `  [${import_path2.default.relative(process.cwd(), filePath)}] Transformed VALIDATE action to CUSTOM with customActionType: '${VALIDATE_DECLARATION_VALUE}'`
         );
       }
     }
@@ -375,7 +375,7 @@ function processFile2(filePath, project) {
 ]`
       });
       console.log(
-        `  [${import_path2.default.relative(getCwd(), filePath)}] Added top-level 'flags' array to defineConfig`
+        `  [${import_path2.default.relative(process.cwd(), filePath)}] Added top-level 'flags' array to defineConfig`
       );
     }
     if (fileNeedsImports) {
@@ -385,7 +385,7 @@ function processFile2(filePath, project) {
   return transformedCount;
 }
 async function main2() {
-  const srcDir = import_path2.default.join(getCwd(), "src");
+  const srcDir = import_path2.default.join(process.cwd(), "src");
   console.log(`Scanning for defineConfig calls in: ${srcDir}
 `);
   const project = new import_ts_morph2.Project({
@@ -420,7 +420,7 @@ Saving ${modifiedFiles.length} modified file(s)...`);
   for (const filePath of modifiedFiles) {
     const sourceFile = project.getSourceFileOrThrow(filePath);
     await sourceFile.save();
-    console.log(`  Saved: ${import_path2.default.relative(getCwd(), filePath)}`);
+    console.log(`  Saved: ${import_path2.default.relative(process.cwd(), filePath)}`);
   }
   console.log(
     `
@@ -491,14 +491,14 @@ function processFile3(filePath, project) {
       actionsInitializer.removeElement(index);
       removedCount++;
       console.log(
-        `  [${import_path3.default.relative(getCwd(), filePath)}] Removed DELETE action at index ${index}`
+        `  [${import_path3.default.relative(process.cwd(), filePath)}] Removed DELETE action at index ${index}`
       );
     }
   }
   return removedCount;
 }
 async function main3() {
-  const srcDir = import_path3.default.join(getCwd(), "src");
+  const srcDir = import_path3.default.join(process.cwd(), "src");
   console.log(`Scanning for defineConfig calls in: ${srcDir}
 `);
   const project = new import_ts_morph3.Project({
@@ -533,7 +533,7 @@ Saving ${modifiedFiles.length} modified file(s)...`);
   for (const filePath of modifiedFiles) {
     const sourceFile = project.getSourceFileOrThrow(filePath);
     await sourceFile.save();
-    console.log(`  Saved: ${import_path3.default.relative(getCwd(), filePath)}`);
+    console.log(`  Saved: ${import_path3.default.relative(process.cwd(), filePath)}`);
   }
   console.log(
     `
@@ -607,19 +607,19 @@ function processFile4(filePath, project) {
     if (result === "converted-to-heading") {
       changedCount++;
       console.log(
-        `  [${import_path4.default.relative(getCwd(), filePath)}] Converted PARAGRAPH with heading fontVariant to HEADING`
+        `  [${import_path4.default.relative(process.cwd(), filePath)}] Converted PARAGRAPH with heading fontVariant to HEADING`
       );
     } else if (result === "removed-font-variant") {
       changedCount++;
       console.log(
-        `  [${import_path4.default.relative(getCwd(), filePath)}] Removed non-heading fontVariant from PARAGRAPH`
+        `  [${import_path4.default.relative(process.cwd(), filePath)}] Removed non-heading fontVariant from PARAGRAPH`
       );
     }
   }
   return changedCount;
 }
 async function main4() {
-  const srcDir = import_path4.default.join(getCwd(), "src");
+  const srcDir = import_path4.default.join(process.cwd(), "src");
   console.log(`Scanning for FieldType.PARAGRAPH fields in: ${srcDir}
 `);
   const project = new import_ts_morph4.Project({
@@ -653,7 +653,7 @@ Saving ${modifiedFiles.length} modified file(s)...`);
   for (const filePath of modifiedFiles) {
     const sourceFile = project.getSourceFileOrThrow(filePath);
     await sourceFile.save();
-    console.log(`  Saved: ${import_path4.default.relative(getCwd(), filePath)}`);
+    console.log(`  Saved: ${import_path4.default.relative(process.cwd(), filePath)}`);
   }
   console.log(`
 Done. Processed ${totalChanged} FieldType.PARAGRAPH field(s).`);
@@ -803,7 +803,7 @@ function processFile5(filePath, project) {
       if (changed > 0) {
         migratedCount += changed;
         console.log(
-          `  [${import_path5.default.relative(getCwd(), filePath)}] Migrated ${changed} clause(s): VALIDATED status \u2192 flags.anyOf`
+          `  [${import_path5.default.relative(process.cwd(), filePath)}] Migrated ${changed} clause(s): VALIDATED status \u2192 flags.anyOf`
         );
       }
     }
@@ -811,7 +811,7 @@ function processFile5(filePath, project) {
   return migratedCount;
 }
 async function main5() {
-  const srcDir = import_path5.default.join(getCwd(), "src");
+  const srcDir = import_path5.default.join(process.cwd(), "src");
   console.log(`Scanning for defineWorkqueues calls in: ${srcDir}
 `);
   const project = new import_ts_morph5.Project({
@@ -845,7 +845,7 @@ Saving ${modifiedFiles.length} modified file(s)...`);
   for (const filePath of modifiedFiles) {
     const sourceFile = project.getSourceFileOrThrow(filePath);
     await sourceFile.save();
-    console.log(`  Saved: ${import_path5.default.relative(getCwd(), filePath)}`);
+    console.log(`  Saved: ${import_path5.default.relative(process.cwd(), filePath)}`);
   }
   console.log(
     `
@@ -1063,7 +1063,7 @@ function processFile6(filePath, project) {
   const sourceFile = project.getSourceFile(filePath);
   if (!sourceFile) return 0;
   let totalChanges = 0;
-  const relPath = import_path6.default.relative(getCwd(), filePath);
+  const relPath = import_path6.default.relative(process.cwd(), filePath);
   const callExpressions = sourceFile.getDescendantsOfKind(
     import_ts_morph6.SyntaxKind.CallExpression
   );
@@ -1104,7 +1104,7 @@ function processFile6(filePath, project) {
   return totalChanges;
 }
 async function main6() {
-  const srcDir = import_path6.default.join(getCwd(), "src");
+  const srcDir = import_path6.default.join(process.cwd(), "src");
   console.log(
     `Scanning for birth defineConfig and PRINT_CERTIFICATE workqueues in: ${srcDir}
 `
@@ -1140,7 +1140,7 @@ Saving ${modifiedFiles.length} modified file(s)...`);
   for (const filePath of modifiedFiles) {
     const sourceFile = project.getSourceFileOrThrow(filePath);
     await sourceFile.save();
-    console.log(`  Saved: ${import_path6.default.relative(getCwd(), filePath)}`);
+    console.log(`  Saved: ${import_path6.default.relative(process.cwd(), filePath)}`);
   }
   console.log(
     `
@@ -1177,14 +1177,14 @@ function processFile7(filePath, project) {
       array3.removeElement(index);
       removedCount++;
       console.log(
-        `  [${import_path7.default.relative(getCwd(), filePath)}] Removed InherentFlags.PENDING_CERTIFICATION from array`
+        `  [${import_path7.default.relative(process.cwd(), filePath)}] Removed InherentFlags.PENDING_CERTIFICATION from array`
       );
     }
   }
   return removedCount;
 }
 async function main7() {
-  const srcDir = import_path7.default.join(getCwd(), "src");
+  const srcDir = import_path7.default.join(process.cwd(), "src");
   console.log(
     `Scanning for InherentFlags.PENDING_CERTIFICATION array elements in: ${srcDir}
 `
@@ -1220,7 +1220,7 @@ Saving ${modifiedFiles.length} modified file(s)...`);
   for (const filePath of modifiedFiles) {
     const sourceFile = project.getSourceFileOrThrow(filePath);
     await sourceFile.save();
-    console.log(`  Saved: ${import_path7.default.relative(getCwd(), filePath)}`);
+    console.log(`  Saved: ${import_path7.default.relative(process.cwd(), filePath)}`);
   }
   console.log(
     `
@@ -1278,13 +1278,13 @@ function processFile8(filePath, project) {
     propAccess.getNameNode().replaceWithText(NEW_PROPERTY_NAME);
     renamedCount++;
     console.log(
-      `  [${import_path8.default.relative(getCwd(), filePath)}] Renamed Location.${OLD_PROPERTY_NAME} \u2192 Location.${NEW_PROPERTY_NAME}`
+      `  [${import_path8.default.relative(process.cwd(), filePath)}] Renamed Location.${OLD_PROPERTY_NAME} \u2192 Location.${NEW_PROPERTY_NAME}`
     );
   }
   return renamedCount;
 }
 async function main8() {
-  const srcDir = import_path8.default.join(getCwd(), "src");
+  const srcDir = import_path8.default.join(process.cwd(), "src");
   console.log(
     `Scanning for Location.${OLD_PROPERTY_NAME} references in: ${srcDir}
 `
@@ -1320,7 +1320,7 @@ Saving ${modifiedFiles.length} modified file(s)...`);
   for (const filePath of modifiedFiles) {
     const sourceFile = project.getSourceFileOrThrow(filePath);
     await sourceFile.save();
-    console.log(`  Saved: ${import_path8.default.relative(getCwd(), filePath)}`);
+    console.log(`  Saved: ${import_path8.default.relative(process.cwd(), filePath)}`);
   }
   console.log(
     `
@@ -1387,7 +1387,7 @@ function processFile9(filePath, project) {
   const sourceFile = project.getSourceFile(filePath);
   if (!sourceFile) return 0;
   let renamedCount = 0;
-  const relPath = import_path9.default.relative(getCwd(), filePath);
+  const relPath = import_path9.default.relative(process.cwd(), filePath);
   const candidates = sourceFile.getDescendantsOfKind(
     import_ts_morph9.SyntaxKind.ObjectLiteralExpression
   );
@@ -1402,7 +1402,7 @@ function processFile9(filePath, project) {
   return renamedCount;
 }
 async function main9() {
-  const srcDir = import_path9.default.join(getCwd(), "src");
+  const srcDir = import_path9.default.join(process.cwd(), "src");
   console.log(`Scanning for Hapi route configs in: ${srcDir}
 `);
   console.log("Active path renames:");
@@ -1439,7 +1439,7 @@ Saving ${modifiedFiles.length} modified file(s)...`);
   for (const filePath of modifiedFiles) {
     const sourceFile = project.getSourceFileOrThrow(filePath);
     await sourceFile.save();
-    console.log(`  Saved: ${import_path9.default.relative(getCwd(), filePath)}`);
+    console.log(`  Saved: ${import_path9.default.relative(process.cwd(), filePath)}`);
   }
   console.log(`
 Done. Renamed ${totalRenamed} route path(s).`);
@@ -1813,9 +1813,9 @@ function updateRouteHandlers(sourceFiles, group, srcDir, relCwd) {
   }
   return replacedCount;
 }
-function resolveConfigChain(configObj, path17) {
+function resolveConfigChain(configObj, path23) {
   let current = configObj;
-  for (const key of path17) {
+  for (const key of path23) {
     if (!import_ts_morph10.Node.isObjectLiteralExpression(current)) return null;
     const prop = current.getProperty(key);
     if (!prop || !import_ts_morph10.Node.isPropertyAssignment(prop)) return null;
@@ -1860,8 +1860,8 @@ function ensureJoinImport(sf) {
   });
 }
 async function main10() {
-  const srcDir = import_path10.default.join(getCwd(), "src");
-  const relCwd = (fp) => import_path10.default.relative(getCwd(), fp);
+  const srcDir = import_path10.default.join(process.cwd(), "src");
+  const relCwd = (fp) => import_path10.default.relative(process.cwd(), fp);
   console.log("Phase 1: Converting JS config files to TypeScript...\n");
   let convertedCount = 0;
   for (const group of CONFIG_GROUPS) {
@@ -1949,7 +1949,7 @@ async function main10() {
                   ensureJoinImport(sf);
                 }
                 console.log(
-                  `  Inlined applicationConfig.${accessPath.join(".")} \u2192 ${adjustedValue} in ${import_path10.default.relative(getCwd(), sf.getFilePath())}`
+                  `  Inlined applicationConfig.${accessPath.join(".")} \u2192 ${adjustedValue} in ${import_path10.default.relative(process.cwd(), sf.getFilePath())}`
                 );
                 filesToSaveAfterInlining.add(sf);
                 madeReplacement = true;
@@ -1961,7 +1961,7 @@ async function main10() {
         for (const sf of Array.from(filesToSaveAfterInlining)) {
           await sf.save();
           console.log(
-            `  Saved (inlined): ${import_path10.default.relative(getCwd(), sf.getFilePath())}`
+            `  Saved (inlined): ${import_path10.default.relative(process.cwd(), sf.getFilePath())}`
           );
         }
         for (const prop of [...propsToRemove].reverse()) {
@@ -2578,7 +2578,7 @@ function migrateScopesArrays(rolesFilePath, project) {
       const scopeKey = resolveScopeKeyFromElementAccess(element);
       if (scopeKey && !(scopeKey in SCOPES)) {
         console.warn(
-          `  [${import_path11.default.relative(getCwd(), rolesFilePath)}] Removing unknown scope reference: SCOPES.${scopeKey}`
+          `  [${import_path11.default.relative(process.cwd(), rolesFilePath)}] Removing unknown scope reference: SCOPES.${scopeKey}`
         );
         initializer.removeElement(index);
         removedCount++;
@@ -2587,7 +2587,7 @@ function migrateScopesArrays(rolesFilePath, project) {
       const legacyScope = resolveLegacyScopeFromElement(element);
       if (!legacyScope) {
         console.warn(
-          `  [${import_path11.default.relative(getCwd(), rolesFilePath)}] Skipping non-literal scope expression: ${element.getText()}`
+          `  [${import_path11.default.relative(process.cwd(), rolesFilePath)}] Skipping non-literal scope expression: ${element.getText()}`
         );
         continue;
       }
@@ -2596,7 +2596,7 @@ function migrateScopesArrays(rolesFilePath, project) {
         const scope = decodeScope(migratedScope);
         if (!scope) {
           console.warn(
-            `  [${import_path11.default.relative(getCwd(), rolesFilePath)}] Could not decode migrated scope '${migratedScope}'.`
+            `  [${import_path11.default.relative(process.cwd(), rolesFilePath)}] Could not decode migrated scope '${migratedScope}'.`
           );
           continue;
         }
@@ -2604,14 +2604,14 @@ function migrateScopesArrays(rolesFilePath, project) {
         migratedCount++;
       } catch (error) {
         console.warn(
-          `  [${import_path11.default.relative(getCwd(), rolesFilePath)}] Could not migrate scope '${legacyScope}': ${error}`
+          `  [${import_path11.default.relative(process.cwd(), rolesFilePath)}] Could not migrate scope '${legacyScope}': ${error}`
         );
       }
     }
   }
   if (removedCount > 0) {
     console.log(
-      `  Removed ${removedCount} unknown SCOPES reference(s) from '${import_path11.default.relative(getCwd(), rolesFilePath)}'.`
+      `  Removed ${removedCount} unknown SCOPES reference(s) from '${import_path11.default.relative(process.cwd(), rolesFilePath)}'.`
     );
   }
   return { migratedCount, removedCount };
@@ -2733,9 +2733,9 @@ function removeRoleTypeDefinitionAndUnusedImports(rolesFilePath, project) {
   return removed;
 }
 async function main11() {
-  const cwd2 = getCwd();
-  const srcDir = import_path11.default.join(cwd2, "src");
-  const rolesFilePath = import_path11.default.join(cwd2, ROLES_FILE_RELATIVE_PATH);
+  const cwd = process.cwd();
+  const srcDir = import_path11.default.join(cwd, "src");
+  const rolesFilePath = import_path11.default.join(cwd, ROLES_FILE_RELATIVE_PATH);
   console.log(`Scanning roles scopes in: ${rolesFilePath}`);
   const project = new import_ts_morph11.Project({
     tsConfigFilePath: import_path11.default.resolve(srcDir, "../tsconfig.json"),
@@ -2799,13 +2799,13 @@ function processFile10(filePath, project) {
       decl.remove();
     }
     console.log(
-      `  [${import_path12.default.relative(getCwd(), filePath)}] Removed ${matchingNamedImports.length} deprecated '${DEPRECATED_IMPORT}' import(s) from '${decl.getModuleSpecifierValue()}'`
+      `  [${import_path12.default.relative(process.cwd(), filePath)}] Removed ${matchingNamedImports.length} deprecated '${DEPRECATED_IMPORT}' import(s) from '${decl.getModuleSpecifierValue()}'`
     );
   }
   return removedCount;
 }
 async function main12() {
-  const srcDir = import_path12.default.join(getCwd(), "src");
+  const srcDir = import_path12.default.join(process.cwd(), "src");
   console.log(`Scanning for deprecated imports in: ${srcDir}
 `);
   const project = new import_ts_morph12.Project({
@@ -2836,15 +2836,738 @@ async function main12() {
 Saving ${modifiedFiles.length} modified file(s)...`);
   for (const filePath of modifiedFiles) {
     await project.getSourceFileOrThrow(filePath).save();
-    console.log(`  Saved: ${import_path12.default.relative(getCwd(), filePath)}`);
+    console.log(`  Saved: ${import_path12.default.relative(process.cwd(), filePath)}`);
   }
   console.log(`
 Done. Removed ${totalRemoved} deprecated import(s).`);
 }
 
-// src/migrations/v2.0/migrate-workqueue-configs.ts
-var import_ts_morph13 = require("ts-morph");
+// src/migrations/v2.0/remove-unused-environment-variables.ts
 var import_path13 = __toESM(require("path"));
+var import_ts_morph13 = require("ts-morph");
+var UNUSED_ENV_VARS = /* @__PURE__ */ new Set([
+  "APPLICATION_CONFIG_URL",
+  "FHIR_URL",
+  "CONFIRM_REGISTRATION_URL"
+]);
+var ENVIRONMENT_FILE_RELATIVE = "src/environment.ts";
+var CONSTANTS_FILE_RELATIVE = "src/constants.ts";
+function cleanEnvironmentFile(project, filePath) {
+  const sourceFile = project.getSourceFile(filePath);
+  if (!sourceFile) return [];
+  const removed = [];
+  const cleanEnvCall = sourceFile.getDescendantsOfKind(import_ts_morph13.SyntaxKind.CallExpression).find((call) => {
+    const expr = call.getExpression();
+    return import_ts_morph13.Node.isIdentifier(expr) && expr.getText() === "cleanEnv";
+  });
+  if (!cleanEnvCall) return removed;
+  const schemaArg = cleanEnvCall.getArguments()[1]?.asKind(import_ts_morph13.SyntaxKind.ObjectLiteralExpression);
+  if (!schemaArg) return removed;
+  for (const name of UNUSED_ENV_VARS) {
+    const prop = schemaArg.getProperty(name);
+    if (!prop) continue;
+    if (prop.isKind(import_ts_morph13.SyntaxKind.PropertyAssignment) || prop.isKind(import_ts_morph13.SyntaxKind.ShorthandPropertyAssignment)) {
+      prop.remove();
+      removed.push(name);
+    }
+  }
+  return removed;
+}
+function extractEnvAccess(initText) {
+  if (!initText) return null;
+  const match = /\benv\.([A-Z][A-Z0-9_]*)\b/.exec(initText);
+  return match ? match[1] : null;
+}
+function cleanConstantsFile(project, filePath) {
+  const sourceFile = project.getSourceFile(filePath);
+  if (!sourceFile) return [];
+  const removed = [];
+  for (const stmt of [...sourceFile.getVariableStatements()]) {
+    const declarations = [...stmt.getDeclarations()];
+    const declarationsToRemove = declarations.filter((decl) => {
+      const name = decl.getName();
+      const accessedEnvVar = extractEnvAccess(decl.getInitializer()?.getText());
+      return UNUSED_ENV_VARS.has(name) || accessedEnvVar !== null && UNUSED_ENV_VARS.has(accessedEnvVar);
+    });
+    if (declarationsToRemove.length === 0) continue;
+    const namesToRemove = declarationsToRemove.map((decl) => decl.getName());
+    removed.push(...namesToRemove);
+    if (declarationsToRemove.length === declarations.length) {
+      stmt.remove();
+    } else {
+      for (const decl of declarationsToRemove) {
+        decl.remove();
+      }
+    }
+  }
+  return removed;
+}
+async function main13() {
+  const project = new import_ts_morph13.Project({
+    tsConfigFilePath: import_path13.default.resolve(process.cwd(), "tsconfig.json"),
+    skipAddingFilesFromTsConfig: false
+  });
+  console.log(
+    `Removing unused environment variable(s) (${[...UNUSED_ENV_VARS].join(", ")})...
+`
+  );
+  const envFilePath = import_path13.default.join(process.cwd(), ENVIRONMENT_FILE_RELATIVE);
+  const constsFilePath = import_path13.default.join(process.cwd(), CONSTANTS_FILE_RELATIVE);
+  const envRemoved = cleanEnvironmentFile(project, envFilePath);
+  if (envRemoved.length > 0) {
+    await project.getSourceFileOrThrow(envFilePath).save();
+    console.log(
+      `  [${ENVIRONMENT_FILE_RELATIVE}] Removed schema entr${envRemoved.length === 1 ? "y" : "ies"}: ${envRemoved.join(", ")}`
+    );
+  } else if (project.getSourceFile(envFilePath)) {
+    console.log(
+      `  [${ENVIRONMENT_FILE_RELATIVE}] No matching schema entries \u2014 nothing to remove.`
+    );
+  } else {
+    console.log(
+      `  [${ENVIRONMENT_FILE_RELATIVE}] File not found \u2014 skipping.`
+    );
+  }
+  const constsRemoved = cleanConstantsFile(project, constsFilePath);
+  if (constsRemoved.length > 0) {
+    await project.getSourceFileOrThrow(constsFilePath).save();
+    console.log(
+      `  [${CONSTANTS_FILE_RELATIVE}] Removed declaration(s): ${constsRemoved.join(", ")}`
+    );
+  } else if (project.getSourceFile(constsFilePath)) {
+    console.log(
+      `  [${CONSTANTS_FILE_RELATIVE}] No matching declarations \u2014 nothing to remove.`
+    );
+  } else {
+    console.log(`  [${CONSTANTS_FILE_RELATIVE}] File not found \u2014 skipping.`);
+  }
+  if (envRemoved.length === 0 && constsRemoved.length === 0) {
+    console.log("\nNothing to do.");
+    return;
+  }
+  console.log(
+    `
+Done. NOTE: usages of these constants elsewhere in 'src/' may now produce TypeScript errors and need manual review.`
+  );
+}
+
+// src/migrations/v2.0/remove-fhir-url-helpers.ts
+var import_path14 = __toESM(require("path"));
+var import_ts_morph14 = require("ts-morph");
+var FHIR_IMPORT = "FHIR_URL";
+var HELPER_NAMES = /* @__PURE__ */ new Set([
+  "getFromFhir",
+  "updateResourceFromHearth",
+  "updateResourceInHearth"
+]);
+function removeHelpers(sourceFilePath, project) {
+  const sourceFile = project.getSourceFile(sourceFilePath);
+  if (!sourceFile) {
+    return {
+      removedHelpers: [],
+      removedImportCount: 0,
+      remainingFhirReferences: 0
+    };
+  }
+  const removedHelpers = [];
+  let removedImportCount = 0;
+  for (const fn of sourceFile.getFunctions()) {
+    const name = fn.getName();
+    if (!name || !HELPER_NAMES.has(name)) continue;
+    removedHelpers.push(name);
+    fn.remove();
+  }
+  for (const stmt of [...sourceFile.getVariableStatements()]) {
+    const declarations = [...stmt.getDeclarations()];
+    const toRemove = declarations.filter((decl) => HELPER_NAMES.has(decl.getName()));
+    if (toRemove.length === 0) continue;
+    removedHelpers.push(...toRemove.map((decl) => decl.getName()));
+    if (toRemove.length === declarations.length) {
+      stmt.remove();
+    } else {
+      for (const decl of toRemove) decl.remove();
+    }
+  }
+  for (const decl of sourceFile.getImportDeclarations()) {
+    const matches = decl.getNamedImports().filter((ni) => ni.getName() === FHIR_IMPORT);
+    if (matches.length === 0) continue;
+    for (const named of matches) {
+      named.remove();
+      removedImportCount++;
+    }
+    const hasAnyNamedImportsLeft = decl.getNamedImports().length > 0;
+    const hasDefaultImport = !!decl.getDefaultImport();
+    const hasNamespaceImport = !!decl.getNamespaceImport();
+    if (!hasAnyNamedImportsLeft && !hasDefaultImport && !hasNamespaceImport) {
+      decl.remove();
+    }
+  }
+  const remainingFhirReferences = sourceFile.getDescendantsOfKind(import_ts_morph14.SyntaxKind.Identifier).filter((id) => id.getText() === FHIR_IMPORT).filter((id) => !id.getFirstAncestorByKind(import_ts_morph14.SyntaxKind.ImportDeclaration)).length;
+  return { removedHelpers, removedImportCount, remainingFhirReferences };
+}
+async function main14() {
+  const project = new import_ts_morph14.Project({
+    tsConfigFilePath: import_path14.default.resolve(process.cwd(), "tsconfig.json"),
+    skipAddingFilesFromTsConfig: false
+  });
+  const sourceFiles = project.getSourceFiles().filter((sf) => {
+    const fp = sf.getFilePath();
+    return fp.includes("/src/") && !fp.includes("/node_modules/");
+  });
+  console.log(`Removing legacy FHIR_URL helpers in ${sourceFiles.length} source file(s)...
+`);
+  let totalRemovedImports = 0;
+  let totalRemovedHelpers = 0;
+  const modifiedFiles = [];
+  const warnings = [];
+  for (const sourceFile of sourceFiles) {
+    const filePath = sourceFile.getFilePath();
+    const rel = import_path14.default.relative(process.cwd(), filePath);
+    const result = removeHelpers(filePath, project);
+    const changed = result.removedImportCount > 0 || result.removedHelpers.length > 0;
+    if (changed) {
+      modifiedFiles.push(filePath);
+      totalRemovedImports += result.removedImportCount;
+      totalRemovedHelpers += result.removedHelpers.length;
+      if (result.removedHelpers.length > 0) {
+        console.log(
+          `  [${rel}] Removed helper(s): ${result.removedHelpers.join(", ")}`
+        );
+      }
+      if (result.removedImportCount > 0) {
+        console.log(
+          `  [${rel}] Removed ${result.removedImportCount} '${FHIR_IMPORT}' import(s)`
+        );
+      }
+    }
+    if (result.remainingFhirReferences > 0) {
+      warnings.push(
+        `${rel}: ${result.remainingFhirReferences} remaining '${FHIR_IMPORT}' reference(s)`
+      );
+    }
+  }
+  if (modifiedFiles.length === 0 && warnings.length === 0) {
+    console.log("No FHIR_URL imports/helpers found. Nothing to do.");
+    return;
+  }
+  if (modifiedFiles.length > 0) {
+    console.log(`
+Saving ${modifiedFiles.length} modified file(s)...`);
+    for (const filePath of modifiedFiles) {
+      await project.getSourceFileOrThrow(filePath).save();
+      console.log(`  Saved: ${import_path14.default.relative(process.cwd(), filePath)}`);
+    }
+  }
+  if (warnings.length > 0) {
+    console.warn(
+      `
+  WARNING: Some '${FHIR_IMPORT}' usages remain and need manual cleanup:
+` + warnings.map((line) => `    - ${line}`).join("\n")
+    );
+  }
+  console.log(
+    `
+Done. Removed ${totalRemovedHelpers} helper declaration(s) and ${totalRemovedImports} '${FHIR_IMPORT}' import(s).`
+  );
+}
+
+// src/migrations/v2.0/migrate-application-config-url.ts
+var import_path15 = __toESM(require("path"));
+var import_ts_morph15 = require("ts-morph");
+var TARGET_IDENTIFIER = "APPLICATION_CONFIG_URL";
+var REPLACEMENT_IDENTIFIER = "applicationConfig";
+var REPLACEMENT_MODULE = "@countryconfig/api/application/application-config";
+var FUNCTION_LIKE_KINDS = [
+  import_ts_morph15.SyntaxKind.FunctionDeclaration,
+  import_ts_morph15.SyntaxKind.FunctionExpression,
+  import_ts_morph15.SyntaxKind.ArrowFunction,
+  import_ts_morph15.SyntaxKind.MethodDeclaration
+];
+function describeFunction(node) {
+  if (import_ts_morph15.Node.isFunctionDeclaration(node) || import_ts_morph15.Node.isMethodDeclaration(node)) {
+    return node.getName() ?? "<anonymous>";
+  }
+  const parent = node.getParent();
+  if (parent && import_ts_morph15.Node.isVariableDeclaration(parent)) {
+    return parent.getName();
+  }
+  if (parent && import_ts_morph15.Node.isPropertyAssignment(parent)) {
+    return parent.getName();
+  }
+  if (import_ts_morph15.Node.isFunctionExpression(node) && node.getNameNode() !== void 0) {
+    return node.getNameNode()?.getText() ?? "<anonymous>";
+  }
+  return "<anonymous>";
+}
+function hasBlockBody(node) {
+  if (import_ts_morph15.Node.isFunctionDeclaration(node) || import_ts_morph15.Node.isFunctionExpression(node) || import_ts_morph15.Node.isMethodDeclaration(node)) {
+    return node.getBody() !== void 0;
+  }
+  if (import_ts_morph15.Node.isArrowFunction(node)) {
+    return node.getBody().getKind() === import_ts_morph15.SyntaxKind.Block;
+  }
+  return false;
+}
+function isConfigFetcher(node) {
+  let referencesTarget = false;
+  let callsFetch = false;
+  for (const id of node.getDescendantsOfKind(import_ts_morph15.SyntaxKind.Identifier)) {
+    const text = id.getText();
+    if (!referencesTarget && text === TARGET_IDENTIFIER) referencesTarget = true;
+    if (!callsFetch && text === "fetch") {
+      const parent = id.getParent();
+      if (import_ts_morph15.Node.isCallExpression(parent) && parent.getExpression() === id) {
+        callsFetch = true;
+      }
+    }
+    if (referencesTarget && callsFetch) return true;
+  }
+  return false;
+}
+function processFile11(sourceFile) {
+  const importsWithTarget = sourceFile.getImportDeclarations().filter(
+    (decl) => decl.getNamedImports().some((ni) => ni.getName() === TARGET_IDENTIFIER)
+  );
+  if (importsWithTarget.length === 0) {
+    return { changed: false, rewrittenFunctions: [], renamedReferences: 0 };
+  }
+  const collidingLocals = sourceFile.getDescendantsOfKind(import_ts_morph15.SyntaxKind.Identifier).filter((id) => id.getText() === REPLACEMENT_IDENTIFIER).filter((id) => {
+    const parent = id.getParent();
+    const kind = parent.getKind();
+    return kind === import_ts_morph15.SyntaxKind.VariableDeclaration || kind === import_ts_morph15.SyntaxKind.FunctionDeclaration || kind === import_ts_morph15.SyntaxKind.ClassDeclaration || kind === import_ts_morph15.SyntaxKind.Parameter;
+  });
+  if (collidingLocals.length > 0) {
+    return {
+      changed: false,
+      rewrittenFunctions: [],
+      renamedReferences: 0,
+      skippedReason: `local declaration named '${REPLACEMENT_IDENTIFIER}' would collide`
+    };
+  }
+  const candidateFunctions = FUNCTION_LIKE_KINDS.flatMap(
+    (kind) => sourceFile.getDescendantsOfKind(kind)
+  );
+  candidateFunctions.sort((a, b) => a.getStart() - b.getStart());
+  const rewrittenFunctions = [];
+  const rewrittenSet = /* @__PURE__ */ new Set();
+  for (const fn of candidateFunctions) {
+    if (!hasBlockBody(fn)) continue;
+    if (!isConfigFetcher(fn)) continue;
+    let inRewrittenAncestor = false;
+    let cursor = fn.getParent();
+    while (cursor) {
+      if (rewrittenSet.has(cursor)) {
+        inRewrittenAncestor = true;
+        break;
+      }
+      cursor = cursor.getParent();
+    }
+    if (inRewrittenAncestor) continue;
+    const start = fn.getStart();
+    const line = sourceFile.getLineAndColumnAtPos(start).line;
+    const name = describeFunction(fn);
+    if (import_ts_morph15.Node.isFunctionDeclaration(fn) || import_ts_morph15.Node.isFunctionExpression(fn) || import_ts_morph15.Node.isMethodDeclaration(fn) || import_ts_morph15.Node.isArrowFunction(fn)) {
+      fn.setBodyText(`return ${REPLACEMENT_IDENTIFIER}`);
+    }
+    rewrittenFunctions.push({ name, line });
+    rewrittenSet.add(fn);
+  }
+  for (const decl of importsWithTarget) {
+    const targetNamed = decl.getNamedImports().find((ni) => ni.getName() === TARGET_IDENTIFIER);
+    targetNamed?.remove();
+    const isNowEmpty = decl.getNamedImports().length === 0 && !decl.getDefaultImport() && !decl.getNamespaceImport();
+    if (isNowEmpty) decl.remove();
+  }
+  const existing = sourceFile.getImportDeclaration(
+    (decl) => decl.getModuleSpecifierValue() === REPLACEMENT_MODULE
+  );
+  if (existing) {
+    const alreadyImported = existing.getNamedImports().some((ni) => ni.getName() === REPLACEMENT_IDENTIFIER);
+    if (!alreadyImported) existing.addNamedImport(REPLACEMENT_IDENTIFIER);
+  } else {
+    sourceFile.addImportDeclaration({
+      moduleSpecifier: REPLACEMENT_MODULE,
+      namedImports: [REPLACEMENT_IDENTIFIER]
+    });
+  }
+  const renameTargets = sourceFile.getDescendantsOfKind(import_ts_morph15.SyntaxKind.Identifier).filter((id) => id.getText() === TARGET_IDENTIFIER).filter((id) => !id.getFirstAncestorByKind(import_ts_morph15.SyntaxKind.ImportDeclaration)).filter((id) => {
+    const parent = id.getParent();
+    const parentKind = parent.getKind();
+    if (parentKind === import_ts_morph15.SyntaxKind.PropertyAccessExpression) {
+      const pae = parent.asKind(import_ts_morph15.SyntaxKind.PropertyAccessExpression);
+      if (pae.getNameNode() === id) return false;
+    }
+    if (parentKind === import_ts_morph15.SyntaxKind.PropertyAssignment) {
+      const pa = parent.asKind(import_ts_morph15.SyntaxKind.PropertyAssignment);
+      if (pa.getNameNode() === id) return false;
+    }
+    if (parentKind === import_ts_morph15.SyntaxKind.ShorthandPropertyAssignment) {
+      return false;
+    }
+    return true;
+  }).sort((a, b) => b.getPos() - a.getPos());
+  for (const id of renameTargets) {
+    id.replaceWithText(REPLACEMENT_IDENTIFIER);
+  }
+  return {
+    changed: true,
+    rewrittenFunctions,
+    renamedReferences: renameTargets.length
+  };
+}
+async function main15() {
+  const project = new import_ts_morph15.Project({
+    tsConfigFilePath: import_path15.default.resolve(process.cwd(), "tsconfig.json"),
+    skipAddingFilesFromTsConfig: false
+  });
+  const sourceFiles = project.getSourceFiles().filter((sf) => {
+    const fp = sf.getFilePath();
+    return fp.includes("/src/") && !fp.includes("/node_modules/");
+  });
+  console.log(
+    `Migrating '${TARGET_IDENTIFIER}' \u2192 '${REPLACEMENT_IDENTIFIER}' across ${sourceFiles.length} source file(s)...
+`
+  );
+  let changedFiles = 0;
+  let totalRewrittenFunctions = 0;
+  let totalRenamedReferences = 0;
+  const skipped = [];
+  for (const sourceFile of sourceFiles) {
+    const filePath = sourceFile.getFilePath();
+    const rel = import_path15.default.relative(process.cwd(), filePath);
+    const result = processFile11(sourceFile);
+    if (result.skippedReason) {
+      skipped.push(`${rel} (${result.skippedReason})`);
+      continue;
+    }
+    if (!result.changed) continue;
+    await sourceFile.save();
+    changedFiles++;
+    totalRewrittenFunctions += result.rewrittenFunctions.length;
+    totalRenamedReferences += result.renamedReferences;
+    for (const fn of result.rewrittenFunctions) {
+      console.log(
+        `  [${rel}:${fn.line}] Rewrote '${fn.name}' body \u2192 'return ${REPLACEMENT_IDENTIFIER}' (config fetch eliminated)`
+      );
+    }
+    if (result.renamedReferences > 0) {
+      console.log(
+        `  [${rel}] Renamed ${result.renamedReferences} stray reference(s) ${TARGET_IDENTIFIER} \u2192 ${REPLACEMENT_IDENTIFIER}`
+      );
+    }
+  }
+  if (skipped.length > 0) {
+    console.warn(
+      `
+  ${skipped.length} file(s) skipped:
+` + skipped.map((s) => `    - ${s}`).join("\n")
+    );
+  }
+  if (changedFiles === 0) {
+    console.log(`
+No files reference '${TARGET_IDENTIFIER}'. Nothing to do.`);
+    return;
+  }
+  console.log(
+    `
+Done. Updated ${changedFiles} file(s): ${totalRewrittenFunctions} fetch function(s) rewritten, ${totalRenamedReferences} bare reference(s) renamed.`
+  );
+  if (totalRewrittenFunctions > 0) {
+    console.log(
+      `NOTE: rewriting fetch functions discards any custom logic that lived inside them. Review the diff and re-apply any country-specific adjustments on top of '${REPLACEMENT_IDENTIFIER}'.`
+    );
+  }
+}
+
+// src/migrations/v2.0/remove-old-statistics-service.ts
+var import_path16 = __toESM(require("path"));
+var import_ts_morph16 = require("ts-morph");
+var ROUTE_PATH = "/statistics";
+var HANDLER_NAME = "statisticsHandler";
+function isStatisticsRouteObject(obj) {
+  const pathProp = obj.getProperty("path");
+  if (!pathProp || !import_ts_morph16.Node.isPropertyAssignment(pathProp)) return false;
+  const init = pathProp.getInitializer();
+  if (!init) return false;
+  if (import_ts_morph16.Node.isStringLiteral(init) || import_ts_morph16.Node.isNoSubstitutionTemplateLiteral(init)) {
+    return init.getLiteralValue() === ROUTE_PATH;
+  }
+  return false;
+}
+function removeStatisticsRoutes(sourceFile) {
+  let removed = 0;
+  const callExpressions = [
+    ...sourceFile.getDescendantsOfKind(import_ts_morph16.SyntaxKind.CallExpression)
+  ];
+  for (const call of callExpressions) {
+    if (call.wasForgotten()) continue;
+    const expr = call.getExpression();
+    if (!import_ts_morph16.Node.isPropertyAccessExpression(expr)) continue;
+    if (expr.getName() !== "route") continue;
+    const args2 = call.getArguments();
+    if (args2.length === 0) continue;
+    const firstArg = args2[0];
+    if (import_ts_morph16.Node.isObjectLiteralExpression(firstArg)) {
+      if (!isStatisticsRouteObject(firstArg)) continue;
+      const stmt = call.getFirstAncestorByKind(import_ts_morph16.SyntaxKind.ExpressionStatement);
+      if (stmt) {
+        stmt.remove();
+        removed++;
+      } else {
+        call.replaceWithText("");
+        removed++;
+      }
+      continue;
+    }
+    if (import_ts_morph16.Node.isArrayLiteralExpression(firstArg)) {
+      const matchingIndexes = firstArg.getElements().map((el, idx) => ({ el, idx })).filter(
+        ({ el }) => import_ts_morph16.Node.isObjectLiteralExpression(el) && isStatisticsRouteObject(el)
+      ).map(({ idx }) => idx);
+      matchingIndexes.sort((a, b) => b - a).forEach((idx) => {
+        firstArg.removeElement(idx);
+        removed++;
+      });
+    }
+  }
+  return removed;
+}
+function removeStatisticsHandlerImports(sourceFile) {
+  let changed = false;
+  for (const decl of sourceFile.getImportDeclarations()) {
+    const targetNamed = decl.getNamedImports().find((ni) => ni.getName() === HANDLER_NAME);
+    if (!targetNamed) continue;
+    targetNamed.remove();
+    changed = true;
+    const isNowEmpty = decl.getNamedImports().length === 0 && !decl.getDefaultImport() && !decl.getNamespaceImport();
+    if (isNowEmpty) decl.remove();
+  }
+  return changed;
+}
+function processFile12(sourceFile) {
+  const routesRemoved = removeStatisticsRoutes(sourceFile);
+  const importsCleaned = removeStatisticsHandlerImports(sourceFile);
+  return { routesRemoved, importsCleaned };
+}
+function collectLocalImportsInSubtree(sourceFile, subtreeRoot) {
+  const result = [];
+  for (const decl of sourceFile.getImportDeclarations()) {
+    const moduleSf = decl.getModuleSpecifierSourceFile();
+    if (!moduleSf) continue;
+    const fp = moduleSf.getFilePath();
+    if (!fp.startsWith(subtreeRoot)) continue;
+    result.push(fp);
+  }
+  return result;
+}
+function deleteOrphanedDescendants(project, startingFile, subtreeRoot) {
+  const initialCandidates = collectLocalImportsInSubtree(
+    startingFile,
+    subtreeRoot
+  );
+  const startingPath = startingFile.getFilePath();
+  const deleted = /* @__PURE__ */ new Set([startingPath]);
+  const seen = /* @__PURE__ */ new Set();
+  const worklist = [...initialCandidates];
+  const orphans = [];
+  while (worklist.length > 0) {
+    const candidate = worklist.shift();
+    if (seen.has(candidate)) continue;
+    seen.add(candidate);
+    if (deleted.has(candidate)) continue;
+    if (!candidate.startsWith(subtreeRoot)) continue;
+    const candidateSf = project.getSourceFile(candidate);
+    if (!candidateSf) continue;
+    const stillImported = project.getSourceFiles().some((sf) => {
+      const sfPath = sf.getFilePath();
+      if (deleted.has(sfPath)) return false;
+      if (sfPath === candidate) return false;
+      return sf.getImportDeclarations().some(
+        (decl) => decl.getModuleSpecifierSourceFile()?.getFilePath() === candidate
+      );
+    });
+    if (stillImported) continue;
+    const next = collectLocalImportsInSubtree(candidateSf, subtreeRoot);
+    worklist.push(...next);
+    candidateSf.delete();
+    deleted.add(candidate);
+    orphans.push(candidate);
+  }
+  return orphans;
+}
+function processHandlerFile(project) {
+  const sourceFiles = project.getSourceFiles().filter((sf) => {
+    const fp = sf.getFilePath();
+    return fp.includes("/src/") && !fp.includes("/node_modules/");
+  });
+  for (const sf of sourceFiles) {
+    const fn = sf.getFunction(HANDLER_NAME);
+    if (!fn) continue;
+    const filePath = sf.getFilePath();
+    const exportsByName = [...sf.getExportedDeclarations().keys()];
+    const otherExports = exportsByName.filter((name) => name !== HANDLER_NAME);
+    if (otherExports.length === 0) {
+      const subtreeRoot = import_path16.default.dirname(filePath) + import_path16.default.sep;
+      const orphansDeleted = deleteOrphanedDescendants(
+        project,
+        sf,
+        subtreeRoot
+      );
+      sf.delete();
+      return { filePath, action: "deleted", orphansDeleted };
+    }
+    fn.remove();
+    return {
+      filePath,
+      action: "function-removed",
+      remainingExports: otherExports,
+      orphansDeleted: []
+    };
+  }
+  return { filePath: "", action: "not-found", orphansDeleted: [] };
+}
+async function main16() {
+  const project = new import_ts_morph16.Project({
+    tsConfigFilePath: import_path16.default.resolve(process.cwd(), "tsconfig.json"),
+    skipAddingFilesFromTsConfig: false
+  });
+  const sourceFiles = project.getSourceFiles().filter((sf) => {
+    const fp = sf.getFilePath();
+    return fp.includes("/src/") && !fp.includes("/node_modules/");
+  });
+  console.log(
+    `Removing legacy 'GET ${ROUTE_PATH}' route and '${HANDLER_NAME}' across ${sourceFiles.length} source file(s)...
+`
+  );
+  let totalRoutesRemoved = 0;
+  let totalFilesWithImportsCleaned = 0;
+  let totalFilesWithRoutesRemoved = 0;
+  for (const sourceFile of sourceFiles) {
+    const filePath = sourceFile.getFilePath();
+    const rel = import_path16.default.relative(process.cwd(), filePath);
+    const result = processFile12(sourceFile);
+    if (result.routesRemoved > 0) {
+      console.log(
+        `  [${rel}] Removed ${result.routesRemoved} '${ROUTE_PATH}' route(s)`
+      );
+      totalRoutesRemoved += result.routesRemoved;
+      totalFilesWithRoutesRemoved++;
+    }
+    if (result.importsCleaned) {
+      console.log(`  [${rel}] Cleaned up '${HANDLER_NAME}' import`);
+      totalFilesWithImportsCleaned++;
+    }
+    if (result.routesRemoved > 0 || result.importsCleaned) {
+      await sourceFile.save();
+    }
+  }
+  const handlerResult = processHandlerFile(project);
+  switch (handlerResult.action) {
+    case "deleted": {
+      const rel = import_path16.default.relative(process.cwd(), handlerResult.filePath);
+      console.log(
+        `  [${rel}] Deleted handler file ('${HANDLER_NAME}' was the sole export).`
+      );
+      for (const orphanPath of handlerResult.orphansDeleted) {
+        const orphanRel = import_path16.default.relative(process.cwd(), orphanPath);
+        console.log(
+          `  [${orphanRel}] Deleted (no remaining importers in the project after handler removal).`
+        );
+      }
+      await project.save();
+      break;
+    }
+    case "function-removed": {
+      const rel = import_path16.default.relative(process.cwd(), handlerResult.filePath);
+      console.warn(
+        `  [${rel}] Removed '${HANDLER_NAME}' function but kept the file (other exports remain: ${handlerResult.remainingExports?.join(", ")}). Review whether the file is still needed.`
+      );
+      const sf = project.getSourceFile(handlerResult.filePath);
+      if (sf) await sf.save();
+      break;
+    }
+    case "not-found":
+      break;
+  }
+  if (totalRoutesRemoved === 0 && totalFilesWithImportsCleaned === 0 && handlerResult.action === "not-found") {
+    console.log(`
+No legacy '${ROUTE_PATH}' route or handler found. Nothing to do.`);
+    return;
+  }
+  const orphansSummary = handlerResult.orphansDeleted.length > 0 ? ` and ${handlerResult.orphansDeleted.length} orphaned helper file(s)` : "";
+  console.log(
+    `
+Done. Removed ${totalRoutesRemoved} route(s) across ${totalFilesWithRoutesRemoved} file(s); cleaned ${HANDLER_NAME} import in ${totalFilesWithImportsCleaned} file(s)${orphansSummary}.`
+  );
+}
+
+// src/migrations/v2.0/update-package-json.ts
+var import_fs = require("fs");
+var import_path17 = __toESM(require("path"));
+var PACKAGE_JSON_RELATIVE = "package.json";
+var TARGET_VERSION = "2.0.0";
+var TARGET_ZOD_RANGE = "^4.2.1";
+async function main17() {
+  const packageJsonPath = import_path17.default.join(process.cwd(), PACKAGE_JSON_RELATIVE);
+  if (!(0, import_fs.existsSync)(packageJsonPath)) {
+    console.log(`'${PACKAGE_JSON_RELATIVE}' not found in ${process.cwd()} \u2014 skipping.`);
+    return;
+  }
+  const raw = (0, import_fs.readFileSync)(packageJsonPath, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    console.warn(
+      `  [${PACKAGE_JSON_RELATIVE}] Failed to parse JSON \u2014 skipping update. ${error.message}`
+    );
+    return;
+  }
+  console.log(`Updating '${PACKAGE_JSON_RELATIVE}'...`);
+  const previousVersion = parsed.version;
+  const versionChanged = previousVersion !== TARGET_VERSION;
+  parsed.version = TARGET_VERSION;
+  if (versionChanged) {
+    console.log(
+      `  Set version: ${previousVersion ?? "<unset>"} \u2192 ${TARGET_VERSION}`
+    );
+  } else {
+    console.log(`  Version already ${TARGET_VERSION} \u2014 no change.`);
+  }
+  let zodBucket = "dependencies";
+  if (parsed.devDependencies && "zod" in parsed.devDependencies) {
+    zodBucket = "devDependencies";
+  }
+  if (!parsed[zodBucket]) {
+    parsed[zodBucket] = {};
+  }
+  const bucket = parsed[zodBucket];
+  const previousZod = bucket.zod;
+  const zodChanged = previousZod !== TARGET_ZOD_RANGE;
+  bucket.zod = TARGET_ZOD_RANGE;
+  if (zodChanged) {
+    console.log(
+      `  Set ${zodBucket}.zod: ${previousZod ?? "<absent>"} \u2192 ${TARGET_ZOD_RANGE}`
+    );
+  } else {
+    console.log(`  ${zodBucket}.zod already ${TARGET_ZOD_RANGE} \u2014 no change.`);
+  }
+  const trailingNewline = raw.endsWith("\n") ? "\n" : "";
+  const next = JSON.stringify(parsed, null, 2) + trailingNewline;
+  if (next === raw) {
+    console.log("\n  No changes to write.");
+    return;
+  }
+  (0, import_fs.writeFileSync)(packageJsonPath, next, "utf8");
+  console.log(`
+  Saved '${PACKAGE_JSON_RELATIVE}'.`);
+  console.log(
+    `  NOTE: run \`yarn install\` (or your package manager equivalent) to install the updated dependency versions.`
+  );
+}
+
+// src/migrations/v2.0/migrate-workqueue-configs.ts
+var import_ts_morph17 = require("ts-morph");
+var import_path18 = __toESM(require("path"));
 var DEFINE_WORKQUEUES_NAME3 = "defineWorkqueues";
 var ACTIONS_PROPERTY_NAME5 = "actions";
 var ACTION_PROPERTY_NAME2 = "action";
@@ -2865,28 +3588,28 @@ var SUPPORTED_WORKQUEUE_ACTION_TYPES = /* @__PURE__ */ new Set([
 ]);
 function getWorkqueueLabel(workqueue) {
   const slugProperty = workqueue.getProperty(SLUG_PROPERTY_NAME);
-  if (!slugProperty || !import_ts_morph13.Node.isPropertyAssignment(slugProperty)) {
+  if (!slugProperty || !import_ts_morph17.Node.isPropertyAssignment(slugProperty)) {
     return "(unknown slug)";
   }
   const slugInitializer = slugProperty.getInitializer();
-  if (!slugInitializer || !import_ts_morph13.Node.isStringLiteral(slugInitializer)) {
+  if (!slugInitializer || !import_ts_morph17.Node.isStringLiteral(slugInitializer)) {
     return "(unknown slug)";
   }
   return slugInitializer.getLiteralValue();
 }
 function getActionTypeName(action) {
   const typeProperty = action.getProperty(TYPE_PROPERTY_NAME7);
-  if (!typeProperty || !import_ts_morph13.Node.isPropertyAssignment(typeProperty)) {
+  if (!typeProperty || !import_ts_morph17.Node.isPropertyAssignment(typeProperty)) {
     return null;
   }
   const typeInitializer = typeProperty.getInitializer();
   if (!typeInitializer) {
     return null;
   }
-  if (import_ts_morph13.Node.isStringLiteral(typeInitializer)) {
+  if (import_ts_morph17.Node.isStringLiteral(typeInitializer)) {
     return typeInitializer.getLiteralValue();
   }
-  if (import_ts_morph13.Node.isPropertyAccessExpression(typeInitializer)) {
+  if (import_ts_morph17.Node.isPropertyAccessExpression(typeInitializer)) {
     return typeInitializer.getName();
   }
   return null;
@@ -2900,19 +3623,19 @@ function isUnsupportedActionType(action) {
 }
 function migrateWorkqueueActions(workqueue, relPath) {
   const actionsProperty = workqueue.getProperty(ACTIONS_PROPERTY_NAME5);
-  if (!actionsProperty || !import_ts_morph13.Node.isPropertyAssignment(actionsProperty)) {
+  if (!actionsProperty || !import_ts_morph17.Node.isPropertyAssignment(actionsProperty)) {
     return 0;
   }
   const actionsInitializer = actionsProperty.getInitializer();
-  if (!actionsInitializer || !import_ts_morph13.Node.isArrayLiteralExpression(actionsInitializer)) {
+  if (!actionsInitializer || !import_ts_morph17.Node.isArrayLiteralExpression(actionsInitializer)) {
     return 0;
   }
   const workqueueLabel = getWorkqueueLabel(workqueue);
   const existingActionProperty = workqueue.getProperty(ACTION_PROPERTY_NAME2);
   if (existingActionProperty) {
-    if (import_ts_morph13.Node.isPropertyAssignment(existingActionProperty)) {
+    if (import_ts_morph17.Node.isPropertyAssignment(existingActionProperty)) {
       const existingActionInitializer = existingActionProperty.getInitializer();
-      if (existingActionInitializer && import_ts_morph13.Node.isObjectLiteralExpression(existingActionInitializer)) {
+      if (existingActionInitializer && import_ts_morph17.Node.isObjectLiteralExpression(existingActionInitializer)) {
         const conditionalsProperty2 = existingActionInitializer.getProperty(
           CONDITIONALS_PROPERTY_NAME
         );
@@ -2937,7 +3660,7 @@ function migrateWorkqueueActions(workqueue, relPath) {
     return 1;
   }
   const actionCandidates = actionsInitializer.getElements().filter(
-    (element) => import_ts_morph13.Node.isObjectLiteralExpression(element)
+    (element) => import_ts_morph17.Node.isObjectLiteralExpression(element)
   );
   if (actionCandidates.length === 0) {
     actionsProperty.remove();
@@ -2979,36 +3702,36 @@ function migrateWorkqueueActions(workqueue, relPath) {
   );
   return 1;
 }
-function processFile11(filePath, project) {
+function processFile13(filePath, project) {
   const sourceFile = project.getSourceFile(filePath);
   if (!sourceFile) return 0;
   let migratedWorkqueues = 0;
-  const relPath = import_path13.default.relative(getCwd(), filePath);
+  const relPath = import_path18.default.relative(process.cwd(), filePath);
   const callExpressions = sourceFile.getDescendantsOfKind(
-    import_ts_morph13.SyntaxKind.CallExpression
+    import_ts_morph17.SyntaxKind.CallExpression
   );
   for (const call of callExpressions) {
     const expression = call.getExpression();
-    if (!import_ts_morph13.Node.isIdentifier(expression) || expression.getText() !== DEFINE_WORKQUEUES_NAME3) {
+    if (!import_ts_morph17.Node.isIdentifier(expression) || expression.getText() !== DEFINE_WORKQUEUES_NAME3) {
       continue;
     }
     const args2 = call.getArguments();
     if (args2.length === 0) continue;
     const workqueuesArg = args2[0];
-    if (!import_ts_morph13.Node.isArrayLiteralExpression(workqueuesArg)) continue;
+    if (!import_ts_morph17.Node.isArrayLiteralExpression(workqueuesArg)) continue;
     for (const element of workqueuesArg.getElements()) {
-      if (!import_ts_morph13.Node.isObjectLiteralExpression(element)) continue;
+      if (!import_ts_morph17.Node.isObjectLiteralExpression(element)) continue;
       migratedWorkqueues += migrateWorkqueueActions(element, relPath);
     }
   }
   return migratedWorkqueues;
 }
-async function main13() {
-  const srcDir = import_path13.default.join(getCwd(), "src");
+async function main18() {
+  const srcDir = import_path18.default.join(process.cwd(), "src");
   console.log(`Scanning for defineWorkqueues calls in: ${srcDir}
 `);
-  const project = new import_ts_morph13.Project({
-    tsConfigFilePath: import_path13.default.resolve(srcDir, "../tsconfig.json"),
+  const project = new import_ts_morph17.Project({
+    tsConfigFilePath: import_path18.default.resolve(srcDir, "../tsconfig.json"),
     skipAddingFilesFromTsConfig: false
   });
   const sourceFiles = project.getSourceFiles().filter((sf) => {
@@ -3021,7 +3744,7 @@ async function main13() {
   const modifiedFiles = [];
   for (const sourceFile of sourceFiles) {
     const filePath = sourceFile.getFilePath();
-    const migrated = processFile11(filePath, project);
+    const migrated = processFile13(filePath, project);
     if (migrated > 0) {
       totalMigrated += migrated;
       modifiedFiles.push(filePath);
@@ -3038,7 +3761,7 @@ Saving ${modifiedFiles.length} modified file(s)...`);
   for (const filePath of modifiedFiles) {
     const sourceFile = project.getSourceFileOrThrow(filePath);
     await sourceFile.save();
-    console.log(`  Saved: ${import_path13.default.relative(getCwd(), filePath)}`);
+    console.log(`  Saved: ${import_path18.default.relative(process.cwd(), filePath)}`);
   }
   console.log(
     `
@@ -3047,13 +3770,13 @@ Done. Migrated ${totalMigrated} deprecated workqueue 'actions' definition(s) to
 }
 
 // src/migrations/v2.0/remove-demo-scope.ts
-var import_path14 = __toESM(require("path"));
-var import_ts_morph14 = require("ts-morph");
+var import_path19 = __toESM(require("path"));
+var import_ts_morph18 = require("ts-morph");
 var ROLES_HANDLER_RELATIVE_PATH = "src/data-seeding/roles/handler.ts";
-async function main14() {
-  const rolesHandlerPath = import_path14.default.join(getCwd(), ROLES_HANDLER_RELATIVE_PATH);
-  const project = new import_ts_morph14.Project({
-    tsConfigFilePath: import_path14.default.resolve(getCwd(), "tsconfig.json"),
+async function main19() {
+  const rolesHandlerPath = import_path19.default.join(process.cwd(), ROLES_HANDLER_RELATIVE_PATH);
+  const project = new import_ts_morph18.Project({
+    tsConfigFilePath: import_path19.default.resolve(process.cwd(), "tsconfig.json"),
     skipAddingFilesFromTsConfig: false
   });
   const sourceFile = project.getSourceFile(rolesHandlerPath);
@@ -3102,7 +3825,7 @@ async function main14() {
 
 // src/migrations/v2.0/remove-hearth-migrations.ts
 var fs2 = __toESM(require("fs"));
-var import_path15 = __toESM(require("path"));
+var import_path20 = __toESM(require("path"));
 var PATHS_TO_REMOVE = [
   {
     relativePath: "src/migrations/hearth",
@@ -3114,9 +3837,9 @@ var PATHS_TO_REMOVE = [
   },
   { relativePath: "src/utils/hearth-helpers.ts", label: "Hearth helpers file" }
 ];
-async function main15() {
+async function main20() {
   for (const { relativePath, label } of PATHS_TO_REMOVE) {
-    const absolutePath = import_path15.default.join(getCwd(), relativePath);
+    const absolutePath = import_path20.default.join(process.cwd(), relativePath);
     if (fs2.existsSync(absolutePath)) {
       fs2.rmSync(absolutePath, { recursive: true, force: true });
       console.log(`Removed ${label} '${relativePath}'.`);
@@ -3127,9 +3850,9 @@ async function main15() {
 }
 
 // src/migrations/v2.0/create-events-index.ts
-var import_ts_morph15 = require("ts-morph");
-var import_fs = __toESM(require("fs"));
-var import_path16 = __toESM(require("path"));
+var import_ts_morph19 = require("ts-morph");
+var import_fs2 = __toESM(require("fs"));
+var import_path21 = __toESM(require("path"));
 var DEFINE_CONFIG_NAME5 = "defineConfig";
 var HANDLER_FUNCTION_NAMES = /* @__PURE__ */ new Set([
   "getCustomEventsHandler",
@@ -3151,7 +3874,7 @@ var LICENSE_HEADER = `/*
 `;
 function findEventConfigExports(project, srcDir) {
   const found = [];
-  const eventsIndexAbs = import_path16.default.join(srcDir, "events", "index.ts");
+  const eventsIndexAbs = import_path21.default.join(srcDir, "events", "index.ts");
   for (const sourceFile of project.getSourceFiles()) {
     const filePath = sourceFile.getFilePath();
     if (!filePath.startsWith(srcDir) || filePath.includes("/node_modules/")) {
@@ -3163,10 +3886,10 @@ function findEventConfigExports(project, srcDir) {
       for (const decl of statement.getDeclarations()) {
         const initializer = decl.getInitializer();
         if (!initializer) continue;
-        const unwrapped = import_ts_morph15.Node.isAsExpression(initializer) ? initializer.getExpression() : initializer;
-        if (!import_ts_morph15.Node.isCallExpression(unwrapped)) continue;
+        const unwrapped = import_ts_morph19.Node.isAsExpression(initializer) ? initializer.getExpression() : initializer;
+        if (!import_ts_morph19.Node.isCallExpression(unwrapped)) continue;
         const callee = unwrapped.getExpression();
-        if (!import_ts_morph15.Node.isIdentifier(callee)) continue;
+        if (!import_ts_morph19.Node.isIdentifier(callee)) continue;
         if (callee.getText() !== DEFINE_CONFIG_NAME5) continue;
         found.push({ name: decl.getName(), filePath });
       }
@@ -3175,8 +3898,8 @@ function findEventConfigExports(project, srcDir) {
   return found;
 }
 function buildIndexImportSpecifier(eventConfigFilePath, srcDir) {
-  const eventsIndexDir = import_path16.default.join(srcDir, "events");
-  let rel = import_path16.default.relative(eventsIndexDir, eventConfigFilePath).split(import_path16.default.sep).join("/");
+  const eventsIndexDir = import_path21.default.join(srcDir, "events");
+  let rel = import_path21.default.relative(eventsIndexDir, eventConfigFilePath).split(import_path21.default.sep).join("/");
   if (rel.endsWith(".ts")) rel = rel.slice(0, -".ts".length);
   if (rel.endsWith("/index")) rel = rel.slice(0, -"/index".length);
   if (!rel.startsWith(".")) rel = "./" + rel;
@@ -3253,17 +3976,17 @@ function modifyHandler(sourceFile, exportNames) {
     );
   }
   for (const call of sourceFile.getDescendantsOfKind(
-    import_ts_morph15.SyntaxKind.CallExpression
+    import_ts_morph19.SyntaxKind.CallExpression
   )) {
     const callee = call.getExpression();
-    if (!import_ts_morph15.Node.isPropertyAccessExpression(callee)) continue;
+    if (!import_ts_morph19.Node.isPropertyAccessExpression(callee)) continue;
     if (callee.getName() !== RESPONSE_METHOD_NAME) continue;
     const args2 = call.getArguments();
     if (args2.length !== 1) continue;
     const [arg] = args2;
-    if (!import_ts_morph15.Node.isArrayLiteralExpression(arg)) continue;
+    if (!import_ts_morph19.Node.isArrayLiteralExpression(arg)) continue;
     if (arg.getElements().length === 0) continue;
-    if (!arg.getElements().every((el) => import_ts_morph15.Node.isIdentifier(el))) continue;
+    if (!arg.getElements().every((el) => import_ts_morph19.Node.isIdentifier(el))) continue;
     arg.replaceWithText(EVENT_CONFIGS_IDENTIFIER);
     changes.push(
       `rewrote h.response([...]) \u2192 h.response(${EVENT_CONFIGS_IDENTIFIER})`
@@ -3271,13 +3994,13 @@ function modifyHandler(sourceFile, exportNames) {
   }
   return changes;
 }
-async function main16() {
-  const cwd2 = getCwd();
-  const srcDir = import_path16.default.join(cwd2, "src");
+async function main21() {
+  const cwd = process.cwd();
+  const srcDir = import_path21.default.join(cwd, "src");
   console.log(`Scanning for defineConfig event exports in: ${srcDir}
 `);
-  const project = new import_ts_morph15.Project({
-    tsConfigFilePath: import_path16.default.resolve(srcDir, "../tsconfig.json"),
+  const project = new import_ts_morph19.Project({
+    tsConfigFilePath: import_path21.default.resolve(srcDir, "../tsconfig.json"),
     skipAddingFilesFromTsConfig: false
   });
   const eventConfigExports = findEventConfigExports(project, srcDir);
@@ -3289,15 +4012,15 @@ async function main16() {
   }
   console.log(`Found ${eventConfigExports.length} event config export(s):`);
   for (const e of eventConfigExports) {
-    console.log(`  ${e.name}  \u2190  ${import_path16.default.relative(cwd2, e.filePath)}`);
+    console.log(`  ${e.name}  \u2190  ${import_path21.default.relative(cwd, e.filePath)}`);
   }
-  const eventsIndexAbs = import_path16.default.join(srcDir, "events", "index.ts");
-  const eventsIndexRel = import_path16.default.relative(cwd2, eventsIndexAbs);
-  if (import_fs.default.existsSync(eventsIndexAbs)) {
+  const eventsIndexAbs = import_path21.default.join(srcDir, "events", "index.ts");
+  const eventsIndexRel = import_path21.default.relative(cwd, eventsIndexAbs);
+  if (import_fs2.default.existsSync(eventsIndexAbs)) {
     console.log(`
 [${eventsIndexRel}] already exists \u2014 leaving untouched.`);
   } else {
-    import_fs.default.mkdirSync(import_path16.default.dirname(eventsIndexAbs), { recursive: true });
+    import_fs2.default.mkdirSync(import_path21.default.dirname(eventsIndexAbs), { recursive: true });
     const source = buildEventsIndexSource(eventConfigExports, srcDir);
     const eventsIndexFile = project.createSourceFile(eventsIndexAbs, source, {
       overwrite: false
@@ -3318,7 +4041,7 @@ No event-config handler file found (looked for exported function(s): ${Array.fro
     );
     return;
   }
-  const handlerRelPath = import_path16.default.relative(cwd2, handler.getFilePath());
+  const handlerRelPath = import_path21.default.relative(cwd, handler.getFilePath());
   const exportNameSet = new Set(eventConfigExports.map((e) => e.name));
   const changes = modifyHandler(handler, exportNameSet);
   if (changes.length === 0) {
@@ -3338,12 +4061,13 @@ var UPSTREAM_URL = "https://github.com/opencrvs/opencrvs-countryconfig.git";
 var UPSTREAM_BRANCH = "develop";
 var TEMP_REMOTE = "opencrvs-upgrade-v19-v20-codemod";
 var FILES_TO_CHECKOUT = [
-  "infrastructure/postgres/setup-analytics.sh",
-  "src/analytics/analytics.ts"
+  "src/analytics/analytics.ts",
+  "Dockerfile",
+  "Dockerfile.assets"
 ];
 function runGit(args2, { silent = false } = {}) {
   return (0, import_child_process.execFileSync)("git", args2, {
-    cwd: getCwd(),
+    cwd: process.cwd(),
     encoding: "utf8",
     stdio: silent ? ["ignore", "pipe", "pipe"] : ["ignore", "pipe", "inherit"]
   });
@@ -3359,11 +4083,11 @@ function tryGit(args2) {
 function assertIsGitRepo() {
   if (!tryGit(["rev-parse", "--is-inside-work-tree"])) {
     throw new Error(
-      `checkout-upstream-files: ${getCwd()} is not a git repository. Initialise git (or run the upgrade inside a git checkout) before re-running.`
+      `${process.cwd()} is not a git repository. Initialise git (or run the upgrade inside a git checkout) before re-running.`
     );
   }
 }
-async function main17() {
+async function main22() {
   console.log(
     `Checking out ${FILES_TO_CHECKOUT.length} file(s) from ${UPSTREAM_URL}@${UPSTREAM_BRANCH}...
 `
@@ -3411,10 +4135,356 @@ async function main17() {
   }
 }
 
+// src/migrations/v2.0/add-resend-invite-notification.ts
+var import_fs3 = require("fs");
+var import_path22 = __toESM(require("path"));
+var import_ts_morph20 = require("ts-morph");
+var TS_MORPH_PROJECT_OPTIONS = {
+  skipAddingFilesFromTsConfig: true,
+  manipulationSettings: {
+    indentationText: import_ts_morph20.IndentationText.TwoSpaces
+  }
+};
+var EMAIL_TEMPLATES_INDEX = "src/api/notification/email-templates/index.ts";
+var NOTIFICATION_HANDLER = "src/api/notification/handler.ts";
+var USER_NOTIFICATION_ROUTES = "src/config/routes/userNotificationRoutes.ts";
+var SMS_SERVICE = "src/api/notification/sms-service.ts";
+var NOTIFICATION_CSV = "src/translations/notification.csv";
+var RESEND_INVITE_HTML = "src/api/notification/email-templates/other/resend-invite.html";
+var RESEND_INVITE_HTML_CONTENT = `<!doctype html>
+<html>
+  <head>
+    <link
+      href="https://fonts.googleapis.com/css2?family=Noto+Sans:wght@400;700&display=swap"
+      rel="stylesheet"
+    />
+    <style type="text/css">
+      body {
+        font-family: 'Noto Sans', sans-serif;
+        color: #222;
+        padding: 16px 24px;
+      }
+
+      h1 {
+        font-size: 21px;
+        margin-top: 32px;
+        margin-bottom: 36px;
+        font-weight: 700;
+      }
+
+      p {
+        font-weight: 400;
+        font-size: 16px;
+        line-height: 1.8;
+        margin-bottom: 24px;
+      }
+
+      i {
+        color: #666;
+        font-weight: 400;
+        font-size: 16px;
+      }
+    </style>
+  </head>
+
+  <body>
+    <img
+      src="{{countryLogo}}"
+      alt="country_logo"
+      style="max-height: 88px; max-width: 100%"
+    />
+    <h1>Your {{applicationName}} account invitation</h1>
+    <p>Hello {{firstname}},</p>
+    <p>Your account invitation has been resent. Please use the following credentials to access your account:</p>
+    <p>
+      Username: <strong>{{username}}</strong><br />
+      Password: <strong>{{temporaryPassword}}</strong>
+    </p>
+    <p>
+      Please click the link below to complete your account setup and start using
+      {{applicationName}}.
+    </p>
+
+    <div style="margin-top: 32px; margin-bottom: 32px">
+      <a href="{{loginURL}}">Complete setup</a>
+    </div>
+    <br />
+    <p>
+      Best regards, <br />
+      {{applicationName}} Team
+    </p>
+  </body>
+</html>
+`;
+var CSV_ROW = "resendInviteNotification,The SMS message that is sent when a user invitation is resent,Your OpenCRVS account invitation was resent. Please login with your username: {{username}} and temporary password: {{temporaryPassword}},Votre invitation de compte OpenCRVS a \xE9t\xE9 renvoy\xE9e. Veuillez vous connecter avec votre nom d'utilisateur : {{username}} et votre mot de passe temporaire : {{temporaryPassword}}.\n";
+function getObjectLiteralFromConst(declaration) {
+  if (!declaration) {
+    return;
+  }
+  const initializer = declaration.getInitializer();
+  if (!initializer) {
+    return;
+  }
+  if (import_ts_morph20.Node.isObjectLiteralExpression(initializer)) {
+    return initializer;
+  }
+  if (import_ts_morph20.Node.isAsExpression(initializer)) {
+    const expression = initializer.getExpression();
+    if (import_ts_morph20.Node.isObjectLiteralExpression(expression)) {
+      return expression;
+    }
+  }
+  if (import_ts_morph20.Node.isSatisfiesExpression(initializer)) {
+    const expression = initializer.getExpression();
+    if (import_ts_morph20.Node.isObjectLiteralExpression(expression)) {
+      return expression;
+    }
+  }
+}
+function patchEmailTemplatesIndex() {
+  const full = import_path22.default.join(process.cwd(), EMAIL_TEMPLATES_INDEX);
+  if (!(0, import_fs3.existsSync)(full)) {
+    console.log(`  '${EMAIL_TEMPLATES_INDEX}' missing \u2014 skipping.`);
+    return false;
+  }
+  const project = new import_ts_morph20.Project(TS_MORPH_PROJECT_OPTIONS);
+  const sourceFile = project.addSourceFileAtPath(full);
+  let changed = false;
+  const triggerVariableObject = getObjectLiteralFromConst(
+    sourceFile.getVariableDeclaration("TriggerVariable")
+  );
+  if (triggerVariableObject) {
+    const hasResendInviteVariable = triggerVariableObject.getProperties().some((prop) => prop.getText().includes("[TriggerEvent.RESEND_INVITE]"));
+    if (!hasResendInviteVariable) {
+      const properties = triggerVariableObject.getProperties();
+      const lastProperty = properties[properties.length - 1];
+      if (lastProperty) {
+        sourceFile.insertText(
+          lastProperty.getEnd(),
+          `,
+  [TriggerEvent.RESEND_INVITE]: z.object({
+    firstname: z.string(),
+    username: z.string(),
+    temporaryPassword: z.string(),
+    completeSetupUrl: z.string(),
+    loginURL: z.string()
+  })`
+        );
+        changed = true;
+      }
+    }
+  }
+  const templatesObject = getObjectLiteralFromConst(
+    sourceFile.getVariableDeclaration("templates")
+  );
+  if (templatesObject) {
+    const hasResendInviteTemplate = templatesObject.getProperties().some(
+      (prop) => prop.getText().includes("readOtherTemplate<TriggerVariable['resend-invite']>")
+    );
+    if (!hasResendInviteTemplate) {
+      const userCreatedProp = templatesObject.getProperties().find((prop) => prop.getText().includes("[TriggerEvent.USER_CREATED]"));
+      const anchor = userCreatedProp ?? templatesObject.getProperties()[templatesObject.getProperties().length - 1];
+      if (anchor) {
+        sourceFile.insertText(
+          anchor.getEnd(),
+          `,
+  [TriggerEvent.RESEND_INVITE]: {
+    type: 'resend-invite',
+    subject: 'Your OpenCRVS account invitation',
+    template:
+      readOtherTemplate<TriggerVariable['resend-invite']>('resend-invite')
+  }`
+        );
+        changed = true;
+      }
+    }
+  }
+  if (changed) {
+    sourceFile.saveSync();
+  }
+  return changed;
+}
+function patchNotificationHandler() {
+  const full = import_path22.default.join(process.cwd(), NOTIFICATION_HANDLER);
+  if (!(0, import_fs3.existsSync)(full)) {
+    return false;
+  }
+  const project = new import_ts_morph20.Project(TS_MORPH_PROJECT_OPTIONS);
+  const sourceFile = project.addSourceFileAtPath(full);
+  const convertFn = sourceFile.getFunction("convertPayloadToVariable");
+  if (!convertFn) {
+    return false;
+  }
+  const switchStmt = convertFn.getFirstDescendantByKind(
+    import_ts_morph20.SyntaxKind.SwitchStatement
+  );
+  if (!switchStmt) {
+    return false;
+  }
+  const clauses = switchStmt.getCaseBlock().getClauses();
+  const hasResendInvite = clauses.some(
+    (clause) => import_ts_morph20.Node.isCaseClause(clause) && clause.getExpression().getText() === "TriggerEvent.RESEND_INVITE"
+  );
+  if (hasResendInvite) {
+    return false;
+  }
+  const userCreatedClauseIndex = clauses.findIndex(
+    (clause) => import_ts_morph20.Node.isCaseClause(clause) && clause.getExpression().getText() === "TriggerEvent.USER_CREATED"
+  );
+  if (userCreatedClauseIndex < 0) {
+    return false;
+  }
+  const userCreatedClause = clauses[userCreatedClauseIndex];
+  sourceFile.insertText(
+    userCreatedClause.getEnd(),
+    `
+
+    case TriggerEvent.RESEND_INVITE:
+      return {
+        firstname,
+        username: payload.username,
+        temporaryPassword: payload.temporaryPassword,
+        completeSetupUrl: LOGIN_URL,
+        loginURL: LOGIN_URL
+      }`
+  );
+  sourceFile.saveSync();
+  return true;
+}
+function getReturnedArrayLiteral(functionFilePath, fnName) {
+  const project = new import_ts_morph20.Project(TS_MORPH_PROJECT_OPTIONS);
+  const sourceFile = project.addSourceFileAtPath(functionFilePath);
+  const fn = sourceFile.getFunction(fnName);
+  const returnStmt = fn?.getFirstDescendantByKind(import_ts_morph20.SyntaxKind.ReturnStatement);
+  const expr = returnStmt?.getExpression();
+  if (!expr || !import_ts_morph20.Node.isArrayLiteralExpression(expr)) {
+    return { sourceFile, arrayLiteral: void 0 };
+  }
+  return { sourceFile, arrayLiteral: expr };
+}
+function patchUserNotificationRoutes() {
+  const full = import_path22.default.join(process.cwd(), USER_NOTIFICATION_ROUTES);
+  if (!(0, import_fs3.existsSync)(full)) {
+    return false;
+  }
+  const { sourceFile, arrayLiteral } = getReturnedArrayLiteral(
+    full,
+    "getUserNotificationRoutes"
+  );
+  if (!arrayLiteral) {
+    return false;
+  }
+  const elements = arrayLiteral.getElements();
+  const routeExists = elements.some(
+    (element) => element.getText().includes(`path: '/triggers/user/resend-invite'`)
+  );
+  if (routeExists) {
+    return false;
+  }
+  const anchor = elements.find(
+    (element) => element.getText().includes(`path: '/triggers/user/user-created'`)
+  ) ?? elements[elements.length - 1];
+  if (!anchor) {
+    return false;
+  }
+  sourceFile.insertText(
+    anchor.getEnd(),
+    `,
+    {
+      method: 'POST',
+      path: '/triggers/user/resend-invite',
+      handler: makeNotificationHandler('resend-invite'),
+      options: {
+        auth: false,
+        tags: ['api'],
+        description: 'Handles notification for resent user invite'
+      }
+    }`
+  );
+  sourceFile.saveSync();
+  return true;
+}
+function patchSmsService() {
+  const full = import_path22.default.join(process.cwd(), SMS_SERVICE);
+  if (!(0, import_fs3.existsSync)(full)) {
+    return false;
+  }
+  const project = new import_ts_morph20.Project(TS_MORPH_PROJECT_OPTIONS);
+  const sourceFile = project.addSourceFileAtPath(full);
+  let changed = false;
+  const otherTemplatesObject = getObjectLiteralFromConst(
+    sourceFile.getVariableDeclaration("otherTemplates")
+  );
+  if (otherTemplatesObject) {
+    const hasResendTemplate = otherTemplatesObject.getProperties().some((prop) => prop.getText().includes("resendInviteNotification"));
+    if (!hasResendTemplate) {
+      const userCredentialsIndex = otherTemplatesObject.getProperties().findIndex((prop) => prop.getText().includes("userCredentialsNotification"));
+      otherTemplatesObject.insertPropertyAssignment(
+        userCredentialsIndex >= 0 ? userCredentialsIndex + 1 : otherTemplatesObject.getProperties().length,
+        {
+          name: "resendInviteNotification",
+          initializer: `'resendInviteNotification'`
+        }
+      );
+      changed = true;
+    }
+  }
+  const triggerToSmsTemplateObject = getObjectLiteralFromConst(
+    sourceFile.getVariableDeclaration("TriggerToSMSTemplate")
+  );
+  if (triggerToSmsTemplateObject) {
+    const hasResendInviteMap = triggerToSmsTemplateObject.getProperties().some((prop) => prop.getText().includes(`['resend-invite']`));
+    if (!hasResendInviteMap) {
+      const userCreatedIndex = triggerToSmsTemplateObject.getProperties().findIndex((prop) => prop.getText().includes(`['user-created']`));
+      triggerToSmsTemplateObject.insertPropertyAssignment(
+        userCreatedIndex >= 0 ? userCreatedIndex + 1 : triggerToSmsTemplateObject.getProperties().length,
+        {
+          name: `['resend-invite']`,
+          initializer: `'resendInviteNotification'`
+        }
+      );
+      changed = true;
+    }
+  }
+  if (changed) {
+    sourceFile.saveSync();
+  }
+  return changed;
+}
+async function main23() {
+  console.log("Adding RESEND_INVITE notification wiring\u2026");
+  const touched = [];
+  if (patchEmailTemplatesIndex()) touched.push(EMAIL_TEMPLATES_INDEX);
+  if (patchNotificationHandler()) touched.push(NOTIFICATION_HANDLER);
+  if (patchUserNotificationRoutes()) touched.push(USER_NOTIFICATION_ROUTES);
+  if (patchSmsService()) touched.push(SMS_SERVICE);
+  const csvPath = import_path22.default.join(process.cwd(), NOTIFICATION_CSV);
+  if ((0, import_fs3.existsSync)(csvPath)) {
+    let t = (0, import_fs3.readFileSync)(csvPath, "utf8");
+    if (!/^resendInviteNotification,/m.test(t)) {
+      if (!t.endsWith("\n")) t += "\n";
+      (0, import_fs3.writeFileSync)(csvPath, t + CSV_ROW);
+      touched.push(NOTIFICATION_CSV);
+    }
+  }
+  const htmlPath = import_path22.default.join(process.cwd(), RESEND_INVITE_HTML);
+  (0, import_fs3.mkdirSync)(import_path22.default.dirname(htmlPath), { recursive: true });
+  if (!(0, import_fs3.existsSync)(htmlPath)) {
+    (0, import_fs3.writeFileSync)(htmlPath, RESEND_INVITE_HTML_CONTENT);
+    touched.push(RESEND_INVITE_HTML);
+  }
+  if (touched.length === 0) {
+    console.log("  Nothing to update (already present or anchors not found).");
+    return;
+  }
+  console.log(`  Updated:
+${touched.map((f) => `    - ${f}`).join("\n")}`);
+}
+
 // src/migrations/v2.0/simplify-analytics-precalculations.ts
-var import_ts_morph16 = require("ts-morph");
-var import_fs2 = __toESM(require("fs"));
-var import_path17 = __toESM(require("path"));
+var import_ts_morph21 = require("ts-morph");
+var import_fs4 = __toESM(require("fs"));
+var import_path23 = __toESM(require("path"));
 var ANALYTICS_FILE_REL = "src/analytics/analytics.ts";
 var FUNCTION_NAME = "precalculateAdditionalAnalytics";
 var IMPORT_NAMES_TO_REMOVE = /* @__PURE__ */ new Set(["Event", "precalculateBirthEvent"]);
@@ -3450,10 +4520,10 @@ function findPrecalculateFunction(sourceFile) {
   return void 0;
 }
 function getFunctionBodyBlock(fn) {
-  if (import_ts_morph16.Node.isFunctionDeclaration(fn)) return fn.getBody();
+  if (import_ts_morph21.Node.isFunctionDeclaration(fn)) return fn.getBody();
   const initializer = fn.getInitializer();
   if (!initializer) return void 0;
-  if (!import_ts_morph16.Node.isArrowFunction(initializer) && !import_ts_morph16.Node.isFunctionExpression(initializer)) {
+  if (!import_ts_morph21.Node.isArrowFunction(initializer) && !import_ts_morph21.Node.isFunctionExpression(initializer)) {
     return void 0;
   }
   return initializer.getBody();
@@ -3463,9 +4533,9 @@ function simplifyPrecalculateFunction(sourceFile) {
   const fn = findPrecalculateFunction(sourceFile);
   if (!fn) return log;
   const body = getFunctionBodyBlock(fn);
-  if (!body || !import_ts_morph16.Node.isBlock(body)) return log;
+  if (!body || !import_ts_morph21.Node.isBlock(body)) return log;
   for (const statement of [...body.getStatements()]) {
-    const references = statement.getDescendantsOfKind(import_ts_morph16.SyntaxKind.Identifier).some((id) => IMPORT_NAMES_TO_REMOVE.has(id.getText()));
+    const references = statement.getDescendantsOfKind(import_ts_morph21.SyntaxKind.Identifier).some((id) => IMPORT_NAMES_TO_REMOVE.has(id.getText()));
     if (references) {
       statement.remove();
       log.push(`removed statement in ${FUNCTION_NAME} referencing removed imports`);
@@ -3473,7 +4543,7 @@ function simplifyPrecalculateFunction(sourceFile) {
   }
   const remaining = body.getStatements();
   const last = remaining[remaining.length - 1];
-  const alreadyCorrect = last && import_ts_morph16.Node.isReturnStatement(last) && last.getExpression()?.getText() === RETURN_EXPRESSION_TEXT;
+  const alreadyCorrect = last && import_ts_morph21.Node.isReturnStatement(last) && last.getExpression()?.getText() === RETURN_EXPRESSION_TEXT;
   if (!alreadyCorrect) {
     body.addStatements(`return ${RETURN_EXPRESSION_TEXT}`);
     log.push(
@@ -3482,17 +4552,17 @@ function simplifyPrecalculateFunction(sourceFile) {
   }
   return log;
 }
-async function main18() {
-  const cwd2 = getCwd();
-  const absPath = import_path17.default.join(cwd2, ANALYTICS_FILE_REL);
-  if (!import_fs2.default.existsSync(absPath)) {
+async function main24() {
+  const cwd = process.cwd();
+  const absPath = import_path23.default.join(cwd, ANALYTICS_FILE_REL);
+  if (!import_fs4.default.existsSync(absPath)) {
     console.log(
       `[${ANALYTICS_FILE_REL}] does not exist \u2014 nothing to clean up.`
     );
     return;
   }
-  const project = new import_ts_morph16.Project({
-    tsConfigFilePath: import_path17.default.resolve(cwd2, "tsconfig.json"),
+  const project = new import_ts_morph21.Project({
+    tsConfigFilePath: import_path23.default.resolve(cwd, "tsconfig.json"),
     skipAddingFilesFromTsConfig: false
   });
   const sourceFile = project.getSourceFile(absPath);
@@ -3519,26 +4589,158 @@ async function main18() {
 Saved ${ANALYTICS_FILE_REL}.`);
 }
 
-// src/migrations/v2.0/index.ts
-var cwd;
-function getCwd() {
-  if (!cwd) {
-    throw new Error("Country config working directory not set.");
+// src/migrations/v2.0/merge-infrastructure-directory.ts
+var import_child_process2 = require("child_process");
+var import_fs5 = require("fs");
+var import_os = require("os");
+var import_path24 = require("path");
+var TEMP_REMOTE2 = "opencrvs-upgrade-v19-v20-codemod-merge-infra";
+var INFRASTRUCTURE_DIR = "infrastructure";
+var BASE_BRANCH = "release-v1.9";
+function gitShowBytes(ref, path23) {
+  try {
+    const buf = (0, import_child_process2.execFileSync)("git", ["show", `${ref}:${path23}`], {
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  } catch {
+    return null;
   }
-  return cwd;
 }
-async function runUpgrade(ccwd) {
-  if (ccwd) {
-    console.log("Country config working directory:", ccwd);
-    cwd = ccwd;
+async function main25() {
+  console.log(
+    `Merging '${INFRASTRUCTURE_DIR}/' from ${UPSTREAM_URL}@${UPSTREAM_BRANCH} (base: ${BASE_BRANCH})...
+`
+  );
+  assertIsGitRepo();
+  tryGit(["remote", "remove", TEMP_REMOTE2]);
+  try {
+    console.log(`  Adding temporary remote '${TEMP_REMOTE2}' \u2192 ${UPSTREAM_URL}`);
+    runGit(["remote", "add", TEMP_REMOTE2, UPSTREAM_URL], { silent: true });
+    console.log(
+      `  Fetching ${TEMP_REMOTE2}/{${UPSTREAM_BRANCH},${BASE_BRANCH}} (depth 1)...`
+    );
+    runGit(["fetch", "--depth=1", TEMP_REMOTE2, UPSTREAM_BRANCH, BASE_BRANCH]);
+    const ref = `${TEMP_REMOTE2}/${UPSTREAM_BRANCH}`;
+    const baseRef = `${TEMP_REMOTE2}/${BASE_BRANCH}`;
+    const upstreamFiles = runGit(
+      [
+        "ls-tree",
+        "-r",
+        "--name-only",
+        "-z",
+        ref,
+        "--",
+        `${INFRASTRUCTURE_DIR}/`
+      ],
+      { silent: true }
+    ).split("\0").filter(Boolean);
+    if (upstreamFiles.length === 0) {
+      console.log(
+        `  No files found under '${INFRASTRUCTURE_DIR}/' on ${ref}. Nothing to merge.`
+      );
+      return;
+    }
+    const tmpDir = (0, import_fs5.mkdtempSync)((0, import_path24.join)((0, import_os.tmpdir)(), "opencrvs-merge-infra-"));
+    const baseTmp = (0, import_path24.join)(tmpDir, "base");
+    const theirsTmp = (0, import_path24.join)(tmpDir, "theirs");
+    let added = 0;
+    let merged = 0;
+    const conflictedFiles = [];
+    for (const file of upstreamFiles) {
+      const fullPath = (0, import_path24.join)(process.cwd(), file);
+      if (!(0, import_fs5.existsSync)(fullPath)) {
+        if (tryGit(["checkout", ref, "--", file])) {
+          console.log(`  + ${file} (new from upstream)`);
+          added++;
+        } else {
+          console.warn(`  [warn] failed to add new file ${file}`);
+        }
+        continue;
+      }
+      const theirContents = gitShowBytes(ref, file);
+      if (theirContents === null) {
+        console.warn(`  [warn] could not read ${file} from ${ref} \u2014 skipping.`);
+        continue;
+      }
+      (0, import_fs5.writeFileSync)(theirsTmp, theirContents);
+      const baseContents = gitShowBytes(baseRef, file);
+      (0, import_fs5.writeFileSync)(baseTmp, baseContents ?? new Uint8Array(0));
+      try {
+        (0, import_child_process2.execFileSync)("git", ["merge-file", fullPath, baseTmp, theirsTmp], {
+          cwd: process.cwd(),
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        runGit(["add", "--", file], { silent: true });
+        merged++;
+      } catch (err) {
+        const status = err.status;
+        if (typeof status === "number" && status > 0) {
+          conflictedFiles.push(file);
+          console.warn(
+            `  ! ${file} (${status} conflict${status > 1 ? "s" : ""})`
+          );
+        } else {
+          conflictedFiles.push(file);
+          console.warn(
+            `  [warn] merge failed for ${file} (likely binary or unreadable) \u2014 left untouched.`
+          );
+        }
+      }
+    }
+    console.log(
+      `
+  Done. ${added} added, ${merged} merged cleanly, ${conflictedFiles.length} with conflicts.`
+    );
+    if (conflictedFiles.length > 0) {
+      console.warn(
+        `
+  NOTE: ${conflictedFiles.length} file(s) under '${INFRASTRUCTURE_DIR}/' have merge conflicts that you must resolve manually.
+        Look for the standard conflict markers (<<<<<<<, =======, >>>>>>>) in:
+` + conflictedFiles.map((f) => `          - ${f}`).join("\n") + `
+        After resolving, stage the fixes with: git add ${INFRASTRUCTURE_DIR}/`
+      );
+    }
+  } finally {
+    if (tryGit(["remote", "remove", TEMP_REMOTE2])) {
+      console.log(`  Removed temporary remote '${TEMP_REMOTE2}'.`);
+    }
   }
-  if (!ccwd) {
+}
+
+// src/migrations/v2.0/delete-infrastructure-directory.ts
+var import_fs6 = require("fs");
+var import_path25 = require("path");
+var INFRASTRUCTURE_DIR2 = "infrastructure";
+async function main26() {
+  const fullPath = (0, import_path25.join)(process.cwd(), INFRASTRUCTURE_DIR2);
+  if (!(0, import_fs6.existsSync)(fullPath)) {
     console.log(
-      "Will use current working directory as country config working directory."
+      `'${INFRASTRUCTURE_DIR2}/' not found in ${process.cwd()} \u2014 nothing to delete.`
     );
-    cwd = process.cwd();
+    return;
   }
-  await main13();
+  console.log(`Deleting '${INFRASTRUCTURE_DIR2}/'...
+`);
+  assertIsGitRepo();
+  runGit(["rm", "-rf", "--ignore-unmatch", "--", `${INFRASTRUCTURE_DIR2}/`], {
+    silent: true
+  });
+  console.log(`  Staged deletion of tracked files under '${INFRASTRUCTURE_DIR2}/'.`);
+  if ((0, import_fs6.existsSync)(fullPath)) {
+    (0, import_fs6.rmSync)(fullPath, { recursive: true, force: true });
+    console.log(`  Removed remaining untracked files under '${INFRASTRUCTURE_DIR2}/'.`);
+  }
+  console.log(
+    `
+  Done. Review the staged deletion with: git diff --cached -- '${INFRASTRUCTURE_DIR2}/'`
+  );
+}
+
+// src/migrations/v2.0/index.ts
+async function runUpgrade(dockerSwarm) {
+  await main18();
   await main();
   await main2();
   await main3();
@@ -3551,11 +4753,22 @@ async function runUpgrade(ccwd) {
   await main10();
   await main11();
   await main12();
+  await main13();
   await main14();
   await main15();
   await main16();
+  await main19();
+  await main20();
+  await main21();
+  await main22();
+  await main23();
+  await main24();
   await main17();
-  await main18();
+  if (dockerSwarm) {
+    await main25();
+  } else {
+    await main26();
+  }
 }
 
 // src/cli.ts
@@ -3570,7 +4783,20 @@ Commands:
 
 Run 'opencrvs <command> --help' for more information on a command.
 `.trim();
-function main19() {
+var UPGRADE_USAGE = `
+Usage: opencrvs upgrade [options]
+
+Upgrade the country config in the current working directory to the next
+major version of OpenCRVS.
+
+Options:
+  --docker-swarm   Keep and merge the 'infrastructure/' directory with
+                   upstream changes. Use this if your country deploys
+                   OpenCRVS via Docker Swarm. When omitted, the
+                   'infrastructure/' directory is deleted (default).
+  -h, --help       Show this message.
+`.trim();
+function main27() {
   const command = args[0];
   if (!command || command === "--help" || command === "-h") {
     console.log(USAGE);
@@ -3615,10 +4841,25 @@ Subcommands:
   }
 }
 async function handleUpgrade() {
+  const upgradeArgs = args.slice(1);
+  if (upgradeArgs.includes("--help") || upgradeArgs.includes("-h")) {
+    console.log(UPGRADE_USAGE);
+    process.exit(0);
+  }
+  const KNOWN_FLAGS = /* @__PURE__ */ new Set(["--docker-swarm"]);
+  const unknownFlags = upgradeArgs.filter(
+    (arg) => arg.startsWith("-") && !KNOWN_FLAGS.has(arg)
+  );
+  if (unknownFlags.length > 0) {
+    console.error(`Unknown option(s): ${unknownFlags.join(", ")}
+`);
+    console.log(UPGRADE_USAGE);
+    process.exit(1);
+  }
+  const dockerSwarm = upgradeArgs.includes("--docker-swarm");
   console.log("Initiating upgrade...");
   try {
-    const pathToCountryconfig = args[1];
-    await runUpgrade(pathToCountryconfig);
+    await runUpgrade(dockerSwarm);
     console.log("Upgrade completed successfully!");
   } catch (error) {
     console.error("Upgrade failed:", error);
@@ -3630,4 +4871,4 @@ function handleCheckTranslations() {
   console.warn("This command is not implemented yet!");
   process.exit(1);
 }
-main19();
+main27();