@graffy/link 0.19.0 → 0.19.1-alpha.1

package/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (defs: any) => (store: any) => void;
+export default _default;

package/index.js

@@ -0,0 +1,36 @@
+import { add, encodePath, finalize, pack, unpack, unwrap, wrap, } from '@graffy/common';
+import debug from 'debug';
+import linkGraph from "./linkGraph.js";
+import prepQueryLinks from "./prepQueryLinks.js";
+const log = debug('graffy:link');
+export default (defs) => (store) => {
+    const prefix = encodePath(store.path);
+    const defEntries = Object.entries(defs).map(([prop, def]) => ({
+        path: prop.split('.'),
+        def,
+    }));
+    store.on('read', async (query, options, next) => {
+        const unwrappedQuery = clone(unwrap(query, prefix));
+        const usedDefs = prepQueryLinks(unwrappedQuery, defEntries);
+        // Shortcut for queries that don't interact with any links
+        if (!usedDefs.length)
+            return next(query, options);
+        const result = await next(wrap(unwrappedQuery, prefix), options);
+        const version = result[0].version;
+        const unwrappedResult = unwrap(result, prefix);
+        // PrepQueryLinks have removed the parts of the query that are
+        // provided by links, so the result would not have "finalized"
+        // them.
+        add(unwrappedQuery, unwrap(query, prefix));
+        log('finalizing', prefix, unwrappedQuery);
+        const finalizedResult = finalize(unwrappedResult, unwrappedQuery, version);
+        log('beforeAddingLinks', prefix, finalizedResult);
+        linkGraph(finalizedResult, usedDefs);
+        log('afterAddingLinks', prefix, finalizedResult);
+        return wrap(finalizedResult, prefix, version);
+    });
+};
+function clone(tree) {
+    // TODO: Do better
+    return unpack(JSON.parse(JSON.stringify(pack(tree))));
+}

package/linkGraph.js

