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

package/dist/migrations/v2.0/remove-old-statistics-service.js

@@ -0,0 +1,356 @@
+"use strict";
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * OpenCRVS is also distributed under the terms of the Civil Registration
+ * & Healthcare Disclaimer located at http://opencrvs.org/license.
+ *
+ * Copyright (C) The OpenCRVS Authors located at https://github.com/opencrvs/opencrvs-core/blob/master/AUTHORS.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+/**
+ * Codemod: Remove the legacy `GET /statistics` Hapi route and its handler.
+ *
+ * Background:
+ *   In v1.x country configs exposed a `GET /statistics` route used by the
+ *   demo data-generator script to seed location statistics. In v2.0 this is
+ *   no longer part of the country config surface — the data-generator (where
+ *   it remains) talks to the Core FHIR APIs directly.
+ *
+ * What it does (per source file under `src/`):
+ *   1. Removes any `<receiver>.route({ method: 'GET', path: '/statistics', ... })`
+ *      call. Both single-route (`server.route({...})`) and array-route
+ *      (`server.route([{...}, {...}])`) forms are handled — for the array
+ *      form only the matching object is removed, the other routes stay.
+ *   2. Removes any `statisticsHandler` named import. If that empties an
+ *      import declaration, the whole declaration is dropped.
+ *   3. Finds the file that defines `export async function statisticsHandler`
+ *      (typically `src/api/data-generator/handler.ts`):
+ *        - If `statisticsHandler` is the file's *only* export → the whole
+ *          file is deleted.
+ *        - Otherwise → just the function declaration is removed and a
+ *          warning is logged so the developer can decide what to do with
+ *          the rest of the file.
+ *   4. After deleting the handler file, performs a transitive orphan sweep
+ *      bounded to the handler's directory subtree (e.g.
+ *      `src/api/data-generator/`):
+ *        - Each project-local import the handler had is checked. If no
+ *          remaining file in the project imports that module, the module
+ *          file is deleted too.
+ *        - Recursive: a deleted file's own local imports are then checked
+ *          the same way. The directory boundary prevents this from ever
+ *          touching shared utilities outside the handler's subtree.
+ *      This is what reaches `service.ts` (and friends) once nothing else
+ *      uses it.
+ *
+ * Caveats:
+ *   - Only project-local imports inside the handler's directory are
+ *     considered for orphan deletion. Helpers in shared locations (e.g.
+ *     `src/utils/`, `src/constants.ts`) are never auto-deleted.
+ *   - Files that are still referenced by *anything* in the project (other
+ *     handlers, scripts, demo/data-generators) are kept untouched.
+ *   - The codemod is a no-op when the route doesn't exist (already
+ *     migrated country configs).
+ */
+const path_1 = __importDefault(require("path"));
+const ts_morph_1 = require("ts-morph");
+const ROUTE_PATH = '/statistics';
+const HANDLER_NAME = 'statisticsHandler';
+/**
+ * Returns true if the given object literal has a property `path` whose
+ * value (string literal or no-substitution template literal) equals
+ * `ROUTE_PATH`.
+ */
+function isStatisticsRouteObject(obj) {
+    const pathProp = obj.getProperty('path');
+    if (!pathProp || !ts_morph_1.Node.isPropertyAssignment(pathProp))
+        return false;
+    const init = pathProp.getInitializer();
+    if (!init)
+        return false;
+    if (ts_morph_1.Node.isStringLiteral(init) || ts_morph_1.Node.isNoSubstitutionTemplateLiteral(init)) {
+        return init.getLiteralValue() === ROUTE_PATH;
+    }
+    return false;
+}
+/**
+ * Removes `<receiver>.route({...})` and `<receiver>.route([{...}, ...])`
+ * calls whose route object has `path: '/statistics'`. For the array form
+ * only the matching element is removed; siblings are preserved.
+ *
+ * Returns the number of routes removed in this file.
+ */
+function removeStatisticsRoutes(sourceFile) {
+    let removed = 0;
+    // Snapshot first — we'll be mutating the AST during iteration.
+    const callExpressions = [
+        ...sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+    ];
+    for (const call of callExpressions) {
+        if (call.wasForgotten())
+            continue;
+        const expr = call.getExpression();
+        if (!ts_morph_1.Node.isPropertyAccessExpression(expr))
+            continue;
+        if (expr.getName() !== 'route')
+            continue;
+        const args = call.getArguments();
+        if (args.length === 0)
+            continue;
+        const firstArg = args[0];
+        // Single-route form: `server.route({ method, path, handler, ... })`
+        if (ts_morph_1.Node.isObjectLiteralExpression(firstArg)) {
+            if (!isStatisticsRouteObject(firstArg))
+                continue;
+            // Drop the whole `server.route({...})` statement, not just the call,
+            // so we don't leave a dangling `;` behind.
+            const stmt = call.getFirstAncestorByKind(ts_morph_1.SyntaxKind.ExpressionStatement);
+            if (stmt) {
+                stmt.remove();
+                removed++;
+            }
+            else {
+                // Fallback (shouldn't happen at top level): replace the call.
+                call.replaceWithText('');
+                removed++;
+            }
+            continue;
+        }
+        // Array-route form: `server.route([{...}, {...}])`
+        if (ts_morph_1.Node.isArrayLiteralExpression(firstArg)) {
+            const matchingIndexes = firstArg
+                .getElements()
+                .map((el, idx) => ({ el, idx }))
+                .filter(({ el }) => ts_morph_1.Node.isObjectLiteralExpression(el) && isStatisticsRouteObject(el))
+                .map(({ idx }) => idx);
+            // Highest index first so each removal doesn't shift the index of
+            // matches we haven't dropped yet.
+            matchingIndexes
+                .sort((a, b) => b - a)
+                .forEach((idx) => {
+                firstArg.removeElement(idx);
+                removed++;
+            });
+        }
+    }
+    return removed;
+}
+/**
+ * Removes any `statisticsHandler` named import. Returns true if the file
+ * was modified.
+ */
+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 processFile(sourceFile) {
+    const routesRemoved = removeStatisticsRoutes(sourceFile);
+    const importsCleaned = removeStatisticsHandlerImports(sourceFile);
+    return { routesRemoved, importsCleaned };
+}
+/**
+ * Returns local-project import paths from the given source file that
+ * resolve to a file inside `subtreeRoot`. External (npm) imports and
+ * imports outside the subtree are excluded.
+ */
+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;
+}
+/**
+ * Walks files reachable from a deleted starting file via local imports
+ * within `subtreeRoot`, deleting any that nobody else imports. Recursive
+ * via worklist — when a file is deleted, its own local imports become
+ * candidates for the next round.
+ */
+function deleteOrphanedDescendants(project, startingFile, subtreeRoot) {
+    const initialCandidates = collectLocalImportsInSubtree(startingFile, subtreeRoot);
+    const startingPath = startingFile.getFilePath();
+    const deleted = new Set([startingPath]);
+    const seen = 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;
+        // Anyone left in the project still importing this file (including
+        // files outside the subtree)? If so, it's not actually orphaned.
+        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) => { var _a; return ((_a = decl.getModuleSpecifierSourceFile()) === null || _a === void 0 ? void 0 : _a.getFilePath()) === candidate; });
+        });
+        if (stillImported)
+            continue;
+        // Capture local imports BEFORE deletion — `delete()` invalidates the
+        // node, so we wouldn't be able to read them afterwards.
+        const next = collectLocalImportsInSubtree(candidateSf, subtreeRoot);
+        worklist.push(...next);
+        candidateSf.delete();
+        deleted.add(candidate);
+        orphans.push(candidate);
+    }
+    return orphans;
+}
+/**
+ * Finds the file that exports `statisticsHandler` and either deletes the
+ * whole file (when it's the sole export) or just removes the function
+ * declaration. When the file is deleted, also performs a transitive
+ * orphan sweep bounded to the file's directory.
+ */
+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) {
+            // Sole export — delete the file, then sweep orphans inside its
+            // directory subtree.
+            const subtreeRoot = path_1.default.dirname(filePath) + path_1.default.sep;
+            const orphansDeleted = deleteOrphanedDescendants(project, sf, subtreeRoot);
+            sf.delete();
+            return { filePath, action: 'deleted', orphansDeleted };
+        }
+        // Other exports exist; surgically remove just this function.
+        // We don't run the orphan sweep here — the file isn't gone, so
+        // anything it imports is presumably still in use.
+        fn.remove();
+        return {
+            filePath,
+            action: 'function-removed',
+            remainingExports: otherExports,
+            orphansDeleted: []
+        };
+    }
+    return { filePath: '', action: 'not-found', orphansDeleted: [] };
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const project = new ts_morph_1.Project({
+            tsConfigFilePath: path_1.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)...\n`);
+        let totalRoutesRemoved = 0;
+        let totalFilesWithImportsCleaned = 0;
+        let totalFilesWithRoutesRemoved = 0;
+        for (const sourceFile of sourceFiles) {
+            const filePath = sourceFile.getFilePath();
+            const rel = path_1.default.relative(process.cwd(), filePath);
+            const result = processFile(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) {
+                yield sourceFile.save();
+            }
+        }
+        const handlerResult = processHandlerFile(project);
+        switch (handlerResult.action) {
+            case 'deleted': {
+                const rel = path_1.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 = path_1.default.relative(process.cwd(), orphanPath);
+                    console.log(`  [${orphanRel}] Deleted (no remaining importers in the project after handler removal).`);
+                }
+                // `delete()` schedules deletion; `save()` writes it to disk.
+                yield project.save();
+                break;
+            }
+            case 'function-removed': {
+                const rel = path_1.default.relative(process.cwd(), handlerResult.filePath);
+                console.warn(`  [${rel}] Removed '${HANDLER_NAME}' function but kept the file (other exports remain: ${(_a = handlerResult.remainingExports) === null || _a === void 0 ? void 0 : _a.join(', ')}). Review whether the file is still needed.`);
+                // Save the source file with the function removed.
+                const sf = project.getSourceFile(handlerResult.filePath);
+                if (sf)
+                    yield sf.save();
+                break;
+            }
+            case 'not-found':
+                // Either already migrated or the handler lives somewhere unexpected.
+                // Not an error — continue silently.
+                break;
+        }
+        if (totalRoutesRemoved === 0 &&
+            totalFilesWithImportsCleaned === 0 &&
+            handlerResult.action === 'not-found') {
+            console.log(`\nNo 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(`\nDone. Removed ${totalRoutesRemoved} route(s) across ${totalFilesWithRoutesRemoved} file(s); cleaned ${HANDLER_NAME} import in ${totalFilesWithImportsCleaned} file(s)${orphansSummary}.`);
+    });
+}

