pgpm 0.2.17 → 0.3.0

package/utils/index.js

@@ -20,3 +20,6 @@ __exportStar(require("./display"), exports);
 __exportStar(require("./cli-error"), exports);
 __exportStar(require("./deployed-changes"), exports);
 __exportStar(require("./module-utils"), exports);
+__exportStar(require("./npm-version"), exports);
+__exportStar(require("./update-check"), exports);
+__exportStar(require("./update-config"), exports);

package/utils/npm-version.d.ts

@@ -0,0 +1,2 @@
+export declare function fetchLatestVersion(pkgName: string, timeoutMs?: number): Promise<string | null>;
+export declare const compareVersions: (current: string, latest: string) => number;

package/utils/npm-version.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareVersions = void 0;
+exports.fetchLatestVersion = fetchLatestVersion;
+const child_process_1 = require("child_process");
+const semver_1 = __importDefault(require("semver"));
+const util_1 = require("util");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+async function fetchLatestVersion(pkgName, timeoutMs = 5000) {
+    try {
+        const result = await execFileAsync('npm', ['view', pkgName, 'version', '--json'], {
+            timeout: timeoutMs,
+            windowsHide: true,
+            maxBuffer: 1024 * 1024
+        });
+        const stdout = typeof result === 'string'
+            ? result
+            : result?.stdout ?? '';
+        const parsed = parseVersionOutput(stdout);
+        return parsed ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+const parseVersionOutput = (raw) => {
+    const trimmed = raw.trim();
+    if (!trimmed.length)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed === 'string')
+            return parsed;
+        if (Array.isArray(parsed) && parsed.length) {
+            return String(parsed[parsed.length - 1]);
+        }
+    }
+    catch {
+        // fall through to plain string parse
+    }
+    return trimmed || null;
+};
+const compareVersions = (current, latest) => {
+    const currentSemver = semver_1.default.coerce(current);
+    const latestSemver = semver_1.default.coerce(latest);
+    if (currentSemver && latestSemver) {
+        return semver_1.default.compare(currentSemver, latestSemver);
+    }
+    return current.localeCompare(latest);
+};
+exports.compareVersions = compareVersions;

package/utils/update-check.d.ts

@@ -0,0 +1,10 @@
+import { UpdateCheckConfig } from '@launchql/types';
+import { UpdateConfigOptions } from './update-config';
+export interface CheckForUpdatesOptions extends UpdateConfigOptions {
+    pkgName?: string;
+    pkgVersion?: string;
+    command?: string;
+    now?: number;
+    updateCommand?: string;
+}
+export declare function checkForUpdates(options?: CheckForUpdatesOptions): Promise<UpdateCheckConfig | null>;

package/utils/update-check.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForUpdates = checkForUpdates;
+const logger_1 = require("@launchql/logger");
+const types_1 = require("@launchql/types");
+const package_1 = require("../package");
+const npm_version_1 = require("./npm-version");
+const update_config_1 = require("./update-config");
+const log = new logger_1.Logger('update-check');
+const shouldSkip = (command) => {
+    if (process.env.PGPM_SKIP_UPDATE_CHECK)
+        return true;
+    if (process.env.CI === 'true')
+        return true;
+    if (command === 'update')
+        return true;
+    return false;
+};
+async function checkForUpdates(options = {}) {
+    const { pkgName = types_1.UPDATE_PACKAGE_NAME, pkgVersion = (0, package_1.readAndParsePackageJson)().version, command, now = Date.now(), key = types_1.UPDATE_CHECK_APPSTASH_KEY, toolName, baseDir } = options;
+    if (shouldSkip(command)) {
+        return null;
+    }
+    try {
+        const existing = await (0, update_config_1.readUpdateConfig)({ toolName, baseDir, key });
+        let latestKnownVersion = existing?.latestKnownVersion ?? pkgVersion;
+        const needsCheck = (0, update_config_1.shouldCheck)(now, existing?.lastCheckedAt, types_1.UPDATE_CHECK_TTL_MS);
+        if (needsCheck) {
+            const fetched = await (0, npm_version_1.fetchLatestVersion)(pkgName);
+            if (fetched) {
+                latestKnownVersion = fetched;
+            }
+            await (0, update_config_1.writeUpdateConfig)({
+                lastCheckedAt: now,
+                latestKnownVersion
+            }, { toolName, baseDir, key });
+        }
+        const comparison = (0, npm_version_1.compareVersions)(pkgVersion, latestKnownVersion);
+        const isOutdated = comparison < 0;
+        if (isOutdated) {
+            const defaultUpdateCommand = pkgName === types_1.UPDATE_PACKAGE_NAME
+                ? 'Run pgpm update to upgrade.'
+                : `Run npm i -g ${pkgName}@latest to upgrade.`;
+            const updateInstruction = options.updateCommand ?? defaultUpdateCommand;
+            log.warn(`A new version of ${pkgName} is available (current ${pkgVersion}, latest ${latestKnownVersion}). ${updateInstruction}`);
+            await (0, update_config_1.writeUpdateConfig)({
+                lastCheckedAt: now,
+                latestKnownVersion
+            }, { toolName, baseDir, key });
+        }
+        return {
+            lastCheckedAt: now,
+            latestKnownVersion
+        };
+    }
+    catch (error) {
+        log.debug('Update check skipped due to error:', error);
+        return null;
+    }
+}

