@trackunit/migrations 0.0.3

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+## 0.0.3 (2026-05-06)
+
+This was a version bump only for migrations to align it with other projects, there were no code changes.
+
+## 0.0.2 (2026-05-04)
+
+This was a version bump only for migrations to align it with other projects, there were no code changes.

package/README.md

@@ -0,0 +1,105 @@
+# @trackunit/migrations
+
+Coordinator library that discovers installed `@trackunit/*` packages, updates their versions, and runs pending migrations.
+
+## How it works
+
+Each published `@trackunit/*` package can declare a `"migrations"` field in its `package.json` pointing to a `migrations.json` manifest. This library recursively scans `node_modules` (including nested/transitive dependencies) to find all such packages, then follows a two-step flow modeled after `nx migrate`:
+
+1. **`migrate`** -- discovers packages, updates `package.json` versions, writes pending migrations to `trackunit-migrations.json`
+2. **`run-migrations`** -- executes the pending migrations from that file, then clears the list
+
+Version state is tracked in `trackunit-migrations.json` so migrations that have already been applied are not re-run.
+
+```mermaid
+flowchart TD
+  subgraph step1 [Step 1: nx g @trackunit/migrations:migrate]
+    scan["Recursively scan node_modules\nfor @trackunit/* packages"]
+    scan --> checkField{"package.json\nhas migrations field?"}
+    checkField -->|No| skipPkg[Skip package]
+    checkField -->|Yes| loadManifest["Load migrations.json"]
+    loadManifest --> readState["Read trackunit-migrations.json\nfor migratedVersions state"]
+    readState --> filterVersion{"migration.version >\nlastMigratedVersion?"}
+    filterVersion -->|No| skipMigration[Skip migration]
+    filterVersion -->|Yes| collect["Add to pending list"]
+  end
+
+  subgraph updatePkg [Version Updates]
+    scan --> compareDeps{"Installed version >\npackage.json version?"}
+    compareDeps -->|Yes| bumpDep["Update version in\nconsumer package.json"]
+    compareDeps -->|No| noop[No change]
+  end
+
+  collect --> writeFile["Write trackunit-migrations.json\nwith pending migrations +\nupdated migratedVersions"]
+
+  subgraph step2 [Step 2: nx g @trackunit/migrations:run-migrations]
+    readFile["Read trackunit-migrations.json"] --> loop["For each pending migration"]
+    loop --> importImpl["Import migration implementation"]
+    importImpl --> execute["Execute migration against NX Tree\n(AST transforms, file rewrites)"]
+    execute --> clearPending["Clear pending list\nPreserve migratedVersions"]
+  end
+
+  writeFile --> review["Developer reviews\ntrackunit-migrations.json"]
+  review --> readFile
+```
+
+```mermaid
+flowchart LR
+  subgraph nodeModules ["node_modules (recursive scan)"]
+    rc["@trackunit/react-components\nv2.0.0\nmigrations: ./migrations.json"]
+    rcc["@trackunit/react-chart-components\nv1.20.0\nmigrations: ./migrations.json"]
+    su["@trackunit/shared-utils\nv1.13.0\n(no migrations field)"]
+    nested["some-lib/node_modules/\n@trackunit/react-components\nv1.21.8 (older, deduped out)"]
+  end
+
+  subgraph migrationsFiles [migrations.json per package]
+    rcMig["react-components/migrations.json\n- rename-button-kind (v1.22.0)\n- button-required-variant (v2.0.0)"]
+    rccMig["react-chart-components/migrations.json\n- chart-api-v2 (v1.20.0)"]
+  end
+
+  subgraph output [trackunit-migrations.json]
+    pending["migrations:\n- rename-button-kind\n- button-required-variant\n- chart-api-v2\n\nmigratedVersions:\n  react-components: 2.0.0\n  react-chart-components: 1.20.0"]
+  end
+
+  rc --> rcMig
+  rcc --> rccMig
+  su -.->|skipped| nodeModules
+  nested -.->|deduped| rc
+  rcMig --> pending
+  rccMig --> pending
+```
+
+## Usage
+
+### Step 1: Discover and collect migrations
+
+```bash
+nx g @trackunit/migrations:migrate
+```
+
+This updates `@trackunit/*` dependency versions in your `package.json` and writes a `trackunit-migrations.json` file listing any pending migrations. Review the file before proceeding.
+
+### Step 2: Run pending migrations
+
+```bash
+nx g @trackunit/migrations:run-migrations
+```
+
+This executes each migration listed in `trackunit-migrations.json` and clears the pending list. You can delete the file afterward or keep it for version tracking.
+
+### Internal monorepo
+
+```bash
+yarn nx g @trackunit/migrations:migrate
+yarn nx g @trackunit/migrations:run-migrations
+```
+
+For more info and a full guide on Iris App SDK Development, please visit our [Developer Hub](https://developers.trackunit.com/).
+
+## Trackunit
+
+This package was developed by Trackunit ApS.
+
+Trackunit is the leading SaaS-based IoT solution for the construction industry, offering an ecosystem of hardware, fleet management software & telematics.
+
+![The Trackunit logo](https://trackunit.com/wp-content/uploads/2022/03/top-logo.svg)

package/generators.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "generators": {
+    "migrate": {
+      "factory": "./src/generators/migrate/generator",
+      "schema": "./src/generators/migrate/schema.json",
+      "description": "Discover @trackunit packages, update package.json versions, and write pending migrations to trackunit-migrations.json"
+    },
+    "run-migrations": {
+      "factory": "./src/generators/run-migrations/generator",
+      "schema": "./src/generators/run-migrations/schema.json",
+      "description": "Execute pending migrations from trackunit-migrations.json"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@trackunit/migrations",
+  "version": "0.0.3",
+  "repository": "https://github.com/Trackunit/manager",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "engines": {
+    "node": ">=24.x"
+  },
+  "main": "src/index.js",
+  "generators": "./generators.json",
+  "dependencies": {
+    "@nx/devkit": "22.6.5",
+    "tslib": "^2.6.2",
+    "semver": "7.5.4"
+  },
+  "types": "./src/index.d.ts",
+  "type": "commonjs"
+}

package/src/generators/migrate/generator.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrate = void 0;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const path_1 = tslib_1.__importDefault(require("path"));
+const discover_packages_1 = require("../utils/discover-packages");
+const TRACKUNIT_MIGRATIONS_FILE = "trackunit-migrations.json";
+const getLastMigratedVersion = (tree, packageName) => {
+    if (!tree.exists(TRACKUNIT_MIGRATIONS_FILE))
+        return undefined;
+    try {
+        const file = (0, devkit_1.readJson)(tree, TRACKUNIT_MIGRATIONS_FILE);
+        return file.migratedVersions[packageName];
+    }
+    catch {
+        return undefined;
+    }
+};
+const getCurrentDepVersion = (tree, packageName) => {
+    const packageJson = (0, devkit_1.readJson)(tree, "package.json");
+    return packageJson.dependencies?.[packageName] ?? packageJson.devDependencies?.[packageName];
+};
+const updateDepVersion = (tree, pkg) => {
+    const currentDep = getCurrentDepVersion(tree, pkg.name);
+    if (currentDep === undefined || (0, discover_packages_1.compareVersions)(pkg.version, currentDep.replace(/^[~^]/, "")) <= 0) {
+        return;
+    }
+    (0, devkit_1.updateJson)(tree, "package.json", json => {
+        if (json.dependencies?.[pkg.name] !== undefined) {
+            json.dependencies[pkg.name] = pkg.version;
+        }
+        if (json.devDependencies?.[pkg.name] !== undefined) {
+            json.devDependencies[pkg.name] = pkg.version;
+        }
+        return json;
+    });
+    devkit_1.logger.info(`  Updated ${pkg.name} to ${pkg.version} in package.json`);
+};
+/**
+ * Returns an implementation path that is relative to the workspace root
+ * (`process.cwd()`) when the resolved path lives inside the workspace,
+ * so that `trackunit-migrations.json` is portable between machines and
+ * checkouts. Falls back to the absolute path for migrations sourced from
+ * outside the workspace (e.g. node_modules in a non-default location).
+ */
+const portableImplementationPath = (absolutePath, workspaceRoot) => {
+    const relative = path_1.default.relative(workspaceRoot, absolutePath);
+    if (relative === "" || relative.startsWith("..") || path_1.default.isAbsolute(relative)) {
+        return absolutePath;
+    }
+    return relative.split(path_1.default.sep).join("/");
+};
+const collectPendingMigrations = (pkg, lastMigrated, migrationsJson, workspaceRoot) => {
+    const pending = [];
+    const migrationsDir = path_1.default.dirname(pkg.migrationsJsonPath);
+    for (const [name, entry] of Object.entries(migrationsJson.generators ?? {})) {
+        if (lastMigrated !== undefined && (0, discover_packages_1.compareVersions)(entry.version, lastMigrated) <= 0) {
+            continue;
+        }
+        const absoluteImpl = path_1.default.resolve(migrationsDir, entry.implementation);
+        pending.push({
+            package: pkg.name,
+            name,
+            version: entry.version,
+            description: entry.description,
+            implementation: portableImplementationPath(absoluteImpl, workspaceRoot),
+        });
+    }
+    return pending;
+};
+/**
+ * Step 1: Discovers installed @trackunit packages, compares versions
+ * against the consumer's package.json, updates dependency versions,
+ * and writes trackunit-migrations.json with pending migrations.
+ *
+ * Usage: nx g @trackunit/migrations:migrate
+ * Then:  nx g @trackunit/migrations:run-migrations
+ */
+const migrate = (tree, options) => {
+    const packages = (0, discover_packages_1.discoverTrackunitPackages)();
+    const workspaceRoot = process.cwd();
+    devkit_1.logger.info(`Discovered ${packages.length} @trackunit/* package(s) with migrations`);
+    const allPending = [];
+    const migratedVersions = {};
+    if (tree.exists(TRACKUNIT_MIGRATIONS_FILE)) {
+        try {
+            const existing = (0, devkit_1.readJson)(tree, TRACKUNIT_MIGRATIONS_FILE);
+            Object.assign(migratedVersions, existing.migratedVersions);
+        }
+        catch {
+            // start fresh
+        }
+    }
+    for (const pkg of packages) {
+        updateDepVersion(tree, pkg);
+        const migrationsJson = (0, discover_packages_1.loadMigrationsJson)(pkg.migrationsJsonPath);
+        if (!migrationsJson?.generators || Object.keys(migrationsJson.generators).length === 0) {
+            if (options.verbose) {
+                devkit_1.logger.info(`  ${pkg.name}: no migrations defined`);
+            }
+            migratedVersions[pkg.name] = pkg.version;
+            continue;
+        }
+        const lastMigrated = getLastMigratedVersion(tree, pkg.name);
+        if (options.verbose) {
+            devkit_1.logger.info(`  ${pkg.name}: installed=${pkg.version}, lastMigrated=${lastMigrated ?? "none"}`);
+        }
+        const pending = collectPendingMigrations(pkg, lastMigrated, migrationsJson, workspaceRoot);
+        allPending.push(...pending);
+        if (pending.length > 0) {
+            devkit_1.logger.info(`${pkg.name}@${pkg.version}: ${pending.length} pending migration(s)`);
+            // Defer advancing migratedVersions until run-migrations has applied
+            // these entries. Otherwise a second `migrate` run would read this
+            // version back as `lastMigrated` and silently drop the queued migrations.
+            continue;
+        }
+        migratedVersions[pkg.name] = pkg.version;
+    }
+    const output = {
+        migratedVersions,
+        migrations: allPending,
+    };
+    tree.write(TRACKUNIT_MIGRATIONS_FILE, JSON.stringify(output, null, 2));
+    if (allPending.length === 0) {
+        devkit_1.logger.info("No pending migrations. trackunit-migrations.json updated.");
+    }
+    else {
+        devkit_1.logger.info(`\nWrote ${allPending.length} pending migration(s) to ${TRACKUNIT_MIGRATIONS_FILE}`);
+        devkit_1.logger.info("Review the file, then run: nx g @trackunit/migrations:run-migrations");
+    }
+};
+exports.migrate = migrate;
+exports.default = exports.migrate;
+//# sourceMappingURL=generator.js.map

package/src/generators/migrate/schema.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "type": "object",
+  "properties": {
+    "verbose": {
+      "type": "boolean",
+      "description": "Show detailed version comparison for each discovered package",
+      "default": false
+    }
+  }
+}

package/src/generators/run-migrations/__fixtures__/failing-migration.cjs

@@ -0,0 +1,3 @@
+module.exports = function failingMigration() {
+  throw new Error("Intentional test failure");
+};

package/src/generators/run-migrations/__fixtures__/noop-migration.cjs

@@ -0,0 +1 @@
+module.exports = function noopMigration() {};

package/src/generators/run-migrations/generator.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMigrations = void 0;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const path_1 = tslib_1.__importDefault(require("path"));
+const discover_packages_1 = require("../utils/discover-packages");
+/**
+ * Resolves a stored implementation path. Relative paths in
+ * `trackunit-migrations.json` are interpreted as relative to the
+ * workspace root (`process.cwd()`); absolute paths are used as-is.
+ * This keeps the on-disk file portable between checkouts while
+ * preserving back-compat with absolute paths.
+ */
+const resolveImplementationPath = (storedPath) => path_1.default.isAbsolute(storedPath) ? storedPath : path_1.default.resolve(process.cwd(), storedPath);
+const TRACKUNIT_MIGRATIONS_FILE = "trackunit-migrations.json";
+const runMigration = async (tree, migration, verbose) => {
+    try {
+        const resolvedPath = resolveImplementationPath(migration.implementation);
+        const migrationModule = await Promise.resolve(`${resolvedPath}`).then(s => tslib_1.__importStar(require(s)));
+        const migrationFn = migrationModule.default ?? migrationModule;
+        if (typeof migrationFn !== "function") {
+            devkit_1.logger.warn(`  "${migration.name}" does not export a function, skipping`);
+            return false;
+        }
+        if (verbose) {
+            devkit_1.logger.info(`  Running: ${migration.name} (v${migration.version}) from ${migration.package}`);
+        }
+        migrationFn(tree);
+        return true;
+    }
+    catch (error) {
+        devkit_1.logger.error(`  Failed "${migration.name}": ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+};
+/**
+ * Step 2: Reads trackunit-migrations.json and executes each pending
+ * migration. Successful migrations are removed from the pending list
+ * and bump `migratedVersions[package]` to their version. Failures
+ * stay in the list so they remain retryable on the next run without
+ * having to go through `migrate` again.
+ *
+ * Usage: nx g @trackunit/migrations:run-migrations
+ */
+const runMigrations = async (tree, options) => {
+    if (!tree.exists(TRACKUNIT_MIGRATIONS_FILE)) {
+        devkit_1.logger.error(`${TRACKUNIT_MIGRATIONS_FILE} not found. Run "nx g @trackunit/migrations:migrate" first.`);
+        return;
+    }
+    const file = (0, devkit_1.readJson)(tree, TRACKUNIT_MIGRATIONS_FILE);
+    if (file.migrations.length === 0) {
+        devkit_1.logger.info("No pending migrations to run.");
+        return;
+    }
+    devkit_1.logger.info(`Running ${file.migrations.length} migration(s)...\n`);
+    let succeeded = 0;
+    const remaining = [];
+    const migratedVersions = { ...file.migratedVersions };
+    for (const migration of file.migrations) {
+        devkit_1.logger.info(`${migration.package}: ${migration.name} - ${migration.description}`);
+        const ok = await runMigration(tree, migration, options.verbose ?? false);
+        if (ok) {
+            succeeded++;
+            const current = migratedVersions[migration.package];
+            if (current === undefined || (0, discover_packages_1.compareVersions)(migration.version, current) > 0) {
+                migratedVersions[migration.package] = migration.version;
+            }
+        }
+        else {
+            remaining.push(migration);
+        }
+    }
+    const updated = {
+        migratedVersions,
+        migrations: remaining,
+    };
+    tree.write(TRACKUNIT_MIGRATIONS_FILE, JSON.stringify(updated, null, 2));
+    await (0, devkit_1.formatFiles)(tree);
+    devkit_1.logger.info(`\n${succeeded} migration(s) applied successfully.`);
+    if (remaining.length > 0) {
+        devkit_1.logger.warn(`${remaining.length} migration(s) failed and remain in ${TRACKUNIT_MIGRATIONS_FILE}. Fix the cause and re-run "nx g @trackunit/migrations:run-migrations".`);
+    }
+    else {
+        devkit_1.logger.info(`\nYou can delete ${TRACKUNIT_MIGRATIONS_FILE} or keep it for version tracking.`);
+    }
+};
+exports.runMigrations = runMigrations;
+exports.default = exports.runMigrations;
+//# sourceMappingURL=generator.js.map

package/src/generators/run-migrations/schema.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "type": "object",
+  "properties": {
+    "verbose": {
+      "type": "boolean",
+      "description": "Show detailed output for each migration",
+      "default": false
+    }
+  }
+}

package/src/generators/utils/discover-packages.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverTrackunitPackages = exports.discoverWorkspaceTrackunitPackages = exports.compareVersions = exports.loadMigrationsJson = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const path_1 = tslib_1.__importDefault(require("path"));
+const readPackageJson = (pkgJsonPath) => {
+    try {
+        const raw = (0, fs_1.readFileSync)(pkgJsonPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+};
+const resolveMigrationsPath = (pkgDir, pkgJson) => {
+    const migrations = pkgJson.migrations;
+    if (migrations === undefined)
+        return undefined;
+    const migrationsFile = typeof migrations === "string" ? migrations : migrations.migrations;
+    const resolved = path_1.default.resolve(pkgDir, migrationsFile);
+    return (0, fs_1.existsSync)(resolved) ? resolved : undefined;
+};
+/** Compares two semver strings, returning negative/zero/positive like Array.sort comparators. */
+/** Loads and parses a migrations.json file from disk. */
+const loadMigrationsJson = (migrationsPath) => {
+    try {
+        const raw = (0, fs_1.readFileSync)(migrationsPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+};
+exports.loadMigrationsJson = loadMigrationsJson;
+const semver_1 = require("semver");
+/**
+ * Compare two semver strings, returning negative/zero/positive like Array.sort comparators.
+ *
+ * @param a - The first semver string to compare.
+ * @param b - The second semver string to compare.
+ * @returns {number} A negative number if a < b, 0 if a === b, and a positive number if a > b.
+ */
+const compareVersions = (a, b) => (0, semver_1.compare)(a, b);
+exports.compareVersions = compareVersions;
+const scanScopeDir = (scopeDir) => {
+    if (!(0, fs_1.existsSync)(scopeDir))
+        return [];
+    const entries = (0, fs_1.readdirSync)(scopeDir, { withFileTypes: true });
+    const found = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() && !entry.isSymbolicLink())
+            continue;
+        const pkgDir = path_1.default.join(scopeDir, entry.name);
+        const pkgJsonPath = path_1.default.join(pkgDir, "package.json");
+        const pkgJson = readPackageJson(pkgJsonPath);
+        if (!pkgJson)
+            continue;
+        const migrationsJsonPath = resolveMigrationsPath(pkgDir, pkgJson);
+        if (migrationsJsonPath) {
+            found.push({
+                name: pkgJson.name ?? `@trackunit/${entry.name}`,
+                version: pkgJson.version,
+                migrationsJsonPath,
+            });
+        }
+    }
+    return found;
+};
+const MANAGER_REPO_PACKAGE_NAME = "@trackunit/manager";
+const WORKSPACE_SCAN_ROOTS = ["libs", "apps"];
+const isManagerMonorepo = (cwd) => {
+    const rootPkgJson = readPackageJson(path_1.default.join(cwd, "package.json"));
+    return rootPkgJson?.name === MANAGER_REPO_PACKAGE_NAME;
+};
+const walkForPackageJsons = (rootDir, onPackageJson) => {
+    if (!(0, fs_1.existsSync)(rootDir))
+        return;
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        if (dir === undefined)
+            continue;
+        let entries;
+        try {
+            entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name === "node_modules" || entry.name.startsWith("."))
+                continue;
+            const entryPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(entryPath);
+            }
+            else if (entry.isFile() && entry.name === "package.json") {
+                onPackageJson(entryPath);
+            }
+        }
+    }
+};
+/**
+ * In-monorepo fallback discovery: scans libs/ and apps/ for
+ * package.json files whose name starts with "@trackunit/" and that
+ * declare a "migrations" field. Used only when the engine is run
+ * inside the manager monorepo (root package.json name is
+ * "@trackunit/manager"), since internal workspace projects are not
+ * symlinked under node_modules/@trackunit/* by Yarn.
+ */
+const discoverWorkspaceTrackunitPackages = (cwd = process.cwd()) => {
+    const found = [];
+    for (const root of WORKSPACE_SCAN_ROOTS) {
+        walkForPackageJsons(path_1.default.join(cwd, root), pkgJsonPath => {
+            const pkgJson = readPackageJson(pkgJsonPath);
+            if (!pkgJson?.name || !pkgJson.name.startsWith("@trackunit/"))
+                return;
+            const migrationsJsonPath = resolveMigrationsPath(path_1.default.dirname(pkgJsonPath), pkgJson);
+            if (!migrationsJsonPath)
+                return;
+            found.push({
+                name: pkgJson.name,
+                version: pkgJson.version,
+                migrationsJsonPath,
+            });
+        });
+    }
+    return found;
+};
+exports.discoverWorkspaceTrackunitPackages = discoverWorkspaceTrackunitPackages;
+/**
+ * Recursively walks node_modules directories looking for @trackunit/*
+ * packages that declare a "migrations" field. Scans root node_modules
+ * and nested node_modules inside every package. When the same package
+ * is found at multiple levels, the highest semver version is kept.
+ *
+ * Works with all package managers (npm, yarn, pnpm, bun).
+ *
+ * When invoked inside the manager monorepo (root package.json name
+ * is "@trackunit/manager"), additionally scans libs/ and apps/ for
+ * workspace packages that ship migrations, since those are not
+ * linked under node_modules/@trackunit/.
+ */
+const discoverTrackunitPackages = () => {
+    const cwd = process.cwd();
+    const rootNodeModules = path_1.default.resolve(cwd, "node_modules");
+    const allFound = [];
+    const visited = new Set();
+    const walkNodeModules = (nodeModulesDir) => {
+        if (!(0, fs_1.existsSync)(nodeModulesDir))
+            return;
+        const canonical = path_1.default.resolve(nodeModulesDir);
+        if (visited.has(canonical))
+            return;
+        visited.add(canonical);
+        const trackunitScope = path_1.default.join(nodeModulesDir, "@trackunit");
+        allFound.push(...scanScopeDir(trackunitScope));
+        const topEntries = (0, fs_1.readdirSync)(nodeModulesDir, {
+            withFileTypes: true,
+        });
+        for (const entry of topEntries) {
+            if (!entry.isDirectory() && !entry.isSymbolicLink())
+                continue;
+            const entryPath = path_1.default.join(nodeModulesDir, entry.name);
+            if (entry.name.startsWith("@")) {
+                const scopeEntries = (0, fs_1.readdirSync)(entryPath, {
+                    withFileTypes: true,
+                });
+                for (const scopeEntry of scopeEntries) {
+                    if (!scopeEntry.isDirectory() && !scopeEntry.isSymbolicLink())
+                        continue;
+                    walkNodeModules(path_1.default.join(entryPath, scopeEntry.name, "node_modules"));
+                }
+            }
+            else {
+                walkNodeModules(path_1.default.join(entryPath, "node_modules"));
+            }
+        }
+    };
+    walkNodeModules(rootNodeModules);
+    if (isManagerMonorepo(cwd)) {
+        allFound.push(...(0, exports.discoverWorkspaceTrackunitPackages)(cwd));
+    }
+    const byName = new Map();
+    for (const pkg of allFound) {
+        const existing = byName.get(pkg.name);
+        if (!existing || (0, exports.compareVersions)(pkg.version, existing.version) > 0) {
+            byName.set(pkg.name, pkg);
+        }
+    }
+    return [...byName.values()];
+};
+exports.discoverTrackunitPackages = discoverTrackunitPackages;
+//# sourceMappingURL=discover-packages.js.map

package/src/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMigrations = exports.migrate = void 0;
+var generator_1 = require("./generators/migrate/generator");
+Object.defineProperty(exports, "migrate", { enumerable: true, get: function () { return generator_1.migrate; } });
+var generator_2 = require("./generators/run-migrations/generator");
+Object.defineProperty(exports, "runMigrations", { enumerable: true, get: function () { return generator_2.runMigrations; } });
+//# sourceMappingURL=index.js.map