package/dist/migrations/v2.0/remove-pending-certification-flag.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remove-pending-certification-flag.d.ts","sourceRoot":"","sources":["../../../src/migrations/v2.0/remove-pending-certification-flag.ts"],"names":[],"mappings":"AA2EA,iBAAe,IAAI,kBAiDlB;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}
+{"version":3,"file":"remove-pending-certification-flag.d.ts","sourceRoot":"","sources":["../../../src/migrations/v2.0/remove-pending-certification-flag.ts"],"names":[],"mappings":"AAyEA,iBAAe,IAAI,kBAiDlB;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}

package/dist/migrations/v2.0/remove-pending-certification-flag.js

@@ -38,7 +38,6 @@ exports.main = main;
  */
 const ts_morph_1 = require("ts-morph");
 const path_1 = __importDefault(require("path"));
-const _1 = require(".");
 const INHERENT_FLAGS_ENUM_NAME = 'InherentFlags';
 const PENDING_CERTIFICATION_MEMBER = 'PENDING_CERTIFICATION';
 function isPendingCertificationFlag(node) {
@@ -67,14 +66,14 @@ function processFile(filePath, project) {
         for (const index of indicesToRemove.reverse()) {
             array.removeElement(index);
             removedCount++;
-            console.log(`  [${path_1.default.relative((0, _1.getCwd)(), filePath)}] Removed InherentFlags.PENDING_CERTIFICATION from array`);
+            console.log(`  [${path_1.default.relative(process.cwd(), filePath)}] Removed InherentFlags.PENDING_CERTIFICATION from array`);
         }
     }
     return removedCount;
 }
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        const srcDir = path_1.default.join((0, _1.getCwd)(), 'src');
+        const srcDir = path_1.default.join(process.cwd(), 'src');
         console.log(`Scanning for InherentFlags.PENDING_CERTIFICATION array elements in: ${srcDir}\n`);
         const project = new ts_morph_1.Project({
             tsConfigFilePath: path_1.default.resolve(srcDir, '../tsconfig.json'),
@@ -103,7 +102,7 @@ function main() {
         for (const filePath of modifiedFiles) {
             const sourceFile = project.getSourceFileOrThrow(filePath);
             yield sourceFile.save();
-            console.log(`  Saved: ${path_1.default.relative((0, _1.getCwd)(), filePath)}`);
+            console.log(`  Saved: ${path_1.default.relative(process.cwd(), filePath)}`);
         }
         console.log(`\nDone. Removed ${totalRemoved} InherentFlags.PENDING_CERTIFICATION element(s) from array(s).`);
     });

package/dist/migrations/v2.0/remove-review-from-register-action.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remove-review-from-register-action.d.ts","sourceRoot":"","sources":["../../../src/migrations/v2.0/remove-review-from-register-action.ts"],"names":[],"mappings":"AAoJA,iBAAe,IAAI,kBAkDlB;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}
+{"version":3,"file":"remove-review-from-register-action.d.ts","sourceRoot":"","sources":["../../../src/migrations/v2.0/remove-review-from-register-action.ts"],"names":[],"mappings":"AAkJA,iBAAe,IAAI,kBAkDlB;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}

package/dist/migrations/v2.0/remove-review-from-register-action.js

@@ -39,7 +39,6 @@ exports.main = main;
  */
 const ts_morph_1 = require("ts-morph");
 const path_1 = __importDefault(require("path"));
-const _1 = require(".");
 const DEFINE_CONFIG_NAME = 'defineConfig';
 const ACTIONS_PROPERTY_NAME = 'actions';
 const TYPE_PROPERTY_NAME = 'type';
@@ -117,7 +116,7 @@ function processFile(filePath, project) {
             const wasRemoved = removeReviewFromRegisterActions(element);
             if (wasRemoved) {
                 removedCount++;
-                console.log(`  [${path_1.default.relative((0, _1.getCwd)(), filePath)}] Removed 'review' from REGISTER action`);
+                console.log(`  [${path_1.default.relative(process.cwd(), filePath)}] Removed 'review' from REGISTER action`);
             }
         }
     }
@@ -125,7 +124,7 @@ function processFile(filePath, project) {
 }
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        const srcDir = path_1.default.join((0, _1.getCwd)(), 'src');
+        const srcDir = path_1.default.join(process.cwd(), 'src');
         console.log(`Scanning for defineConfig calls in: ${srcDir}\n`);
         const project = new ts_morph_1.Project({
             tsConfigFilePath: path_1.default.resolve(srcDir, '../tsconfig.json'),
@@ -157,7 +156,7 @@ function main() {
         for (const filePath of modifiedFiles) {
             const sourceFile = project.getSourceFileOrThrow(filePath);
             yield sourceFile.save();
-            console.log(`  Saved: ${path_1.default.relative((0, _1.getCwd)(), filePath)}`);
+            console.log(`  Saved: ${path_1.default.relative(process.cwd(), filePath)}`);
         }
         console.log(`\nDone. Removed ${totalRemoved} 'review' property assignment(s) from REGISTER action(s).`);
     });

package/dist/migrations/v2.0/remove-unused-environment-variables.d.ts

@@ -0,0 +1,3 @@
+declare function main(): Promise<void>;
+export { main };
+//# sourceMappingURL=remove-unused-environment-variables.d.ts.map

package/dist/migrations/v2.0/remove-unused-environment-variables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-unused-environment-variables.d.ts","sourceRoot":"","sources":["../../../src/migrations/v2.0/remove-unused-environment-variables.ts"],"names":[],"mappings":"AAsJA,iBAAe,IAAI,kBAmDlB;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}

package/dist/migrations/v2.0/remove-unused-environment-variables.js

@@ -0,0 +1,186 @@
+"use strict";
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * OpenCRVS is also distributed under the terms of the Civil Registration
+ * & Healthcare Disclaimer located at http://opencrvs.org/license.
+ *
+ * Copyright (C) The OpenCRVS Authors located at https://github.com/opencrvs/opencrvs-core/blob/master/AUTHORS.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+/**
+ * Codemod: Remove environment variables that are no longer consumed by
+ * country config code in v2.0.
+ *
+ * Targets:
+ *   - APPLICATION_CONFIG_URL
+ *   - FHIR_URL
+ *   - CONFIRM_REGISTRATION_URL
+ *
+ * What it does:
+ *   1. In `src/environment.ts`, removes the matching properties from the
+ *      `cleanEnv(process.env, { ... })` schema object.
+ *   2. In `src/constants.ts`, removes the matching top-level `const`
+ *      declarations — by name OR by `env.<NAME>` reference (so that
+ *      country forks that renamed the constant but still read the same env
+ *      var are also cleaned up).
+ *
+ * Caveats:
+ *   - Removing these constants may produce TypeScript errors at usage
+ *     sites elsewhere in `src/` (e.g. files that imported `FHIR_URL` from
+ *     `@countryconfig/constants`). Those usages are intentionally left
+ *     for the developer to resolve, since the right replacement is
+ *     country-specific.
+ *   - The codemod is a no-op when the target files or properties don't
+ *     exist (e.g. the country config has already removed them).
+ */
+const path_1 = __importDefault(require("path"));
+const ts_morph_1 = require("ts-morph");
+const UNUSED_ENV_VARS = new Set([
+    'APPLICATION_CONFIG_URL',
+    'FHIR_URL',
+    'CONFIRM_REGISTRATION_URL'
+]);
+const ENVIRONMENT_FILE_RELATIVE = 'src/environment.ts';
+const CONSTANTS_FILE_RELATIVE = 'src/constants.ts';
+/**
+ * Strip matching properties from the `cleanEnv(process.env, { ... })` call
+ * in `src/environment.ts`. Returns the names that were removed.
+ */
+function cleanEnvironmentFile(project, filePath) {
+    var _a;
+    const sourceFile = project.getSourceFile(filePath);
+    if (!sourceFile)
+        return [];
+    const removed = [];
+    // IMPORTANT: never iterate all call expressions while mutating this object.
+    // Removing a property deletes nested `url(...)` nodes, and touching those
+    // forgotten nodes later causes `InvalidOperationError`.
+    const cleanEnvCall = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression).find((call) => {
+        const expr = call.getExpression();
+        return ts_morph_1.Node.isIdentifier(expr) && expr.getText() === 'cleanEnv';
+    });
+    if (!cleanEnvCall)
+        return removed;
+    const schemaArg = (_a = cleanEnvCall
+        .getArguments()[1]) === null || _a === void 0 ? void 0 : _a.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+    if (!schemaArg)
+        return removed;
+    // Remove by explicit property-name lookup to avoid iterating over a live
+    // node list while mutating the object literal.
+    for (const name of UNUSED_ENV_VARS) {
+        const prop = schemaArg.getProperty(name);
+        if (!prop)
+            continue;
+        if (prop.isKind(ts_morph_1.SyntaxKind.PropertyAssignment) ||
+            prop.isKind(ts_morph_1.SyntaxKind.ShorthandPropertyAssignment)) {
+            prop.remove();
+            removed.push(name);
+        }
+    }
+    return removed;
+}
+/**
+ * Match `env.<NAME>` in an initializer (allowing surrounding parens / `as`
+ * casts that ts-morph emits in `getText()` as e.g. `(env.X as string)`).
+ * Returns the env var name if matched, or null.
+ */
+function extractEnvAccess(initText) {
+    if (!initText)
+        return null;
+    const match = /\benv\.([A-Z][A-Z0-9_]*)\b/.exec(initText);
+    return match ? match[1] : null;
+}
+/**
+ * Strip top-level `const` declarations in `src/constants.ts` whose name is
+ * in `UNUSED_ENV_VARS` OR whose initializer reads `env.<NAME>` for one of
+ * those names. Returns the declaration names that were removed.
+ */
+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) => {
+            var _a;
+            const name = decl.getName();
+            const accessedEnvVar = extractEnvAccess((_a = decl.getInitializer()) === null || _a === void 0 ? void 0 : _a.getText());
+            return (UNUSED_ENV_VARS.has(name) ||
+                (accessedEnvVar !== null && UNUSED_ENV_VARS.has(accessedEnvVar)));
+        });
+        if (declarationsToRemove.length === 0)
+            continue;
+        // Resolve all names before mutating the AST; once a declaration or its
+        // parent statement is removed, ts-morph marks old nodes as forgotten.
+        const namesToRemove = declarationsToRemove.map((decl) => decl.getName());
+        removed.push(...namesToRemove);
+        if (declarationsToRemove.length === declarations.length) {
+            // All declarations in this statement are unused → drop the whole line
+            // (handles the dominant pattern: `export const X = env.X`).
+            stmt.remove();
+        }
+        else {
+            // Mixed statement (e.g. `const A = env.A, B = somethingElse`) — keep
+            // the survivors by removing matching declarators in place.
+            for (const decl of declarationsToRemove) {
+                decl.remove();
+            }
+        }
+    }
+    return removed;
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const project = new ts_morph_1.Project({
+            tsConfigFilePath: path_1.default.resolve(process.cwd(), 'tsconfig.json'),
+            skipAddingFilesFromTsConfig: false
+        });
+        console.log(`Removing unused environment variable(s) (${[...UNUSED_ENV_VARS].join(', ')})...\n`);
+        const envFilePath = path_1.default.join(process.cwd(), ENVIRONMENT_FILE_RELATIVE);
+        const constsFilePath = path_1.default.join(process.cwd(), CONSTANTS_FILE_RELATIVE);
+        const envRemoved = cleanEnvironmentFile(project, envFilePath);
+        if (envRemoved.length > 0) {
+            yield 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 — nothing to remove.`);
+        }
+        else {
+            console.log(`  [${ENVIRONMENT_FILE_RELATIVE}] File not found — skipping.`);
+        }
+        const constsRemoved = cleanConstantsFile(project, constsFilePath);
+        if (constsRemoved.length > 0) {
+            yield 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 — nothing to remove.`);
+        }
+        else {
+            console.log(`  [${CONSTANTS_FILE_RELATIVE}] File not found — skipping.`);
+        }
+        if (envRemoved.length === 0 && constsRemoved.length === 0) {
+            console.log('\nNothing to do.');
+            return;
+        }
+        console.log(`\nDone. NOTE: usages of these constants elsewhere in 'src/' may now produce TypeScript errors and need manual review.`);
+    });
+}

