@peers-app/peers-sdk 0.12.5 → 0.13.0

package/dist/data/files/files.js

@@ -141,7 +141,6 @@ rpc_types_1.rpcServerCalls.getFileContentsBase64 = async (fileId) => {
 rpc_types_1.rpcServerCalls.saveFile = async (input) => {
     const fileId = input.fileId || (0, utils_1.newid)();
     const encoding = input.encoding || 'utf8';
-    // Convert data to Uint8Array based on encoding
     const dataBuffer = encoding === 'base64'
         ? Buffer.from(input.data, 'base64')
         : Buffer.from(input.data, 'utf8');

package/dist/data/orm/decorators.d.ts

@@ -2,5 +2,9 @@
  * Decorator that marks a table method as server-side only.
  * When used on the client side, these methods will be automatically proxied
  * to the server via rpcServerCalls.tableMethodCall.
+ *
+ * The original (unproxied) method is stored on the proxy function as `__original`
+ * so that same-process implementations (e.g. PWA) can call it directly and avoid
+ * an infinite proxy loop.
  */
 export declare function ProxyClientTableMethodCalls(): (target: any, context: any) => any;

package/dist/data/orm/decorators.js

@@ -6,16 +6,22 @@ const rpc_types_1 = require("../../rpc-types");
  * Decorator that marks a table method as server-side only.
  * When used on the client side, these methods will be automatically proxied
  * to the server via rpcServerCalls.tableMethodCall.
+ *
+ * The original (unproxied) method is stored on the proxy function as `__original`
+ * so that same-process implementations (e.g. PWA) can call it directly and avoid
+ * an infinite proxy loop.
  */
 function ProxyClientTableMethodCalls() {
     return function (target, context) {
         if (context.kind === 'method' && rpc_types_1.isClient) {
             const methodName = context.name;
             // WARNING: Using typescript's magical `this` param
-            return function (...args) {
+            const proxyFn = function (...args) {
                 const dataContextId = this.dataSource.dataContextId || this.groupId || '';
                 return rpc_types_1.rpcServerCalls.tableMethodCall(dataContextId, this.tableName, methodName, ...args);
             };
+            proxyFn.__original = target;
+            return proxyFn;
         }
         return target;
     };

package/dist/data/orm/table.js

@@ -33,7 +33,7 @@ class Table {
         const eventName = this.tableName + "_DataChanged";
         this.dataChangedEmitter = deps.eventRegistry.getEmitter(eventName);
         this.dataChanged = this.dataChangedEmitter.event;
-        if (rpc_types_1.isClient) {
+        if (rpc_types_1.isClient && !(0, rpc_types_1.isSingleProcessClient)()) {
             // Don't emit table events from client (they are just duplicates from server)
             this.dataChangedEmitter.emit = lodash_1.noop;
         }

package/dist/data/package-versions.d.ts

@@ -92,5 +92,9 @@ export declare function PackageVersions(dataContext?: DataContext): PackageVersi
  */
 export declare function computePackageVersionHash(version: string, versionTag: string, packageBundleFileHash: string, routesBundleFileHash?: string, uiBundleFileHash?: string): string;
 export declare function isVersionInRange(activeVersion: string, incomingVersion: string, range: 'pinned' | 'patch' | 'minor' | 'latest'): boolean;
+/**
+ * Returns true if incomingVersion is strictly newer than activeVersion (semver comparison).
+ */
+export declare function isNewerVersion(activeVersion: string, incomingVersion: string): boolean;
 export declare function doesTagMatch(activeVersionTag: string | undefined, incomingVersionTag: string | undefined, followVersionTags: string | undefined, deviceVersionTag: string | undefined): boolean;
 export {};

package/dist/data/package-versions.js

@@ -38,6 +38,7 @@ exports.PackageVersionsTable = void 0;
 exports.PackageVersions = PackageVersions;
 exports.computePackageVersionHash = computePackageVersionHash;
 exports.isVersionInRange = isVersionInRange;
+exports.isNewerVersion = isNewerVersion;
 exports.doesTagMatch = doesTagMatch;
 const zod_1 = require("zod");
 const context_1 = require("../context");
@@ -149,6 +150,18 @@ function isVersionInRange(activeVersion, incomingVersion, range) {
         return aMaj === iMaj;
     return false;
 }
+/**
+ * Returns true if incomingVersion is strictly newer than activeVersion (semver comparison).
+ */
+function isNewerVersion(activeVersion, incomingVersion) {
+    const [aMaj = 0, aMin = 0, aPat = 0] = activeVersion.split('.').map(Number);
+    const [iMaj = 0, iMin = 0, iPat = 0] = incomingVersion.split('.').map(Number);
+    if (iMaj !== aMaj)
+        return iMaj > aMaj;
+    if (iMin !== aMin)
+        return iMin > aMin;
+    return iPat > aPat;
+}
 function doesTagMatch(activeVersionTag, incomingVersionTag, followVersionTags, deviceVersionTag) {
     const inTag = incomingVersionTag || 'stable';
     if (deviceVersionTag)

package/dist/rpc-types.d.ts

@@ -39,6 +39,7 @@ export declare const rpcServerCalls: {
     setUserIdAndSecretKey: ((userId: string, secretKey: string) => Promise<void>);
     getUserId: () => Promise<string | undefined>;
     encryptData: ((value: string, groupId?: string) => Promise<string>);
+    logout: (() => Promise<void>);
     tableMethodCall: ((dataContextId: string, tableName: string, methodName: string, ...args: any[]) => Promise<any>);
     getFileContents: ((fileId: string, encoding?: BufferEncoding) => Promise<string>);
     getFileContentsBase64: ((fileId: string) => Promise<string>);
@@ -145,3 +146,5 @@ export declare const rpcClientCalls: {
 export type RpcServerNames = keyof typeof rpcServerCalls;
 export type RpcClientNames = keyof typeof rpcClientCalls;
 export declare const isClient: boolean;
+export declare function setSingleProcessClient(value: boolean): void;
+export declare function isSingleProcessClient(): boolean;

package/dist/rpc-types.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isClient = exports.rpcClientCalls = exports.rpcServerCalls = void 0;
+exports.setSingleProcessClient = setSingleProcessClient;
+exports.isSingleProcessClient = isSingleProcessClient;
 function rpcStub(rpcName) {
     return async (...args) => {
         console.warn(rpcName + ': rpc fn not set. This means that an RPC call is happening before the RPC function has been set. This is either a race condition or the RPC handler was never set.' + JSON.stringify({ rpcName, args }, null, 2));
@@ -16,6 +18,7 @@ exports.rpcServerCalls = {
     setUserIdAndSecretKey: rpcStub('setUserIdAndSecretKey'),
     getUserId: rpcStub('getUserId'),
     encryptData: rpcStub('encryptData'),
+    logout: rpcStub('logout'),
     tableMethodCall: rpcStub('tableMethodCall'),
     // TODO lock this down so not all code can get any file contents
     getFileContents: rpcStub('getFileContents'),
@@ -79,6 +82,11 @@ exports.rpcClientCalls = {
 // - CLI: process.env.PEERS_IS_CLIENT === 'true'
 exports.isClient = (typeof window !== 'undefined' && typeof document !== 'undefined')
     || (typeof process !== 'undefined' && process.env?.PEERS_IS_CLIENT === 'true');
+// Single-process mode (PWA): client and server live in the same process,
+// so Table events must NOT be suppressed on the client side.
+let _singleProcessClient = false;
+function setSingleProcessClient(value) { _singleProcessClient = value; }
+function isSingleProcessClient() { return _singleProcessClient; }
 if (exports.isClient) {
     if (typeof window !== 'undefined') {
         // @ts-ignore

package/package.json

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