@graffy/core 0.16.3-alpha.4 → 0.16.3-alpha.6

package/index.cjs

@@ -42,33 +42,24 @@ async function mapStream(stream2, fn) {
     fn(value);
   }
 }
-function wrapProvider(fn, decodedPath, isRead) {
-  const decodePayload = isRead ? common.decodeQuery : common.decodeGraph;
-  const encodePayload = isRead ? common.encodeQuery : common.encodeGraph;
-  const path = common.encodePath(decodedPath);
-  return async function wrappedProvider(payload, options, next) {
+function shiftFn(fn, path) {
+  path = common.encodePath(path);
+  return async function shiftedFn(payload, options, next) {
     let nextCalled = false;
     let remainingNextResult;
-    const porcelainPayload = common.unwrapObject(decodePayload(payload), decodedPath);
+    const unwrappedPayload = common.unwrap(payload, path);
     const remainingPayload = common.remove(payload, path) || [];
-    async function shiftedNext(porcelainNextPayload) {
+    async function shiftedNext(unwrappedNextPayload) {
       nextCalled = true;
-      const nextPayload = encodePayload(
-        common.wrapObject(porcelainNextPayload, decodedPath)
-      );
+      const nextPayload = common.wrap(unwrappedNextPayload, path);
       if (remainingPayload.length)
         common.merge(nextPayload, remainingPayload);
       const nextResult = await next(nextPayload);
       remainingNextResult = common.remove(nextResult, path) || [];
-      return common.unwrapObject(common.decodeGraph(nextResult), decodedPath);
-    }
-    const porcelainResult = await fn(porcelainPayload, options, shiftedNext);
-    let result = common.encodeGraph(common.wrapObject(porcelainResult, decodedPath));
-    if (isRead && !nextCalled) {
-      const appliedQuery = common.wrap(common.unwrap(payload, path), path);
-      result = common.finalize(result, appliedQuery);
-      result = common.wrap(common.unwrap(result, path), path);
+      return common.unwrap(nextResult, path);
     }
+    const rawResult = await fn(unwrappedPayload, options, shiftedNext);
+    const result = common.wrap(rawResult, path);
     if (!nextCalled && remainingPayload.length) {
       remainingNextResult = await next(remainingPayload);
     }
@@ -169,7 +160,32 @@ class Graffy {
   onRead(...args) {
     const [pathArg, handle] = validateOn(...args);
     const path = this.path.concat(pathArg);
-    this.core.on("read", path, wrapProvider(handle, path, true));
+    this.core.on(
+      "read",
+      path,
+      shiftFn(async function porcelainRead(query, options, next) {
+        const porcelainQuery = common.decodeQuery(query);
+        let nextCalled = false;
+        const encoded = common.encodeGraph(
+          await handle(porcelainQuery, options, async (nextQuery, nextOpts) => {
+            nextCalled = true;
+            const nextResult = await next(common.encodeQuery(nextQuery), nextOpts);
+            return common.decodeGraph(nextResult);
+          })
+        );
+        let final;
+        if (!nextCalled) {
+          const encodedPath = common.encodePath(path);
+          final = common.unwrap(
+            common.finalize(common.wrap(encoded, encodedPath), common.wrap(query, encodedPath)),
+            encodedPath
+          );
+        } else {
+          final = encoded;
+        }
+        return final;
+      }, path)
+    );
   }
   onWatch(...args) {
     const [pathArg, handle] = validateOn(...args);
@@ -201,7 +217,22 @@ class Graffy {
   onWrite(...args) {
     const [pathArg, handle] = validateOn(...args);
     const path = this.path.concat(pathArg);
-    this.core.on("write", path, wrapProvider(handle, path, false));
+    this.core.on(
+      "write",
+      path,
+      shiftFn(async function porcelainWrite(change, options, next) {
+        return common.encodeGraph(
+          await handle(
+            common.decodeGraph(change),
+            options,
+            async (nextChange, nextOpts) => {
+              const nextResult = await next(common.encodeGraph(nextChange), nextOpts);
+              return common.decodeGraph(nextResult);
+            }
+          )
+        );
+      }, path)
+    );
   }
   use(...args) {
     const [pathArg, provider] = validateOn(...args);

package/index.mjs

@@ -1,4 +1,4 @@
-import { isPlainObject, encodePath, unwrapObject, remove, encodeGraph, wrapObject, wrap, unwrap, finalize, merge, mergeStreams, decodeQuery, decodeGraph, encodeQuery, decorate } from "@graffy/common";
+import { isPlainObject, encodePath, unwrap, remove, wrap, merge, mergeStreams, wrapObject, encodeQuery, unwrapObject, decorate, encodeGraph, decodeGraph, decodeQuery, finalize } from "@graffy/common";
 import { makeStream, mapStream as mapStream$1 } from "@graffy/stream";
 import debug from "debug";
 const splitPath = (path) => Array.isArray(path) ? path : path === "" ? [] : String(path).split(".");
@@ -41,33 +41,24 @@ async function mapStream(stream, fn) {
     fn(value);
   }
 }
-function wrapProvider(fn, decodedPath, isRead) {
-  const decodePayload = isRead ? decodeQuery : decodeGraph;
-  const encodePayload = isRead ? encodeQuery : encodeGraph;
-  const path = encodePath(decodedPath);
-  return async function wrappedProvider(payload, options, next) {
+function shiftFn(fn, path) {
+  path = encodePath(path);
+  return async function shiftedFn(payload, options, next) {
     let nextCalled = false;
     let remainingNextResult;
-    const porcelainPayload = unwrapObject(decodePayload(payload), decodedPath);
+    const unwrappedPayload = unwrap(payload, path);
     const remainingPayload = remove(payload, path) || [];
-    async function shiftedNext(porcelainNextPayload) {
+    async function shiftedNext(unwrappedNextPayload) {
       nextCalled = true;
-      const nextPayload = encodePayload(
-        wrapObject(porcelainNextPayload, decodedPath)
-      );
+      const nextPayload = wrap(unwrappedNextPayload, path);
       if (remainingPayload.length)
         merge(nextPayload, remainingPayload);
       const nextResult = await next(nextPayload);
       remainingNextResult = remove(nextResult, path) || [];
-      return unwrapObject(decodeGraph(nextResult), decodedPath);
-    }
-    const porcelainResult = await fn(porcelainPayload, options, shiftedNext);
-    let result = encodeGraph(wrapObject(porcelainResult, decodedPath));
-    if (isRead && !nextCalled) {
-      const appliedQuery = wrap(unwrap(payload, path), path);
-      result = finalize(result, appliedQuery);
-      result = wrap(unwrap(result, path), path);
+      return unwrap(nextResult, path);
     }
+    const rawResult = await fn(unwrappedPayload, options, shiftedNext);
+    const result = wrap(rawResult, path);
     if (!nextCalled && remainingPayload.length) {
       remainingNextResult = await next(remainingPayload);
     }
@@ -168,7 +159,32 @@ class Graffy {
   onRead(...args) {
     const [pathArg, handle] = validateOn(...args);
     const path = this.path.concat(pathArg);
-    this.core.on("read", path, wrapProvider(handle, path, true));
+    this.core.on(
+      "read",
+      path,
+      shiftFn(async function porcelainRead(query, options, next) {
+        const porcelainQuery = decodeQuery(query);
+        let nextCalled = false;
+        const encoded = encodeGraph(
+          await handle(porcelainQuery, options, async (nextQuery, nextOpts) => {
+            nextCalled = true;
+            const nextResult = await next(encodeQuery(nextQuery), nextOpts);
+            return decodeGraph(nextResult);
+          })
+        );
+        let final;
+        if (!nextCalled) {
+          const encodedPath = encodePath(path);
+          final = unwrap(
+            finalize(wrap(encoded, encodedPath), wrap(query, encodedPath)),
+            encodedPath
+          );
+        } else {
+          final = encoded;
+        }
+        return final;
+      }, path)
+    );
   }
   onWatch(...args) {
     const [pathArg, handle] = validateOn(...args);
@@ -200,7 +216,22 @@ class Graffy {
   onWrite(...args) {
     const [pathArg, handle] = validateOn(...args);
     const path = this.path.concat(pathArg);
-    this.core.on("write", path, wrapProvider(handle, path, false));
+    this.core.on(
+      "write",
+      path,
+      shiftFn(async function porcelainWrite(change, options, next) {
+        return encodeGraph(
+          await handle(
+            decodeGraph(change),
+            options,
+            async (nextChange, nextOpts) => {
+              const nextResult = await next(encodeGraph(nextChange), nextOpts);
+              return decodeGraph(nextResult);
+            }
+          )
+        );
+      }, path)
+    );
   }
   use(...args) {
     const [pathArg, provider] = validateOn(...args);

package/package.json

@@ -2,7 +2,7 @@
   "name": "@graffy/core",
   "description": "The main module for Graffy, a library for intuitive real-time data APIs.",
   "author": "aravind (https://github.com/aravindet)",
-  "version": "0.16.3-alpha.4",
+  "version": "0.16.3-alpha.6",
   "main": "./index.cjs",
   "exports": {
     "import": "./index.mjs",
@@ -16,8 +16,8 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@graffy/common": "0.16.3-alpha.4",
-    "@graffy/stream": "0.16.3-alpha.4",
+    "@graffy/common": "0.16.3-alpha.6",
+    "@graffy/stream": "0.16.3-alpha.6",
     "debug": "^4.3.3"
   }
 }

package/types/shift.d.ts

@@ -1,2 +1,2 @@
-export function wrapProvider(fn: any, decodedPath: any, isRead: any): (payload: any, options: any, next: any) => Promise<any>;
+export function shiftFn(fn: any, path: any): (payload: any, options: any, next: any) => Promise<any>;
 export function shiftGen(fn: any, path: any): (payload: any, options: any, next: any) => AsyncGenerator<any, void, any>;