@graffy/pg 0.15.25-alpha.4 → 0.15.25-alpha.5

package/package.json

@@ -2,13 +2,8 @@
   "name": "@graffy/pg",
   "description": "The standard Postgres module for Graffy. Each instance this module mounts a Postgres table as a Graffy subtree.",
   "author": "aravind (https://github.com/aravindet)",
-  "version": "0.15.25-alpha.4",
-  "main": "./index.cjs",
-  "exports": {
-    "import": "./index.mjs",
-    "require": "./index.cjs"
-  },
-  "module": "./index.mjs",
+  "version": "0.15.25-alpha.5",
+  "main": "./index.mjs",
   "types": "./types/index.d.ts",
   "repository": {
     "type": "git",
@@ -16,7 +11,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@graffy/common": "0.15.25-alpha.4",
+    "@graffy/common": "0.15.25-alpha.5",
     "sql-template-tag": "^5.0.3",
     "debug": "^4.3.3"
   },

package/index.cjs

@@ -1,711 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const common = require("@graffy/common");
-const pg$1 = require("pg");
-const sql = require("sql-template-tag");
-const debug = require("debug");
-const _interopDefaultLegacy = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
-const pg__default = /* @__PURE__ */ _interopDefaultLegacy(pg$1);
-const sql__default = /* @__PURE__ */ _interopDefaultLegacy(sql);
-const debug__default = /* @__PURE__ */ _interopDefaultLegacy(debug);
-const valid = {
-  $eq: true,
-  $lt: true,
-  $gt: true,
-  $lte: true,
-  $gte: true,
-  $re: true,
-  $ire: true,
-  $text: true,
-  $and: true,
-  $or: true,
-  $any: true,
-  $all: true,
-  $has: true,
-  $cts: true,
-  $ctd: true
-};
-const inverse = {
-  $eq: "$neq",
-  $neq: "$eq",
-  $in: "$nin",
-  $nin: "$in",
-  $lt: "$gte",
-  $gte: "$lt",
-  $gt: "$lte",
-  $lte: "$gt"
-};
-function getAst(filter) {
-  return simplify(construct(filter));
-}
-function construct(node, prop, op) {
-  if (!node || typeof node !== "object" || prop && op) {
-    if (op && prop)
-      return [op, prop, node];
-    if (prop)
-      return ["$eq", prop, node];
-    throw Error("pgast.expected_prop_before:" + JSON.stringify(node));
-  }
-  if (Array.isArray(node)) {
-    return ["$or", node.map((item) => construct(item, prop, op))];
-  }
-  return [
-    "$and",
-    Object.entries(node).map(([key, val]) => {
-      if (key === "$or" || key === "$and") {
-        return [key, construct(val, prop, op)[1]];
-      }
-      if (key === "$not") {
-        return [key, construct(val, prop, op)];
-      }
-      if (key[0] === "$") {
-        if (!valid[key])
-          throw Error("pgast.invalid_op:" + key);
-        if (op)
-          throw Error("pgast.unexpected_op:" + op + " before:" + key);
-        if (!prop)
-          throw Error("pgast.expected_prop_before:" + key);
-        return construct(val, prop, key);
-      }
-      if (prop) {
-        if (key[0] === ".")
-          return construct(val, prop + key);
-        throw Error("pgast.unexpected_prop: " + key);
-      }
-      return construct(val, key);
-    })
-  ];
-}
-function simplify(node) {
-  const op = node[0];
-  if (op === "$and" || op === "$or") {
-    node[1] = node[1].map((subnode) => simplify(subnode));
-  } else if (op === "$not") {
-    node[1] = simplify(node[1]);
-  }
-  if (op === "$and") {
-    if (!node[1].length)
-      return true;
-    if (node[1].includes(false))
-      return false;
-    node[1] = node[1].filter((item) => item !== true);
-  } else if (op === "$or") {
-    if (!node[1].length)
-      return false;
-    if (node[1].includes(true))
-      return true;
-    node[1] = node[1].filter((item) => item !== false);
-  } else if (op === "$not" && typeof node[1] === "boolean") {
-    return !node[1];
-  }
-  if (op === "$or") {
-    const { eqmap, noneq, change } = node[1].reduce(
-      (acc, item) => {
-        if (item[0] !== "$eq") {
-          acc.noneq.push(item);
-        } else if (acc.eqmap[item[1]]) {
-          acc.change = true;
-          acc.eqmap[item[1]].push(item[2]);
-          return acc;
-        } else {
-          acc.eqmap[item[1]] = [item[2]];
-        }
-        return acc;
-      },
-      { eqmap: {}, noneq: [], change: false }
-    );
-    if (change) {
-      node[1] = [
-        ...noneq,
-        ...Object.entries(eqmap).map(
-          ([prop, val]) => val.length > 1 ? ["$in", prop, val] : ["$eq", prop, val[0]]
-        )
-      ];
-    }
-  }
-  if ((op === "$and" || op === "$or") && node[1].length === 1) {
-    return node[1][0];
-  }
-  if (op === "$not") {
-    const [subop, ...subargs] = node[1];
-    const invop = inverse[subop];
-    return invop ? [invop, ...subargs] : node;
-  }
-  return node;
-}
-const getJsonBuildTrusted = (variadic) => {
-  const args = sql.join(
-    Object.entries(variadic).map(([name, value]) => {
-      return sql__default.default`'${sql.raw(name)}', ${getJsonBuildValue(value)}`;
-    })
-  );
-  return sql__default.default`jsonb_build_object(${args})`;
-};
-const getJsonBuildValue = (value) => {
-  if (value instanceof sql.Sql)
-    return value;
-  if (typeof value === "string")
-    return sql__default.default`${value}::text`;
-  return sql__default.default`${JSON.stringify(stripAttributes(value))}::jsonb`;
-};
-const lookup = (prop) => {
-  const [prefix, ...suffix] = common.encodePath(prop);
-  return suffix.length ? sql__default.default`"${sql.raw(prefix)}" #> ${suffix}` : sql__default.default`"${sql.raw(prefix)}"`;
-};
-const lookupNumeric = (prop) => {
-  const [prefix, ...suffix] = common.encodePath(prop);
-  return suffix.length ? sql__default.default`CASE WHEN "${sql.raw(prefix)}" #> ${suffix} = 'null'::jsonb THEN 0 ELSE ("${sql.raw(
-    prefix
-  )}" #> ${suffix})::numeric END` : sql__default.default`"${sql.raw(prefix)}"`;
-};
-const aggSql = {
-  $sum: (prop) => sql__default.default`sum((${lookupNumeric(prop)})::numeric)`,
-  $card: (prop) => sql__default.default`count(distinct(${lookup(prop)}))`,
-  $avg: (prop) => sql__default.default`avg((${lookupNumeric(prop)})::numeric)`,
-  $max: (prop) => sql__default.default`max((${lookupNumeric(prop)})::numeric)`,
-  $min: (prop) => sql__default.default`min((${lookupNumeric(prop)})::numeric)`
-};
-const getSelectCols = (table, projection = null) => {
-  if (!projection)
-    return sql__default.default`*`;
-  const sqls = [];
-  for (const key in projection) {
-    if (key === "$count") {
-      sqls.push(sql__default.default`count(*) AS "$count"`);
-    } else if (aggSql[key]) {
-      const subSqls = [];
-      for (const prop in projection[key]) {
-        subSqls.push(sql__default.default`${prop}::text, ${aggSql[key](prop)}`);
-      }
-      sqls.push(
-        sql__default.default`jsonb_build_object(${sql.join(subSqls, ", ")}) AS "${sql.raw(key)}"`
-      );
-    } else {
-      sqls.push(sql__default.default`"${sql.raw(key)}"`);
-    }
-  }
-  return sql.join(sqls, ", ");
-};
-function vertexSql(array, nullValue) {
-  return sql__default.default`array[${sql.join(
-    array.map((num) => num === null ? nullValue : num)
-  )}]::float8[]`;
-}
-function cubeLiteralSql(value) {
-  if (!Array.isArray(value) || !value.length || Array.isArray(value[0]) && value.length !== 2) {
-    throw Error("pg.castValue_bad_cube" + JSON.stringify(value));
-  }
-  return Array.isArray(value[0]) ? sql__default.default`cube(${vertexSql(value[0], sql__default.default`'-Infinity'`)}, ${vertexSql(
-    value[1],
-    sql__default.default`'Infinity'`
-  )})` : sql__default.default`cube(${vertexSql(value, 0)})`;
-}
-function castValue(value, type, name, isPut) {
-  if (!type)
-    throw Error("pg.write_no_column " + name);
-  if (value instanceof sql.Sql)
-    return value;
-  if (value === null)
-    return sql__default.default`NULL`;
-  if (type === "jsonb") {
-    return isPut ? JSON.stringify(stripAttributes(value)) : sql__default.default`jsonb_strip_nulls(${getJsonUpdate(value, name, [])})`;
-  }
-  if (type === "cube")
-    return cubeLiteralSql(value);
-  return value;
-}
-const getInsert = (row, options) => {
-  const cols = [];
-  const vals = [];
-  Object.entries(row).filter(([col]) => col !== options.verCol && col[0] !== "$").concat([[options.verCol, sql__default.default`default`]]).forEach(([col, val]) => {
-    cols.push(sql__default.default`"${sql.raw(col)}"`);
-    vals.push(castValue(val, options.schema.types[col], col, row.$put));
-  });
-  return { cols: sql.join(cols, ", "), vals: sql.join(vals, ", ") };
-};
-const getUpdates = (row, options) => {
-  return sql.join(
-    Object.entries(row).filter(([col]) => col !== options.idCol && col[0] !== "$").map(
-      ([col, val]) => sql__default.default`"${sql.raw(col)}" = ${castValue(
-        val,
-        options.schema.types[col],
-        col,
-        row.$put
-      )}`
-    ).concat(sql__default.default`"${sql.raw(options.verCol)}" = default`),
-    ", "
-  );
-};
-function getJsonUpdate(object, col, path) {
-  if (!object || typeof object !== "object" || Array.isArray(object) || object.$put) {
-    return getJsonBuildValue(object);
-  }
-  const curr = sql__default.default`"${sql.raw(col)}"${path.length ? sql__default.default`#>${path}` : sql.empty}`;
-  if (common.isEmpty(object))
-    return curr;
-  return sql__default.default`(case jsonb_typeof(${curr})
-    when 'object' then ${curr}
-    else '{}'::jsonb
-  end) || jsonb_build_object(${sql.join(
-    Object.entries(object).map(
-      ([key, value]) => sql__default.default`${key}::text, ${getJsonUpdate(value, col, path.concat(key))}`
-    ),
-    ", "
-  )})`;
-}
-function stripAttributes(object) {
-  if (typeof object !== "object" || !object)
-    return object;
-  if (Array.isArray(object)) {
-    return object.map((item) => stripAttributes(item));
-  }
-  return Object.entries(object).reduce((out, [key, val]) => {
-    if (key === "$put")
-      return out;
-    out[key] = stripAttributes(val);
-    return out;
-  }, {});
-}
-const opSql = {
-  $and: `AND`,
-  $or: `OR`,
-  $not: sql__default.default`NOT`,
-  $eq: sql__default.default`=`,
-  $neq: sql__default.default`<>`,
-  $in: sql__default.default`IN`,
-  $nin: sql__default.default`NOT IN`,
-  $lt: sql__default.default`<`,
-  $lte: sql__default.default`<=`,
-  $gt: sql__default.default`>`,
-  $gte: sql__default.default`>=`,
-  $re: sql__default.default`~`,
-  $ire: sql__default.default`~*`,
-  $cts: sql__default.default`@>`,
-  $ctd: sql__default.default`<@`
-};
-function getBinarySql(lhs, type, op, value, textLhs) {
-  if (value === null && op === "$eq")
-    return sql__default.default`${lhs} IS NULL`;
-  if (value === null && op === "$neq")
-    return sql__default.default`${lhs} IS NOT NULL`;
-  const sqlOp = opSql[op];
-  if (!sqlOp)
-    throw Error("pg.getSql_unknown_operator " + op);
-  if (op === "$in" || op === "$nin") {
-    if (type === "jsonb" && typeof value[0] === "string")
-      lhs = textLhs;
-    return sql__default.default`${lhs} ${sqlOp} (${sql.join(value)})`;
-  }
-  if (op === "$re" || op === "$ire") {
-    if (type === "jsonb") {
-      lhs = textLhs;
-    } else if (type !== "text") {
-      lhs = sql__default.default`(${lhs})::text`;
-    }
-    return sql__default.default`${lhs} ${sqlOp} ${String(value)}`;
-  }
-  if (type === "jsonb") {
-    if (typeof value === "string") {
-      return sql__default.default`${textLhs} ${sqlOp} ${value}`;
-    }
-    return sql__default.default`${lhs} ${sqlOp} ${JSON.stringify(value)}::jsonb`;
-  }
-  if (type === "cube")
-    return sql__default.default`${lhs} ${sqlOp} ${cubeLiteralSql(value)}`;
-  return sql__default.default`${lhs} ${sqlOp} ${value}`;
-}
-function getSql(filter, options) {
-  function getNodeSql(ast) {
-    if (typeof ast === "boolean")
-      return ast;
-    const op = ast[0];
-    if (op === "$and" || op === "$or") {
-      return sql__default.default`(${sql.join(
-        ast[1].map((node) => getNodeSql(node)),
-        `) ${opSql[op]} (`
-      )})`;
-    } else if (op === "$not") {
-      return sql__default.default`${opSql[op]} (${getNodeSql(ast[1])})`;
-    }
-    const [prefix, ...suffix] = common.encodePath(ast[1]);
-    const { types: types2 } = options.schema;
-    if (!types2[prefix])
-      throw Error("pg.no_column " + prefix);
-    if (types2[prefix] === "jsonb") {
-      const [lhs, textLhs] = suffix.length ? [
-        sql__default.default`"${sql.raw(prefix)}" #> ${suffix}`,
-        sql__default.default`"${sql.raw(prefix)}" #>> ${suffix}`
-      ] : [sql__default.default`"${sql.raw(prefix)}"`, sql__default.default`"${sql.raw(prefix)}" #>> '{}'`];
-      return getBinarySql(lhs, "jsonb", op, ast[2], textLhs);
-    } else {
-      if (suffix.length)
-        throw Error("pg.lookup_not_jsonb " + prefix);
-      return getBinarySql(sql__default.default`"${sql.raw(prefix)}"`, types2[prefix], op, ast[2]);
-    }
-  }
-  return getNodeSql(getAst(filter));
-}
-const getIdMeta = ({ idCol, verDefault }) => sql__default.default`"${sql.raw(idCol)}" AS "$key", ${sql.raw(verDefault)} AS "$ver"`;
-const getArgMeta = (key, { prefix, idCol, verDefault }) => sql__default.default`
-    ${key} AS "$key",
-    ${sql.raw(verDefault)} AS "$ver",
-    array[
-      ${sql.join(prefix.map((k) => sql__default.default`${k}::text`))},
-      "${sql.raw(idCol)}"
-    ]::text[] AS "$ref"
-  `;
-const getAggMeta = (key, { verDefault }) => sql__default.default`${key} AS "$key", ${sql.raw(verDefault)} AS "$ver"`;
-function getArgSql({ $first, $last, $after, $before, $since, $until, $all, $cursor: _, ...rest }, options) {
-  const { $order, $group, ...filter } = rest;
-  const { prefix, idCol } = options;
-  const meta = (key2) => $group ? getAggMeta(key2, options) : getArgMeta(key2, options);
-  const hasRangeArg = $before || $after || $since || $until || $first || $last || $all;
-  if ($order && $group) {
-    throw Error("pg_arg.order_and_group_unsupported in " + prefix);
-  }
-  if (($order || $group && $group !== true) && !hasRangeArg) {
-    throw Error("pg_arg.range_arg_expected in " + prefix);
-  }
-  const baseKey = sql__default.default`${JSON.stringify(rest)}::jsonb`;
-  const where = [];
-  if (!common.isEmpty(filter))
-    where.push(getSql(filter, options));
-  if (!hasRangeArg)
-    return { meta: meta(baseKey), where, limit: 1 };
-  const groupCols = Array.isArray($group) && $group.length && $group.map(lookup);
-  const group = groupCols ? sql.join(groupCols, ", ") : void 0;
-  const orderCols = ($order || [idCol]).map(
-    (orderItem) => orderItem[0] === "!" ? sql__default.default`-(${lookup(orderItem.slice(1))})::float8` : lookup(orderItem)
-  );
-  Object.entries({ $after, $before, $since, $until }).forEach(
-    ([name, value]) => {
-      if (value)
-        where.push(getBoundCond(orderCols, value, name));
-    }
-  );
-  const order = !$group && sql.join(
-    ($order || [idCol]).map(
-      (orderItem) => orderItem[0] === "!" ? sql__default.default`${lookup(orderItem.slice(1))} ${$last ? sql__default.default`ASC` : sql__default.default`DESC`}` : sql__default.default`${lookup(orderItem)} ${$last ? sql__default.default`DESC` : sql__default.default`ASC`}`
-    ),
-    `, `
-  );
-  const cursorKey = getJsonBuildTrusted({
-    $cursor: $group === true ? sql__default.default`''` : sql__default.default`jsonb_build_array(${sql.join(groupCols || orderCols)})`
-  });
-  const key = sql__default.default`(${baseKey} || ${cursorKey})`;
-  return {
-    meta: meta(key),
-    where,
-    order,
-    group,
-    limit: $first || $last
-  };
-}
-function getBoundCond(orderCols, bound, kind) {
-  if (!Array.isArray(bound)) {
-    throw Error("pg_arg.bad_query bound : " + JSON.stringify(bound));
-  }
-  const lhs = orderCols[0];
-  const rhs = bound[0];
-  if (orderCols.length > 1 && bound.length > 1) {
-    const subCond = getBoundCond(orderCols.slice(1), bound.slice(1), kind);
-    switch (kind) {
-      case "$after":
-      case "$since":
-        return sql__default.default`${lhs} > ${rhs} OR ${lhs} = ${rhs} AND (${subCond})`;
-      case "$before":
-      case "$until":
-        return sql__default.default`${lhs} < ${rhs} OR ${lhs} = ${rhs} AND (${subCond})`;
-    }
-  } else {
-    switch (kind) {
-      case "$after":
-        return sql__default.default`${lhs} > ${rhs}`;
-      case "$since":
-        return sql__default.default`${lhs} >= ${rhs}`;
-      case "$before":
-        return sql__default.default`${lhs} < ${rhs}`;
-      case "$until":
-        return sql__default.default`${lhs} <= ${rhs}`;
-    }
-  }
-}
-const MAX_LIMIT = 4096;
-function selectByArgs(args, projection, options) {
-  const { table } = options;
-  const { where, order, group, limit, meta } = getArgSql(args, options);
-  const clampedLimit = Math.min(MAX_LIMIT, limit || MAX_LIMIT);
-  return sql__default.default`
-    SELECT
-    ${getSelectCols(table, projection)}, ${meta}
-    FROM "${sql.raw(table)}"
-    ${where.length ? sql__default.default`WHERE ${sql.join(where, ` AND `)}` : sql.empty}
-    ${group ? sql__default.default`GROUP BY ${group}` : sql.empty}
-    ${order ? sql__default.default`ORDER BY ${order}` : sql.empty}
-    LIMIT ${clampedLimit}
-  `;
-}
-function selectByIds(ids, projection, options) {
-  const { table, idCol } = options;
-  return sql__default.default`
-    SELECT
-    ${getSelectCols(table, projection)}, ${getIdMeta(options)}
-    FROM "${sql.raw(table)}"
-    WHERE "${sql.raw(idCol)}" IN (${sql.join(ids)})
-  `;
-}
-function getSingleSql(arg, options) {
-  const { table, idCol } = options;
-  if (!common.isPlainObject(arg)) {
-    return {
-      where: sql__default.default`"${sql.raw(idCol)}" = ${arg}`,
-      meta: getIdMeta(options)
-    };
-  }
-  const { where, meta } = getArgSql(arg, options);
-  if (!where || !where.length)
-    throw Error("pg_write.no_condition");
-  return {
-    where: sql__default.default`"${sql.raw(idCol)}" = (
-        SELECT "${sql.raw(idCol)}"
-        FROM "${sql.raw(table)}"
-        WHERE ${sql.join(where, ` AND `)}
-        LIMIT 1
-      )`,
-    meta
-  };
-}
-function patch(object, arg, options) {
-  const { table } = options;
-  const { where, meta } = getSingleSql(arg, options);
-  const row = object;
-  return sql__default.default`
-    UPDATE "${sql.raw(table)}" SET ${getUpdates(row, options)}
-    WHERE ${where}
-    RETURNING ${getSelectCols()}, ${meta}`;
-}
-function put(object, arg, options) {
-  const { idCol, table } = options;
-  const row = object;
-  let meta, conflictTarget;
-  if (common.isPlainObject(arg)) {
-    ({ meta } = getArgSql(arg, options));
-    conflictTarget = sql.join(Object.keys(arg).map((col) => sql__default.default`"${sql.raw(col)}"`));
-  } else {
-    meta = getIdMeta(options);
-    conflictTarget = sql__default.default`"${sql.raw(idCol)}"`;
-  }
-  const { cols, vals } = getInsert(row, options);
-  return sql__default.default`
-    INSERT INTO "${sql.raw(table)}" (${cols}) VALUES (${vals})
-    ON CONFLICT (${conflictTarget}) DO UPDATE SET (${cols}) = (${vals})
-    RETURNING ${getSelectCols()}, ${meta}`;
-}
-function del(arg, options) {
-  const { table } = options;
-  const { where } = getSingleSql(arg, options);
-  return sql__default.default`
-    DELETE FROM "${sql.raw(table)}"
-    WHERE ${where}
-    RETURNING ${arg} "$key"`;
-}
-const log = debug__default.default("graffy:pg:db");
-const { Pool, Client, types } = pg__default.default;
-class Db {
-  constructor(connection) {
-    if (typeof connection === "object" && connection && (connection instanceof Pool || connection instanceof Client)) {
-      this.client = connection;
-    } else {
-      this.client = new Pool(connection);
-    }
-  }
-  async query(sql2) {
-    log("Making SQL query: " + sql2.text, sql2.values);
-    try {
-      sql2.types = {
-        getTypeParser: (oid, format) => {
-          if (oid === types.builtins.INT8) {
-            return (value) => parseInt(value, 10);
-          }
-          return types.getTypeParser(oid, format);
-        }
-      };
-      return await this.client.query(sql2);
-    } catch (e) {
-      const message = [
-        e.message,
-        e.detail,
-        e.hint,
-        e.where,
-        sql2.text,
-        JSON.stringify(sql2.values)
-      ].filter(Boolean).join("; ");
-      throw Error("pg.sql_error " + message);
-    }
-  }
-  async readSql(sql2) {
-    const result = (await this.query(sql2)).rows;
-    log("Read result", result);
-    return result;
-  }
-  async writeSql(sql2) {
-    const res = await this.query(sql2);
-    log("Rows written", res.rowCount);
-    if (!res.rowCount) {
-      throw Error("pg.nothing_written " + sql2.text + " with " + sql2.values);
-    }
-    return res.rows[0];
-  }
-  async ensureSchema(tableOptions) {
-    if (tableOptions.schema)
-      return;
-    const { table, verCol } = tableOptions;
-    const tableSchema = (await this.query(sql__default.default`
-        SELECT table_schema
-        FROM information_schema.tables
-        WHERE table_name = ${table}
-        ORDER BY array_position(current_schemas(false)::text[], table_schema::text) ASC
-        LIMIT 1`)).rows[0].table_schema;
-    const types2 = (await this.query(sql__default.default`
-        SELECT jsonb_object_agg(column_name, udt_name) AS column_types
-        FROM information_schema.columns
-        WHERE
-          table_name = ${table} AND
-          table_schema = ${tableSchema}`)).rows[0].column_types;
-    if (!types2)
-      throw Error(`pg.missing_table ${table}`);
-    const verDefault = (await this.query(sql__default.default`
-        SELECT column_default
-        FROM information_schema.columns
-        WHERE
-          table_name = ${table} AND
-          table_schema = ${tableSchema} AND
-          column_name = ${verCol}`)).rows[0].column_default;
-    if (!verDefault) {
-      throw Error(`pg.verCol_without_default ${verCol}`);
-    }
-    log("ensureSchema", types2);
-    tableOptions.schema = { types: types2 };
-    tableOptions.verDefault = verDefault;
-  }
-  async read(rootQuery, tableOptions) {
-    const idQueries = {};
-    const promises = [];
-    const results = [];
-    const { prefix } = tableOptions;
-    await this.ensureSchema(tableOptions);
-    const getByArgs = async (args, projection) => {
-      const result = await this.readSql(
-        selectByArgs(args, projection, tableOptions)
-      );
-      const wrappedGraph = common.encodeGraph(common.wrapObject(result, prefix));
-      log("getByArgs", wrappedGraph);
-      common.merge(results, wrappedGraph);
-    };
-    const getByIds = async () => {
-      const result = await this.readSql(
-        selectByIds(Object.keys(idQueries), null, tableOptions)
-      );
-      result.forEach((object) => {
-        const wrappedGraph = common.encodeGraph(common.wrapObject(object, prefix));
-        log("getByIds", wrappedGraph);
-        common.merge(results, wrappedGraph);
-      });
-    };
-    const query = common.unwrap(rootQuery, prefix);
-    for (const node of query) {
-      const args = common.decodeArgs(node);
-      if (common.isPlainObject(args)) {
-        if (node.prefix) {
-          for (const childNode of node.children) {
-            const childArgs = common.decodeArgs(childNode);
-            const projection = childNode.children ? common.decodeQuery(childNode.children) : null;
-            promises.push(getByArgs({ ...args, ...childArgs }, projection));
-          }
-        } else {
-          const projection = node.children ? common.decodeQuery(node.children) : null;
-          promises.push(getByArgs(args, projection));
-        }
-      } else {
-        idQueries[node.key] = node.children;
-      }
-    }
-    if (!common.isEmpty(idQueries))
-      promises.push(getByIds());
-    await Promise.all(promises);
-    log("dbRead", rootQuery, results);
-    return common.finalize(results, common.wrap(query, prefix));
-  }
-  async write(rootChange, tableOptions) {
-    const { prefix } = tableOptions;
-    await this.ensureSchema(tableOptions);
-    const change = common.unwrap(rootChange, prefix);
-    const sqls = change.map((node) => {
-      const arg = common.decodeArgs(node);
-      if (common.isRange(node)) {
-        if (node.key === node.end)
-          return del(arg, tableOptions);
-        throw Error("pg_write.write_range_unsupported");
-      }
-      const object = common.decodeGraph(node.children);
-      if (common.isPlainObject(arg)) {
-        common.mergeObject(object, arg);
-      } else {
-        object.id = arg;
-      }
-      if (object.$put && object.$put !== true) {
-        throw Error("pg_write.partial_put_unsupported");
-      }
-      return object.$put ? put(object, arg, tableOptions) : patch(object, arg, tableOptions);
-    });
-    const result = [];
-    await Promise.all(
-      sqls.map(
-        (sql2) => this.writeSql(sql2).then((object) => {
-          common.merge(result, common.encodeGraph(common.wrapObject(object, prefix)));
-        })
-      )
-    );
-    log("dbWrite", rootChange, result);
-    return result;
-  }
-}
-const pg = ({ table, idCol, verCol, connection, schema, verDefault }) => (store) => {
-  store.on("read", read);
-  store.on("write", write);
-  const prefix = store.path;
-  const tableOpts = {
-    prefix,
-    table: table || prefix[prefix.length - 1] || "default",
-    idCol: idCol || "id",
-    verCol: verCol || "updatedAt",
-    schema,
-    verDefault
-  };
-  const defaultDb = new Db(connection);
-  function read(query, options, next) {
-    const { pgClient } = options;
-    const db = pgClient ? new Db(pgClient) : defaultDb;
-    const readPromise = db.read(query, tableOpts);
-    const remainingQuery = common.remove(query, prefix);
-    const nextPromise = next(remainingQuery);
-    return Promise.all([readPromise, nextPromise]).then(
-      ([readRes, nextRes]) => {
-        return common.merge(readRes, nextRes);
-      }
-    );
-  }
-  function write(change, options, next) {
-    const { pgClient } = options;
-    const db = pgClient ? new Db(pgClient) : defaultDb;
-    const writePromise = db.write(change, tableOpts);
-    const remainingChange = common.remove(change, prefix);
-    const nextPromise = next(remainingChange);
-    return Promise.all([writePromise, nextPromise]).then(
-      ([writeRes, nextRes]) => {
-        return common.merge(writeRes, nextRes);
-      }
-    );
-  }
-};
-exports.pg = pg;