@graffy/core 0.15.8-alpha.5 → 0.15.8

package/index.cjs

@@ -1 +1,231 @@
-"use strict";var t=require("@graffy/common"),r=require("@graffy/stream"),e=require("debug"),n=require("@graffy/testing");function a(t){return t&&"object"==typeof t&&"default"in t?t:{default:t}}function o(t){return t&&"object"==typeof t&&!Array.isArray(t)}function i(...r){if(1===r.length)return[[],r[0],{}];if(2===r.length){if(o(r[0])){if(!o(r[1]))throw Error(`validateCall.invalid_options: ${JSON.stringify(r[1])}`);return[[],r[0],r[1]]}return[t.encodePath(r[0]),r[1],{}]}if(3===r.length){if(!o(r[2]))throw Error(`validateCall.invalid_options: ${JSON.stringify(r[1])}`);return[t.encodePath(r[0]),r[1],r[2]]}throw Error(`validateCall.invalid_args: ${JSON.stringify(r)}`)}function c(...r){if(1===r.length){if("function"!=typeof r[0])throw Error(`validateOn.invalid_handler: ${JSON.stringify(r[0])}`);return[[],r[0]]}if(2===r.length){if("function"!=typeof r[1])throw Error(`validateOn.invalid_handler: ${JSON.stringify(r[1])}`);return[t.encodePath(r[0]),r[1]]}throw Error(`validateOn.invalid_args: ${JSON.stringify(r)}`)}function s(r,e){return async function(n,a,o){let i,c=!1;const s=t.unwrap(n,e),h=t.remove(n,e)||[];const l=await r(s,a,(async function(r){c=!0;const n=t.wrap(r,e);h.length&&t.merge(n,h);const a=await o(n);return i=t.remove(a,e)||[],t.unwrap(a,e)})),u=t.wrap(l,e);return!c&&h.length&&(i=await o(h)),i&&i.length&&t.merge(u,i),u}}const h=a(e).default("graffy:core");class l{constructor(){this.handlers={}}on(t,r,e){this.handlers[t]=this.handlers[t]||[],this.handlers[t].push({path:r,handle:e})}call(r,e,a={}){return h("call",r,n.format(e)),function(r,e,n){if(!r||!r.length)throw Error("resolve.no_provider");return function e(a,o){if(a>=r.length)throw Error("resolve.no_providers_for "+JSON.stringify(o));const{path:i,handle:c}=r[a];if(!t.unwrap(o,i))return e(a+1,o);let s=!1;return c(o,n,(t=>{if(s)throw Error("resolve.duplicate_next_call: "+r[a].name);if(void 0===t)throw Error("resolve.next_without_payload: "+r[a].name);return s=!0,e(a+1,t)}))}(0,e)}(this.handlers[r],e,a)}}class u{constructor(t=[],r=new l){this.core=r,this.path=t}on(t,...r){const[e,n]=c(...r),a=this.path.concat(e);this.core.on(t,a,n)}onRead(...r){const[e,n]=c(...r),a=this.path.concat(e);this.core.on("read",a,s((async function(r,e){const a=t.decodeQuery(r),o=t.encodeGraph(await n(a,e));return t.finalize(o,r)}),a))}onWatch(...e){const[n,a]=c(...e),o=this.path.concat(n);this.core.on("watch",o,function(e,n){return async function*(a,o,i){let c,s=!1;const h=t.unwrap(a,n),l=t.remove(a,n)||[],u=e(h,o,(async function*(e){s=!0;const a=t.wrap(e,n);let o;l.length&&t.merge(a,l),c=r.makeStream((t=>{o=t}));for await(const r of i(a)){const e=t.unwrap(r,n),a=t.remove(r,n);a&&o(a),e&&(yield e)}})),f=await(await u.next()).value,d=r.makeStream((r=>(r(t.wrap(f,n)),async function(t,r){for await(const e of t)r(e)}(u,(e=>{r(t.wrap(e,n))})),()=>u.return())));!s&&l.length&&(c=i(l)),yield*c?t.mergeStreams(d,c):d}}((function(e,n){return r.makeStream(((r,o)=>{const i=a(t.decodeQuery(e),n);return async function(){try{let n=(await i.next()).value;r(n&&t.finalize(t.encodeGraph(n),e));for await(const e of i)r(e&&t.encodeGraph(e))}catch(n){o(n)}}(),()=>i.return()}))}),o))}onWrite(...r){const[e,n]=c(...r),a=this.path.concat(e);this.core.on("write",a,s((async function(r,e){return t.encodeGraph(await n(t.decodeGraph(r),e))}),a))}use(...t){const[r,e]=c(...t);e(new u(r,this.core))}call(t,r,e={}){return this.core.call(t,r,e)}async read(...r){const[e,n,a]=i(...r),o=t.wrapObject(n,e),c=t.encodeQuery(o),s=await this.core.call("read",c,a||{});return t.unwrapObject(t.decorate(s,o),t.decodePath(e))}watch(...e){const[n,a,o]=i(...e),c=t.wrapObject(a,n),s=t.encodeQuery(c),h=this.core.call("watch",s,o||{});return r.mapStream(h,(r=>t.unwrapObject(t.decorate(r,c),t.decodePath(n))))}async write(...r){const[e,n,a]=i(...r),o=t.wrap(t.encodeGraph(n),e),c=await this.core.call("write",o,a||{});return t.unwrapObject(t.decodeGraph(c),t.decodePath(e))}}module.exports=u;
+"use strict";
+var common = require("@graffy/common");
+var stream = require("@graffy/stream");
+var debug = require("debug");
+var testing = require("@graffy/testing");
+function _interopDefaultLegacy(e) {
+  return e && typeof e === "object" && "default" in e ? e : { "default": e };
+}
+var debug__default = /* @__PURE__ */ _interopDefaultLegacy(debug);
+function isPlainObject(obj) {
+  return obj && typeof obj === "object" && !Array.isArray(obj);
+}
+function validateCall(...args) {
+  if (args.length === 1) {
+    return [[], args[0], {}];
+  } else if (args.length === 2) {
+    if (isPlainObject(args[0])) {
+      if (!isPlainObject(args[1])) {
+        throw Error(`validateCall.invalid_options: ${JSON.stringify(args[1])}`);
+      }
+      return [[], args[0], args[1]];
+    } else {
+      return [common.encodePath(args[0]), args[1], {}];
+    }
+  } else if (args.length === 3) {
+    if (!isPlainObject(args[2])) {
+      throw Error(`validateCall.invalid_options: ${JSON.stringify(args[1])}`);
+    }
+    return [common.encodePath(args[0]), args[1], args[2]];
+  }
+  throw Error(`validateCall.invalid_args: ${JSON.stringify(args)}`);
+}
+function validateOn(...args) {
+  if (args.length === 1) {
+    if (typeof args[0] !== "function") {
+      throw Error(`validateOn.invalid_handler: ${JSON.stringify(args[0])}`);
+    }
+    return [[], args[0]];
+  } else if (args.length === 2) {
+    if (typeof args[1] !== "function") {
+      throw Error(`validateOn.invalid_handler: ${JSON.stringify(args[1])}`);
+    }
+    return [common.encodePath(args[0]), args[1]];
+  }
+  throw Error(`validateOn.invalid_args: ${JSON.stringify(args)}`);
+}
+async function mapStream(stream2, fn) {
+  for await (const value of stream2) {
+    fn(value);
+  }
+}
+function shiftFn(fn, path) {
+  return async function shiftedFn(payload, options, next) {
+    let nextCalled = false;
+    let remainingNextResult;
+    const unwrappedPayload = common.unwrap(payload, path);
+    const remainingPayload = common.remove(payload, path) || [];
+    async function shiftedNext(unwrappedNextPayload) {
+      nextCalled = true;
+      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.unwrap(nextResult, path);
+    }
+    const rawResult = await fn(unwrappedPayload, options, shiftedNext);
+    const result = common.wrap(rawResult, path);
+    if (!nextCalled && remainingPayload.length) {
+      remainingNextResult = await next(remainingPayload);
+    }
+    if (remainingNextResult && remainingNextResult.length) {
+      common.merge(result, remainingNextResult);
+    }
+    return result;
+  };
+}
+function shiftGen(fn, path) {
+  return async function* shiftedGen(payload, options, next) {
+    let nextCalled = false;
+    let remainingNextStream;
+    const unwrappedPayload = common.unwrap(payload, path);
+    const remainingPayload = common.remove(payload, path) || [];
+    const shiftedNext = async function* shiftedNextFn(unwrappedNextPayload) {
+      nextCalled = true;
+      const nextPayload = common.wrap(unwrappedNextPayload, path);
+      if (remainingPayload.length)
+        common.merge(nextPayload, remainingPayload);
+      let pushRemaining;
+      remainingNextStream = stream.makeStream((push) => {
+        pushRemaining = push;
+      });
+      for await (const value of next(nextPayload)) {
+        const unwrappedValue = common.unwrap(value, path);
+        const remainingValue = common.remove(value, path);
+        if (remainingValue)
+          pushRemaining(remainingValue);
+        if (unwrappedValue)
+          yield unwrappedValue;
+      }
+    };
+    const unwrappedStream = fn(unwrappedPayload, options, shiftedNext);
+    const firstValue = await (await unwrappedStream.next()).value;
+    const resultStream = stream.makeStream((push) => {
+      push(common.wrap(firstValue, path));
+      mapStream(unwrappedStream, (value) => {
+        push(common.wrap(value, path));
+      });
+      return () => unwrappedStream.return();
+    });
+    if (!nextCalled && remainingPayload.length) {
+      remainingNextStream = next(remainingPayload);
+    }
+    yield* remainingNextStream ? common.mergeStreams(resultStream, remainingNextStream) : resultStream;
+  };
+}
+const log = debug__default["default"]("graffy:core");
+function resolve(handlers, firstPayload, options) {
+  if (!handlers || !handlers.length)
+    throw Error("resolve.no_provider");
+  function run(i, payload) {
+    if (i >= handlers.length) {
+      throw Error("resolve.no_providers_for " + JSON.stringify(payload));
+    }
+    const { path, handle } = handlers[i];
+    if (!common.unwrap(payload, path))
+      return run(i + 1, payload);
+    let nextCalled = false;
+    return handle(payload, options, (nextPayload) => {
+      if (nextCalled) {
+        throw Error("resolve.duplicate_next_call: " + handlers[i].name);
+      }
+      if (typeof nextPayload === "undefined") {
+        throw Error("resolve.next_without_payload: " + handlers[i].name);
+      }
+      nextCalled = true;
+      return run(i + 1, nextPayload);
+    });
+  }
+  return run(0, firstPayload);
+}
+class Core {
+  constructor() {
+    this.handlers = {};
+  }
+  on(type, path, handle) {
+    this.handlers[type] = this.handlers[type] || [];
+    this.handlers[type].push({ path, handle });
+  }
+  call(type, payload, options = {}) {
+    log("call", type, testing.format(payload));
+    return resolve(this.handlers[type], payload, options);
+  }
+}
+class Graffy {
+  constructor(path = [], core = new Core()) {
+    this.core = core;
+    this.path = path;
+  }
+  on(type, ...args) {
+    const [pathArg, handler] = validateOn(...args);
+    const path = this.path.concat(pathArg);
+    this.core.on(type, path, handler);
+  }
+  onRead(...args) {
+    const [pathArg, handle] = validateOn(...args);
+    const path = this.path.concat(pathArg);
+    this.core.on("read", path, shiftFn(async function porcelainRead(query, options) {
+      const decoded = common.decodeQuery(query);
+      const encoded = common.encodeGraph(await handle(decoded, options));
+      const finalized = common.finalize(encoded, query);
+      return finalized;
+    }, path));
+  }
+  onWatch(...args) {
+    const [pathArg, handle] = validateOn(...args);
+    const path = this.path.concat(pathArg);
+    this.core.on("watch", path, shiftGen(function porcelainWatch(query, options) {
+      return stream.makeStream((push, end) => {
+        const subscription = handle(common.decodeQuery(query), options);
+        (async function() {
+          try {
+            let firstValue = (await subscription.next()).value;
+            push(firstValue && common.finalize(common.encodeGraph(firstValue), query));
+            for await (const value of subscription) {
+              push(value && common.encodeGraph(value));
+            }
+          } catch (e) {
+            end(e);
+          }
+        })();
+        return () => subscription.return();
+      });
+    }, path));
+  }
+  onWrite(...args) {
+    const [pathArg, handle] = validateOn(...args);
+    const path = this.path.concat(pathArg);
+    this.core.on("write", path, shiftFn(async function porcelainWrite(change, options) {
+      return common.encodeGraph(await handle(common.decodeGraph(change), options));
+    }, path));
+  }
+  use(...args) {
+    const [path, provider] = validateOn(...args);
+    provider(new Graffy(path, this.core));
+  }
+  call(type, payload, options = {}) {
+    return this.core.call(type, payload, options);
+  }
+  async read(...args) {
+    const [path, porcelainQuery, options] = validateCall(...args);
+    const rootQuery = common.wrapObject(porcelainQuery, path);
+    const query = common.encodeQuery(rootQuery);
+    const result = await this.core.call("read", query, options || {});
+    return common.unwrapObject(common.decorate(result, rootQuery), common.decodePath(path));
+  }
+  watch(...args) {
+    const [path, porcelainQuery, options] = validateCall(...args);
+    const rootQuery = common.wrapObject(porcelainQuery, path);
+    const query = common.encodeQuery(rootQuery);
+    const stream$1 = this.core.call("watch", query, options || {});
+    return stream.mapStream(stream$1, (value) => common.unwrapObject(common.decorate(value, rootQuery), common.decodePath(path)));
+  }
+  async write(...args) {
+    const [path, porcelainChange, options] = validateCall(...args);
+    const change = common.wrap(common.encodeGraph(porcelainChange), path);
+    const writtenChange = await this.core.call("write", change, options || {});
+    return common.unwrapObject(common.decodeGraph(writtenChange), common.decodePath(path));
+  }
+}
+module.exports = Graffy;

