@peers-app/peers-sdk 0.18.8 → 0.19.0

package/dist/package-installer/package-installer.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installPackageFromBundles = installPackageFromBundles;
+exports.installAllPackageBundles = installAllPackageBundles;
+exports.saveBundleFile = saveBundleFile;
+exports.getPackageInfo = getPackageInfo;
+const file_types_1 = require("../data/files/file.types");
+const files_1 = require("../data/files/files");
+const package_version_resolver_1 = require("../data/package-version-resolver");
+const package_versions_1 = require("../data/package-versions");
+const packages_1 = require("../data/packages");
+const persistent_vars_1 = require("../data/persistent-vars");
+const utils_1 = require("../utils");
+/**
+ * Install or update a dev PackageVersion from locally-built bundle files.
+ *
+ * This is the core workhorse of the package-installer module. It reads
+ * bundles from `dist/`, hashes them for deduplication, saves File records
+ * only when content has changed, upserts the PackageVersion, and optionally
+ * triggers the package loader and device version resolution.
+ */
+async function installPackageFromBundles(dataContext, deps, packageId, opts) {
+    const versionTag = opts?.versionTag ?? "dev";
+    // 1. Resolve local path
+    const localPath = opts?.localPath ?? (await getPackageLocalPath(packageId, dataContext, deps));
+    if (!(await deps.fs.exists(localPath))) {
+        throw new Error(`Package directory does not exist: ${localPath}`);
+    }
+    // 2. Read package info
+    const info = await getPackageInfo(deps, localPath);
+    const version = info.version ?? "0.0.1";
+    // 3. Read bundle files
+    const distDir = deps.resolvePath(localPath, "dist");
+    const packageBundlePath = deps.resolvePath(distDir, "package.bundle.js");
+    if (!(await deps.fs.exists(packageBundlePath))) {
+        throw new Error(`Required bundle not found: ${packageBundlePath}. Run 'npm run build' first.`);
+    }
+    const packageBundle = await deps.fs.readFile(packageBundlePath);
+    const routesBundlePath = deps.resolvePath(distDir, "routes.bundle.js");
+    const routesBundle = (await deps.fs.exists(routesBundlePath))
+        ? await deps.fs.readFile(routesBundlePath)
+        : undefined;
+    const uiBundlePath = deps.resolvePath(distDir, "uis.bundle.js");
+    const uiBundle = (await deps.fs.exists(uiBundlePath))
+        ? await deps.fs.readFile(uiBundlePath)
+        : undefined;
+    // 4. Hash each bundle (must match file-system hashes for signature consistency)
+    const packageHash = (0, file_types_1.computeFileHash)(packageBundle);
+    const routesHash = routesBundle ? (0, file_types_1.computeFileHash)(routesBundle) : undefined;
+    const uiHash = uiBundle ? (0, file_types_1.computeFileHash)(uiBundle) : undefined;
+    // 5. Compute PV hash
+    const pvHash = (0, package_versions_1.computePackageVersionHash)(version, "", packageHash, routesHash, uiHash);
+    // 6. Early exit if unchanged
+    const pvTable = (0, package_versions_1.PackageVersions)(dataContext);
+    const existingPv = await pvTable.findOne({ packageId, versionTag });
+    if (existingPv && existingPv.packageVersionHash === pvHash) {
+        return {
+            packageVersion: existingPv,
+            loaded: undefined,
+            unchanged: true,
+        };
+    }
+    // 7. Save bundle files (deduped by hash)
+    const packageFile = await saveBundleFile(dataContext, packageBundle, `${packageId}-package.bundle.js`, packageId);
+    let routesFile;
+    if (routesBundle) {
+        routesFile = await saveBundleFile(dataContext, routesBundle, `${packageId}-routes.bundle.js`, packageId);
+    }
+    let uiFile;
+    if (uiBundle) {
+        uiFile = await saveBundleFile(dataContext, uiBundle, `${packageId}-uis.bundle.js`, packageId);
+    }
+    // 8. Upsert PackageVersion
+    const now = new Date().toISOString();
+    const pv = {
+        packageVersionId: existingPv?.packageVersionId ?? (0, utils_1.newid)(),
+        packageId,
+        version,
+        versionTag,
+        packageVersionHash: pvHash,
+        packageBundleFileId: packageFile.fileId,
+        packageBundleFileHash: packageFile.fileHash,
+        routesBundleFileId: routesFile?.fileId,
+        routesBundleFileHash: routesFile?.fileHash,
+        uiBundleFileId: uiFile?.fileId,
+        uiBundleFileHash: uiFile?.fileHash,
+        appNavs: existingPv?.appNavs,
+        history: existingPv?.history,
+        signature: existingPv?.signature ?? "",
+        createdBy: existingPv?.createdBy ?? packageId,
+        createdAt: now,
+    };
+    const savedPv = await pvTable.signAndSave(pv);
+    // 9. Load package (unless skipLoad)
+    let loaded;
+    if (!opts?.skipLoad) {
+        const pkg = await (0, packages_1.Packages)(dataContext).get(packageId);
+        if (pkg) {
+            loaded = await dataContext.packageLoader.loadPackage(pkg, {
+                force: true,
+                localPath,
+                packageVersionId: savedPv.packageVersionId,
+            });
+            // Extract appNavs from loaded instance onto the PV
+            if (loaded?.appNavs && JSON.stringify(loaded.appNavs) !== JSON.stringify(savedPv.appNavs)) {
+                savedPv.appNavs = loaded.appNavs;
+                await pvTable.signAndSave(savedPv);
+            }
+        }
+    }
+    // 10. Update package description if info provides one and it differs
+    const pkg = await (0, packages_1.Packages)(dataContext).get(packageId);
+    if (pkg && info.description && info.description !== pkg.description) {
+        await (0, packages_1.Packages)(dataContext).signAndSave({
+            ...pkg,
+            description: info.description,
+        });
+    }
+    // 11. Activate on device (unless skipResolve)
+    if (!opts?.skipResolve && pkg) {
+        await (0, package_version_resolver_1.updatePackagePrefs)(packageId, { activePackageVersionId: savedPv.packageVersionId }, dataContext);
+        await (0, package_version_resolver_1.resolveDevicePackageVersion)(pkg, dataContext, {
+            force: true,
+            localPath,
+        });
+    }
+    return { packageVersion: savedPv, loaded, unchanged: false };
+}
+/**
+ * Install bundles for all non-disabled packages in a data context.
+ * Errors are caught per-package so one failure doesn't block others.
+ */
+async function installAllPackageBundles(dataContext, deps) {
+    const packages = await (0, packages_1.Packages)(dataContext).list();
+    for (const pkg of packages) {
+        if (pkg.disabled)
+            continue;
+        try {
+            await installPackageFromBundles(dataContext, deps, pkg.packageId);
+        }
+        catch (err) {
+            console.error(`[package-installer] Failed to install bundles for ${pkg.name} (${pkg.packageId}):`, err);
+        }
+    }
+}
+/**
+ * Save a bundle's content as a File record, deduplicating by hash.
+ *
+ * If a File with the same hash already exists for this bundle name,
+ * the existing record is reused — no new File is created. This eliminates
+ * the "new File record on every dev reload" bug.
+ */
+async function saveBundleFile(dataContext, content, name, _packageId) {
+    const fileHash = (0, file_types_1.computeFileHash)(content);
+    const filesTable = (0, files_1.Files)(dataContext);
+    // Check if a file with this hash already exists for this bundle name
+    const existing = await filesTable.findOne({ name, fileHash });
+    if (existing) {
+        return { fileId: existing.fileId, fileHash: existing.fileHash };
+    }
+    const fileId = (0, utils_1.newid)();
+    const metadata = {
+        fileId,
+        name,
+        fileSize: content.length,
+        mimeType: "application/javascript",
+    };
+    const saved = await filesTable.saveFile(metadata, content);
+    return { fileId: saved.fileId, fileHash: saved.fileHash };
+}
+/**
+ * Read package metadata from a local package directory.
+ * Uses `deps.fs.readJson` instead of `require()` — no cache issues.
+ */
+async function getPackageInfo(deps, localPath) {
+    const pkgJsonPath = deps.resolvePath(localPath, "package.json");
+    const pkgJson = await deps.fs.readJson(pkgJsonPath);
+    const info = {
+        packageId: pkgJson.peers?.packageId,
+        name: pkgJson.name ?? "unknown",
+        version: pkgJson.version,
+        description: pkgJson.description,
+    };
+    // Try to get a richer description from README
+    const readmePath = deps.resolvePath(localPath, "README.md");
+    if (await deps.fs.exists(readmePath)) {
+        try {
+            const readme = await deps.fs.readFile(readmePath);
+            const firstParagraph = extractReadmeDescription(readme);
+            if (firstParagraph) {
+                info.description = firstParagraph;
+            }
+        }
+        catch {
+            // README read failure is non-fatal
+        }
+    }
+    // Try to detect remoteRepo from git
+    try {
+        const { stdout } = await deps.shell.exec("git remote get-url origin", {
+            cwd: localPath,
+        });
+        const url = stdout.trim();
+        if (url) {
+            info.remoteRepo = url;
+        }
+    }
+    catch {
+        // No git remote is fine
+    }
+    return info;
+}
+/**
+ * Resolve the local filesystem path for a package based on device vars.
+ * Awaits the loading promise to ensure the DB-stored value is available
+ * before reading. Falls back to `{packagesRootDir}`.
+ */
+async function getPackageLocalPath(packageId, dataContext, deps) {
+    const pvar = (0, persistent_vars_1.groupDeviceVar)(`packageLocalPath_${packageId}`, {
+        defaultValue: deps.packagesRootDir,
+        dataContext,
+    });
+    await pvar.loadingPromise;
+    return deps.resolvePath(pvar() ?? deps.packagesRootDir);
+}
+/** Extract the first non-heading paragraph from a README as a description. */
+function extractReadmeDescription(readme) {
+    const lines = readme.split("\n");
+    let foundContent = false;
+    const descLines = [];
+    for (const line of lines) {
+        // Skip headings and blank lines at the start
+        if (!foundContent) {
+            if (line.startsWith("#") || line.trim() === "")
+                continue;
+            foundContent = true;
+        }
+        // Stop at the next heading or blank line after content
+        if (foundContent) {
+            if (line.startsWith("#") || (line.trim() === "" && descLines.length > 0))
+                break;
+            descLines.push(line.trim());
+        }
+    }
+    const desc = descLines.join(" ").trim();
+    return desc || undefined;
+}

package/dist/package-installer/package-installer.test.d.ts

@@ -0,0 +1 @@
+export {};