@graffy/pg 0.15.12 → 0.15.14-alpha.1

package/index.cjs

@@ -53,8 +53,7 @@ const valid = {
   $all: true,
   $has: true,
   $cts: true,
-  $ctd: true,
-  $ovl: true
+  $ctd: true
 };
 const inverse = {
   $eq: "$neq",
@@ -67,10 +66,8 @@ const inverse = {
   $lte: "$gt"
 };
 function getAst(filter) {
-  counter = 0;
   return simplify(construct(filter));
 }
-let counter;
 function construct(node, prop, op) {
   if (!node || typeof node !== "object" || prop && op) {
     if (op && prop)
@@ -91,14 +88,6 @@ function construct(node, prop, op) {
       if (key === "$not") {
         return [key, construct(val, prop, op)];
       }
-      if (key === "$any" || key === "$all") {
-        const elkey = "el$" + counter++;
-        return [key, prop, elkey, construct(val, elkey)];
-      }
-      if (key === "$has") {
-        const elkey = "el$" + counter++;
-        return [key, prop, elkey, construct(val, elkey)[1]];
-      }
       if (key[0] === "$") {
         if (!valid[key])
           throw Error("pgast.invalid_op:" + key);
@@ -123,10 +112,21 @@ function simplify(node) {
     node[1] = node[1].map((subnode) => simplify(subnode));
   } else if (op === "$not") {
     node[1] = simplify(node[1]);
-  } else if (op === "$all" || op === "$any") {
-    node[3] = simplify(node[3]);
-  } else if (op === "$has") {
-    node[3] = node[3].map((subnode) => simplify(subnode));
+  }
+  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) => {
@@ -148,112 +148,75 @@ function simplify(node) {
       ];
     }
   }
-  if (op === "$and" || op === "$or") {
-    if (!node[1].length)
-      throw Error("pgast.expected_children:" + op);
-    return node[1].length === 1 ? node[1][0] : node;
+  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;
   }
-  if (op === "$any" || op === "$all") {
-    const [_, list, elkey, subnode] = node;
-    const [subop, elk, val] = subnode;
-    return (subop === "$eq" || subop === "$in") && elkey === elk ? [op === "$any" ? "$ovl" : "$ctd", list, subop === "$eq" ? [val] : val] : node;
-  }
-  if (op === "$has") {
-    const [_, list, elkey, limbs] = node;
-    return limbs.every(([subop, elk]) => subop === "$eq" && elk === elkey) ? ["$cts", list, limbs.map(([_op, _prop, val]) => val)] : node;
-  }
   return node;
 }
-function defaultColumnType(_) {
-  return "any";
-}
-function getCompatibleTypes(value) {
-  if (value === null)
-    return "any";
-  if (Array.isArray(value))
-    return "array";
-  if (typeof value === "object")
-    return "jsonb";
-  if (typeof value === "number")
-    return "numeric";
-  if (typeof value === "string")
-    return "text";
-}
-function getSql(filter, getLookupSql, getColumnType = defaultColumnType) {
-  function lookup(string, type) {
-    if (string.substr(0, 3) === "el$")
-      return sql__default["default"]`"${sql.raw(string)}"`;
-    return getLookupSql(string, type);
+const opSql = {
+  $and: `AND`,
+  $or: `OR`,
+  $not: sql__default["default"]`NOT`,
+  $eq: sql__default["default"]`=`,
+  $neq: sql__default["default"]`<>`,
+  $in: sql__default["default"]`IN`,
+  $nin: sql__default["default"]`NOT IN`,
+  $lt: sql__default["default"]`<`,
+  $lte: sql__default["default"]`<=`,
+  $gt: sql__default["default"]`>`,
+  $gte: sql__default["default"]`>=`,
+  $re: sql__default["default"]`~`,
+  $ire: sql__default["default"]`~*`,
+  $cts: sql__default["default"]`@>`,
+  $ctd: sql__default["default"]`<@`
+};
+function castValue$1(value, type, op) {
+  if (value === null && op === "$eq")
+    return sql__default["default"]`IS NULL`;
+  if (value === null && op === "$neq")
+    return sql__default["default"]`IS NOT NULL`;
+  const sqlOp = opSql[op];
+  if (!sqlOp)
+    throw Error("pg.getSql_unknown_operator " + op);
+  if (op === "$in" || op === "$nin") {
+    return sql__default["default"]`${sqlOp} (${sql.join(value)})`;
   }
-  function binop(op, left, right) {
-    const lType = left.substr(0, 3) === "el$" ? "any" : getColumnType(left);
-    const rType = getCompatibleTypes(right);
-    if (lType === "any" || rType === "any" || rType === lType) {
-      return sql__default["default"]`${lookup(left)} ${sql.raw(op)} ${right}`;
-    } else {
-      return sql__default["default"]`(${lookup(left, rType)})::${sql.raw(rType)} ${sql.raw(op)} ${right}`;
+  if (type === "jsonb") {
+    return sql__default["default"]`${sqlOp} ${JSON.stringify(value)}::jsonb`;
+  }
+  if (type === "cube") {
+    if (!Array.isArray(value) || value.length !== 2 || !Array.isArray(value[0])) {
+      throw Error("pg.castValue_bad_cube" + JSON.stringify(value));
     }
+    return sql__default["default"]`${sqlOp} cube(${sql.join(value)})`;
   }
+  return sql__default["default"]`${sqlOp} ${value}`;
+}
+function getSql(filter, options) {
   function getNodeSql(ast) {
-    switch (ast[0]) {
-      case "$eq":
-        if (ast[2] === null)
-          return sql__default["default"]`${lookup(ast[1])} IS NULL`;
-        return binop("=", ast[1], ast[2]);
-      case "$neq":
-        if (ast[2] === null)
-          return sql__default["default"]`${lookup(ast[1])} IS NOT NULL`;
-        return binop("<>", ast[1], ast[2]);
-      case "$lt":
-        return binop("<", ast[1], ast[2]);
-      case "$lte":
-        return binop("<=", ast[1], ast[2]);
-      case "$gt":
-        return binop(">", ast[1], ast[2]);
-      case "$gte":
-        return binop(">=", ast[1], ast[2]);
-      case "$re":
-        return binop("~", ast[1], ast[2]);
-      case "$ire":
-        return binop("~*", ast[1], ast[2]);
-      case "$in":
-        return sql__default["default"]`${lookup(ast[1])} IN (${sql.join(ast[2])})`;
-      case "$nin":
-        return sql__default["default"]`${lookup(ast[1])} NOT IN (${sql.join(ast[2])})`;
-      case "$cts":
-        return sql__default["default"]`${lookup(ast[1])} @> ${ast[2]}`;
-      case "$ctd":
-        return sql__default["default"]`${lookup(ast[1])} <@ ${ast[2]}`;
-      case "$ovl":
-        switch (getColumnType(ast[1])) {
-          case "jsonb":
-          case "any":
-            return sql__default["default"]`${lookup(ast[1])} ?| ${Array.isArray(ast[2]) ? ast[2] : Object.keys(ast[2])}`;
-          case "array":
-            return sql__default["default"]`${lookup(ast[1])} && ${ast[2]}`;
-          default:
-            throw Error("pg.getSql_ovl_unknown_column_type");
-        }
-      case "$and":
-        return sql__default["default"]`(${sql.join(ast[1].map((node) => getNodeSql(node)), `) AND (`)})`;
-      case "$or":
-        return sql__default["default"]`(${sql.join(ast[1].map((node) => getNodeSql(node)), `) OR (`)})`;
-      case "$not":
-        return sql__default["default"]`NOT (${getNodeSql(ast[1])})`;
-      case "$any":
-        return sql__default["default"]`(SELECT bool_or(${getNodeSql(ast[3])}) FROM UNNEST(${lookup(ast[1])}) ${lookup(ast[2])})`;
-      case "$all":
-        return sql__default["default"]`(SELECT bool_and(${getNodeSql(ast[3])}) FROM UNNEST(${lookup(ast[1])}) ${lookup(ast[2])})`;
-      case "$has":
-        return sql__default["default"]`(SELECT bool_or(${sql.join(ast[3].map((node) => getNodeSql(node)), `) AND bool_or(`)}) FROM UNNEST(${lookup(ast[1])}) ${lookup(ast[2])})`;
-      default:
-        throw Error("pg.getSql_unknown_operator: " + ast[0]);
+    if (typeof ast === "boolean")
+      return ast;
+    const op = ast[0];
+    if (op === "$and" || op === "$or") {
+      return sql__default["default"]`(${sql.join(ast[1].map((node) => getNodeSql(node)), `) ${opSql[op]} (`)})`;
+    } else if (op === "$not") {
+      return sql__default["default"]`${opSql[op]} (${getNodeSql(ast[1])})`;
     }
+    const [prefix, ...suffix] = common.encodePath(ast[1]);
+    const { types } = options.schema;
+    if (!types[prefix])
+      throw Error("pg.no_column " + prefix);
+    if (suffix.length && types[prefix] !== "jsonb") {
+      throw Error("pg.lookup_not_jsonb " + prefix);
+    }
+    const [lhs, type] = suffix.length ? [sql__default["default"]`"${sql.raw(prefix)}" #> ${suffix}`, "jsonb"] : [sql__default["default"]`"${sql.raw(prefix)}"`, types[prefix]];
+    const rhs = castValue$1(ast[2], type, op);
+    return sql__default["default"]`${lhs} ${rhs}`;
   }
   return getNodeSql(getAst(filter));
 }
@@ -271,22 +234,68 @@ const getJsonBuildValue = (value) => {
     return sql__default["default"]`${value}::text`;
   return sql__default["default"]`${JSON.stringify(stripAttributes(value))}::jsonb`;
 };
-const getSelectCols = (table) => {
-  return sql__default["default"]`to_jsonb("${sql.raw(table)}")`;
+const lookup = (prop) => {
+  const [prefix, ...suffix] = common.encodePath(prop);
+  return suffix.length ? sql__default["default"]`"${sql.raw(prefix)}" #> ${suffix}` : sql__default["default"]`"${sql.raw(prefix)}"`;
+};
+const aggSql = {
+  $sum: (prop) => sql__default["default"]`sum((${lookup(prop)})::numeric)`,
+  $card: (prop) => sql__default["default"]`count(distinct(${lookup(prop)}))`,
+  $avg: (prop) => sql__default["default"]`sum((${lookup(prop)})::numeric)`,
+  $max: (prop) => sql__default["default"]`sum((${lookup(prop)})::numeric)`,
+  $min: (prop) => sql__default["default"]`sum((${lookup(prop)})::numeric)`
 };
+const getSelectCols = (table, projection = null) => {
+  if (!projection)
+    return sql__default["default"]`to_jsonb("${sql.raw(table)}")`;
+  const sqls = [];
+  for (const key in projection) {
+    if (key === "$count") {
+      sqls.push(sql__default["default"]`'$count', count(*)`);
+    } else if (aggSql[key]) {
+      const subSqls = [];
+      for (const prop in projection[key]) {
+        subSqls.push(sql__default["default"]`${prop}::text, ${aggSql[key](prop)}`);
+      }
+      sqls.push(sql__default["default"]`${key}::text, jsonb_build_object(${sql.join(subSqls, ", ")})`);
+    } else {
+      sqls.push(sql__default["default"]`${key}::text, "${sql.raw(key)}"`);
+    }
+  }
+  return sql__default["default"]`jsonb_build_object(${sql.join(sqls, ", ")})`;
+};
+function infJoin(array) {
+  return sql__default["default"]`array[${sql.join(array.map((num) => num === Infinity ? sql__default["default"]`'Infinity'` : num === -Infinity ? sql__default["default"]`'-Infinity'` : num))}]::float8[]`;
+}
+function castValue(value, type, name) {
+  if (!type)
+    throw Error("pg.write_no_column " + name);
+  if (value instanceof sql.Sql)
+    return value;
+  if (value === null)
+    return sql__default["default"]`NULL`;
+  if (type === "jsonb") {
+    return value.$put ? JSON.stringify(stripAttributes(value)) : sql__default["default"]`jsonb_strip_nulls(${getJsonUpdate(value, name, [])})`;
+  }
+  if (type === "cube") {
+    if (!Array.isArray(value) || !value.length || Array.isArray(value[0]) && value.length !== 2) {
+      throw Error("pg.castValue_bad_cube" + JSON.stringify(value));
+    }
+    return Array.isArray(value[0]) ? sql__default["default"]`cube(${infJoin(value[0])}, ${infJoin(value[1])})` : sql__default["default"]`cube(${infJoin(value)})`;
+  }
+  return value;
+}
 const getInsert = (row, options) => {
   const cols = [];
   const vals = [];
-  Object.entries(row).filter(([name]) => name !== options.verCol && name[0] !== "$").concat([[options.verCol, nowTimestamp]]).forEach(([col, val]) => {
+  Object.entries(row).filter(([col]) => col !== options.verCol && col[0] !== "$").concat([[options.verCol, nowTimestamp]]).forEach(([col, val]) => {
     cols.push(sql__default["default"]`"${sql.raw(col)}"`);
-    vals.push(val instanceof sql.Sql || typeof val !== "object" || !val ? val : sql__default["default"]`${JSON.stringify(stripAttributes(val))}::jsonb`);
+    vals.push(castValue(val, options.schema.types[col], col));
   });
   return { cols: sql.join(cols, ", "), vals: sql.join(vals, ", ") };
 };
 const getUpdates = (row, options) => {
-  return sql.join(Object.entries(row).filter(([name]) => name !== options.idCol && name[0] !== "$").map(([name, value]) => {
-    return sql__default["default"]`"${sql.raw(name)}" = ${value instanceof sql.Sql || typeof value !== "object" || !value ? value : !value.$put ? sql__default["default"]`jsonb_strip_nulls(${getJsonUpdate(value, name, [])})` : sql__default["default"]`${JSON.stringify(stripAttributes(value))}::jsonb`}`;
-  }).concat(sql__default["default"]`"${sql.raw(options.verCol)}" = ${nowTimestamp}`), ", ");
+  return sql.join(Object.entries(row).filter(([col]) => col !== options.idCol && col[0] !== "$").map(([col, val]) => sql__default["default"]`"${sql.raw(col)}" = ${castValue(val, options.schema.types[col], col)}`).concat(sql__default["default"]`"${sql.raw(options.verCol)}" = ${nowTimestamp}`), ", ");
 };
 function getJsonUpdate(_a, col, path) {
   var _b = _a, { $put } = _b, object = __objRest(_b, ["$put"]);
@@ -322,29 +331,29 @@ const getArgMeta = (key, prefix, idCol) => getJsonBuildObject({
   $ref: sql__default["default"]`jsonb_build_array(${sql.join(prefix.map((k) => sql__default["default"]`${k}::text`))}, "${sql.raw(idCol)}")`,
   $ver: nowTimestamp
 });
+const getAggMeta = (key, $group) => getJsonBuildObject({
+  $key: sql.join([key, getJsonBuildObject({ $group })].filter(Boolean), " || "),
+  $ver: nowTimestamp
+});
 function getArgSql(_c, options) {
   var _d = _c, { $first, $last, $after, $before, $since, $until, $all, $cursor: _ } = _d, rest = __objRest(_d, ["$first", "$last", "$after", "$before", "$since", "$until", "$all", "$cursor"]);
-  const _a = rest, { $order } = _a, filter = __objRest(_a, ["$order"]);
+  const _a = rest, { $order, $group } = _a, filter = __objRest(_a, ["$order", "$group"]);
   const { prefix, idCol } = options;
-  const lookup = (prop, type) => {
-    const [prefix2, ...suffix] = common.encodePath(prop);
-    const op = type === "text" ? sql__default["default"]`#>>` : sql__default["default"]`#>`;
-    return suffix.length ? sql__default["default"]`"${sql.raw(prefix2)}" ${op} ${suffix}` : sql__default["default"]`"${sql.raw(prefix2)}"`;
-  };
-  const getType = (prop) => {
-    const [_prefix, ...suffix] = common.encodePath(prop);
-    return suffix.length ? "jsonb" : "any";
-  };
-  const meta = (key2) => getArgMeta(key2, prefix, idCol);
+  if ($order && $group) {
+    throw Error("pg_arg.order_and_group_unsupported in " + prefix);
+  }
+  const meta = (key2) => $group ? getAggMeta(key2, $group) : getArgMeta(key2, prefix, idCol);
+  const groupCols = Array.isArray($group) && $group.length && $group.map(lookup);
+  const group = groupCols ? sql.join(groupCols, ", ") : void 0;
   const hasRangeArg = $before || $after || $since || $until || $first || $last || $all || $order;
   let key;
   const where = [];
   if (!common.isEmpty(filter)) {
-    where.push(getSql(filter, lookup, getType));
+    where.push(getSql(filter, options));
     key = sql__default["default"]`${JSON.stringify(filter)}::jsonb`;
   }
   if (!hasRangeArg)
-    return { meta: meta(key), where, limit: 1 };
+    return { meta: meta(key), where, group, limit: 1 };
   if (common.isEmpty(rest)) {
     throw Error("pg_arg.pagination_only_unsupported in " + prefix);
   }
@@ -355,13 +364,14 @@ function getArgSql(_c, options) {
   });
   const orderQuery = $order && getJsonBuildObject({ $order: sql__default["default"]`${JSON.stringify($order)}::jsonb` });
   const cursorQuery = getJsonBuildObject({
-    $cursor: sql__default["default"]`jsonb_build_array(${sql.join(orderCols)})`
+    $cursor: sql__default["default"]`jsonb_build_array(${sql.join(groupCols || orderCols)})`
   });
   key = sql__default["default"]`(${sql.join([key, orderQuery, cursorQuery].filter(Boolean), ` || `)})`;
   return {
     meta: meta(key),
     where,
-    order: sql.join(orderCols.map((col) => sql__default["default"]`${col} ${$last ? sql__default["default"]`DESC` : sql__default["default"]`ASC`}`), `, `),
+    order: $order && sql.join(orderCols.map((col) => sql__default["default"]`${col} ${$last ? sql__default["default"]`DESC` : sql__default["default"]`ASC`}`), `, `),
+    group,
     limit: $first || $last
   };
 }
@@ -395,39 +405,57 @@ function getBoundCond(orderCols, bound, kind) {
   }
 }
 const MAX_LIMIT = 4096;
-function selectByArgs(args, options) {
+function selectByArgs(args, projection, options) {
   const { table } = options;
-  const { where, order, limit, meta } = getArgSql(args, options);
+  const { where, order, group, limit, meta } = getArgSql(args, options);
   const clampedLimit = Math.min(MAX_LIMIT, limit || MAX_LIMIT);
   return sql__default["default"]`
     SELECT
-    ${getSelectCols(table)} || ${meta}
+    ${getSelectCols(table, projection)} || ${meta}
     FROM "${sql.raw(table)}"
     ${where.length ? sql__default["default"]`WHERE ${sql.join(where, ` AND `)}` : sql.empty}
+    ${group ? sql__default["default"]`GROUP BY ${group}` : sql.empty}
     ${order ? sql__default["default"]`ORDER BY ${order}` : sql.empty}
     LIMIT ${clampedLimit}
   `;
 }
-function selectByIds(ids, options) {
+function selectByIds(ids, projection, options) {
   const { table, idCol } = options;
   return sql__default["default"]`
     SELECT
-    ${getSelectCols(table)} || ${getIdMeta(options)}
+    ${getSelectCols(table, projection)} || ${getIdMeta(options)}
     FROM "${sql.raw(table)}"
     WHERE "${sql.raw(idCol)}" IN (${sql.join(ids)})
   `;
 }
-function patch(object, arg, options) {
+function getSingleSql(arg, options) {
   const { table, idCol } = options;
-  const { where, meta } = common.isPlainObject(arg) ? getArgSql(arg, options) : { where: [sql__default["default"]`"${sql.raw(idCol)}" = ${arg}`], meta: getIdMeta(options) };
+  if (!common.isPlainObject(arg)) {
+    return {
+      where: sql__default["default"]`"${sql.raw(idCol)}" = ${arg}`,
+      meta: getIdMeta(options)
+    };
+  }
+  const { where, meta } = getArgSql(arg, options);
   if (!where || !where.length)
     throw Error("pg_write.no_condition");
+  return {
+    where: sql__default["default"]`"${sql.raw(idCol)}" = (
+        SELECT "${sql.raw(idCol)}"
+        FROM "${sql.raw(table)}"
+        WHERE ${sql.join(where, ` AND `)}
+        LIMIT 1
+      )`,
+    meta
+  };
+}
+function patch(object, arg, options) {
+  const { table } = options;
+  const { where, meta } = getSingleSql(arg, options);
   const row = object;
   return sql__default["default"]`
     UPDATE "${sql.raw(table)}" SET ${getUpdates(row, options)}
-    WHERE ${common.isPlainObject(arg) ? sql__default["default"]`"${sql.raw(idCol)}" = (
-            SELECT "${sql.raw(idCol)}" FROM "${sql.raw(table)}"
-            WHERE ${sql.join(where, ` AND `)} LIMIT 1)` : sql.join(where, ` AND `)}
+    WHERE ${where}
     RETURNING (${getSelectCols(table)} || ${meta})`;
 }
 function put(object, arg, options) {
@@ -447,6 +475,14 @@ function put(object, arg, options) {
     ON CONFLICT (${conflictTarget}) DO UPDATE SET (${cols}) = (${vals})
     RETURNING (${getSelectCols(table)} || ${meta})`;
 }
+function del(arg, options) {
+  const { table } = options;
+  const { where } = getSingleSql(arg, options);
+  return sql__default["default"]`
+    DELETE FROM "${sql.raw(table)}"
+    WHERE ${where}
+    RETURNING (${getJsonBuildObject({ $key: arg })})`;
+}
 const log = debug__default["default"]("graffy:pg:db");
 class Db {
   constructor(connection) {
@@ -474,32 +510,54 @@ class Db {
     }
   }
   async readSql(sql2) {
-    let result = await this.query(sql2);
-    result = result.rows.flat();
+    const result = (await this.query(sql2)).rows.flat();
     log("Read result", result);
     return result;
   }
   async writeSql(sql2) {
-    let res = await this.query(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][0];
   }
+  async ensureSchema(tableOptions) {
+    if (tableOptions.schema)
+      return;
+    const { table } = tableOptions;
+    const types = (await this.query(sql__default["default"]`SELECT jsonb_object_agg(
+          column_name,
+          udt_name
+      )
+      FROM information_schema.columns
+      WHERE
+          table_name = ${table} AND
+          table_schema = (
+              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][0];
+    if (!types)
+      throw Error(`pg.missing_table ${table}`);
+    log("ensureSchema", types);
+    tableOptions.schema = { types };
+  }
   async read(rootQuery, tableOptions) {
     const idQueries = {};
     const promises = [];
     const results = [];
     const { prefix } = tableOptions;
-    const getByArgs = async (args) => {
-      const result = await this.readSql(selectByArgs(args, 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), tableOptions));
+      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);
@@ -513,10 +571,12 @@ class Db {
         if (node.prefix) {
           for (const childNode of node.children) {
             const childArgs = common.decodeArgs(childNode);
-            promises.push(getByArgs(__spreadValues(__spreadValues({}, args), childArgs)));
+            const projection = childNode.children ? common.decodeQuery(childNode.children) : null;
+            promises.push(getByArgs(__spreadValues(__spreadValues({}, args), childArgs), projection));
           }
         } else {
-          promises.push(getByArgs(args));
+          const projection = node.children ? common.decodeQuery(node.children) : null;
+          promises.push(getByArgs(args, projection));
         }
       } else {
         idQueries[node.key] = node.children;
@@ -529,15 +589,16 @@ class Db {
     return common.slice(common.finalize(results, common.wrap(query, prefix)), rootQuery).known || [];
   }
   async write(rootChange, tableOptions) {
-    const sqls = [];
-    const addToQuery = (sql2) => sqls.push(sql2);
     const { prefix } = tableOptions;
+    await this.ensureSchema(tableOptions);
     const change = common.unwrap(rootChange, prefix);
-    for (const node of change) {
+    const sqls = change.map((node) => {
+      const arg = common.decodeArgs(node);
       if (common.isRange(node)) {
-        throw Error(node.key === node.end ? "pg_write.delete_unsupported" : "pg_write.write_range_unsupported");
+        if (node.key === node.end)
+          return del(arg, tableOptions);
+        throw Error("pg_write.write_range_unsupported");
       }
-      const arg = common.decodeArgs(node);
       const object = common.decodeGraph(node.children);
       if (common.isPlainObject(arg)) {
         common.mergeObject(object, arg);
@@ -547,8 +608,8 @@ class Db {
       if (object.$put && object.$put !== true) {
         throw Error("pg_write.partial_put_unsupported");
       }
-      object.$put ? addToQuery(put(object, arg, tableOptions)) : addToQuery(patch(object, arg, tableOptions));
-    }
+      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)));
@@ -557,7 +618,7 @@ class Db {
     return result;
   }
 }
-const pg = ({ table, idCol, verCol, links, connection }) => (store) => {
+const pg = ({ table, idCol, verCol, connection, schema }) => (store) => {
   store.on("read", read);
   store.on("write", write);
   const prefix = store.path;
@@ -566,12 +627,13 @@ const pg = ({ table, idCol, verCol, links, connection }) => (store) => {
     table: table || prefix[prefix.length - 1] || "default",
     idCol: idCol || "id",
     verCol: verCol || "updatedAt",
-    links: links || {}
+    schema
   };
   const defaultDb = new Db(connection);
   function read(query, options, next) {
-    const _a = options, { transactionDb = defaultDb } = _a, readOpts = __objRest(_a, ["transactionDb"]);
-    const readPromise = transactionDb.read(query, tableOpts, readOpts);
+    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]) => {
@@ -579,8 +641,9 @@ const pg = ({ table, idCol, verCol, links, connection }) => (store) => {
     });
   }
   function write(change, options, next) {
-    const _a = options, { transactionDb = defaultDb } = _a, writeOpts = __objRest(_a, ["transactionDb"]);
-    const writePromise = transactionDb.write(change, tableOpts, writeOpts);
+    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]) => {