@graffy/pg 0.19.0 → 0.19.1-alpha.2

package/sql/clauses.js

@@ -0,0 +1,224 @@
+import { isEmpty } from '@graffy/common';
+import sql, { empty, join, raw, Sql } from 'sql-template-tag';
+/*
+  Important: This function assumes that the object's keys are from
+  trusted sources.
+*/
+export 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);
+}
+export const lookup = (prop, options) => {
+    const [prefix, ...suffix] = prop.split('.');
+    if (!suffix.length)
+        return sql `"${colName(prefix, options)}"`;
+    const { types } = options.schema;
+    if (types[prefix] === 'jsonb') {
+        return sql `"${raw(prefix)}" #> ${suffix}`;
+    }
+    if (types[prefix] === 'cube' && suffix.length === 1) {
+        return sql `"${raw(prefix)}" ~> ${Number.parseInt(suffix[0], 10)}`;
+    }
+    throw Error(`pg.cannot_lookup ${prop}`);
+};
+export 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;
+};
+export 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[]`;
+}
+export 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;
+}
+export 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), ', '),
+    };
+};
+export 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`), ', ');
+};
+/**
+ * @param {any} object
+ * @param {string} col
+ * @param {string[]} path
+ * @returns {[Sql, boolean]}
+ * The boolean is true if the SQL may evaluate to null
+ */
+function getJsonUpdate(object, col, path) {
+    if (!object ||
+        typeof object !== 'object' ||
+        Array.isArray(object) ||
+        object.$put) {
+        const patch = stripAttributes(object);
+        return [sql `${JSON.stringify(patch)}::jsonb`, patch === 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; // Is it possible for this object to lose *all* its properties?
+    let hasNulls = false; // Is it possible that one of the properties becomes null?
+    const patchSqls = Object.entries(object).map(([key, value]) => {
+        const [valSql, nullable] = getJsonUpdate(value, col, path.concat(key));
+        maybeNull && (maybeNull = nullable);
+        hasNulls || (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);
+}

package/sql/format.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param {import('sql-template-tag').Sql} sql
+ * @returns {string}
+ */
+export default function formatSql(sql: any): string;

package/sql/format.js

@@ -0,0 +1,36 @@
+import { escapeLiteral } from 'pg';
+import { format } from 'sql-formatter';
+/**
+ * @param {any} value
+ * @returns {string}
+ */
+function formatSqlParam(value) {
+    if (value === null || value === undefined)
+        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:
+            // shouldn't be reached
+            return '';
+    }
+}
+/**
+ * @param {import('sql-template-tag').Sql} sql
+ * @returns {string}
+ */
+export default function formatSql(sql) {
+    return format(sql.text, {
+        language: 'postgresql',
+        params: Object.fromEntries(sql.values.map((value, idx) => [idx + 1, formatSqlParam(value)])),
+    });
+}

package/sql/getArgSql.d.ts

@@ -0,0 +1,34 @@
+/**
+  Uses the args object (typically passed in the $key attribute)
+
+  @param {object} args
+  @param {{prefix: string, idCol: string, verDefault: string, schema: { types: Record<string, any> } }} options
+
+  @typedef { import('sql-template-tag').Sql } Sql
+  @return {{ meta: Sql, where: Sql[], order?: Sql, group?: Sql, limit: number, ensureSingleRow: boolean }}
+*/
+export default function getArgSql({ $first, $last, $after, $before, $since, $until, $all, $cursor: _, ...rest }: {
+    [x: string]: any;
+    $first: any;
+    $last: any;
+    $after: any;
+    $before: any;
+    $since: any;
+    $until: any;
+    $all: any;
+    $cursor: any;
+}, options: any): {
+    meta: import("sql-template-tag").Sql;
+    where: any[];
+    limit: number;
+    ensureSingleRow: boolean;
+    order?: undefined;
+    group?: undefined;
+} | {
+    meta: import("sql-template-tag").Sql;
+    where: any[];
+    order: import("sql-template-tag").Sql;
+    group: import("sql-template-tag").Sql;
+    limit: any;
+    ensureSingleRow: boolean;
+};

package/sql/getArgSql.js

@@ -0,0 +1,82 @@
+import { isEmpty } from '@graffy/common';
+import sql, { join } from 'sql-template-tag';
+import { getFilterSql } from "../filter/index.js";
+import { getJsonBuildTrusted, lookup } from "./clauses.js";
+import { getAggMeta, getArgMeta } from "./getMeta.js";
+/**
+  Uses the args object (typically passed in the $key attribute)
+
+  @param {object} args
+  @param {{prefix: string, idCol: string, verDefault: string, schema: { types: Record<string, any> } }} options
+
+  @typedef { import('sql-template-tag').Sql } Sql
+  @return {{ meta: Sql, where: Sql[], order?: Sql, group?: Sql, limit: number, ensureSingleRow: boolean }}
+*/
+export default function getArgSql({ $first, $last, $after, $before, $since, $until, $all, $cursor: _, ...rest }, options) {
+    const { $order, $group, ...filter } = rest;
+    const { prefix, idCol } = options;
+    const meta = (key) => $group ? getAggMeta(key, options) : getArgMeta(key, options);
+    const hasRangeArg = $before || $after || $since || $until || $first || $last || $all;
+    if ($order && $group) {
+        // TODO: Allow this.
+        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(getFilterSql(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, ', ') : undefined;
+    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, ',')})`;
+    }
+}

package/sql/getMeta.d.ts

@@ -0,0 +1,12 @@
+export declare const getIdMeta: ({ idCol, verDefault }: {
+    idCol: any;
+    verDefault: any;
+}) => import("sql-template-tag").Sql;
+export declare const getArgMeta: (key: any, { prefix, idCol, verDefault }: {
+    prefix: any;
+    idCol: any;
+    verDefault: any;
+}) => import("sql-template-tag").Sql;
+export declare const getAggMeta: (key: any, { verDefault }: {
+    verDefault: any;
+}) => import("sql-template-tag").Sql;

package/sql/getMeta.js

@@ -0,0 +1,11 @@
+import sql, { join, raw } from 'sql-template-tag';
+export const getIdMeta = ({ idCol, verDefault }) => sql `"${raw(idCol)}" AS "$key", ${raw(verDefault)} AS "$ver"`;
+export 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"
+  `;
+export const getAggMeta = (key, { verDefault }) => sql `${key} AS "$key", ${raw(verDefault)} AS "$ver"`;

package/sql/index.d.ts

@@ -0,0 +1,2 @@
+export * from './select.js';
+export * from './upsert.js';

package/sql/select.d.ts

@@ -0,0 +1,2 @@
+export declare function selectByArgs(args: any, projection: any, options: any): import("sql-template-tag").Sql;
+export declare function selectByIds(ids: any, projection: any, options: any): import("sql-template-tag").Sql;

package/sql/select.js

@@ -0,0 +1,41 @@
+import sql, { empty, join, raw } from 'sql-template-tag';
+import { getSelectCols } from "./clauses.js";
+import getArgSql from "./getArgSql.js";
+import { getIdMeta } from "./getMeta.js";
+const MAX_LIMIT = 4096;
+export 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);
+    // We use an "id" = (... LIMIT 2) query to ensure an error is thrown if more
+    // the WHERE clause matches multiple rows.
+    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}
+  `;
+}
+export 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)})
+  `;
+}

