@graffy/pg 0.19.1-alpha.1 → 0.19.1

package/index.mjs

@@ -0,0 +1,996 @@
+import { isEmpty, isPlainObject, encodePath, unwrap, decodeArgs, decodeQuery, finalize, wrap, isRange, cmp, decodeGraph, mergeObject, wrapObject, merge, encodeGraph, remove } from "@graffy/common";
+import debug from "debug";
+import pg$1, { escapeLiteral } from "pg";
+import { format } from "sql-formatter";
+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 sql() {
+    const len = this.strings.length;
+    let i = 1;
+    let value = this.strings[0];
+    while (i < len)
+      value += `?${this.strings[i++]}`;
+    return value;
+  }
+  get statement() {
+    const len = this.strings.length;
+    let i = 1;
+    let value = this.strings[0];
+    while (i < len)
+      value += `:${i}${this.strings[i++]}`;
+    return value;
+  }
+  get text() {
+    const len = this.strings.length;
+    let i = 1;
+    let value = this.strings[0];
+    while (i < len)
+      value += `$${i}${this.strings[i++]}`;
+    return value;
+  }
+  inspect() {
+    return {
+      sql: this.sql,
+      statement: this.statement,
+      text: this.text,
+      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);
+}
+function formatSqlParam(value) {
+  if (value === null || value === void 0) return "null";
+  if (["number", "boolean"].includes(typeof value)) return value.toString();
+  switch (typeof value) {
+    case "number":
+    case "boolean":
+      return value.toString();
+    case "string":
+      return escapeLiteral(value);
+    case "object":
+      if (Array.isArray(value))
+        return `array[${value.map(formatSqlParam).join(", ")}]`;
+      return `'${JSON.stringify(value)}'`;
+    default:
+      return "";
+  }
+}
+function formatSql(sql2) {
+  return format(sql2.text, {
+    language: "postgresql",
+    params: Object.fromEntries(
+      sql2.values.map((value, idx) => [idx + 1, formatSqlParam(value)])
+    )
+  });
+}
+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`;
+};
+function colName(prefix, options) {
+  if (!options.schema.types[prefix]) throw Error(`pg.no_column ${prefix}`);
+  return raw(prefix);
+}
+const lookup = (prop, options) => {
+  const [prefix, ...suffix] = prop.split(".");
+  if (!suffix.length) return sql`"${colName(prefix, options)}"`;
+  const { types: types2 } = options.schema;
+  if (types2[prefix] === "jsonb") {
+    return sql`"${raw(prefix)}" #> ${suffix}`;
+  }
+  if (types2[prefix] === "cube" && suffix.length === 1) {
+    return sql`"${raw(prefix)}" ~> ${Number.parseInt(suffix[0], 10)}`;
+  }
+  throw Error(`pg.cannot_lookup ${prop}`);
+};
+const lookupNumeric = (prop) => {
+  const [prefix, ...suffix] = prop.split(".");
+  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, options) => sql`count(distinct(${lookup(prop, options)}))`,
+  $avg: (prop) => sql`avg((${lookupNumeric(prop)})::numeric)`,
+  $max: (prop) => sql`max((${lookupNumeric(prop)})::numeric)`,
+  $min: (prop) => sql`min((${lookupNumeric(prop)})::numeric)`
+};
+const getOptimisedJsonBuild = (object, path, parentPropertyName, options) => {
+  const propertyNames = Object.keys(object);
+  const propertyPath = [...path, parentPropertyName];
+  const buildConfig = [];
+  path = path || [];
+  propertyNames.forEach((propertyName) => {
+    const property = object[propertyName];
+    if (typeof property === "object") {
+      const childJSONBuild = getOptimisedJsonBuild(
+        property,
+        propertyPath,
+        propertyName,
+        options
+      );
+      buildConfig.push(
+        sql`${propertyName}::text, jsonb_build_object(${join(childJSONBuild, ", ")})`
+      );
+    } else {
+      if (property === true) {
+        buildConfig.push(
+          sql`${propertyName}::text, ${lookup([...propertyPath, propertyName].join("."), options)}`
+        );
+      }
+    }
+  });
+  return buildConfig;
+};
+const getSelectCols = (options, 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, options)}`);
+      }
+      sqls.push(
+        sql`jsonb_build_object(${join(subSqls, ", ")}) AS "${raw(key)}"`
+      );
+    } else {
+      if (typeof projection[key] === "object") {
+        const optimisedJsonBuild = getOptimisedJsonBuild(
+          projection[key],
+          [],
+          key,
+          options
+        );
+        sqls.push(
+          sql`jsonb_build_object(${join(optimisedJsonBuild, ", ")}) 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)) : getJsonUpdate(value, name, [])[0];
+  }
+  if (type === "cube") return cubeLiteralSql(value);
+  return value;
+}
+const getInsert = (rows, options) => {
+  const { verCol, schema } = options;
+  const cols = [];
+  const colSqls = [];
+  const colIx = {};
+  const colUsed = [];
+  for (const col of Object.keys(options.schema.types)) {
+    colIx[col] = cols.length;
+    colUsed[cols.length] = false;
+    cols.push(col);
+    colSqls.push(sql`"${raw(col)}"`);
+  }
+  colUsed[colIx[verCol]] = true;
+  const vals = [];
+  for (const row of rows) {
+    const rowVals = Array(cols.length).fill(sql`default`);
+    for (const col of cols) {
+      if (col === verCol || !(col in row)) continue;
+      const ix = colIx[col];
+      colUsed[ix] = true;
+      rowVals[ix] = castValue(row[col], schema.types[col], col, row.$put);
+    }
+    vals.push(rowVals);
+  }
+  const isUsed = (_, ix) => colUsed[ix];
+  return {
+    cols: join(colSqls.filter(isUsed), ", "),
+    vals: join(
+      vals.map((rowVals) => sql`(${join(rowVals.filter(isUsed), ", ")})`),
+      ", "
+    ),
+    updates: join(
+      colSqls.map((col, _ix) => sql`${col} =  "excluded".${col}`).filter(isUsed),
+      ", "
+    )
+  };
+};
+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) {
+    const patch2 = stripAttributes(object);
+    return [sql`${JSON.stringify(patch2)}::jsonb`, patch2 === null];
+  }
+  if ("$val" in object) {
+    const value = object.$val === true ? stripAttributes(object) : object.$val;
+    return [sql`${JSON.stringify({ $val: value })}::jsonb`, false];
+  }
+  const curr = sql`"${raw(col)}"${path.length ? sql`#>${path}` : empty}`;
+  if (isEmpty(object)) return [curr, false];
+  const baseSql = sql`case jsonb_typeof(${curr})
+    when 'object' then ${curr}
+    else '{}'::jsonb
+  end`;
+  let maybeNull = true;
+  let hasNulls = false;
+  const patchSqls = Object.entries(object).map(([key, value]) => {
+    const [valSql, nullable] = getJsonUpdate(value, col, path.concat(key));
+    maybeNull &&= nullable;
+    hasNulls ||= nullable;
+    return sql`${key}::text, ${valSql}`;
+  });
+  let clause = sql`${baseSql} || jsonb_build_object(${join(patchSqls, ", ")})`;
+  if (hasNulls) {
+    clause = sql`(select jsonb_object_agg(key, value)
+      from jsonb_each(${clause}) where value <> 'null'::jsonb)`;
+  }
+  if (maybeNull) {
+    clause = sql`nullif(${clause}, '{}'::jsonb)`;
+  }
+  return [clause, maybeNull];
+}
+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" || val === null) return out;
+      if (out === null) out = {};
+      out[key] = stripAttributes(val);
+      return out;
+    },
+    null
+  );
+}
+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,
+  $keycts: true,
+  $keyctd: 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 isValidSubQuery(node) {
+  if (!node || typeof node !== "object") return false;
+  const keys = Object.keys(node);
+  for (const key of keys) {
+    if (key[0] === "$" && !["$and", "$or", "$not"].includes(key)) return false;
+    if (key[0] !== "$") return true;
+  }
+  for (const key in node) {
+    if (!isValidSubQuery(node[key])) return false;
+  }
+  return false;
+}
+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))];
+  }
+  if (prop && isValidSubQuery(node)) {
+    return ["$sub", prop, construct(node)];
+  }
+  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);
+      }
+      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]);
+  } else if (op === "$sub") {
+    node[2] = simplify(node[2]);
+  }
+  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" || item[2] === null) {
+          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 opSql = {
+  $and: "AND",
+  // Not SQL as these are used as delimiters
+  $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`<@`,
+  $keycts: sql`?|`,
+  $keyctd: 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}`;
+    }
+    if ((op === "$keycts" || op === "$keyctd") && Array.isArray(value))
+      return sql`${lhs} ${sqlOp} ${value}::text[]`;
+    return sql`${lhs} ${sqlOp} ${JSON.stringify(value)}::jsonb`;
+  }
+  if (type === "cube") return sql`${lhs} ${sqlOp} ${cubeLiteralSql(value)}`;
+  return sql`${lhs} ${sqlOp} ${value}`;
+}
+function getNodeSql(ast, options) {
+  if (typeof ast === "boolean") return ast;
+  const op = ast[0];
+  if (op === "$and" || op === "$or") {
+    return sql`(${join(
+      ast[1].map((node) => getNodeSql(node, options)),
+      `) ${opSql[op]} (`
+    )})`;
+  }
+  if (op === "$not") {
+    return sql`${opSql[op]} (${getNodeSql(ast[1], options)})`;
+  }
+  if (op === "$sub") {
+    const joinName = ast[1];
+    if (!options.joins[joinName]) throw Error(`pg.no_join ${joinName}`);
+    const { idCol, schema } = options;
+    const joinOptions = options.joins[joinName];
+    const { table: joinTable, refCol } = options.joins[joinName];
+    return sql`"${raw(idCol)}" IN (SELECT "${raw(refCol)}"::${raw(
+      schema.types[idCol]
+    )} FROM "${raw(joinTable)}" WHERE ${getNodeSql(ast[2], joinOptions)})`;
+  }
+  const [prefix, ...suffix] = ast[1].split(".");
+  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);
+  }
+  if (suffix.length) throw Error(`pg.lookup_not_jsonb ${prefix}`);
+  return getBinarySql(sql`"${raw(prefix)}"`, types2[prefix], op, ast[2]);
+}
+function getSql(filter, options) {
+  const ast = getAst(filter);
+  return getNodeSql(ast, options);
+}
+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 (!isEmpty(filter)) where.push(getSql(filter, options));
+  if (!hasRangeArg)
+    return {
+      meta: meta(baseKey),
+      where,
+      limit: 1,
+      ensureSingleRow: $group === true
+    };
+  const groupCols = Array.isArray($group) && $group.length && $group.map((prop) => lookup(prop, options));
+  const group = groupCols ? join(groupCols, ", ") : void 0;
+  const orderCols = ($order || [idCol]).map(
+    (orderItem) => orderItem[0] === "!" ? sql`-(${lookup(orderItem.slice(1), options)})::float8` : lookup(orderItem, options)
+  );
+  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), options)} ${$last ? sql`ASC` : sql`DESC`}` : sql`${lookup(orderItem, options)} ${$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,
+    ensureSingleRow: true
+  };
+}
+function getBoundCond(orderCols, bound, kind) {
+  if (!Array.isArray(bound) || orderCols.length === 0 || bound.length === 0) {
+    throw Error(`pg_arg.bad_query bound : ${JSON.stringify(bound)}`);
+  }
+  switch (kind) {
+    case "$after":
+      return sql`(${join(orderCols, ",")}) > (${join(bound, ",")})`;
+    case "$since":
+      return sql`(${join(orderCols, ",")}) >= (${join(bound, ",")})`;
+    case "$before":
+      return sql`(${join(orderCols, ",")}) < (${join(bound, ",")})`;
+    case "$until":
+      return sql`(${join(orderCols, ",")}) <= (${join(bound, ",")})`;
+  }
+}
+const MAX_LIMIT = 4096;
+function selectByArgs(args, projection, options) {
+  const { table, idCol } = options;
+  const { where, order, group, limit, meta, ensureSingleRow } = getArgSql(
+    args,
+    options
+  );
+  const clampedLimit = Math.min(MAX_LIMIT, limit || MAX_LIMIT);
+  if (!ensureSingleRow) {
+    return sql`
+      SELECT
+      ${getSelectCols(options, projection)}, ${meta}
+      FROM "${raw(table)}" WHERE "${raw(idCol)}" = (
+        SELECT "${raw(idCol)}" FROM "${raw(table)}"
+        ${where.length ? sql`WHERE ${join(where, " AND ")}` : empty}
+        LIMIT 2
+      )
+    `;
+  }
+  return sql`
+    SELECT
+    ${getSelectCols(options, 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(options, projection)}, ${getIdMeta(options)}
+    FROM "${raw(table)}"
+    WHERE "${raw(idCol)}" IN (${join(ids)})
+  `;
+}
+function getSingleSql(arg, options) {
+  const { table, idCol } = options;
+  if (!isPlainObject(arg)) {
+    return {
+      where: sql`"${raw(idCol)}" = ${arg}`,
+      meta: getIdMeta(options)
+    };
+  }
+  const { where, meta } = getArgSql(arg, options);
+  if (!where?.length) throw Error("pg_write.no_condition");
+  return {
+    where: sql`"${raw(idCol)}" = (
+        SELECT "${raw(idCol)}"
+        FROM "${raw(table)}"
+        WHERE ${join(where, " AND ")}
+        LIMIT 2
+      )`,
+    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(options)}, ${meta}`;
+}
+function put(puts, options) {
+  const { idCol, table } = options;
+  const sqls = [];
+  const addSql = (rows, meta, conflictTarget) => {
+    const { cols, vals, updates } = getInsert(rows, options);
+    sqls.push(sql`
+      INSERT INTO "${raw(table)}" (${cols}) VALUES ${vals}
+      ON CONFLICT (${conflictTarget}) DO UPDATE SET ${updates}
+      RETURNING ${getSelectCols(options)}, ${meta}`);
+  };
+  const idRows = [];
+  for (const put2 of puts) {
+    const [row, arg] = put2;
+    if (!isPlainObject(arg)) {
+      idRows.push(row);
+      continue;
+    }
+    const { meta } = getArgSql(arg, options);
+    const conflictTarget = join(
+      Object.keys(arg).map((col) => sql`"${raw(col)}"`)
+    );
+    addSql([row], meta, conflictTarget);
+  }
+  if (idRows.length) {
+    const meta = getIdMeta(options);
+    const conflictTarget = sql`"${raw(idCol)}"`;
+    addSql(idRows, meta, conflictTarget);
+  }
+  return sqls;
+}
+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("graffy:pg:db");
+const { Pool, Client, types } = pg$1;
+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, tableOptions) {
+    log(`Making SQL query: ${sql2.text}`, sql2.values);
+    const cubeOid = Number.parseInt(tableOptions?.schema?.typeOids?.cube || "0", 10) || null;
+    try {
+      sql2.types = {
+        getTypeParser: (oid, format2) => {
+          if (oid === types.builtins.INT8) {
+            return (value) => Number.parseInt(value, 10);
+          }
+          if (oid === cubeOid) {
+            return (value) => {
+              const array = value.slice(1, -1).split(/\)\s*,\s*\(/).map(
+                (corner) => corner.split(",").map((coord) => Number.parseFloat(coord.trim()))
+              );
+              return array.length > 1 ? array : array[0];
+            };
+          }
+          return types.getTypeParser(oid, format2);
+        }
+      };
+      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, tableOptions) {
+    const result = (await this.query(sql2, tableOptions)).rows;
+    log("Read result", result);
+    return result;
+  }
+  async writeSql(sql2, tableOptions) {
+    const res = await this.query(sql2, tableOptions);
+    log("Rows written", res.rowCount);
+    if (!res.rowCount) {
+      throw Error(`pg.nothing_written ${sql2.text} with ${sql2.values}`);
+    }
+    return res.rows;
+  }
+  /*
+    Adds .schema to tableOptions if it doesn't exist yet.
+    It mutates the argument, to "persist" the results and
+    avoid this query in every operation.
+  */
+  async ensureSchema(tableOptions, typeOids) {
+    if (tableOptions.schema) return;
+    const { table, verCol, joins } = tableOptions;
+    const tableInfoSchema = (await this.query(sql`
+        SELECT table_schema, table_type
+        FROM information_schema.tables
+        WHERE table_name = ${table}
+        ORDER BY array_position(current_schemas(false)::text[], table_schema::text) ASC
+        LIMIT 1`)).rows[0];
+    const tableSchema = tableInfoSchema.table_schema;
+    const tableType = tableInfoSchema.table_type;
+    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}`);
+    typeOids = typeOids || (await this.query(sql`
+        SELECT jsonb_object_agg(typname, oid) AS type_oids
+        FROM pg_type
+        WHERE typname = 'cube'`)).rows[0].type_oids;
+    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 && tableType !== "VIEW") {
+      throw Error(`pg.verCol_without_default ${verCol}`);
+    }
+    await Promise.all(
+      Object.values(joins).map(
+        (joinOptions) => this.ensureSchema(joinOptions, typeOids)
+      )
+    );
+    log("ensureSchema", types2);
+    tableOptions.schema = { types: types2, typeOids };
+    tableOptions.verDefault = verDefault;
+  }
+  async read(rootQuery, tableOptions) {
+    const idQueries = {};
+    const promises = [];
+    const results = [];
+    const { prefix: rawPrefix } = tableOptions;
+    const prefix = encodePath(rawPrefix);
+    await this.ensureSchema(tableOptions);
+    const getByArgs = async (args, projection) => {
+      const sql2 = selectByArgs(args, projection, tableOptions);
+      const result = await this.readSql(sql2, tableOptions);
+      const wrappedGraph = encodeGraph(wrapObject(result, rawPrefix));
+      log("getByArgs", wrappedGraph);
+      merge(results, wrappedGraph);
+    };
+    const explainArgs = async (args, _projection) => {
+      const { analyze, $explain: qArgs } = args;
+      const qSql = selectByArgs(qArgs, null, tableOptions);
+      const sql$1 = sql`EXPLAIN (${analyze ? sql`ANALYZE, BUFFERS, TIMING, ` : sql``}COSTS, VERBOSE, FORMAT JSON) ${qSql}`;
+      const result = await this.readSql(sql$1, tableOptions);
+      const wrappedGraph = encodeGraph(
+        wrapObject(
+          {
+            $key: args,
+            sql: formatSql(qSql),
+            plan: result[0]["QUERY PLAN"][0]
+          },
+          rawPrefix
+        )
+      );
+      log("explainArgs", wrappedGraph);
+      merge(results, wrappedGraph);
+    };
+    const getByIds = async () => {
+      const sql2 = selectByIds(Object.keys(idQueries), null, tableOptions);
+      const result = await this.readSql(sql2, tableOptions);
+      for (const object of result) {
+        const wrappedGraph = encodeGraph(wrapObject(object, rawPrefix));
+        log("getByIds", wrappedGraph);
+        merge(results, wrappedGraph);
+      }
+    };
+    const query = unwrap(rootQuery, prefix);
+    for (const node of query) {
+      const args = decodeArgs(node);
+      if (isPlainObject(args)) {
+        if (node.prefix) {
+          for (const childNode of node.children) {
+            const childArgs = decodeArgs(childNode);
+            const projection = childNode.children ? decodeQuery(childNode.children) : null;
+            promises.push(getByArgs({ ...args, ...childArgs }, projection));
+          }
+        } else {
+          const projection = node.children ? decodeQuery(node.children) : null;
+          if (args.$explain) {
+            promises.push(explainArgs(args));
+          } else {
+            promises.push(getByArgs(args, projection));
+          }
+        }
+      } else {
+        idQueries[args] = node.children;
+      }
+    }
+    if (!isEmpty(idQueries)) promises.push(getByIds());
+    await Promise.all(promises);
+    log("dbRead", rootQuery, results);
+    return finalize(results, wrap(query, prefix));
+  }
+  async write(rootChange, tableOptions) {
+    const { prefix: rawPrefix } = tableOptions;
+    const prefix = encodePath(rawPrefix);
+    await this.ensureSchema(tableOptions);
+    const change = unwrap(rootChange, prefix);
+    const puts = [];
+    const sqls = [];
+    for (const node of change) {
+      const arg = decodeArgs(node);
+      if (isRange(node)) {
+        if (cmp(node.key, node.end) === 0) {
+          log("delete", node);
+          sqls.push(del(arg, tableOptions));
+          continue;
+        }
+        throw Error("pg_write.write_range_unsupported");
+      }
+      const object = decodeGraph(node.children);
+      if (isPlainObject(arg)) {
+        mergeObject(object, arg);
+      } else {
+        object[tableOptions.idCol] = arg;
+      }
+      if (object.$put && object.$put !== true) {
+        throw Error("pg_write.partial_put_unsupported");
+      }
+      if (object.$put) {
+        puts.push([object, arg]);
+      } else {
+        sqls.push(patch(object, arg, tableOptions));
+      }
+    }
+    if (puts.length) sqls.push(...put(puts, tableOptions));
+    const result = [];
+    await Promise.all(
+      sqls.map(
+        (sql2) => this.writeSql(sql2, tableOptions).then((object) => {
+          log("returned_object_wrapped", wrapObject(object, rawPrefix));
+          merge(result, encodeGraph(wrapObject(object, rawPrefix)));
+        })
+      )
+    );
+    log("dbWrite", rootChange, result);
+    return result;
+  }
+}
+function getTableOpts(name, { table, idCol, verCol, joins, schema, verDefault } = {}, parentName = null) {
+  const tableName = table || name;
+  return {
+    table: table || name,
+    idCol: idCol || "id",
+    verCol: verCol || "updatedAt",
+    joins: Object.fromEntries(
+      Object.entries(joins || {}).map(
+        ([joinName, { refCol = parentName, ...joinOptions }]) => [
+          joinName,
+          {
+            refCol,
+            ...getTableOpts(joinName, joinOptions, tableName)
+          }
+        ]
+      )
+    ),
+    schema,
+    verDefault
+  };
+}
+const pg = ({ connection, ...rawOptions }) => (store) => {
+  store.on("read", read);
+  store.on("write", write);
+  const prefix = store.path;
+  const tableOpts = getTableOpts(prefix[prefix.length - 1], rawOptions);
+  tableOpts.prefix = prefix;
+  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 = remove(query, encodePath(prefix));
+    const nextPromise = next(remainingQuery);
+    return Promise.all([readPromise, nextPromise]).then(
+      ([readRes, nextRes]) => {
+        return 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 = remove(change, encodePath(prefix));
+    const nextPromise = next(remainingChange);
+    return Promise.all([writePromise, nextPromise]).then(
+      ([writeRes, nextRes]) => {
+        return merge(writeRes, nextRes);
+      }
+    );
+  }
+};
+export {
+  pg
+};