@@ -0,0 +1,197 @@
+import { cmp, encodeArgs, encodePath, findFirst, merge, splitArgs, splitRef, unwrap, wrap, } from '@graffy/common';
+export default function linkGraph(rootGraph, defs) {
+    const version = rootGraph[0].version;
+    /*
+      Braids and Strands are different representations of the set of paths
+      you obtain by replacing placeholders in the path.
+  
+      This is better explained using an example.
+  
+      Say we have a blogging application. Posts have multiple authors identified by
+      authorId, and a single post category. Authors have different "taglines" for each
+      category. We want to add a link "tagline" from the post to the relevant author
+      tagline.
+      
+      We use the link definition:
+      'post.$i.authors.$j.tagline': [
+        'user',
+        '$$post.$i.authors.$j.id',
+        'taglines',
+        '$$post.$i.category
+      ]
+  
+      By traversing the graph, we get all possible values of ($i, $j); say
+      they are (p0, 0), (p1, 0), (p1, 1).
+  
+      We can replace the placeholders with these values to get the "braid":
+      [
+        [{ value: 'user', vars: {} }],
+        [
+          { value: u0, vars: {i: p0, j: 0} },
+          { value: u1, vars: {i: p1, j: 0} },
+          { value: u2, vars: {i: p1, j: 1} },
+        ],
+        [{ value: 'taglines', vars: {} }],
+        [
+          { value: 'cooking', vars: {i: p0} },
+          { value: 'fitness', vars: {i: p1} },
+        ]
+      ]
+  
+      We then "unbraid" the "braid" into an array of "strands":
+  
+      [
+        { value: ['user', u0, 'taglines', 'cooking'], vars: {p0, 0} },
+        { value: ['user', u1, 'taglines', 'fitness'], vars: {p1, 0} },
+        { value: ['user', u2, 'taglines', 'fitness'], vars: {p1, 1} },
+      ]
+  
+      Note that combinations with incompatible vars such as are removed during
+      the unbraid operation (e.g. ['user', u0, 'taglines', 'fitness'])
+    */
+    for (const { path, def } of defs) {
+        /** @type {{ value: any, vars: Record<string, any> }[][]} */
+        const braid = def.map(getChoices);
+        const strands = unbraid(braid);
+        for (const { value, vars } of strands) {
+            const realPath = makeRef(path, vars);
+            const realRef = makeRef(value, vars);
+            const node = { key: realPath.pop(), path: encodePath(realRef), version };
+            const [range] = splitRef(value);
+            if (range)
+                node.prefix = true;
+            let target = rootGraph;
+            do {
+                const key = realPath.shift();
+                const nextTarget = target[findFirst(target, key)];
+                if (!nextTarget || cmp(nextTarget.key, key) !== 0 || nextTarget.end) {
+                    realPath.unshift(key);
+                    break;
+                }
+                target = nextTarget.path
+                    ? unwrap(rootGraph, nextTarget.path)
+                    : nextTarget.children;
+            } while (target && realPath.length);
+            if (!target)
+                return;
+            merge(target, realPath.length ? wrap([node], realPath, version) : [node]);
+        }
+    }
+    return rootGraph;
+    function getChoices(key) {
+        if (typeof key === 'string' && key[0] === '$' && key[1] === '$') {
+            return lookupValues(rootGraph, key.slice(2).split('.'));
+        }
+        if (Array.isArray(key)) {
+            if (!key.length)
+                return [{ value: [], vars: {} }];
+            return unbraid(key.map(getChoices));
+        }
+        if (typeof key === 'object' && key) {
+            const [range = {}, filter = {}] = splitArgs(key);
+            const entries = Object.entries(filter).flat();
+            if (!entries.length)
+                return [{ value: {}, vars: {} }];
+            const strands = unbraid(entries.map(getChoices));
+            return strands.map(({ value, vars }) => ({
+                value: {
+                    ...range,
+                    ...Object.fromEntries(value.reduce((acc, item, i) => {
+                        if (i % 2) {
+                            acc[acc.length - 1].push(item);
+                        }
+                        else {
+                            acc.push([item]);
+                        }
+                        return acc;
+                    }, [])),
+                },
+                vars,
+            }));
+        }
+        return [{ value: key, vars: {} }];
+    }
+    /**
+      Takes a lookup expression which may optionally contain named placeholders,
+      and returns an array of possible values in the graph that it matches.
+      For each such value, it also returns the corresponding placeholder values.
+      @param {string[]} path
+      @return {{ value: any, vars: Record<string,any> }[]}
+    */
+    function lookupValues(graph, path, vars = {}) {
+        const [key, ...rest] = path;
+        if (key[0] === '$') {
+            return graph.flatMap((node) => {
+                if (node.end)
+                    return [];
+                const newVars = { ...vars, [key.slice(1)]: node.key };
+                return recurse(node, rest, newVars);
+            });
+        }
+        const encodedKey = encodeArgs(key).key;
+        const node = graph[findFirst(graph, encodedKey)];
+        if (!node || cmp(node.key, encodedKey) !== 0 || node.end)
+            return [];
+        return recurse(node, rest, vars);
+    }
+    function recurse(node, path, vars) {
+        if (!path.length)
+            return [{ value: node.value, vars }];
+        if (node.children)
+            return lookupValues(node.children, path, vars);
+        if (node.path) {
+            const linked = unwrap(rootGraph, node.path);
+            if (Array.isArray(linked))
+                return lookupValues(linked, path, vars);
+        }
+        throw Error(`link.no_children ${JSON.stringify(node)}`);
+    }
+}
+function unbraid(braid) {
+    if (!braid.length)
+        return [];
+    const [options, ...rest] = braid;
+    if (!rest.length) {
+        return options.map((option) => ({
+            value: [option.value],
+            vars: option.vars,
+        }));
+    }
+    const strands = unbraid(rest);
+    return options.flatMap((option) => strands
+        .filter((strand) => isCompatible(option.vars, strand.vars))
+        .map((strand) => ({
+        value: [option.value, ...strand.value],
+        vars: { ...option.vars, ...strand.vars },
+    })));
+}
+function isCompatible(oVars, sVars) {
+    for (const name in oVars) {
+        if (name in sVars && oVars[name] !== sVars[name])
+            return false;
+    }
+    return true;
+}
+// If you find yourself editing this function, you probably want
+// to edit prepareDef in prepQueryLinks too.
+function makeRef(def, vars) {
+    function getValue(key) {
+        if (typeof key !== 'string')
+            return key;
+        return key[0] === '$' && key.slice(1) in vars ? vars[key.slice(1)] : key;
+    }
+    function replacePlaceholders(key) {
+        if (Array.isArray(key)) {
+            return key.map(replacePlaceholders);
+        }
+        if (typeof key === 'object' && !ArrayBuffer.isView(key) && key) {
+            const result = {};
+            for (const prop in key) {
+                result[replacePlaceholders(prop)] = replacePlaceholders(key[prop]);
+            }
+            return result;
+        }
+        return getValue(key);
+    }
+    return encodePath(def.map(replacePlaceholders));
+}

package/package.json

@@ -2,21 +2,26 @@
   "name": "@graffy/link",
   "description": "Graffy module for constructing links using an intuitive, declarative notation.",
   "author": "aravind (https://github.com/aravindet)",