package/dist/migrations/v2.0/rename-api-paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rename-api-paths.d.ts","sourceRoot":"","sources":["../../../src/migrations/v2.0/rename-api-paths.ts"],"names":[],"mappings":"AAyJA,iBAAe,IAAI,kBAgDlB;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}
+{"version":3,"file":"rename-api-paths.d.ts","sourceRoot":"","sources":["../../../src/migrations/v2.0/rename-api-paths.ts"],"names":[],"mappings":"AAuJA,iBAAe,IAAI,kBAgDlB;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}

package/dist/migrations/v2.0/rename-api-paths.js

@@ -43,7 +43,6 @@ exports.main = main;
  */
 const ts_morph_1 = require("ts-morph");
 const path_1 = __importDefault(require("path"));
-const _1 = require(".");
 // ─── Path rename table ────────────────────────────────────────────────────────
 // Add new renames here as further API paths are changed between versions.
 const PATH_RENAMES = {
@@ -130,7 +129,7 @@ function processFile(filePath, project) {
     if (!sourceFile)
         return 0;
     let renamedCount = 0;
-    const relPath = path_1.default.relative((0, _1.getCwd)(), filePath);
+    const relPath = path_1.default.relative(process.cwd(), filePath);
     // Collect candidates first to avoid iterating a mutating tree
     const candidates = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
     for (const obj of candidates) {
@@ -147,7 +146,7 @@ function processFile(filePath, project) {
 // ─── Entry point ─────────────────────────────────────────────────────────────
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        const srcDir = path_1.default.join((0, _1.getCwd)(), 'src');
+        const srcDir = path_1.default.join(process.cwd(), 'src');
         console.log(`Scanning for Hapi route configs in: ${srcDir}\n`);
         console.log('Active path renames:');
         for (const [from, to] of Object.entries(PATH_RENAMES)) {
@@ -181,7 +180,7 @@ function main() {
         for (const filePath of modifiedFiles) {
             const sourceFile = project.getSourceFileOrThrow(filePath);
             yield sourceFile.save();
-            console.log(`  Saved: ${path_1.default.relative((0, _1.getCwd)(), filePath)}`);
+            console.log(`  Saved: ${path_1.default.relative(process.cwd(), filePath)}`);
         }
         console.log(`\nDone. Renamed ${totalRenamed} route path(s).`);
     });