package/utils/update-config.d.ts

@@ -0,0 +1,10 @@
+import { UpdateCheckConfig } from '@launchql/types';
+export interface UpdateConfigOptions {
+    toolName?: string;
+    baseDir?: string;
+    key?: string;
+}
+export declare const shouldCheck: (now: number, lastCheckedAt: number | undefined, ttlMs: number) => boolean;
+export declare function readUpdateConfig(options?: UpdateConfigOptions): Promise<UpdateCheckConfig | null>;
+export declare function writeUpdateConfig(config: UpdateCheckConfig, options?: UpdateConfigOptions): Promise<void>;
+export declare const resolveUpdateConfigPath: (options?: UpdateConfigOptions) => string;

package/utils/update-config.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUpdateConfigPath = exports.shouldCheck = void 0;
+exports.readUpdateConfig = readUpdateConfig;
+exports.writeUpdateConfig = writeUpdateConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const appstash_1 = require("appstash");
+const types_1 = require("@launchql/types");
+const defaultToolName = 'pgpm';
+const getConfigPath = (options = {}) => {
+    const toolName = options.toolName ?? defaultToolName;
+    const dirs = (0, appstash_1.appstash)(toolName, {
+        ensure: true,
+        baseDir: options.baseDir
+    });
+    const configDir = (0, appstash_1.resolve)(dirs, 'config');
+    if (!fs_1.default.existsSync(configDir)) {
+        fs_1.default.mkdirSync(configDir, { recursive: true });
+    }
+    const fileName = `${(options.key ?? types_1.UPDATE_CHECK_APPSTASH_KEY).replace(/[^a-z0-9-_]/gi, '_')}.json`;
+    return path_1.default.join(configDir, fileName);
+};
+const shouldCheck = (now, lastCheckedAt, ttlMs) => {
+    if (!lastCheckedAt)
+        return true;
+    return now - lastCheckedAt > ttlMs;
+};
+exports.shouldCheck = shouldCheck;
+async function readUpdateConfig(options = {}) {
+    const configPath = getConfigPath(options);
+    if (!fs_1.default.existsSync(configPath)) {
+        return null;
+    }
+    try {
+        const contents = await fs_1.default.promises.readFile(configPath, 'utf8');
+        const parsed = JSON.parse(contents);
+        return parsed;
+    }
+    catch {
+        // Corrupted config – clear it
+        try {
+            await fs_1.default.promises.rm(configPath, { force: true });
+        }
+        catch {
+            // ignore
+        }
+        return null;
+    }
+}
+async function writeUpdateConfig(config, options = {}) {
+    const configPath = getConfigPath(options);
+    await fs_1.default.promises.writeFile(configPath, JSON.stringify(config, null, 2), 'utf8');
+}
+// Exposed for testing to locate the config path for a given namespace/baseDir
+const resolveUpdateConfigPath = (options = {}) => getConfigPath(options);
+exports.resolveUpdateConfigPath = resolveUpdateConfigPath;