package/index.mjs

@@ -1 +1,226 @@
-import{encodePath as t,unwrap as r,remove as n,wrap as o,merge as a,mergeStreams as i,encodeGraph as e,decodeGraph as c,wrapObject as s,encodeQuery as l,unwrapObject as h,decorate as f,decodePath as u,decodeQuery as d,finalize as w}from"@graffy/common";import{makeStream as y,mapStream as g}from"@graffy/stream";import p from"debug";import{format as v}from"@graffy/testing";function m(t){return t&&"object"==typeof t&&!Array.isArray(t)}function _(...r){if(1===r.length)return[[],r[0],{}];if(2===r.length){if(m(r[0])){if(!m(r[1]))throw Error(`validateCall.invalid_options: ${JSON.stringify(r[1])}`);return[[],r[0],r[1]]}return[t(r[0]),r[1],{}]}if(3===r.length){if(!m(r[2]))throw Error(`validateCall.invalid_options: ${JSON.stringify(r[1])}`);return[t(r[0]),r[1],r[2]]}throw Error(`validateCall.invalid_args: ${JSON.stringify(r)}`)}function E(...r){if(1===r.length){if("function"!=typeof r[0])throw Error(`validateOn.invalid_handler: ${JSON.stringify(r[0])}`);return[[],r[0]]}if(2===r.length){if("function"!=typeof r[1])throw Error(`validateOn.invalid_handler: ${JSON.stringify(r[1])}`);return[t(r[0]),r[1]]}throw Error(`validateOn.invalid_args: ${JSON.stringify(r)}`)}function O(t,i){return async function(e,c,s){let l,h=!1;const f=r(e,i),u=n(e,i)||[];const d=await t(f,c,(async function(t){h=!0;const e=o(t,i);u.length&&a(e,u);const c=await s(e);return l=n(c,i)||[],r(c,i)})),w=o(d,i);return!h&&u.length&&(l=await s(u)),l&&l.length&&a(w,l),w}}const S=p("graffy:core");class J{constructor(){this.handlers={}}on(t,r,n){this.handlers[t]=this.handlers[t]||[],this.handlers[t].push({path:r,handle:n})}call(t,n,o={}){return S("call",t,v(n)),function(t,n,o){if(!t||!t.length)throw Error("resolve.no_provider");return function n(a,i){if(a>=t.length)throw Error("resolve.no_providers_for "+JSON.stringify(i));const{path:e,handle:c}=t[a];if(!r(i,e))return n(a+1,i);let s=!1;return c(i,o,(r=>{if(s)throw Error("resolve.duplicate_next_call: "+t[a].name);if(void 0===r)throw Error("resolve.next_without_payload: "+t[a].name);return s=!0,n(a+1,r)}))}(0,n)}(this.handlers[t],n,o)}}class N{constructor(t=[],r=new J){this.core=r,this.path=t}on(t,...r){const[n,o]=E(...r),a=this.path.concat(n);this.core.on(t,a,o)}onRead(...t){const[r,n]=E(...t),o=this.path.concat(r);this.core.on("read",o,O((async function(t,r){const o=d(t),a=e(await n(o,r));return w(a,t)}),o))}onWatch(...t){const[c,s]=E(...t),l=this.path.concat(c);this.core.on("watch",l,function(t,e){return async function*(c,s,l){let h,f=!1;const u=r(c,e),d=n(c,e)||[],w=t(u,s,(async function*(t){f=!0;const i=o(t,e);let c;d.length&&a(i,d),h=y((t=>{c=t}));for await(const o of l(i)){const t=r(o,e),a=n(o,e);a&&c(a),t&&(yield t)}})),g=await(await w.next()).value,p=y((t=>(t(o(g,e)),async function(t,r){for await(const n of t)r(n)}(w,(r=>{t(o(r,e))})),()=>w.return())));!f&&d.length&&(h=l(d)),yield*h?i(p,h):p}}((function(t,r){return y(((n,o)=>{const a=s(d(t),r);return async function(){try{let r=(await a.next()).value;n(r&&w(e(r),t));for await(const t of a)n(t&&e(t))}catch(r){o(r)}}(),()=>a.return()}))}),l))}onWrite(...t){const[r,n]=E(...t),o=this.path.concat(r);this.core.on("write",o,O((async function(t,r){return e(await n(c(t),r))}),o))}use(...t){const[r,n]=E(...t);n(new N(r,this.core))}call(t,r,n={}){return this.core.call(t,r,n)}async read(...t){const[r,n,o]=_(...t),a=s(n,r),i=l(a),e=await this.core.call("read",i,o||{});return h(f(e,a),u(r))}watch(...t){const[r,n,o]=_(...t),a=s(n,r),i=l(a),e=this.core.call("watch",i,o||{});return g(e,(t=>h(f(t,a),u(r))))}async write(...t){const[r,n,a]=_(...t),i=o(e(n),r),s=await this.core.call("write",i,a||{});return h(c(s),u(r))}}export{N as default};
+import { encodePath, unwrap, remove, wrap, merge, mergeStreams, encodeGraph, decodeGraph, wrapObject, encodeQuery, unwrapObject, decorate, decodePath, decodeQuery, finalize } from "@graffy/common";
+import { makeStream, mapStream as mapStream$1 } from "@graffy/stream";
+import debug from "debug";
+import { format } from "@graffy/testing";
+function isPlainObject(obj) {
+  return obj && typeof obj === "object" && !Array.isArray(obj);
+}
+function validateCall(...args) {
+  if (args.length === 1) {
+    return [[], args[0], {}];
+  } else if (args.length === 2) {
+    if (isPlainObject(args[0])) {
+      if (!isPlainObject(args[1])) {
+        throw Error(`validateCall.invalid_options: ${JSON.stringify(args[1])}`);
+      }
+      return [[], args[0], args[1]];
+    } else {
+      return [encodePath(args[0]), args[1], {}];
+    }
+  } else if (args.length === 3) {
+    if (!isPlainObject(args[2])) {
+      throw Error(`validateCall.invalid_options: ${JSON.stringify(args[1])}`);
+    }
+    return [encodePath(args[0]), args[1], args[2]];
+  }
+  throw Error(`validateCall.invalid_args: ${JSON.stringify(args)}`);
+}
+function validateOn(...args) {
+  if (args.length === 1) {
+    if (typeof args[0] !== "function") {
+      throw Error(`validateOn.invalid_handler: ${JSON.stringify(args[0])}`);
+    }
+    return [[], args[0]];
+  } else if (args.length === 2) {
+    if (typeof args[1] !== "function") {
+      throw Error(`validateOn.invalid_handler: ${JSON.stringify(args[1])}`);
+    }
+    return [encodePath(args[0]), args[1]];
+  }
+  throw Error(`validateOn.invalid_args: ${JSON.stringify(args)}`);
+}
+async function mapStream(stream, fn) {
+  for await (const value of stream) {
+    fn(value);
+  }
+}
+function shiftFn(fn, path) {
+  return async function shiftedFn(payload, options, next) {
+    let nextCalled = false;
+    let remainingNextResult;
+    const unwrappedPayload = unwrap(payload, path);
+    const remainingPayload = remove(payload, path) || [];
+    async function shiftedNext(unwrappedNextPayload) {
+      nextCalled = true;
+      const nextPayload = wrap(unwrappedNextPayload, path);
+      if (remainingPayload.length)
+        merge(nextPayload, remainingPayload);
+      const nextResult = await next(nextPayload);
+      remainingNextResult = remove(nextResult, 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);
+    }
+    if (remainingNextResult && remainingNextResult.length) {
+      merge(result, remainingNextResult);
+    }
+    return result;
+  };
+}
+function shiftGen(fn, path) {
+  return async function* shiftedGen(payload, options, next) {
+    let nextCalled = false;
+    let remainingNextStream;
+    const unwrappedPayload = unwrap(payload, path);
+    const remainingPayload = remove(payload, path) || [];
+    const shiftedNext = async function* shiftedNextFn(unwrappedNextPayload) {
+      nextCalled = true;
+      const nextPayload = wrap(unwrappedNextPayload, path);
+      if (remainingPayload.length)
+        merge(nextPayload, remainingPayload);
+      let pushRemaining;
+      remainingNextStream = makeStream((push) => {
+        pushRemaining = push;
+      });
+      for await (const value of next(nextPayload)) {
+        const unwrappedValue = unwrap(value, path);
+        const remainingValue = remove(value, path);
+        if (remainingValue)
+          pushRemaining(remainingValue);
+        if (unwrappedValue)
+          yield unwrappedValue;
+      }
+    };
+    const unwrappedStream = fn(unwrappedPayload, options, shiftedNext);
+    const firstValue = await (await unwrappedStream.next()).value;
+    const resultStream = makeStream((push) => {
+      push(wrap(firstValue, path));
+      mapStream(unwrappedStream, (value) => {
+        push(wrap(value, path));
+      });
+      return () => unwrappedStream.return();
+    });
+    if (!nextCalled && remainingPayload.length) {
+      remainingNextStream = next(remainingPayload);
+    }
+    yield* remainingNextStream ? mergeStreams(resultStream, remainingNextStream) : resultStream;
+  };
+}
+const log = debug("graffy:core");
+function resolve(handlers, firstPayload, options) {
+  if (!handlers || !handlers.length)
+    throw Error("resolve.no_provider");
+  function run(i, payload) {
+    if (i >= handlers.length) {
+      throw Error("resolve.no_providers_for " + JSON.stringify(payload));
+    }
+    const { path, handle } = handlers[i];
+    if (!unwrap(payload, path))
+      return run(i + 1, payload);
+    let nextCalled = false;
+    return handle(payload, options, (nextPayload) => {
+      if (nextCalled) {
+        throw Error("resolve.duplicate_next_call: " + handlers[i].name);
+      }
+      if (typeof nextPayload === "undefined") {
+        throw Error("resolve.next_without_payload: " + handlers[i].name);
+      }
+      nextCalled = true;
+      return run(i + 1, nextPayload);
+    });
+  }
+  return run(0, firstPayload);
+}
+class Core {
+  constructor() {
+    this.handlers = {};
+  }
+  on(type, path, handle) {
+    this.handlers[type] = this.handlers[type] || [];
+    this.handlers[type].push({ path, handle });
+  }
+  call(type, payload, options = {}) {
+    log("call", type, format(payload));
+    return resolve(this.handlers[type], payload, options);
+  }
+}
+class Graffy {
+  constructor(path = [], core = new Core()) {
+    this.core = core;
+    this.path = path;
+  }
+  on(type, ...args) {
+    const [pathArg, handler] = validateOn(...args);
+    const path = this.path.concat(pathArg);
+    this.core.on(type, path, handler);
+  }
+  onRead(...args) {
+    const [pathArg, handle] = validateOn(...args);
+    const path = this.path.concat(pathArg);
+    this.core.on("read", path, shiftFn(async function porcelainRead(query, options) {
+      const decoded = decodeQuery(query);
+      const encoded = encodeGraph(await handle(decoded, options));
+      const finalized = finalize(encoded, query);
+      return finalized;
+    }, path));
+  }
+  onWatch(...args) {
+    const [pathArg, handle] = validateOn(...args);
+    const path = this.path.concat(pathArg);
+    this.core.on("watch", path, shiftGen(function porcelainWatch(query, options) {
+      return makeStream((push, end) => {
+        const subscription = handle(decodeQuery(query), options);
+        (async function() {
+          try {
+            let firstValue = (await subscription.next()).value;
+            push(firstValue && finalize(encodeGraph(firstValue), query));
+            for await (const value of subscription) {
+              push(value && encodeGraph(value));
+            }
+          } catch (e) {
+            end(e);
+          }
+        })();
+        return () => subscription.return();
+      });
+    }, path));
+  }
+  onWrite(...args) {
+    const [pathArg, handle] = validateOn(...args);
+    const path = this.path.concat(pathArg);
+    this.core.on("write", path, shiftFn(async function porcelainWrite(change, options) {
+      return encodeGraph(await handle(decodeGraph(change), options));
+    }, path));
+  }
+  use(...args) {
+    const [path, provider] = validateOn(...args);
+    provider(new Graffy(path, this.core));
+  }
+  call(type, payload, options = {}) {
+    return this.core.call(type, payload, options);
+  }
+  async read(...args) {
+    const [path, porcelainQuery, options] = validateCall(...args);
+    const rootQuery = wrapObject(porcelainQuery, path);
+    const query = encodeQuery(rootQuery);
+    const result = await this.core.call("read", query, options || {});
+    return unwrapObject(decorate(result, rootQuery), decodePath(path));
+  }
+  watch(...args) {
+    const [path, porcelainQuery, options] = validateCall(...args);
+    const rootQuery = wrapObject(porcelainQuery, path);
+    const query = encodeQuery(rootQuery);
+    const stream = this.core.call("watch", query, options || {});
+    return mapStream$1(stream, (value) => unwrapObject(decorate(value, rootQuery), decodePath(path)));
+  }
+  async write(...args) {
+    const [path, porcelainChange, options] = validateCall(...args);
+    const change = wrap(encodeGraph(porcelainChange), path);
+    const writtenChange = await this.core.call("write", change, options || {});
+    return unwrapObject(decodeGraph(writtenChange), decodePath(path));
+  }
+}
+export { Graffy as default };

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.15.8-alpha.5",
+  "version": "0.15.8",
   "main": "./index.cjs",
   "exports": {
     "import": "./index.mjs",
@@ -16,9 +16,9 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@graffy/common": "0.15.8-alpha.5",
-    "@graffy/stream": "0.15.8-alpha.5",
+    "@graffy/common": "0.15.8",
+    "@graffy/stream": "0.15.8",
     "debug": "^4.3.2",
-    "@graffy/testing": "0.15.8-alpha.5"
+    "@graffy/testing": "0.15.8"
   }
 }