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

package/index.cjs

@@ -2,12 +2,73 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const common = require("@graffy/common");
 const pg$1 = require("pg");
-const sql = require("sql-template-tag");
 const debug = require("debug");
 const _interopDefaultLegacy = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
 const pg__default = /* @__PURE__ */ _interopDefaultLegacy(pg$1);
-const sql__default = /* @__PURE__ */ _interopDefaultLegacy(sql);
 const debug__default = /* @__PURE__ */ _interopDefaultLegacy(debug);
+class Sql {
+  constructor(rawStrings, rawValues) {
+    if (rawStrings.length - 1 !== rawValues.length) {
+      if (rawStrings.length === 0) {
+        throw new TypeError("Expected at least 1 string");
+      }
+      throw new TypeError(`Expected ${rawStrings.length} strings to have ${rawStrings.length - 1} values`);
+    }
+    const valuesLength = rawValues.reduce((len, value) => len + (value instanceof Sql ? value.values.length : 1), 0);
+    this.values = new Array(valuesLength);
+    this.strings = new Array(valuesLength + 1);
+    this.strings[0] = rawStrings[0];
+    let i = 0, pos = 0;
+    while (i < rawValues.length) {
+      const child = rawValues[i++];
+      const rawString = rawStrings[i];
+      if (child instanceof Sql) {
+        this.strings[pos] += child.strings[0];
+        let childIndex = 0;
+        while (childIndex < child.values.length) {
+          this.values[pos++] = child.values[childIndex++];
+          this.strings[pos] = child.strings[childIndex];
+        }
+        this.strings[pos] += rawString;
+      } else {
+        this.values[pos++] = child;
+        this.strings[pos] = rawString;
+      }
+    }
+  }
+  get text() {
+    let i = 1, value = this.strings[0];
+    while (i < this.strings.length)
+      value += `$${i}${this.strings[i++]}`;
+    return value;
+  }
+  get sql() {
+    let i = 1, value = this.strings[0];
+    while (i < this.strings.length)
+      value += `?${this.strings[i++]}`;
+    return value;
+  }
+  inspect() {
+    return {
+      text: this.text,
+      sql: this.sql,
+      values: this.values
+    };
+  }
+}
+function join(values, separator = ",", prefix = "", suffix = "") {
+  if (values.length === 0) {
+    throw new TypeError("Expected `join([])` to be called with an array of multiple elements, but got an empty array");
+  }
+  return new Sql([prefix, ...Array(values.length - 1).fill(separator), suffix], values);
+}
+function raw(value) {
+  return new Sql([value], []);
+}
+const empty = raw("");
+function sql(strings, ...values) {
+  return new Sql(strings, values);
+}
 const valid = {
   $eq: true,
   $lt: true,
@@ -134,60 +195,60 @@ function simplify(node) {
   return node;
 }
 const getJsonBuildTrusted = (variadic) => {
-  const args = sql.join(
+  const args = join(
     Object.entries(variadic).map(([name, value]) => {
-      return sql__default.default`'${sql.raw(name)}', ${getJsonBuildValue(value)}`;
+      return sql`'${raw(name)}', ${getJsonBuildValue(value)}`;
     })
   );
-  return sql__default.default`jsonb_build_object(${args})`;
+  return sql`jsonb_build_object(${args})`;
 };
 const getJsonBuildValue = (value) => {
-  if (value instanceof sql.Sql)
+  if (value instanceof Sql)
     return value;
   if (typeof value === "string")
-    return sql__default.default`${value}::text`;
-  return sql__default.default`${JSON.stringify(stripAttributes(value))}::jsonb`;
+    return sql`${value}::text`;
+  return sql`${JSON.stringify(stripAttributes(value))}::jsonb`;
 };
 const lookup = (prop) => {
   const [prefix, ...suffix] = common.encodePath(prop);
-  return suffix.length ? sql__default.default`"${sql.raw(prefix)}" #> ${suffix}` : sql__default.default`"${sql.raw(prefix)}"`;
+  return suffix.length ? sql`"${raw(prefix)}" #> ${suffix}` : sql`"${raw(prefix)}"`;
 };
 const lookupNumeric = (prop) => {
   const [prefix, ...suffix] = common.encodePath(prop);
-  return suffix.length ? sql__default.default`CASE WHEN "${sql.raw(prefix)}" #> ${suffix} = 'null'::jsonb THEN 0 ELSE ("${sql.raw(
+  return suffix.length ? sql`CASE WHEN "${raw(prefix)}" #> ${suffix} = 'null'::jsonb THEN 0 ELSE ("${raw(
     prefix
-  )}" #> ${suffix})::numeric END` : sql__default.default`"${sql.raw(prefix)}"`;
+  )}" #> ${suffix})::numeric END` : sql`"${raw(prefix)}"`;
 };
 const aggSql = {
-  $sum: (prop) => sql__default.default`sum((${lookupNumeric(prop)})::numeric)`,
-  $card: (prop) => sql__default.default`count(distinct(${lookup(prop)}))`,
-  $avg: (prop) => sql__default.default`avg((${lookupNumeric(prop)})::numeric)`,
-  $max: (prop) => sql__default.default`max((${lookupNumeric(prop)})::numeric)`,
-  $min: (prop) => sql__default.default`min((${lookupNumeric(prop)})::numeric)`
+  $sum: (prop) => sql`sum((${lookupNumeric(prop)})::numeric)`,
+  $card: (prop) => sql`count(distinct(${lookup(prop)}))`,
+  $avg: (prop) => sql`avg((${lookupNumeric(prop)})::numeric)`,
+  $max: (prop) => sql`max((${lookupNumeric(prop)})::numeric)`,
+  $min: (prop) => sql`min((${lookupNumeric(prop)})::numeric)`
 };
 const getSelectCols = (table, projection = null) => {
   if (!projection)
-    return sql__default.default`*`;
+    return sql`*`;
   const sqls = [];
   for (const key in projection) {
     if (key === "$count") {
-      sqls.push(sql__default.default`count(*) AS "$count"`);
+      sqls.push(sql`count(*) AS "$count"`);
     } else if (aggSql[key]) {
       const subSqls = [];
       for (const prop in projection[key]) {
-        subSqls.push(sql__default.default`${prop}::text, ${aggSql[key](prop)}`);
+        subSqls.push(sql`${prop}::text, ${aggSql[key](prop)}`);
       }
       sqls.push(
-        sql__default.default`jsonb_build_object(${sql.join(subSqls, ", ")}) AS "${sql.raw(key)}"`
+        sql`jsonb_build_object(${join(subSqls, ", ")}) AS "${raw(key)}"`
       );
     } else {
-      sqls.push(sql__default.default`"${sql.raw(key)}"`);
+      sqls.push(sql`"${raw(key)}"`);
     }
   }
-  return sql.join(sqls, ", ");
+  return join(sqls, ", ");
 };
 function vertexSql(array, nullValue) {
-  return sql__default.default`array[${sql.join(
+  return sql`array[${join(
     array.map((num) => num === null ? nullValue : num)
   )}]::float8[]`;
 }
@@ -195,20 +256,20 @@ function cubeLiteralSql(value) {
   if (!Array.isArray(value) || !value.length || Array.isArray(value[0]) && value.length !== 2) {
     throw Error("pg.castValue_bad_cube" + JSON.stringify(value));
   }
-  return Array.isArray(value[0]) ? sql__default.default`cube(${vertexSql(value[0], sql__default.default`'-Infinity'`)}, ${vertexSql(
+  return Array.isArray(value[0]) ? sql`cube(${vertexSql(value[0], sql`'-Infinity'`)}, ${vertexSql(
     value[1],
-    sql__default.default`'Infinity'`
-  )})` : sql__default.default`cube(${vertexSql(value, 0)})`;
+    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.Sql)
+  if (value instanceof Sql)
     return value;
   if (value === null)
-    return sql__default.default`NULL`;
+    return sql`NULL`;
   if (type === "jsonb") {
-    return isPut ? JSON.stringify(stripAttributes(value)) : sql__default.default`jsonb_strip_nulls(${getJsonUpdate(value, name, [])})`;
+    return isPut ? JSON.stringify(stripAttributes(value)) : sql`jsonb_strip_nulls(${getJsonUpdate(value, name, [])})`;
   }
   if (type === "cube")
     return cubeLiteralSql(value);
@@ -217,22 +278,22 @@ function castValue(value, type, name, isPut) {
 const getInsert = (row, options) => {
   const cols = [];
   const vals = [];
-  Object.entries(row).filter(([col]) => col !== options.verCol && col[0] !== "$").concat([[options.verCol, sql__default.default`default`]]).forEach(([col, val]) => {
-    cols.push(sql__default.default`"${sql.raw(col)}"`);
+  Object.entries(row).filter(([col]) => col !== options.verCol && col[0] !== "$").concat([[options.verCol, sql`default`]]).forEach(([col, val]) => {
+    cols.push(sql`"${raw(col)}"`);
     vals.push(castValue(val, options.schema.types[col], col, row.$put));
   });
-  return { cols: sql.join(cols, ", "), vals: sql.join(vals, ", ") };
+  return { cols: join(cols, ", "), vals: join(vals, ", ") };
 };
 const getUpdates = (row, options) => {
-  return sql.join(
+  return join(
     Object.entries(row).filter(([col]) => col !== options.idCol && col[0] !== "$").map(
-      ([col, val]) => sql__default.default`"${sql.raw(col)}" = ${castValue(
+      ([col, val]) => sql`"${raw(col)}" = ${castValue(
         val,
         options.schema.types[col],
         col,
         row.$put
       )}`
-    ).concat(sql__default.default`"${sql.raw(options.verCol)}" = default`),
+    ).concat(sql`"${raw(options.verCol)}" = default`),
     ", "
   );
 };
@@ -240,15 +301,15 @@ function getJsonUpdate(object, col, path) {
   if (!object || typeof object !== "object" || Array.isArray(object) || object.$put) {
     return getJsonBuildValue(object);
   }
-  const curr = sql__default.default`"${sql.raw(col)}"${path.length ? sql__default.default`#>${path}` : sql.empty}`;
+  const curr = sql`"${raw(col)}"${path.length ? sql`#>${path}` : empty}`;
   if (common.isEmpty(object))
     return curr;
-  return sql__default.default`(case jsonb_typeof(${curr})
+  return sql`(case jsonb_typeof(${curr})
     when 'object' then ${curr}
     else '{}'::jsonb
-  end) || jsonb_build_object(${sql.join(
+  end) || jsonb_build_object(${join(
     Object.entries(object).map(
-      ([key, value]) => sql__default.default`${key}::text, ${getJsonUpdate(value, col, path.concat(key))}`
+      ([key, value]) => sql`${key}::text, ${getJsonUpdate(value, col, path.concat(key))}`
     ),
     ", "
   )})`;
@@ -269,50 +330,50 @@ function stripAttributes(object) {
 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`<@`
+  $not: sql`NOT`,
+  $eq: sql`=`,
+  $neq: sql`<>`,
+  $in: sql`IN`,
+  $nin: sql`NOT IN`,
+  $lt: sql`<`,
+  $lte: sql`<=`,
+  $gt: sql`>`,
+  $gte: sql`>=`,
+  $re: sql`~`,
+  $ire: sql`~*`,
+  $cts: sql`@>`,
+  $ctd: sql`<@`
 };
 function getBinarySql(lhs, type, op, value, textLhs) {
   if (value === null && op === "$eq")
-    return sql__default.default`${lhs} IS NULL`;
+    return sql`${lhs} IS NULL`;
   if (value === null && op === "$neq")
-    return sql__default.default`${lhs} IS NOT NULL`;
+    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__default.default`${lhs} ${sqlOp} (${sql.join(value)})`;
+    return sql`${lhs} ${sqlOp} (${join(value)})`;
   }
   if (op === "$re" || op === "$ire") {
     if (type === "jsonb") {
       lhs = textLhs;
     } else if (type !== "text") {
-      lhs = sql__default.default`(${lhs})::text`;
+      lhs = sql`(${lhs})::text`;
     }
-    return sql__default.default`${lhs} ${sqlOp} ${String(value)}`;
+    return sql`${lhs} ${sqlOp} ${String(value)}`;
   }
   if (type === "jsonb") {
     if (typeof value === "string") {
-      return sql__default.default`${textLhs} ${sqlOp} ${value}`;
+      return sql`${textLhs} ${sqlOp} ${value}`;
     }
-    return sql__default.default`${lhs} ${sqlOp} ${JSON.stringify(value)}::jsonb`;
+    return sql`${lhs} ${sqlOp} ${JSON.stringify(value)}::jsonb`;
   }
   if (type === "cube")
-    return sql__default.default`${lhs} ${sqlOp} ${cubeLiteralSql(value)}`;
-  return sql__default.default`${lhs} ${sqlOp} ${value}`;
+    return sql`${lhs} ${sqlOp} ${cubeLiteralSql(value)}`;
+  return sql`${lhs} ${sqlOp} ${value}`;
 }
 function getSql(filter, options) {
   function getNodeSql(ast) {
@@ -320,12 +381,12 @@ function getSql(filter, options) {
       return ast;
     const op = ast[0];
     if (op === "$and" || op === "$or") {
-      return sql__default.default`(${sql.join(
+      return sql`(${join(
         ast[1].map((node) => getNodeSql(node)),
         `) ${opSql[op]} (`
       )})`;
     } else if (op === "$not") {
-      return sql__default.default`${opSql[op]} (${getNodeSql(ast[1])})`;
+      return sql`${opSql[op]} (${getNodeSql(ast[1])})`;
     }
     const [prefix, ...suffix] = common.encodePath(ast[1]);
     const { types: types2 } = options.schema;
@@ -333,28 +394,28 @@ function getSql(filter, options) {
       throw Error("pg.no_column " + prefix);
     if (types2[prefix] === "jsonb") {
       const [lhs, textLhs] = suffix.length ? [
-        sql__default.default`"${sql.raw(prefix)}" #> ${suffix}`,
-        sql__default.default`"${sql.raw(prefix)}" #>> ${suffix}`
-      ] : [sql__default.default`"${sql.raw(prefix)}"`, sql__default.default`"${sql.raw(prefix)}" #>> '{}'`];
+        sql`"${raw(prefix)}" #> ${suffix}`,
+        sql`"${raw(prefix)}" #>> ${suffix}`
+      ] : [sql`"${raw(prefix)}"`, sql`"${raw(prefix)}" #>> '{}'`];
       return getBinarySql(lhs, "jsonb", op, ast[2], textLhs);
     } else {
       if (suffix.length)
         throw Error("pg.lookup_not_jsonb " + prefix);
-      return getBinarySql(sql__default.default`"${sql.raw(prefix)}"`, types2[prefix], op, ast[2]);
+      return getBinarySql(sql`"${raw(prefix)}"`, types2[prefix], op, ast[2]);
     }
   }
   return getNodeSql(getAst(filter));
 }
-const getIdMeta = ({ idCol, verDefault }) => sql__default.default`"${sql.raw(idCol)}" AS "$key", ${sql.raw(verDefault)} AS "$ver"`;
-const getArgMeta = (key, { prefix, idCol, verDefault }) => sql__default.default`
+const getIdMeta = ({ idCol, verDefault }) => sql`"${raw(idCol)}" AS "$key", ${raw(verDefault)} AS "$ver"`;
+const getArgMeta = (key, { prefix, idCol, verDefault }) => sql`
     ${key} AS "$key",
-    ${sql.raw(verDefault)} AS "$ver",
+    ${raw(verDefault)} AS "$ver",
     array[
-      ${sql.join(prefix.map((k) => sql__default.default`${k}::text`))},
-      "${sql.raw(idCol)}"
+      ${join(prefix.map((k) => sql`${k}::text`))},
+      "${raw(idCol)}"
     ]::text[] AS "$ref"
   `;
-const getAggMeta = (key, { verDefault }) => sql__default.default`${key} AS "$key", ${sql.raw(verDefault)} AS "$ver"`;
+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;
@@ -366,16 +427,16 @@ function getArgSql({ $first, $last, $after, $before, $since, $until, $all, $curs
   if (($order || $group && $group !== true) && !hasRangeArg) {
     throw Error("pg_arg.range_arg_expected in " + prefix);
   }
-  const baseKey = sql__default.default`${JSON.stringify(rest)}::jsonb`;
+  const baseKey = sql`${JSON.stringify(rest)}::jsonb`;
   const where = [];
   if (!common.isEmpty(filter))
     where.push(getSql(filter, options));
   if (!hasRangeArg)
     return { meta: meta(baseKey), where, limit: 1 };
   const groupCols = Array.isArray($group) && $group.length && $group.map(lookup);
-  const group = groupCols ? sql.join(groupCols, ", ") : void 0;
+  const group = groupCols ? join(groupCols, ", ") : void 0;
   const orderCols = ($order || [idCol]).map(
-    (orderItem) => orderItem[0] === "!" ? sql__default.default`-(${lookup(orderItem.slice(1))})::float8` : lookup(orderItem)
+    (orderItem) => orderItem[0] === "!" ? sql`-(${lookup(orderItem.slice(1))})::float8` : lookup(orderItem)
   );
   Object.entries({ $after, $before, $since, $until }).forEach(
     ([name, value]) => {
@@ -383,16 +444,16 @@ function getArgSql({ $first, $last, $after, $before, $since, $until, $all, $curs
         where.push(getBoundCond(orderCols, value, name));
     }
   );
-  const order = !$group && sql.join(
+  const order = !$group && join(
     ($order || [idCol]).map(
-      (orderItem) => orderItem[0] === "!" ? sql__default.default`${lookup(orderItem.slice(1))} ${$last ? sql__default.default`ASC` : sql__default.default`DESC`}` : sql__default.default`${lookup(orderItem)} ${$last ? sql__default.default`DESC` : sql__default.default`ASC`}`
+      (orderItem) => orderItem[0] === "!" ? sql`${lookup(orderItem.slice(1))} ${$last ? sql`ASC` : sql`DESC`}` : sql`${lookup(orderItem)} ${$last ? sql`DESC` : sql`ASC`}`
     ),
     `, `
   );
   const cursorKey = getJsonBuildTrusted({
-    $cursor: $group === true ? sql__default.default`''` : sql__default.default`jsonb_build_array(${sql.join(groupCols || orderCols)})`
+    $cursor: $group === true ? sql`''` : sql`jsonb_build_array(${join(groupCols || orderCols)})`
   });
-  const key = sql__default.default`(${baseKey} || ${cursorKey})`;
+  const key = sql`(${baseKey} || ${cursorKey})`;
   return {
     meta: meta(key),
     where,
@@ -412,21 +473,21 @@ function getBoundCond(orderCols, bound, kind) {
     switch (kind) {
       case "$after":
       case "$since":
-        return sql__default.default`${lhs} > ${rhs} OR ${lhs} = ${rhs} AND (${subCond})`;
+        return sql`${lhs} > ${rhs} OR ${lhs} = ${rhs} AND (${subCond})`;
       case "$before":
       case "$until":
-        return sql__default.default`${lhs} < ${rhs} OR ${lhs} = ${rhs} AND (${subCond})`;
+        return sql`${lhs} < ${rhs} OR ${lhs} = ${rhs} AND (${subCond})`;
     }
   } else {
     switch (kind) {
       case "$after":
-        return sql__default.default`${lhs} > ${rhs}`;
+        return sql`${lhs} > ${rhs}`;
       case "$since":
-        return sql__default.default`${lhs} >= ${rhs}`;
+        return sql`${lhs} >= ${rhs}`;
       case "$before":
-        return sql__default.default`${lhs} < ${rhs}`;
+        return sql`${lhs} < ${rhs}`;
       case "$until":
-        return sql__default.default`${lhs} <= ${rhs}`;
+        return sql`${lhs} <= ${rhs}`;
     }
   }
 }
@@ -435,30 +496,30 @@ function selectByArgs(args, projection, options) {
   const { table } = options;
   const { where, order, group, limit, meta } = getArgSql(args, options);
   const clampedLimit = Math.min(MAX_LIMIT, limit || MAX_LIMIT);
-  return sql__default.default`
+  return sql`
     SELECT
     ${getSelectCols(table, projection)}, ${meta}
-    FROM "${sql.raw(table)}"
-    ${where.length ? sql__default.default`WHERE ${sql.join(where, ` AND `)}` : sql.empty}
-    ${group ? sql__default.default`GROUP BY ${group}` : sql.empty}
-    ${order ? sql__default.default`ORDER BY ${order}` : sql.empty}
+    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__default.default`
+  return sql`
     SELECT
     ${getSelectCols(table, projection)}, ${getIdMeta(options)}
-    FROM "${sql.raw(table)}"
-    WHERE "${sql.raw(idCol)}" IN (${sql.join(ids)})
+    FROM "${raw(table)}"
+    WHERE "${raw(idCol)}" IN (${join(ids)})
   `;
 }
 function getSingleSql(arg, options) {
   const { table, idCol } = options;
   if (!common.isPlainObject(arg)) {
     return {
-      where: sql__default.default`"${sql.raw(idCol)}" = ${arg}`,
+      where: sql`"${raw(idCol)}" = ${arg}`,
       meta: getIdMeta(options)
     };
   }
@@ -466,10 +527,10 @@ function getSingleSql(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 `)}
+    where: sql`"${raw(idCol)}" = (
+        SELECT "${raw(idCol)}"
+        FROM "${raw(table)}"
+        WHERE ${join(where, ` AND `)}
         LIMIT 1
       )`,
     meta
@@ -479,8 +540,8 @@ 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)}
+  return sql`
+    UPDATE "${raw(table)}" SET ${getUpdates(row, options)}
     WHERE ${where}
     RETURNING ${getSelectCols()}, ${meta}`;
 }
@@ -490,22 +551,22 @@ function put(object, arg, options) {
   let meta, conflictTarget;
   if (common.isPlainObject(arg)) {
     ({ meta } = getArgSql(arg, options));
-    conflictTarget = sql.join(Object.keys(arg).map((col) => sql__default.default`"${sql.raw(col)}"`));
+    conflictTarget = join(Object.keys(arg).map((col) => sql`"${raw(col)}"`));
   } else {
     meta = getIdMeta(options);
-    conflictTarget = sql__default.default`"${sql.raw(idCol)}"`;
+    conflictTarget = sql`"${raw(idCol)}"`;
   }
   const { cols, vals } = getInsert(row, options);
-  return sql__default.default`
-    INSERT INTO "${sql.raw(table)}" (${cols}) VALUES (${vals})
+  return sql`
+    INSERT INTO "${raw(table)}" (${cols}) VALUES (${vals})
     ON CONFLICT (${conflictTarget}) DO UPDATE SET (${cols}) = (${vals})
     RETURNING ${getSelectCols()}, ${meta}`;
 }
 function del(arg, options) {
   const { table } = options;
   const { where } = getSingleSql(arg, options);
-  return sql__default.default`
-    DELETE FROM "${sql.raw(table)}"
+  return sql`
+    DELETE FROM "${raw(table)}"
     WHERE ${where}
     RETURNING ${arg} "$key"`;
 }
@@ -560,13 +621,13 @@ class Db {
     if (tableOptions.schema)
       return;
     const { table, verCol } = tableOptions;
-    const tableSchema = (await this.query(sql__default.default`
+    const tableSchema = (await this.query(sql`
         SELECT table_schema
         FROM information_schema.tables
         WHERE table_name = ${table}
         ORDER BY array_position(current_schemas(false)::text[], table_schema::text) ASC
         LIMIT 1`)).rows[0].table_schema;
-    const types2 = (await this.query(sql__default.default`
+    const types2 = (await this.query(sql`
         SELECT jsonb_object_agg(column_name, udt_name) AS column_types
         FROM information_schema.columns
         WHERE
@@ -574,7 +635,7 @@ class Db {
           table_schema = ${tableSchema}`)).rows[0].column_types;
     if (!types2)
       throw Error(`pg.missing_table ${table}`);
-    const verDefault = (await this.query(sql__default.default`
+    const verDefault = (await this.query(sql`
         SELECT column_default
         FROM information_schema.columns
         WHERE

package/index.mjs

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

package/package.json

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