@graffy/pg 0.18.1-alpha.2 → 0.19.1-alpha.1

package/index.cjs

@@ -1,996 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const common = require("@graffy/common");
-const debug = require("debug");
-const pg$1 = require("pg");
-const sqlFormatter = require("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 pg$1.escapeLiteral(value);
-    case "object":
-      if (Array.isArray(value))
-        return `array[${value.map(formatSqlParam).join(", ")}]`;
-      return `'${JSON.stringify(value)}'`;
-    default:
-      return "";
-  }
-}
-function formatSql(sql2) {
-  return sqlFormatter.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 (common.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 (!common.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 (!common.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 (!common.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, format) => {
-          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, 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, 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 = common.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 = common.encodeGraph(common.wrapObject(result, rawPrefix));
-      log("getByArgs", wrappedGraph);
-      common.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 = common.encodeGraph(
-        common.wrapObject(
-          {
-            $key: args,
-            sql: formatSql(qSql),
-            plan: result[0]["QUERY PLAN"][0]
-          },
-          rawPrefix
-        )
-      );
-      log("explainArgs", wrappedGraph);
-      common.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 = common.encodeGraph(common.wrapObject(object, rawPrefix));
-        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;
-          if (args.$explain) {
-            promises.push(explainArgs(args));
-          } else {
-            promises.push(getByArgs(args, projection));
-          }
-        }
-      } else {
-        idQueries[args] = 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: rawPrefix } = tableOptions;
-    const prefix = common.encodePath(rawPrefix);
-    await this.ensureSchema(tableOptions);
-    const change = common.unwrap(rootChange, prefix);
-    const puts = [];
-    const sqls = [];
-    for (const node of change) {
-      const arg = common.decodeArgs(node);
-      if (common.isRange(node)) {
-        if (common.cmp(node.key, node.end) === 0) {
-          log("delete", node);
-          sqls.push(del(arg, tableOptions));
-          continue;
-        }
-        throw Error("pg_write.write_range_unsupported");
-      }
-      const object = common.decodeGraph(node.children);
-      if (common.isPlainObject(arg)) {
-        common.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", common.wrapObject(object, rawPrefix));
-          common.merge(result, common.encodeGraph(common.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 = common.remove(query, common.encodePath(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, common.encodePath(prefix));
-    const nextPromise = next(remainingChange);
-    return Promise.all([writePromise, nextPromise]).then(
-      ([writeRes, nextRes]) => {
-        return common.merge(writeRes, nextRes);
-      }
-    );
-  }
-};
-exports.pg = pg;