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

package/index.cjs

@@ -0,0 +1,772 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const common = require("@graffy/common");
+const pg$1 = require("pg");
+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 debug__default = /* @__PURE__ */ _interopDefaultLegacy(debug);
+class Sql {
+  constructor(rawStrings, rawValues) {
+    if (rawStrings.length - 1 !== rawValues.length) {
+      if (rawStrings.length === 0) {
+        throw new TypeError("Expected at least 1 string");
+      }
+      throw new TypeError(`Expected ${rawStrings.length} strings to have ${rawStrings.length - 1} values`);
+    }
+    const valuesLength = rawValues.reduce((len, value) => len + (value instanceof Sql ? value.values.length : 1), 0);
+    this.values = new Array(valuesLength);
+    this.strings = new Array(valuesLength + 1);
+    this.strings[0] = rawStrings[0];
+    let i = 0, pos = 0;
+    while (i < rawValues.length) {
+      const child = rawValues[i++];
+      const rawString = rawStrings[i];
+      if (child instanceof Sql) {
+        this.strings[pos] += child.strings[0];
+        let childIndex = 0;
+        while (childIndex < child.values.length) {
+          this.values[pos++] = child.values[childIndex++];
+          this.strings[pos] = child.strings[childIndex];
+        }
+        this.strings[pos] += rawString;
+      } else {
+        this.values[pos++] = child;
+        this.strings[pos] = rawString;
+      }
+    }
+  }
+  get text() {
+    let i = 1, value = this.strings[0];
+    while (i < this.strings.length)
+      value += `$${i}${this.strings[i++]}`;
+    return value;
+  }
+  get sql() {
+    let i = 1, value = this.strings[0];
+    while (i < this.strings.length)
+      value += `?${this.strings[i++]}`;
+    return value;
+  }
+  inspect() {
+    return {
+      text: this.text,
+      sql: this.sql,
+      values: this.values
+    };
+  }
+}
+function join(values, separator = ",", prefix = "", suffix = "") {
+  if (values.length === 0) {
+    throw new TypeError("Expected `join([])` to be called with an array of multiple elements, but got an empty array");
+  }
+  return new Sql([prefix, ...Array(values.length - 1).fill(separator), suffix], values);
+}
+function raw(value) {
+  return new Sql([value], []);
+}
+const empty = raw("");
+function sql(strings, ...values) {
+  return new Sql(strings, values);
+}
+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 = join(
+    Object.entries(variadic).map(([name, value]) => {
+      return sql`'${raw(name)}', ${getJsonBuildValue(value)}`;
+    })
+  );
+  return sql`jsonb_build_object(${args})`;
+};
+const getJsonBuildValue = (value) => {
+  if (value instanceof Sql)
+    return value;
+  if (typeof value === "string")
+    return sql`${value}::text`;
+  return sql`${JSON.stringify(stripAttributes(value))}::jsonb`;
+};
+const lookup = (prop) => {
+  const [prefix, ...suffix] = common.encodePath(prop);
+  return suffix.length ? sql`"${raw(prefix)}" #> ${suffix}` : sql`"${raw(prefix)}"`;
+};
+const lookupNumeric = (prop) => {
+  const [prefix, ...suffix] = common.encodePath(prop);
+  return suffix.length ? sql`CASE WHEN "${raw(prefix)}" #> ${suffix} = 'null'::jsonb THEN 0 ELSE ("${raw(
+    prefix
+  )}" #> ${suffix})::numeric END` : sql`"${raw(prefix)}"`;
+};
+const aggSql = {
+  $sum: (prop) => sql`sum((${lookupNumeric(prop)})::numeric)`,
+  $card: (prop) => sql`count(distinct(${lookup(prop)}))`,
+  $avg: (prop) => sql`avg((${lookupNumeric(prop)})::numeric)`,
+  $max: (prop) => sql`max((${lookupNumeric(prop)})::numeric)`,
+  $min: (prop) => sql`min((${lookupNumeric(prop)})::numeric)`
+};
+const getSelectCols = (table, projection = null) => {
+  if (!projection)
+    return sql`*`;
+  const sqls = [];
+  for (const key in projection) {
+    if (key === "$count") {
+      sqls.push(sql`count(*) AS "$count"`);
+    } else if (aggSql[key]) {
+      const subSqls = [];
+      for (const prop in projection[key]) {
+        subSqls.push(sql`${prop}::text, ${aggSql[key](prop)}`);
+      }
+      sqls.push(
+        sql`jsonb_build_object(${join(subSqls, ", ")}) AS "${raw(key)}"`
+      );
+    } else {
+      sqls.push(sql`"${raw(key)}"`);
+    }
+  }
+  return join(sqls, ", ");
+};
+function vertexSql(array, nullValue) {
+  return sql`array[${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`cube(${vertexSql(value[0], sql`'-Infinity'`)}, ${vertexSql(
+    value[1],
+    sql`'Infinity'`
+  )})` : sql`cube(${vertexSql(value, 0)})`;
+}
+function castValue(value, type, name, isPut) {
+  if (!type)
+    throw Error("pg.write_no_column " + name);
+  if (value instanceof Sql)
+    return value;
+  if (value === null)
+    return sql`NULL`;
+  if (type === "jsonb") {
+    return isPut ? JSON.stringify(stripAttributes(value)) : sql`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`]]).forEach(([col, val]) => {
+    cols.push(sql`"${raw(col)}"`);
+    vals.push(castValue(val, options.schema.types[col], col, row.$put));
+  });
+  return { cols: join(cols, ", "), vals: join(vals, ", ") };
+};
+const getUpdates = (row, options) => {
+  return join(
+    Object.entries(row).filter(([col]) => col !== options.idCol && col[0] !== "$").map(
+      ([col, val]) => sql`"${raw(col)}" = ${castValue(
+        val,
+        options.schema.types[col],
+        col,
+        row.$put
+      )}`
+    ).concat(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`"${raw(col)}"${path.length ? sql`#>${path}` : empty}`;
+  if (common.isEmpty(object))
+    return curr;
+  return sql`(case jsonb_typeof(${curr})
+    when 'object' then ${curr}
+    else '{}'::jsonb
+  end) || jsonb_build_object(${join(
+    Object.entries(object).map(
+      ([key, value]) => sql`${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`NOT`,
+  $eq: sql`=`,
+  $neq: sql`<>`,
+  $in: sql`IN`,
+  $nin: sql`NOT IN`,
+  $lt: sql`<`,
+  $lte: sql`<=`,
+  $gt: sql`>`,
+  $gte: sql`>=`,
+  $re: sql`~`,
+  $ire: sql`~*`,
+  $cts: sql`@>`,
+  $ctd: sql`<@`
+};
+function getBinarySql(lhs, type, op, value, textLhs) {
+  if (value === null && op === "$eq")
+    return sql`${lhs} IS NULL`;
+  if (value === null && op === "$neq")
+    return sql`${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`${lhs} ${sqlOp} (${join(value)})`;
+  }
+  if (op === "$re" || op === "$ire") {
+    if (type === "jsonb") {
+      lhs = textLhs;
+    } else if (type !== "text") {
+      lhs = sql`(${lhs})::text`;
+    }
+    return sql`${lhs} ${sqlOp} ${String(value)}`;
+  }
+  if (type === "jsonb") {
+    if (typeof value === "string") {
+      return sql`${textLhs} ${sqlOp} ${value}`;
+    }
+    return sql`${lhs} ${sqlOp} ${JSON.stringify(value)}::jsonb`;
+  }
+  if (type === "cube")
+    return sql`${lhs} ${sqlOp} ${cubeLiteralSql(value)}`;
+  return sql`${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`(${join(
+        ast[1].map((node) => getNodeSql(node)),
+        `) ${opSql[op]} (`
+      )})`;
+    } else if (op === "$not") {
+      return sql`${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`"${raw(prefix)}" #> ${suffix}`,
+        sql`"${raw(prefix)}" #>> ${suffix}`
+      ] : [sql`"${raw(prefix)}"`, 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`"${raw(prefix)}"`, types2[prefix], op, ast[2]);
+    }
+  }
+  return getNodeSql(getAst(filter));
+}
+const getIdMeta = ({ idCol, verDefault }) => sql`"${raw(idCol)}" AS "$key", ${raw(verDefault)} AS "$ver"`;
+const getArgMeta = (key, { prefix, idCol, verDefault }) => sql`
+    ${key} AS "$key",
+    ${raw(verDefault)} AS "$ver",
+    array[
+      ${join(prefix.map((k) => sql`${k}::text`))},
+      "${raw(idCol)}"
+    ]::text[] AS "$ref"
+  `;
+const getAggMeta = (key, { verDefault }) => sql`${key} AS "$key", ${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`${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 ? join(groupCols, ", ") : void 0;
+  const orderCols = ($order || [idCol]).map(
+    (orderItem) => orderItem[0] === "!" ? sql`-(${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 && join(
+    ($order || [idCol]).map(
+      (orderItem) => orderItem[0] === "!" ? sql`${lookup(orderItem.slice(1))} ${$last ? sql`ASC` : sql`DESC`}` : sql`${lookup(orderItem)} ${$last ? sql`DESC` : sql`ASC`}`
+    ),
+    `, `
+  );
+  const cursorKey = getJsonBuildTrusted({
+    $cursor: $group === true ? sql`''` : sql`jsonb_build_array(${join(groupCols || orderCols)})`
+  });
+  const key = sql`(${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`${lhs} > ${rhs} OR ${lhs} = ${rhs} AND (${subCond})`;
+      case "$before":
+      case "$until":
+        return sql`${lhs} < ${rhs} OR ${lhs} = ${rhs} AND (${subCond})`;
+    }
+  } else {
+    switch (kind) {
+      case "$after":
+        return sql`${lhs} > ${rhs}`;
+      case "$since":
+        return sql`${lhs} >= ${rhs}`;
+      case "$before":
+        return sql`${lhs} < ${rhs}`;
+      case "$until":
+        return sql`${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`
+    SELECT
+    ${getSelectCols(table, projection)}, ${meta}
+    FROM "${raw(table)}"
+    ${where.length ? sql`WHERE ${join(where, ` AND `)}` : empty}
+    ${group ? sql`GROUP BY ${group}` : empty}
+    ${order ? sql`ORDER BY ${order}` : empty}
+    LIMIT ${clampedLimit}
+  `;
+}
+function selectByIds(ids, projection, options) {
+  const { table, idCol } = options;
+  return sql`
+    SELECT
+    ${getSelectCols(table, projection)}, ${getIdMeta(options)}
+    FROM "${raw(table)}"
+    WHERE "${raw(idCol)}" IN (${join(ids)})
+  `;
+}
+function getSingleSql(arg, options) {
+  const { table, idCol } = options;
+  if (!common.isPlainObject(arg)) {
+    return {
+      where: 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`"${raw(idCol)}" = (
+        SELECT "${raw(idCol)}"
+        FROM "${raw(table)}"
+        WHERE ${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`
+    UPDATE "${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 = join(Object.keys(arg).map((col) => sql`"${raw(col)}"`));
+  } else {
+    meta = getIdMeta(options);
+    conflictTarget = sql`"${raw(idCol)}"`;
+  }
+  const { cols, vals } = getInsert(row, options);
+  return sql`
+    INSERT INTO "${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`
+    DELETE FROM "${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`
+        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`
+        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`
+        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;

package/index.mjs

@@ -1,7 +1,69 @@
 import { encodePath, isEmpty, isPlainObject, unwrap, decodeArgs, decodeQuery, finalize, wrap, isRange, decodeGraph, mergeObject, merge, encodeGraph, wrapObject, remove } from "@graffy/common";
 import pg$1 from "pg";
-import sql, { join, raw, Sql, empty } from "sql-template-tag";
 import debug from "debug";
+class Sql {
+  constructor(rawStrings, rawValues) {
+    if (rawStrings.length - 1 !== rawValues.length) {
+      if (rawStrings.length === 0) {
+        throw new TypeError("Expected at least 1 string");
+      }
+      throw new TypeError(`Expected ${rawStrings.length} strings to have ${rawStrings.length - 1} values`);
+    }
+    const valuesLength = rawValues.reduce((len, value) => len + (value instanceof Sql ? value.values.length : 1), 0);
+    this.values = new Array(valuesLength);
+    this.strings = new Array(valuesLength + 1);
+    this.strings[0] = rawStrings[0];
+    let i = 0, pos = 0;
+    while (i < rawValues.length) {
+      const child = rawValues[i++];
+      const rawString = rawStrings[i];
+      if (child instanceof Sql) {
+        this.strings[pos] += child.strings[0];
+        let childIndex = 0;
+        while (childIndex < child.values.length) {
+          this.values[pos++] = child.values[childIndex++];
+          this.strings[pos] = child.strings[childIndex];
+        }
+        this.strings[pos] += rawString;
+      } else {
+        this.values[pos++] = child;
+        this.strings[pos] = rawString;
+      }
+    }
+  }
+  get text() {
+    let i = 1, value = this.strings[0];
+    while (i < this.strings.length)
+      value += `$${i}${this.strings[i++]}`;
+    return value;
+  }
+  get sql() {
+    let i = 1, value = this.strings[0];
+    while (i < this.strings.length)
+      value += `?${this.strings[i++]}`;
+    return value;
+  }
+  inspect() {
+    return {
+      text: this.text,
+      sql: this.sql,
+      values: this.values
+    };
+  }
+}
+function join(values, separator = ",", prefix = "", suffix = "") {
+  if (values.length === 0) {
+    throw new TypeError("Expected `join([])` to be called with an array of multiple elements, but got an empty array");
+  }
+  return new Sql([prefix, ...Array(values.length - 1).fill(separator), suffix], values);
+}
+function raw(value) {
+  return new Sql([value], []);
+}
+const empty = raw("");
+function sql(strings, ...values) {
+  return new Sql(strings, values);
+}
 const valid = {
   $eq: true,
   $lt: true,

package/package.json

@@ -2,8 +2,13 @@
   "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.5",
-  "main": "./index.mjs",
+  "version": "0.15.25-alpha.6",
+  "main": "./index.cjs",
+  "exports": {
+    "import": "./index.mjs",
+    "require": "./index.cjs"
+  },
+  "module": "./index.mjs",
   "types": "./types/index.d.ts",
   "repository": {
     "type": "git",
@@ -11,8 +16,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@graffy/common": "0.15.25-alpha.5",
-    "sql-template-tag": "^5.0.3",
+    "@graffy/common": "0.15.25-alpha.6",
     "debug": "^4.3.3"
   },
   "peerDependencies": {