@peers-app/peers-sdk 0.9.2 → 0.9.3

package/dist/data/orm/sql.data-source.js

@@ -484,7 +484,7 @@ function sqlValueToJsValue(value, fieldType, isArray) {
     if (value === undefined)
         return undefined;
     if (isArray) {
-        return JSON.parse(value);
+        return (0, serial_json_1.fromJSONString)(value);
     }
     if (fieldType === 'Date') {
         return new Date(value);

package/dist/data/orm/table-container.js

@@ -7,6 +7,19 @@ const table_1 = require("./table");
 const table_definitions_system_1 = require("./table-definitions.system");
 const utils_1 = require("../../utils");
 const rpc_types_1 = require("../../rpc-types");
+/**
+ * Normalize metaData for structural comparison by stripping fields that can differ
+ * between in-memory and DB-serialized representations without representing a real schema change.
+ * Specifically, `defaultValue` contains functions that the DB layer serializes as "__FUNCTION ..."
+ * strings (via serial-json.ts toJSON), causing false hash mismatches on every load.
+ * `defaultValue` is not part of the SQLite column schema so excluding it is semantically correct.
+ */
+function normalizeMetaDataForComparison(metaData) {
+    return {
+        ...metaData,
+        fields: metaData.fields.map(({ defaultValue: _omit, ...rest }) => rest),
+    };
+}
 /**
  * Compare two table definition versions and decide whether to update.
  * @returns 'update' when incoming version is strictly newer, 'skip' otherwise.
@@ -17,7 +30,7 @@ function checkVersionedUpdate(existingVersion, incomingVersion, existingMetaData
         return 'update';
     }
     if (existingVersion === incomingVersion) {
-        const sameDefinition = (0, utils_1.simpleObjectHash)(existingMetaData) === (0, utils_1.simpleObjectHash)(incomingMetaData);
+        const sameDefinition = (0, utils_1.simpleObjectHash)(normalizeMetaDataForComparison(existingMetaData)) === (0, utils_1.simpleObjectHash)(normalizeMetaDataForComparison(incomingMetaData));
         if (!sameDefinition) {
             const tableName = (0, utils_1.getFullTableName)(existingMetaData);
             console.error(`Table "${tableName}" has two different definitions with the same versionNumber (${existingMetaData.versionNumber}). Skipping update. Increment versionNumber when changing table definitions.`);

package/dist/data/packages.d.ts

@@ -90,4 +90,5 @@ export declare class PackagesTable extends Table<IPackage> {
 export declare function Packages(dataContext?: DataContext): PackagesTable;
 export declare const packagesRootDir: import("./persistent-vars").PersistentVar<string>;
 export declare const reloadPackagesOnPageRefresh: import("./persistent-vars").PersistentVar<boolean>;
+export declare const autoUpdatePeersCore: import("./persistent-vars").PersistentVar<boolean>;
 export {};

package/dist/data/packages.js

@@ -34,7 +34,7 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     done = true;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reloadPackagesOnPageRefresh = exports.packagesRootDir = exports.PackagesTable = void 0;
+exports.autoUpdatePeersCore = exports.reloadPackagesOnPageRefresh = exports.packagesRootDir = exports.PackagesTable = void 0;
 exports.Packages = Packages;
 const zod_1 = require("zod");
 const context_1 = require("../context");
@@ -138,3 +138,4 @@ function Packages(dataContext) {
 }
 exports.packagesRootDir = (0, persistent_vars_1.deviceVar)('packagesRootDir', { defaultValue: '~/peers-packages' });
 exports.reloadPackagesOnPageRefresh = (0, persistent_vars_1.deviceVar)('reloadPackagesOnPageRefresh', { defaultValue: true, });
+exports.autoUpdatePeersCore = (0, persistent_vars_1.deviceVar)('autoUpdatePeersCore', { defaultValue: true });

package/dist/package-loader/package-loader.d.ts

@@ -14,5 +14,7 @@ export declare class PackageLoader {
     loadPackage(pkg: IPackage, opts?: {
         force?: boolean;
     }): Promise<IPeersPackage | undefined>;
+    private _readLocalBundle;
+    private _evaluateBundle;
 }
 export declare function setDefaultRequire(require: (<T>(module: string) => T)): void;

package/dist/package-loader/package-loader.js

@@ -28,7 +28,6 @@ class PackageLoader {
         if (this.packageInstances[pkg.packageId] && !opts?.force) {
             return this.packageInstances[pkg.packageId];
         }
-        // console.debug(`Loading package bundle for ${pkg.name} (${pkg.packageId})`);
         try {
             let bundleCode = '';
             if (pkg.packageBundleFileId) {
@@ -39,63 +38,86 @@ class PackageLoader {
                 }
                 else {
                     console.warn(`Package bundle file not found for ${pkg.name} (fileId: ${pkg.packageBundleFileId})`);
-                    return;
                 }
             }
             else {
                 console.warn(`Package ${pkg.name} does not have a bundle file defined.`);
             }
-            // Create a safe execution context
-            const moduleExports = {};
-            const module = { exports: moduleExports };
-            // Create a custom require function that provides necessary dependencies
-            const customRequire = (moduleId) => {
-                // const require = getRequire(this.require);  
-                const _require = this.require ?? defaultRequire ?? typeof require === 'function' ? require : undefined;
-                if (!_require) {
-                    throw new Error('You must set the `require` function in package loader before loading a package');
+            // Fallback: try loading from local path if stored bundle is not available
+            if (!bundleCode && pkg.localPath) {
+                bundleCode = this._readLocalBundle(pkg) ?? '';
+            }
+            if (!bundleCode)
+                return;
+            return this._evaluateBundle(pkg, bundleCode);
+        }
+        catch (err) {
+            // If stored bundle failed to evaluate, try local path as fallback
+            if (pkg.localPath) {
+                console.warn(`[PackageLoader] Stored bundle failed for ${pkg.name}, trying local path fallback`, err.message);
+                try {
+                    const localBundleCode = this._readLocalBundle(pkg);
+                    if (localBundleCode) {
+                        return this._evaluateBundle(pkg, localBundleCode);
+                    }
                 }
-                // console.debug(`Custom require for module: ${moduleId}`);
-                switch (moduleId) {
-                    case 'peers-sdk':
-                    case 'PeersSDK':
-                        // Import all peers-sdk exports
-                        // return _require('peers-sdk');
-                        return PackageLoader.PeersSDK || _require('../index');
-                    case 'zod':
-                        return PackageLoader.Zod || _require('zod');
-                    default:
-                        // For other modules, use the standard require
-                        console.warn(`Package ${pkg.name} is requiring a module ${moduleId}, which is not provided by the package loader.`);
-                        return _require(moduleId);
+                catch (localErr) {
+                    console.debug(`Could not load local bundle for ${pkg.name}`, localErr);
                 }
-            };
-            // Evaluate the bundle using Function (safer than eval)
-            const bundleFunction = new Function('module', 'exports', 'require', bundleCode);
-            bundleFunction(module, moduleExports, customRequire);
-            // Extract the package instance from the bundle exports
-            const bundleExports = module.exports;
-            const packageInstance = bundleExports?.exports || bundleExports?.package || bundleExports?.default || bundleExports;
-            this.packageInstances[pkg.packageId] = packageInstance;
-            if (packageInstance && typeof packageInstance === 'object') {
-                // Register tools centrally using the tools-factory
-                packageInstance.toolInstances?.forEach((toolInstance) => {
-                    // Note that this isn't unregistering prior tools when force loading
-                    (0, tools_1.registerTool)(toolInstance);
-                    (0, tools_2.Tools)(this.dataContext).save(toolInstance.tool);
-                });
-                packageInstance.tableDefinitions?.forEach((tableDefinition) => {
-                    this.dataContext.tableContainer.registerTableDefinition(tableDefinition, { overwrite: true });
-                });
-                return packageInstance;
             }
+            console.debug(`Could not load package bundle for ${pkg.name}`, err);
             return;
         }
-        catch (err) {
-            console.debug(`Could not load package bundle for ${pkg.name}`, err);
+    }
+    _readLocalBundle(pkg) {
+        try {
+            const _require = this.require ?? defaultRequire ?? (typeof require === 'function' ? require : null);
+            if (!_require || !pkg.localPath)
+                return;
+            const fs = _require('fs');
+            const path = _require('path');
+            return fs.readFileSync(path.join(pkg.localPath, 'dist', 'package.bundle.js'), 'utf8');
+        }
+        catch {
             return;
         }
     }
+    _evaluateBundle(pkg, bundleCode) {
+        const moduleExports = {};
+        const module = { exports: moduleExports };
+        const customRequire = (moduleId) => {
+            const _require = this.require ?? defaultRequire ?? typeof require === 'function' ? require : undefined;
+            if (!_require) {
+                throw new Error('You must set the `require` function in package loader before loading a package');
+            }
+            switch (moduleId) {
+                case 'peers-sdk':
+                case 'PeersSDK':
+                    return PackageLoader.PeersSDK || _require('../index');
+                case 'zod':
+                    return PackageLoader.Zod || _require('zod');
+                default:
+                    console.warn(`Package ${pkg.name} is requiring a module ${moduleId}, which is not provided by the package loader.`);
+                    return _require(moduleId);
+            }
+        };
+        const bundleFunction = new Function('module', 'exports', 'require', bundleCode);
+        bundleFunction(module, moduleExports, customRequire);
+        const bundleExports = module.exports;
+        const packageInstance = bundleExports?.exports || bundleExports?.package || bundleExports?.default || bundleExports;
+        this.packageInstances[pkg.packageId] = packageInstance;
+        if (packageInstance && typeof packageInstance === 'object') {
+            packageInstance.toolInstances?.forEach((toolInstance) => {
+                (0, tools_1.registerTool)(toolInstance);
+                (0, tools_2.Tools)(this.dataContext).save(toolInstance.tool);
+            });
+            packageInstance.tableDefinitions?.forEach((tableDefinition) => {
+                this.dataContext.tableContainer.registerTableDefinition(tableDefinition, { overwrite: true });
+            });
+            return packageInstance;
+        }
+        return;
+    }
 }
 exports.PackageLoader = PackageLoader;
 let defaultRequire = undefined;

package/package.json

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