-  "version": "0.19.0",
-  "main": "./index.cjs",
+  "version": "0.19.1-alpha.1",
+  "main": "./cjs/index.js",
   "exports": {
-    "import": "./index.mjs",
-    "require": "./index.cjs"
+    ".": {
+      "import": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./*": {
+      "import": "./*.js",
+      "types": "./*.d.ts"
+    }
   },
-  "module": "./index.mjs",
-  "types": "./types/index.d.ts",
+  "types": "./index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/usegraffy/graffy.git"
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@graffy/common": "0.19.0",
+    "@graffy/common": "0.19.1-alpha.1",
     "debug": "^4.4.3"
   }
 }

package/prepQueryLinks.js

@@ -0,0 +1,176 @@
+import { add, cmp, decodeArgs, encodeArgs, encodeQuery, findFirst, isBranch, MIN_KEY, splitRef, } from '@graffy/common';
+/*
+  Given a query and an array of link definitions, it:
+  - modifies the query in-place to remove the link properties
+    and add data properties required to construct the link.
+  - returns an array of link definitions used in this query,
+    along with the subQueries for each.
+  - as far as possible, placeholders in the returned defs are
+    replaced with actual keys from the query. In cases where
+    the keys are not known before the query is evaluated
+    (i.e. pagination), placeholders are preserved to be
+    replaced in the linkGraph function.
+*/
+export default function prepQueryLinks(rootQuery, defs) {
+    return defs.flatMap(({ path, def }) => prepQueryDef(rootQuery, path, def));
+    function prepQueryDef(query, path, def, vars = {}, version = 0) {
+        function addDefQuery(subQuery) {
+            // Request the data we will need later to construct the link.
+            add(rootQuery, getDefQuery(def, vars, version));
+            // Return the "used defs" for use by linkGraph
+            const [range, filter] = splitRef(def);
+            if (range && subQuery.length) {
+                return subQuery.map((node) => {
+                    if (!(node.prefix || node.end)) {
+                        throw Error(`link.range_expected: ${path.concat(node.key).join('.')}`);
+                    }
+                    return {
+                        // Range queries that don't specify prefix:true are those
+                        // without filters; we expect that the result will contain
+                        // a prefix node with MIN_KEY to indicate this, so we add
+                        // MIN_KEY here to match that.
+                        path: path.concat(node.prefix ? decodeArgs(node) : MIN_KEY),
+                        def: prepareDef(def.slice(0, -1).concat({
+                            ...filter,
+                            ...(node.prefix ? decodeArgs(node) : {}),
+                            ...range,
+                        }), vars),
+                    };
+                });
+            }
+            return [{ path, def: prepareDef(def, vars) }];
+        }
+        function prefixKey(defs, key) {
+            return defs.map(({ path, def }) => ({
+                path: [key, ...path],
+                def,
+            }));
+        }
+        if (!(Array.isArray(query) && query.length))
+            return [];
+        const [key, ...rest] = path;
+        const encodedKey = encodeArgs(key).key;
+        if (rest.length === 0) {
+            if (key[0] === '$') {
+                return query.splice(0).flatMap((node) => {
+                    vars[key.slice(1)] = decodeArgs(node);
+                    return addDefQuery(node.children);
+                });
+            }
+            const ix = findFirst(query, encodedKey);
+            if (!query[ix] || cmp(query[ix].key, encodedKey) !== 0)
+                return []; // Not using this def
+            // Remove the request for the link itself.
+            const [{ children: subQuery }] = query.splice(ix, 1);
+            return addDefQuery(subQuery);
+        }
+        let used = [];
+        if (key[0] === '$') {
+            for (const node of query) {
+                if (!isBranch(node))
+                    continue;
+                let usedHere;
+                if (node.prefix) {
+                    usedHere = node.children.flatMap((subNode) => {
+                        return prefixKey(prepQueryDef(subNode.children, rest, def, {
+                            ...vars,
+                            [key.slice(1)]: {
+                                ...decodeArgs(node),
+                                ...decodeArgs(subNode),
+                            },
+                        }, node.version), key);
+                    });
+                }
+                else {
+                    usedHere = prepQueryDef(node.children, rest, def, { ...vars, [key.slice(1)]: decodeArgs(node) }, node.version);
+                }
+                if (!node.prefix)
+                    usedHere = prefixKey(usedHere, decodeArgs(node));
+                used = used.concat(usedHere);
+            }
+        }
+        else {
+            const node = query[findFirst(query, encodedKey)];
+            if (!node || cmp(node.key, encodedKey) !== 0 || !node.children)
+                return [];
+            used = prepQueryDef(node.children, rest, def, vars, node.version);
+            if (!node.prefix)
+                used = prefixKey(used, decodeArgs(node));
+        }
+        // Remove any childnodes whose children are now empty.
+        for (let i = 0; i < query.length; i++) {
+            if (query[i].children && query[i].children.length === 0) {
+                query.splice(i, 1);
+                i--;
+            }
+        }
+        // console.log('Used def', used);
+        return used;
+    }
+}
+function getDefQuery(def, vars, version) {
+    // console.log('getDefQuery', def, vars);
+    function getValue(key) {
+        return key[0] === '$' ? vars[key.slice(1)] : key;
+    }
+    function getPath(template) {
+        return template.split('.').flatMap(getValue);
+    }
+    const defQuery = [];
+    function addDefQueries(key) {
+        if (typeof key === 'string' && key[0] === '$' && key[1] === '$') {
+            const path = getPath(key.slice(2));
+            // We do this to ensure that range queries are made correctly.
+            let porcelainQuery = { $key: path.pop() };
+            let $key;
+            // biome-ignore lint/suspicious/noAssignInExpressions: idiomatic while-pop pattern
+            while (($key = path.pop())) {
+                porcelainQuery = { $key, $chi: [porcelainQuery] };
+            }
+            const query = encodeQuery(porcelainQuery, version);
+            add(defQuery, query);
+        }
+        if (Array.isArray(key)) {
+            key.map(addDefQueries);
+        }
+        if (typeof key === 'object' && key) {
+            for (const prop in key) {
+                addDefQueries(prop);
+                addDefQueries(key[prop]);
+            }
+        }
+    }
+    def.map(addDefQueries);
+    return defQuery;
+}
+// If you find yourself editing this function, you probably want
+// to edit makeRef in linkGraph too.
+function prepareDef(def, vars) {
+    function getValue(key) {
+        if (typeof key !== 'string')
+            return key;
+        if (key[0] === '$' && key.slice(1) in vars) {
+            const value = vars[key.slice(1)];
+            return typeof value === 'object' && value !== null ? key : value;
+        }
+        return key;
+    }
+    function replacePlaceholders(key) {
+        if (typeof key === 'string' && key[0] === '$' && key[1] === '$') {
+            return `$$${key.slice(2).split('.').flatMap(getValue).join('.')}`;
+        }
+        if (Array.isArray(key)) {
+            return key.map(replacePlaceholders);
+        }
+        if (typeof key === 'object' && key) {
+            const result = {};
+            for (const prop in key) {
+                result[replacePlaceholders(prop)] = replacePlaceholders(key[prop]);
+            }
+            return result;
+        }
+        return getValue(key);
+    }
+    const ref = def.map(replacePlaceholders);
+    return ref;
+}

package/index.cjs

@@ -1,319 +0,0 @@
-"use strict";
-const common = require("@graffy/common");
-const debug = require("debug");
-function linkGraph(rootGraph, defs) {
-  const version = rootGraph[0].version;
-  for (const { path, def } of defs) {
-    const braid = def.map(getChoices);
-    const strands = unbraid(braid);
-    for (const { value, vars } of strands) {
-      const realPath = makeRef(path, vars);
-      const realRef = makeRef(value, vars);
-      const node = { key: realPath.pop(), path: common.encodePath(realRef), version };
-      const [range] = common.splitRef(value);
-      if (range) node.prefix = true;
-      let target = rootGraph;
-      do {
-        const key = realPath.shift();
-        const nextTarget = target[common.findFirst(target, key)];
-        if (!nextTarget || common.cmp(nextTarget.key, key) !== 0 || nextTarget.end) {
-          realPath.unshift(key);
-          break;
-        }
-        target = nextTarget.path ? common.unwrap(rootGraph, nextTarget.path) : nextTarget.children;
-      } while (target && realPath.length);
-      if (!target) return;
-      common.merge(target, realPath.length ? common.wrap([node], realPath, version) : [node]);
-    }
-  }
-  return rootGraph;
-  function getChoices(key) {
-    if (typeof key === "string" && key[0] === "$" && key[1] === "$") {
-      return lookupValues(rootGraph, key.slice(2).split("."));
-    }
-    if (Array.isArray(key)) {
-      if (!key.length) return [{ value: [], vars: {} }];
-      return unbraid(key.map(getChoices));
-    }
-    if (typeof key === "object" && key) {
-      const [range = {}, filter = {}] = common.splitArgs(key);
-      const entries = Object.entries(filter).flat();
-      if (!entries.length) return [{ value: {}, vars: {} }];
-      const strands = unbraid(entries.map(getChoices));
-      return strands.map(({ value, vars }) => ({
-        value: {
-          ...range,
-          ...Object.fromEntries(
-            value.reduce((acc, item, i) => {
-              if (i % 2) {
-                acc[acc.length - 1].push(item);
-              } else {
-                acc.push([item]);
-              }
-              return acc;
-            }, [])
-          )
-        },
-        vars
-      }));
-    }
-    return [{ value: key, vars: {} }];
-  }
-  function lookupValues(graph, path, vars = {}) {
-    const [key, ...rest] = path;
-    if (key[0] === "$") {
-      return graph.flatMap((node2) => {
-        if (node2.end) return [];
-        const newVars = { ...vars, [key.slice(1)]: node2.key };
-        return recurse(node2, rest, newVars);
-      });
-    }
-    const encodedKey = common.encodeArgs(key).key;
-    const node = graph[common.findFirst(graph, encodedKey)];
-    if (!node || common.cmp(node.key, encodedKey) !== 0 || node.end) return [];
-    return recurse(node, rest, vars);
-  }
-  function recurse(node, path, vars) {
-    if (!path.length) return [{ value: node.value, vars }];
-    if (node.children) return lookupValues(node.children, path, vars);
-    if (node.path) {
-      const linked = common.unwrap(rootGraph, node.path);
-      if (Array.isArray(linked)) return lookupValues(linked, path, vars);
-    }
-    throw Error(`link.no_children ${JSON.stringify(node)}`);
-  }
-}
-function unbraid(braid) {
-  if (!braid.length) return [];
-  const [options, ...rest] = braid;
-  if (!rest.length) {
-    return options.map((option) => ({
-      value: [option.value],
-      vars: option.vars
-    }));
-  }
-  const strands = unbraid(rest);
-  return options.flatMap(
-    (option) => strands.filter((strand) => isCompatible(option.vars, strand.vars)).map((strand) => ({
-      value: [option.value, ...strand.value],
-      vars: { ...option.vars, ...strand.vars }
-    }))
-  );
-}
-function isCompatible(oVars, sVars) {
-  for (const name in oVars) {
-    if (name in sVars && oVars[name] !== sVars[name]) return false;
-  }
-  return true;
-}
-function makeRef(def, vars) {
-  function getValue(key) {
-    if (typeof key !== "string") return key;
-    return key[0] === "$" && key.slice(1) in vars ? vars[key.slice(1)] : key;
-  }
-  function replacePlaceholders(key) {
-    if (Array.isArray(key)) {
-      return key.map(replacePlaceholders);
-    }
-    if (typeof key === "object" && !ArrayBuffer.isView(key) && key) {
-      const result = {};
-      for (const prop in key) {
-        result[replacePlaceholders(prop)] = replacePlaceholders(key[prop]);
-      }
-      return result;
-    }
-    return getValue(key);
-  }
-  return common.encodePath(def.map(replacePlaceholders));
-}
-function prepQueryLinks(rootQuery, defs) {
-  return defs.flatMap(({ path, def }) => prepQueryDef(rootQuery, path, def));
-  function prepQueryDef(query, path, def, vars = {}, version = 0) {
-    function addDefQuery(subQuery) {
-      common.add(rootQuery, getDefQuery(def, vars, version));
-      const [range, filter] = common.splitRef(def);
-      if (range && subQuery.length) {
-        return subQuery.map((node) => {
-          if (!(node.prefix || node.end)) {
-            throw Error(
-              `link.range_expected: ${path.concat(node.key).join(".")}`
-            );
-          }
-          return {
-            // Range queries that don't specify prefix:true are those
-            // without filters; we expect that the result will contain
-            // a prefix node with MIN_KEY to indicate this, so we add
-            // MIN_KEY here to match that.
-            path: path.concat(node.prefix ? common.decodeArgs(node) : common.MIN_KEY),
-            def: prepareDef(
-              def.slice(0, -1).concat({
-                ...filter,
-                ...node.prefix ? common.decodeArgs(node) : {},
-                ...range
-              }),
-              vars
-            )
-          };
-        });
-      }
-      return [{ path, def: prepareDef(def, vars) }];
-    }
-    function prefixKey(defs2, key2) {
-      return defs2.map(({ path: path2, def: def2 }) => ({
-        path: [key2, ...path2],
-        def: def2
-      }));
-    }
-    if (!(Array.isArray(query) && query.length)) return [];
-    const [key, ...rest] = path;
-    const encodedKey = common.encodeArgs(key).key;
-    if (rest.length === 0) {
-      if (key[0] === "$") {
-        return query.splice(0).flatMap((node) => {
-          vars[key.slice(1)] = common.decodeArgs(node);
-          return addDefQuery(node.children);
-        });
-      }
-      const ix = common.findFirst(query, encodedKey);
-      if (!query[ix] || common.cmp(query[ix].key, encodedKey) !== 0) return [];
-      const [{ children: subQuery }] = query.splice(ix, 1);
-      return addDefQuery(subQuery);
-    }
-    let used = [];
-    if (key[0] === "$") {
-      for (const node of query) {
-        if (!common.isBranch(node)) continue;
-        let usedHere;
-        if (node.prefix) {
-          usedHere = node.children.flatMap((subNode) => {
-            return prefixKey(
-              prepQueryDef(
-                subNode.children,
-                rest,
-                def,
-                {
-                  ...vars,
-                  [key.slice(1)]: {
-                    ...common.decodeArgs(node),
-                    ...common.decodeArgs(subNode)
-                  }
-                },
-                node.version
-              ),
-              key
-            );
-          });
-        } else {
-          usedHere = prepQueryDef(
-            node.children,
-            rest,
-            def,
-            { ...vars, [key.slice(1)]: common.decodeArgs(node) },
-            node.version
-          );
-        }
-        if (!node.prefix) usedHere = prefixKey(usedHere, common.decodeArgs(node));
-        used = used.concat(usedHere);
-      }
-    } else {
-      const node = query[common.findFirst(query, encodedKey)];
-      if (!node || common.cmp(node.key, encodedKey) !== 0 || !node.children) return [];
-      used = prepQueryDef(node.children, rest, def, vars, node.version);
-      if (!node.prefix) used = prefixKey(used, common.decodeArgs(node));
-    }
-    for (let i = 0; i < query.length; i++) {
-      if (query[i].children && query[i].children.length === 0) {
-        query.splice(i, 1);
-        i--;
-      }
-    }
-    return used;
-  }
-}
-function getDefQuery(def, vars, version) {
-  function getValue(key) {
-    return key[0] === "$" ? vars[key.slice(1)] : key;
-  }
-  function getPath(template) {
-    return template.split(".").flatMap(getValue);
-  }
-  const defQuery = [];
-  function addDefQueries(key) {
-    if (typeof key === "string" && key[0] === "$" && key[1] === "$") {
-      const path = getPath(key.slice(2));
-      let porcelainQuery = { $key: path.pop() };
-      let $key;
-      while ($key = path.pop()) {
-        porcelainQuery = { $key, $chi: [porcelainQuery] };
-      }
-      const query = common.encodeQuery(porcelainQuery, version);
-      common.add(defQuery, query);
-    }
-    if (Array.isArray(key)) {
-      key.map(addDefQueries);
-    }
-    if (typeof key === "object" && key) {
-      for (const prop in key) {
-        addDefQueries(prop);
-        addDefQueries(key[prop]);
-      }
-    }
-  }
-  def.map(addDefQueries);
-  return defQuery;
-}
-function prepareDef(def, vars) {
-  function getValue(key) {
-    if (typeof key !== "string") return key;
-    if (key[0] === "$" && key.slice(1) in vars) {
-      const value = vars[key.slice(1)];
-      return typeof value === "object" && value !== null ? key : value;
-    }
-    return key;
-  }
-  function replacePlaceholders(key) {
-    if (typeof key === "string" && key[0] === "$" && key[1] === "$") {
-      return `$$${key.slice(2).split(".").flatMap(getValue).join(".")}`;
-    }
-    if (Array.isArray(key)) {
-      return key.map(replacePlaceholders);
-    }
-    if (typeof key === "object" && key) {
-      const result = {};
-      for (const prop in key) {
-        result[replacePlaceholders(prop)] = replacePlaceholders(key[prop]);
-      }
-      return result;
-    }
-    return getValue(key);
-  }
-  const ref = def.map(replacePlaceholders);
-  return ref;
-}
-const log = debug("graffy:link");
-const index = (defs) => (store) => {
-  const prefix = common.encodePath(store.path);
-  const defEntries = Object.entries(defs).map(([prop, def]) => ({
-    path: prop.split("."),
-    def
-  }));
-  store.on("read", async (query, options, next) => {
-    const unwrappedQuery = clone(common.unwrap(query, prefix));
-    const usedDefs = prepQueryLinks(unwrappedQuery, defEntries);
-    if (!usedDefs.length) return next(query, options);
-    const result = await next(common.wrap(unwrappedQuery, prefix), options);
-    const version = result[0].version;
-    const unwrappedResult = common.unwrap(result, prefix);
-    common.add(unwrappedQuery, common.unwrap(query, prefix));
-    log("finalizing", prefix, unwrappedQuery);
-    const finalizedResult = common.finalize(unwrappedResult, unwrappedQuery, version);
-    log("beforeAddingLinks", prefix, finalizedResult);
-    linkGraph(finalizedResult, usedDefs);
-    log("afterAddingLinks", prefix, finalizedResult);
-    return common.wrap(finalizedResult, prefix, version);
-  });
-};
-function clone(tree) {
-  return common.unpack(JSON.parse(JSON.stringify(common.pack(tree))));
-}
-module.exports = index;

package/index.mjs

@@ -1,320 +0,0 @@
-import { encodePath, splitRef, findFirst, cmp, unwrap, merge, wrap, splitArgs, encodeArgs, decodeArgs, isBranch, add, MIN_KEY, encodeQuery, finalize, unpack, pack } from "@graffy/common";
-import debug from "debug";
-function linkGraph(rootGraph, defs) {
-  const version = rootGraph[0].version;
-  for (const { path, def } of defs) {
-    const braid = def.map(getChoices);
-    const strands = unbraid(braid);
-    for (const { value, vars } of strands) {
-      const realPath = makeRef(path, vars);
-      const realRef = makeRef(value, vars);
-      const node = { key: realPath.pop(), path: encodePath(realRef), version };
-      const [range] = splitRef(value);
-      if (range) node.prefix = true;
-      let target = rootGraph;
-      do {
-        const key = realPath.shift();
-        const nextTarget = target[findFirst(target, key)];
-        if (!nextTarget || cmp(nextTarget.key, key) !== 0 || nextTarget.end) {
-          realPath.unshift(key);
-          break;
-        }
-        target = nextTarget.path ? unwrap(rootGraph, nextTarget.path) : nextTarget.children;
-      } while (target && realPath.length);
-      if (!target) return;
-      merge(target, realPath.length ? wrap([node], realPath, version) : [node]);
-    }
-  }
-  return rootGraph;
-  function getChoices(key) {
-    if (typeof key === "string" && key[0] === "$" && key[1] === "$") {
-      return lookupValues(rootGraph, key.slice(2).split("."));
-    }
-    if (Array.isArray(key)) {
-      if (!key.length) return [{ value: [], vars: {} }];
-      return unbraid(key.map(getChoices));
-    }
-    if (typeof key === "object" && key) {
-      const [range = {}, filter = {}] = splitArgs(key);
-      const entries = Object.entries(filter).flat();
-      if (!entries.length) return [{ value: {}, vars: {} }];
-      const strands = unbraid(entries.map(getChoices));
-      return strands.map(({ value, vars }) => ({
-        value: {
-          ...range,
-          ...Object.fromEntries(
-            value.reduce((acc, item, i) => {
-              if (i % 2) {
-                acc[acc.length - 1].push(item);
-              } else {
-                acc.push([item]);
-              }
-              return acc;
-            }, [])
-          )
-        },
-        vars
-      }));
-    }
-    return [{ value: key, vars: {} }];
-  }
-  function lookupValues(graph, path, vars = {}) {
-    const [key, ...rest] = path;
-    if (key[0] === "$") {
-      return graph.flatMap((node2) => {
-        if (node2.end) return [];
-        const newVars = { ...vars, [key.slice(1)]: node2.key };
-        return recurse(node2, rest, newVars);
-      });
-    }
-    const encodedKey = encodeArgs(key).key;
-    const node = graph[findFirst(graph, encodedKey)];
-    if (!node || cmp(node.key, encodedKey) !== 0 || node.end) return [];
-    return recurse(node, rest, vars);
-  }
-  function recurse(node, path, vars) {
-    if (!path.length) return [{ value: node.value, vars }];
-    if (node.children) return lookupValues(node.children, path, vars);
-    if (node.path) {
-      const linked = unwrap(rootGraph, node.path);
-      if (Array.isArray(linked)) return lookupValues(linked, path, vars);
-    }
-    throw Error(`link.no_children ${JSON.stringify(node)}`);
-  }
-}
-function unbraid(braid) {
-  if (!braid.length) return [];
-  const [options, ...rest] = braid;
-  if (!rest.length) {
-    return options.map((option) => ({
-      value: [option.value],
-      vars: option.vars
-    }));
-  }
-  const strands = unbraid(rest);
-  return options.flatMap(
-    (option) => strands.filter((strand) => isCompatible(option.vars, strand.vars)).map((strand) => ({
-      value: [option.value, ...strand.value],
-      vars: { ...option.vars, ...strand.vars }
-    }))
-  );
-}
-function isCompatible(oVars, sVars) {
-  for (const name in oVars) {
-    if (name in sVars && oVars[name] !== sVars[name]) return false;
-  }
-  return true;
-}
-function makeRef(def, vars) {
-  function getValue(key) {
-    if (typeof key !== "string") return key;
-    return key[0] === "$" && key.slice(1) in vars ? vars[key.slice(1)] : key;
-  }
-  function replacePlaceholders(key) {
-    if (Array.isArray(key)) {
-      return key.map(replacePlaceholders);
-    }
-    if (typeof key === "object" && !ArrayBuffer.isView(key) && key) {
-      const result = {};
-      for (const prop in key) {
-        result[replacePlaceholders(prop)] = replacePlaceholders(key[prop]);
-      }
-      return result;
-    }
-    return getValue(key);
-  }
-  return encodePath(def.map(replacePlaceholders));
-}
-function prepQueryLinks(rootQuery, defs) {
-  return defs.flatMap(({ path, def }) => prepQueryDef(rootQuery, path, def));
-  function prepQueryDef(query, path, def, vars = {}, version = 0) {
-    function addDefQuery(subQuery) {
-      add(rootQuery, getDefQuery(def, vars, version));
-      const [range, filter] = splitRef(def);
-      if (range && subQuery.length) {
-        return subQuery.map((node) => {
-          if (!(node.prefix || node.end)) {
-            throw Error(
-              `link.range_expected: ${path.concat(node.key).join(".")}`
-            );
-          }
-          return {
-            // Range queries that don't specify prefix:true are those
-            // without filters; we expect that the result will contain
-            // a prefix node with MIN_KEY to indicate this, so we add
-            // MIN_KEY here to match that.
-            path: path.concat(node.prefix ? decodeArgs(node) : MIN_KEY),
-            def: prepareDef(
-              def.slice(0, -1).concat({
-                ...filter,
-                ...node.prefix ? decodeArgs(node) : {},
-                ...range
-              }),
-              vars
-            )
-          };
-        });
-      }
-      return [{ path, def: prepareDef(def, vars) }];
-    }
-    function prefixKey(defs2, key2) {
-      return defs2.map(({ path: path2, def: def2 }) => ({
-        path: [key2, ...path2],
-        def: def2
-      }));
-    }
-    if (!(Array.isArray(query) && query.length)) return [];
-    const [key, ...rest] = path;
-    const encodedKey = encodeArgs(key).key;
-    if (rest.length === 0) {
-      if (key[0] === "$") {
-        return query.splice(0).flatMap((node) => {
-          vars[key.slice(1)] = decodeArgs(node);
-          return addDefQuery(node.children);
-        });
-      }
-      const ix = findFirst(query, encodedKey);
-      if (!query[ix] || cmp(query[ix].key, encodedKey) !== 0) return [];
-      const [{ children: subQuery }] = query.splice(ix, 1);
-      return addDefQuery(subQuery);
-    }
-    let used = [];
-    if (key[0] === "$") {
-      for (const node of query) {
-        if (!isBranch(node)) continue;
-        let usedHere;
-        if (node.prefix) {
-          usedHere = node.children.flatMap((subNode) => {
-            return prefixKey(
-              prepQueryDef(
-                subNode.children,
-                rest,
-                def,
-                {
-                  ...vars,
-                  [key.slice(1)]: {
-                    ...decodeArgs(node),
-                    ...decodeArgs(subNode)
-                  }
-                },
-                node.version
-              ),
-              key
-            );
-          });
-        } else {
-          usedHere = prepQueryDef(
-            node.children,
-            rest,
-            def,
-            { ...vars, [key.slice(1)]: decodeArgs(node) },
-            node.version
-          );
-        }
-        if (!node.prefix) usedHere = prefixKey(usedHere, decodeArgs(node));
-        used = used.concat(usedHere);
-      }
-    } else {
-      const node = query[findFirst(query, encodedKey)];
-      if (!node || cmp(node.key, encodedKey) !== 0 || !node.children) return [];
-      used = prepQueryDef(node.children, rest, def, vars, node.version);
-      if (!node.prefix) used = prefixKey(used, decodeArgs(node));
-    }
-    for (let i = 0; i < query.length; i++) {
-      if (query[i].children && query[i].children.length === 0) {
-        query.splice(i, 1);
-        i--;
-      }
-    }
-    return used;
-  }
-}
-function getDefQuery(def, vars, version) {
-  function getValue(key) {
-    return key[0] === "$" ? vars[key.slice(1)] : key;
-  }
-  function getPath(template) {
-    return template.split(".").flatMap(getValue);
-  }
-  const defQuery = [];
-  function addDefQueries(key) {
-    if (typeof key === "string" && key[0] === "$" && key[1] === "$") {
-      const path = getPath(key.slice(2));
-      let porcelainQuery = { $key: path.pop() };
-      let $key;
-      while ($key = path.pop()) {
-        porcelainQuery = { $key, $chi: [porcelainQuery] };
-      }
-      const query = encodeQuery(porcelainQuery, version);
-      add(defQuery, query);
-    }
-    if (Array.isArray(key)) {
-      key.map(addDefQueries);
-    }
-    if (typeof key === "object" && key) {
-      for (const prop in key) {
-        addDefQueries(prop);
-        addDefQueries(key[prop]);
-      }
-    }
-  }
-  def.map(addDefQueries);
-  return defQuery;
-}
-function prepareDef(def, vars) {
-  function getValue(key) {
-    if (typeof key !== "string") return key;
-    if (key[0] === "$" && key.slice(1) in vars) {
-      const value = vars[key.slice(1)];
-      return typeof value === "object" && value !== null ? key : value;
-    }
-    return key;
-  }
-  function replacePlaceholders(key) {
-    if (typeof key === "string" && key[0] === "$" && key[1] === "$") {
-      return `$$${key.slice(2).split(".").flatMap(getValue).join(".")}`;
-    }
-    if (Array.isArray(key)) {
-      return key.map(replacePlaceholders);
-    }
-    if (typeof key === "object" && key) {
-      const result = {};
-      for (const prop in key) {
-        result[replacePlaceholders(prop)] = replacePlaceholders(key[prop]);
-      }
-      return result;
-    }
-    return getValue(key);
-  }
-  const ref = def.map(replacePlaceholders);
-  return ref;
-}
-const log = debug("graffy:link");
-const index = (defs) => (store) => {
-  const prefix = encodePath(store.path);
-  const defEntries = Object.entries(defs).map(([prop, def]) => ({
-    path: prop.split("."),
-    def
-  }));
-  store.on("read", async (query, options, next) => {
-    const unwrappedQuery = clone(unwrap(query, prefix));
-    const usedDefs = prepQueryLinks(unwrappedQuery, defEntries);
-    if (!usedDefs.length) return next(query, options);
-    const result = await next(wrap(unwrappedQuery, prefix), options);
-    const version = result[0].version;
-    const unwrappedResult = unwrap(result, prefix);
-    add(unwrappedQuery, unwrap(query, prefix));
-    log("finalizing", prefix, unwrappedQuery);
-    const finalizedResult = finalize(unwrappedResult, unwrappedQuery, version);
-    log("beforeAddingLinks", prefix, finalizedResult);
-    linkGraph(finalizedResult, usedDefs);
-    log("afterAddingLinks", prefix, finalizedResult);
-    return wrap(finalizedResult, prefix, version);
-  });
-};
-function clone(tree) {
-  return unpack(JSON.parse(JSON.stringify(pack(tree))));
-}
-export {
-  index as default
-};

package/types/index.d.ts

@@ -1,2 +0,0 @@
-declare function _default(defs: any): (store: any) => void;
-export default _default;