@peers-app/peers-sdk 0.19.10 → 0.19.12

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

@@ -7,4 +7,5 @@ export * from "./package-publisher";
 export * from "./package-remote-checker";
 export * from "./package-seed-installer";
 export * from "./package-tarball";
+export * from "./peers-core-installer";
 export * from "./types";

package/dist/package-installer/index.js

@@ -23,4 +23,5 @@ __exportStar(require("./package-publisher"), exports);
 __exportStar(require("./package-remote-checker"), exports);
 __exportStar(require("./package-seed-installer"), exports);
 __exportStar(require("./package-tarball"), exports);
+__exportStar(require("./peers-core-installer"), exports);
 __exportStar(require("./types"), exports);

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

@@ -5,8 +5,13 @@
  * Called at group creation time (not on every startup).
  */
 import type { DataContext } from "../context/data-context";
-/** Options for seeding a package into a data context. */
-export interface ISeedPackageOpts {
+import { type IPackage } from "../data/packages";
+/**
+ * Metadata needed to create (or backfill) a {@link IPackage} record, without
+ * any version/bundle data. Shared by {@link ensurePackageRecord} and
+ * {@link seedPackageInContext}.
+ */
+export interface IEnsurePackageRecordOpts {
     packageId: string;
     name: string;
     description?: string;
@@ -16,6 +21,9 @@ export interface ISeedPackageOpts {
     followVersionTags?: string;
     updateUrl?: string;
     remoteRepo?: string;
+}
+/** Options for seeding a package into a data context. */
+export interface ISeedPackageOpts extends IEnsurePackageRecordOpts {
     /** Bundle data for the initial PackageVersion. */
     version: string;
     versionTag: string;
@@ -43,3 +51,11 @@ export interface ISeedPackageOpts {
  * @returns true if seeding occurred, false if package already existed.
  */
 export declare function seedPackageInContext(dataContext: DataContext, opts: ISeedPackageOpts): Promise<boolean>;
+/**
+ * Ensure a {@link IPackage} record exists in `dataContext`, creating it from
+ * `opts` when absent and backfilling any missing metadata defaults when
+ * present. Does not create or modify any PackageVersion.
+ *
+ * @returns The current (created or existing) Package record.
+ */
+export declare function ensurePackageRecord(dataContext: DataContext, opts: IEnsurePackageRecordOpts): Promise<IPackage>;

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

@@ -7,6 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.seedPackageInContext = seedPackageInContext;
+exports.ensurePackageRecord = ensurePackageRecord;
 const package_versions_1 = require("../data/package-versions");
 const packages_1 = require("../data/packages");
 const utils_1 = require("../utils");
@@ -21,20 +22,35 @@ const package_installer_1 = require("./package-installer");
  * @returns true if seeding occurred, false if package already existed.
  */
 async function seedPackageInContext(dataContext, opts) {
-    const pkgTable = (0, packages_1.Packages)(dataContext);
-    const existingPkg = await pkgTable.get(opts.packageId);
+    const existingPkg = await (0, packages_1.Packages)(dataContext).get(opts.packageId);
     if (existingPkg) {
         // Package already exists — check if it has any version installed
-        const pvTable = (0, package_versions_1.PackageVersions)(dataContext);
-        const existingPvs = await pvTable.list({ packageId: opts.packageId });
+        const existingPvs = await (0, package_versions_1.PackageVersions)(dataContext).list({ packageId: opts.packageId });
         if (existingPvs.length > 0) {
             return false;
         }
-        // Package record exists but no versions — install the initial PV
-        applyMissingSeedDefaults(existingPkg, opts);
-        return await installSeedVersion(dataContext, existingPkg, opts);
     }
-    // Create Package record with provided defaults
+    // Create the Package record (or backfill missing defaults on an existing one),
+    // then install the initial PackageVersion from the bundle.
+    const pkg = await ensurePackageRecord(dataContext, opts);
+    return await installSeedVersion(dataContext, pkg, opts);
+}
+/**
+ * Ensure a {@link IPackage} record exists in `dataContext`, creating it from
+ * `opts` when absent and backfilling any missing metadata defaults when
+ * present. Does not create or modify any PackageVersion.
+ *
+ * @returns The current (created or existing) Package record.
+ */
+async function ensurePackageRecord(dataContext, opts) {
+    const pkgTable = (0, packages_1.Packages)(dataContext);
+    const existing = await pkgTable.get(opts.packageId);
+    if (existing) {
+        if (applyMissingRecordDefaults(existing, opts)) {
+            return await pkgTable.signAndSave(existing, { saveAsSnapshot: true });
+        }
+        return existing;
+    }
     const pkg = {
         packageId: opts.packageId,
         name: opts.name,
@@ -48,17 +64,24 @@ async function seedPackageInContext(dataContext, opts) {
         remoteRepo: opts.remoteRepo,
         signature: "",
     };
-    await pkgTable.signAndSave(pkg, { saveAsSnapshot: true });
-    await installSeedVersion(dataContext, pkg, opts);
-    return true;
+    return pkgTable.signAndSave(pkg, { saveAsSnapshot: true });
 }
-function applyMissingSeedDefaults(pkg, opts) {
-    pkg.description ||= opts.description ?? "";
-    pkg.publishPublicKey ||= opts.publishPublicKey ?? "";
-    pkg.versionFollowRange ||= opts.versionFollowRange;
-    pkg.followVersionTags ||= opts.followVersionTags;
-    pkg.updateUrl ||= opts.updateUrl;
-    pkg.remoteRepo ||= opts.remoteRepo;
+/** Backfill missing metadata onto an existing record. Returns true if changed. */
+function applyMissingRecordDefaults(pkg, opts) {
+    let changed = false;
+    const setIfEmpty = (key, value) => {
+        if (!pkg[key] && value) {
+            pkg[key] = value;
+            changed = true;
+        }
+    };
+    setIfEmpty("description", opts.description);
+    setIfEmpty("publishPublicKey", opts.publishPublicKey);
+    setIfEmpty("versionFollowRange", opts.versionFollowRange);
+    setIfEmpty("followVersionTags", opts.followVersionTags);
+    setIfEmpty("updateUrl", opts.updateUrl);
+    setIfEmpty("remoteRepo", opts.remoteRepo);
+    return changed;
 }
 async function installSeedVersion(dataContext, pkg, opts) {
     // Save bundle files (deduped by hash)

package/dist/package-installer/peers-core-installer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * peers-core install orchestrator.
+ *
+ * Ensures the `peers-core` package is installed into a given data context using
+ * a layered strategy:
+ *
+ * 1. No-op if peers-core already has a version in the context.
+ * 2. Copy from another context that already has it (used for new groups).
+ * 3. Install from the remote S3 `updateUrl` (used for new users; group fallback).
+ * 4. Seed the bundled copy shipped with the host app (offline fallback).
+ *
+ * Callers shape the strategy by what they pass: new users provide no
+ * `copyFromContexts` (remote-first), while new groups pass sibling contexts so
+ * they copy first and fall back to the remote `updateUrl`.
+ */
+import type { DataContext } from "../context/data-context";
+import type { UserContext } from "../context/user-context";
+import type { IHttpDeps } from "./types";
+/** Bundled peers-core sources shipped with the host app (offline fallback). */
+export interface IPeersCoreBundle {
+    version: string;
+    versionTag: string;
+    packageBundleCode: string;
+    routesBundleCode?: string;
+    uiBundleCode?: string;
+}
+/** Options controlling {@link ensurePeersCore}'s install strategy. */
+export interface IEnsurePeersCoreOpts {
+    /** HTTP interface for remote install. Omit to disable the remote path. */
+    http?: IHttpDeps;
+    /** S3 `updateUrl` for peers-core. Required for the remote path. */
+    updateUrl?: string;
+    /** Contexts to copy an already-installed peers-core from (e.g. personal + other groups). */
+    copyFromContexts?: DataContext[];
+    /** Bundled sources used as the offline fallback. */
+    bundle?: IPeersCoreBundle;
+    /** When true, try the bundled seed before the remote install (dev electron). */
+    preferBundle?: boolean;
+    /** Version tag to follow for the remote install. Defaults to `"stable"`. */
+    followTag?: string;
+}
+/**
+ * Ensure peers-core is installed (with a usable, loaded version) in
+ * `dataContext`, applying the layered strategy described in the module docs.
+ *
+ * @returns true if an install occurred, false if it was already present or no
+ *   strategy succeeded.
+ */
+export declare function ensurePeersCore(userContext: UserContext, dataContext: DataContext, opts: IEnsurePeersCoreOpts): Promise<boolean>;

package/dist/package-installer/peers-core-installer.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * peers-core install orchestrator.
+ *
+ * Ensures the `peers-core` package is installed into a given data context using
+ * a layered strategy:
+ *
+ * 1. No-op if peers-core already has a version in the context.
+ * 2. Copy from another context that already has it (used for new groups).
+ * 3. Install from the remote S3 `updateUrl` (used for new users; group fallback).
+ * 4. Seed the bundled copy shipped with the host app (offline fallback).
+ *
+ * Callers shape the strategy by what they pass: new users provide no
+ * `copyFromContexts` (remote-first), while new groups pass sibling contexts so
+ * they copy first and fall back to the remote `updateUrl`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensurePeersCore = ensurePeersCore;
+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 packages_utils_1 = require("../data/packages.utils");
+const system_ids_1 = require("../system-ids");
+const package_remote_checker_1 = require("./package-remote-checker");
+const package_seed_installer_1 = require("./package-seed-installer");
+const PEERS_CORE_NAME = "peers-core";
+const PEERS_CORE_DESCRIPTION = "Core system package for Peers platform";
+/**
+ * Ensure peers-core is installed (with a usable, loaded version) in
+ * `dataContext`, applying the layered strategy described in the module docs.
+ *
+ * @returns true if an install occurred, false if it was already present or no
+ *   strategy succeeded.
+ */
+async function ensurePeersCore(userContext, dataContext, opts) {
+    const existingPvs = await (0, package_versions_1.PackageVersions)(dataContext).list({ packageId: system_ids_1.peersCorePackageId });
+    if (existingPvs.length > 0)
+        return false;
+    if (await tryCopyFromContexts(dataContext, opts.copyFromContexts)) {
+        return true;
+    }
+    const tryRemote = () => tryRemoteInstall(userContext, dataContext, opts);
+    const tryBundle = () => tryBundleSeed(userContext, dataContext, opts);
+    const strategies = opts.preferBundle ? [tryBundle, tryRemote] : [tryRemote, tryBundle];
+    for (const strategy of strategies) {
+        if (await strategy())
+            return true;
+    }
+    return false;
+}
+/** Copy peers-core from the first sibling context that already has it, then load it. */
+async function tryCopyFromContexts(dataContext, copyFromContexts) {
+    if (!copyFromContexts?.length)
+        return false;
+    for (const source of copyFromContexts) {
+        if (source.dataContextId === dataContext.dataContextId)
+            continue;
+        try {
+            const sourcePkg = await (0, packages_1.Packages)(source).get(system_ids_1.peersCorePackageId);
+            if (!sourcePkg?.activePackageVersionId)
+                continue;
+            await (0, packages_utils_1.copyPackageToAnotherDataContext)(system_ids_1.peersCorePackageId, source, dataContext);
+            const copied = await (0, packages_1.Packages)(dataContext).get(system_ids_1.peersCorePackageId);
+            if (copied) {
+                await (0, package_version_resolver_1.resolveDevicePackageVersion)(copied, dataContext, { force: true });
+            }
+            return true;
+        }
+        catch (err) {
+            console.warn(`[peers-core-installer] copy from ${source.dataContextId} failed:`, err);
+        }
+    }
+    return false;
+}
+/** Create the Package record (if needed) and install the latest remote version. */
+async function tryRemoteInstall(userContext, dataContext, opts) {
+    if (!opts.http || !opts.updateUrl)
+        return false;
+    try {
+        const pkg = await (0, package_seed_installer_1.ensurePackageRecord)(dataContext, {
+            packageId: system_ids_1.peersCorePackageId,
+            name: PEERS_CORE_NAME,
+            description: PEERS_CORE_DESCRIPTION,
+            createdBy: userContext.userId,
+            publishPublicKey: system_ids_1.peersCorePublishPublicKey,
+            versionFollowRange: "latest",
+            followVersionTags: "stable",
+            updateUrl: opts.updateUrl,
+            remoteRepo: system_ids_1.peersCorePackageRepoUrl,
+        });
+        const result = await (0, package_remote_checker_1.checkAndInstallPackageRemoteVersion)(dataContext, pkg, opts.followTag ?? "stable", opts.http);
+        return !!result;
+    }
+    catch (err) {
+        console.warn("[peers-core-installer] remote install failed:", err);
+        return false;
+    }
+}
+/** Seed the bundled peers-core sources as an offline fallback. */
+async function tryBundleSeed(userContext, dataContext, opts) {
+    if (!opts.bundle)
+        return false;
+    try {
+        return await (0, package_seed_installer_1.seedPackageInContext)(dataContext, {
+            packageId: system_ids_1.peersCorePackageId,
+            name: PEERS_CORE_NAME,
+            description: PEERS_CORE_DESCRIPTION,
+            createdBy: userContext.userId,
+            publishPublicKey: system_ids_1.peersCorePublishPublicKey,
+            versionFollowRange: "latest",
+            followVersionTags: "stable",
+            updateUrl: opts.updateUrl,
+            remoteRepo: system_ids_1.peersCorePackageRepoUrl,
+            version: opts.bundle.version,
+            versionTag: opts.bundle.versionTag,
+            packageBundleCode: opts.bundle.packageBundleCode,
+            routesBundleCode: opts.bundle.routesBundleCode,
+            uiBundleCode: opts.bundle.uiBundleCode,
+            loadAfterSeed: true,
+        });
+    }
+    catch (err) {
+        console.warn("[peers-core-installer] bundle seed failed:", err);
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.19.10",
+  "version": "0.19.12",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"