package/sql/upsert.d.ts

@@ -0,0 +1,3 @@
+export declare function patch(object: any, arg: any, options: any): import("sql-template-tag").Sql;
+export declare function put(puts: any, options: any): any[];
+export declare function del(arg: any, options: any): import("sql-template-tag").Sql;

package/sql/upsert.js

@@ -0,0 +1,73 @@
+import { isPlainObject } from '@graffy/common';
+import sql, { join, raw } from 'sql-template-tag';
+import { getInsert, getSelectCols, getUpdates } from "./clauses.js";
+import getArgSql from "./getArgSql.js";
+import { getIdMeta } from "./getMeta.js";
+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');
+    // We use a subquery with limit 2 to ensure an error is thrown if the filter
+    // matches multiple rows.
+    return {
+        where: sql `"${raw(idCol)}" = (
+        SELECT "${raw(idCol)}"
+        FROM "${raw(table)}"
+        WHERE ${join(where, ' AND ')}
+        LIMIT 2
+      )`,
+        meta,
+    };
+}
+export 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}`;
+}
+export 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 put of puts) {
+        const [row, arg] = put;
+        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;
+}
+export function del(arg, options) {
+    const { table } = options;
+    const { where } = getSingleSql(arg, options);
+    return sql `
+    DELETE FROM "${raw(table)}"
+    WHERE ${where}
+    RETURNING ${arg} "$key"`;
+}