socket-function 0.85.0 → 0.87.0

package/SocketFunction.ts

@@ -244,6 +244,9 @@ export class SocketFunction {
             let callFactory = await getCreateCallFactory(nodeId);
 
             let shapeObj = shape?.[functionName];
+            if (!shapeObj) {
+                shapeObj = {};
+            }
             // NOTE: Actually... this just means the client doesn't have a definition for it. The server
             //  might, so call it, and let them throw if it is unrecognized.
             // if (!shapeObj) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.85.0",
+	"version": "0.87.0",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/CallFactory.ts

@@ -155,18 +155,22 @@ export async function createCallFactory(
                 functionName: call.functionName,
                 seqNum,
             };
+            let data: Buffer[];
             let originalArgs = call.args;
-            if (shouldCompressCall(fullCall)) {
-                fullCall.args = await compressObj(fullCall.args) as any;
-                fullCall.isArgsCompressed = true;
-            }
             let time = Date.now();
-            let data: Buffer[];
-            let dataMaybePromise = SocketFunction.WIRE_SERIALIZER.serialize(fullCall);
-            if (dataMaybePromise instanceof Promise) {
-                data = await dataMaybePromise;
-            } else {
-                data = dataMaybePromise;
+            try {
+                if (shouldCompressCall(fullCall)) {
+                    fullCall.args = await compressObj(fullCall.args) as any;
+                    fullCall.isArgsCompressed = true;
+                }
+                let dataMaybePromise = SocketFunction.WIRE_SERIALIZER.serialize(fullCall);
+                if (dataMaybePromise instanceof Promise) {
+                    data = await dataMaybePromise;
+                } else {
+                    data = dataMaybePromise;
+                }
+            } catch (e: any) {
+                throw new Error(`Error serializing data for call ${call.classGuid}.${call.functionName}\n${e.stack}`);
             }
             time = Date.now() - time;
             let size = data.map(x => x.length).reduce((a, b) => a + b, 0);

package/src/nodeProxy.ts

@@ -20,6 +20,10 @@ export function getCallProxy(id: string, callback: (callType: FullCallType) => P
                     nodeProxy = new Proxy(Object.create(null), {
                         get(target, functionName) {
                             if (typeof functionName !== "string") return undefined;
+                            // Ignore "then" calls, as they happen when awaiting a callProxy (to check if it's
+                            //  a promise), and we don't want to act like a promise (we don't want to call the
+                            //  "then" api call).
+                            if (functionName === "then") return undefined;
                             return Object.assign(
                                 (...args: unknown[]) => {
                                     let call: FullCallType = {