From 48d481919c2808440899e3cdd099680b045fbbdc Mon Sep 17 00:00:00 2001 From: Benjamin Simon Date: Wed, 18 Nov 2026 17:37:52 +0100 Subject: [PATCH] feat(rds): joins, subquery sources and column aliases in select rds.select() now renders the join keys (all fifteen kinds, with `on` or `using`), a subquery aliased in `from` (a select or a sql template), and alias objects in `columns` and `returning`. Joins were previously dropped from the generated SQL without an error. Co-Authored-By: Claude Opus 5.5 --- .../__snapshots__/rds-select.test.js.snap | 924 ++++++++++++++++++ __tests__/rds-select.test.js | 460 +++++++++ rds/index.js | 238 ++++- 3 files changed, 1572 insertions(+), 50 deletions(-) create mode 100644 __tests__/__snapshots__/rds-select.test.js.snap create mode 100644 __tests__/rds-select.test.js diff --git a/__tests__/__snapshots__/rds-select.test.js.snap b/__tests__/__snapshots__/rds-select.test.js.snap new file mode 100644 index 0000000..8a6619e --- /dev/null +++ b/__tests__/__snapshots__/rds-select.test.js.snap @@ -0,0 +1,924 @@ +// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing + +exports[`column aliases aliased columns 1`] = ` +{ + "statements": [ + "SELECT "b" as "a", "x"."y" as "c", "plain" FROM "t"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`column aliases aliased columns in mysql 1`] = ` +{ + "statements": [ + "SELECT \`db\`.\`a\` as \`x\` FROM \`t\`", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`column aliases aliased returning columns 1`] = ` +{ + "statements": [ + "INSERT INTO "t" ("a") VALUES (:P0) RETURNING "a" as "x", "b"", + ], + "variableMap": { + ":P0": 1, + }, + "variableTypeHintMap": {}, +} +`; + +exports[`column aliases an aliased star is quoted 1`] = ` +{ + "statements": [ + "SELECT "*" as "a" FROM "t"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`column aliases rejects a number as the aliased column 1`] = ` +{ + "message": "Column alias value is expected to be a string or rds.agg.", +} +`; + +exports[`column aliases rejects a select as the aliased column 1`] = ` +{ + "message": "Column alias value is expected to be a string or rds.agg.", +} +`; + +exports[`column aliases rejects a sql template as the aliased column 1`] = ` +{ + "message": "Column alias value is expected to be a string or rds.agg.", +} +`; + +exports[`column aliases rejects an alias with two entries 1`] = ` +{ + "message": "column alias is allowed only one key-value pair.", +} +`; + +exports[`column aliases rejects an array in the column list 1`] = ` +{ + "message": "Invalid type in column array.", +} +`; + +exports[`column aliases rejects an empty alias 1`] = ` +{ + "message": "java.util.NoSuchElementException", +} +`; + +exports[`column aliases rejects null as the aliased column 1`] = ` +{ + "message": "Column alias value is expected to be a string or rds.agg.", +} +`; + +exports[`joins join items a cross join keeps its using clause 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" CROSS JOIN "u" USING ("id")", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join items a natural join keeps its on clause 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" NATURAL JOIN "u" ON a=b", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join items an empty join list renders nothing 1`] = ` +{ + "statements": [ + "SELECT * FROM "t"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join items join a subquery 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN (SELECT * FROM "u") as "s" ON s.id = t.id", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join items join a table given as from 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join items join in mysql 1`] = ` +{ + "statements": [ + "SELECT * FROM \`t\` LEFT JOIN \`db\`.\`u\` as \`s\` ON s.a = t.a", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join items join items that are not objects are skipped 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u" LEFT JOIN "v"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join items join with every other select clause 1`] = ` +{ + "statements": [ + "SELECT "u"."name" as "n" FROM "t" LEFT JOIN "u" USING ("id") WHERE "a" = :P0 ORDER BY "u"."name" ASC LIMIT :P1 OFFSET :P2", + ], + "variableMap": { + ":P0": 1, + ":P1": 1, + ":P2": 2, + }, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join items rejects a join from given as an array 1`] = ` +{ + "message": "'from' value is expected to be string or object.", +} +`; + +exports[`joins join items rejects a join kind that is not an array 1`] = ` +{ + "message": "leftJoin expects an array.", +} +`; + +exports[`joins join items rejects a join with both table and from 1`] = ` +{ + "message": "'from' and 'table' keys cannot be used together", +} +`; + +exports[`joins join items rejects a join with neither table nor from 1`] = ` +{ + "message": "'table' or 'from' key is required.", +} +`; + +exports[`joins join items rejects a sql template as a join table alias value 1`] = ` +{ + "message": "Table alias value is expected to be a string.", +} +`; + +exports[`joins join items rejects an empty join table alias 1`] = ` +{ + "message": "java.util.NoSuchElementException", +} +`; + +exports[`joins join items rejects on and using together 1`] = ` +{ + "message": "'on' and 'using' keys cannot be used together", +} +`; + +exports[`joins join items remove ignores joins 1`] = ` +{ + "statements": [ + "DELETE FROM "t"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join items several joins of one kind 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u" ON 1=1 LEFT JOIN "vv" as "v" ON 2=2", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join items variables are numbered source, joins, where, limit 1`] = ` +{ + "statements": [ + "SELECT * FROM (SELECT * FROM "u" WHERE "a" = :P0) as "s" LEFT JOIN "v" ON "x" = :P1 LEFT JOIN "w" ON y = :P2 WHERE "b" = :P3 LIMIT :P4", + ], + "variableMap": { + ":P0": "from", + ":P1": "join1", + ":P2": "join2", + ":P3": "where", + ":P4": 3, + }, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence a malformed later kind is ignored 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence a null earlier kind is skipped 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence an empty earlier kind suppresses a later one 1`] = ` +{ + "statements": [ + "SELECT * FROM "t"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence crossJoin wins over leftJoin 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" CROSS JOIN "crossJoin"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence fullOuterJoin wins over fullOuterJoinNatural 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" FULL OUTER JOIN "fullOuterJoin"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence innerJoin wins over crossJoin 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" INNER JOIN "innerJoin"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence innerJoinNatural wins over innerJoin 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" NATURAL INNER JOIN "innerJoinNatural"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence join wins over joinNatural 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" JOIN "join"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence joinNatural wins over innerJoinNatural 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" NATURAL JOIN "joinNatural"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence leftJoin wins over leftJoinNatural 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "leftJoin"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence leftJoinNatural wins over leftOuterJoin 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" NATURAL LEFT JOIN "leftJoinNatural"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence leftOuterJoin wins over leftOuterJoinNatural 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT OUTER JOIN "leftOuterJoin"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence leftOuterJoinNatural wins over rightJoin 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" NATURAL LEFT OUTER JOIN "leftOuterJoinNatural"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence rightJoin wins over rightJoinNatural 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" RIGHT JOIN "rightJoin"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence rightJoinNatural wins over rightOuterJoin 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" NATURAL RIGHT JOIN "rightJoinNatural"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence rightOuterJoin wins over rightOuterJoinNatural 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" RIGHT OUTER JOIN "rightOuterJoin"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kind precedence rightOuterJoinNatural wins over fullOuterJoin 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" NATURAL RIGHT OUTER JOIN "rightOuterJoinNatural"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kinds crossJoin 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" CROSS JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kinds fullOuterJoin 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" FULL OUTER JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kinds fullOuterJoinNatural 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" NATURAL FULL OUTER JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kinds innerJoin 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" INNER JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kinds innerJoinNatural 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" NATURAL INNER JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kinds join 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" JOIN "u" ON t.id = u.tid", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kinds joinNatural 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" NATURAL JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kinds leftJoin 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kinds leftJoinNatural 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" NATURAL LEFT JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kinds leftOuterJoin 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT OUTER JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kinds leftOuterJoinNatural 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" NATURAL LEFT OUTER JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kinds rightJoin 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" RIGHT JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kinds rightJoinNatural 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" NATURAL RIGHT JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kinds rightOuterJoin 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" RIGHT OUTER JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins join kinds rightOuterJoinNatural 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" NATURAL RIGHT OUTER JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins on condition objects a null on renders no ON 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins on condition objects a type hinted value 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u" ON "a" = :P0", + ], + "variableMap": { + ":P0": "x", + }, + "variableTypeHintMap": { + ":P0": "UUID", + }, +} +`; + +exports[`joins on condition objects an empty condition renders no ON 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins on condition objects an or group 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u" ON "u"."x" = :P0 AND ("u"."y" != :P1) OR ("u"."z" <= :P2)", + ], + "variableMap": { + ":P0": "t.x", + ":P1": "t.y", + ":P2": "t.z", + }, + "variableTypeHintMap": {}, +} +`; + +exports[`joins on condition objects attributeExists 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u" ON "a" IS NOT NULL", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins on condition objects between strings 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u" ON "a" BETWEEN :P0 AND :P1", + ], + "variableMap": { + ":P0": "b", + ":P1": "c", + }, + "variableTypeHintMap": {}, +} +`; + +exports[`joins on condition objects comparisons bind string values 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u" ON "u"."x" = :P0 AND "u"."y" > :P1", + ], + "variableMap": { + ":P0": "t.x", + ":P1": "t.y", + }, + "variableTypeHintMap": {}, +} +`; + +exports[`joins on condition objects contains 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u" ON "a" LIKE :P0", + ], + "variableMap": { + ":P0": "%b%", + }, + "variableTypeHintMap": {}, +} +`; + +exports[`joins on condition objects in mysql 1`] = ` +{ + "statements": [ + "SELECT * FROM \`t\` LEFT JOIN \`db\`.\`u\` as \`s\` ON \`s\`.\`a\` = :P0", + ], + "variableMap": { + ":P0": "t.a", + }, + "variableTypeHintMap": {}, +} +`; + +exports[`joins on condition objects rejects a boolean 1`] = ` +{ + "message": "ON expects a string value comparisons.", +} +`; + +exports[`joins on condition objects rejects a null value 1`] = ` +{ + "message": "Value for a.eq can't be null.", +} +`; + +exports[`joins on condition objects rejects a number 1`] = ` +{ + "message": "ON expects a string value comparisons.", +} +`; + +exports[`joins on condition objects rejects a number in a later join 1`] = ` +{ + "message": "ON expects a string value comparisons.", +} +`; + +exports[`joins on condition objects rejects a number in an or group 1`] = ` +{ + "message": "ON expects a string value comparisons.", +} +`; + +exports[`joins on condition objects rejects a number in size 1`] = ` +{ + "message": "ON expects a string value comparisons.", +} +`; + +exports[`joins on condition objects rejects a plain string 1`] = ` +{ + "message": "ON values are expected to be SQL templates or a condition object.", +} +`; + +exports[`joins on condition objects rejects an array 1`] = ` +{ + "message": "ON values are expected to be SQL templates or a condition object.", +} +`; + +exports[`joins on condition objects rejects an unknown operator 1`] = ` +{ + "message": "Unsupported condition a.foo.", +} +`; + +exports[`joins on condition objects rejects numbers in between 1`] = ` +{ + "message": "ON expects a string value comparisons.", +} +`; + +exports[`joins on condition objects several comparisons on one column 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u" ON "a" < :P0 AND "a" >= :P1", + ], + "variableMap": { + ":P0": "b", + ":P1": "c", + }, + "variableTypeHintMap": {}, +} +`; + +exports[`joins on condition objects size against a string 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u" ON LENGTH ("a") = :P0", + ], + "variableMap": { + ":P0": "b", + }, + "variableTypeHintMap": {}, +} +`; + +exports[`joins using an empty using list 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u" USING ()", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`joins using rejects a number in using 1`] = ` +{ + "message": "Invalid type in column array.", +} +`; + +exports[`joins using rejects a using alias with two entries 1`] = ` +{ + "message": "column alias is allowed only one key-value pair.", +} +`; + +exports[`joins using rejects using given as a string 1`] = ` +{ + "message": "Expected column to be * or an array.", +} +`; + +exports[`joins using using columns and aliases 1`] = ` +{ + "statements": [ + "SELECT * FROM "t" LEFT JOIN "u" USING ("id", "kk" as "k")", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`subquery source with aliased columns and a left join 1`] = ` +{ + "statements": [ + "SELECT "item"."sys_i" as "sys_i", "item"."name", "s"."label" as "st" FROM (SELECT "sys_i", "name" FROM "item" WHERE "name" = :P0) as "item" LEFT JOIN "domain"."status" as "s" ON s.id = item.status_id AND s.kind = :P1 WHERE "item"."name" != :P2", + ], + "variableMap": { + ":P0": "x", + ":P1": "k", + ":P2": "y", + }, + "variableTypeHintMap": {}, +} +`; + +exports[`subquery sources from a nested subquery 1`] = ` +{ + "statements": [ + "SELECT * FROM (SELECT * FROM (SELECT * FROM "c") as "b") as "a"", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`subquery sources from a select 1`] = ` +{ + "statements": [ + "SELECT * FROM (SELECT * FROM "u" WHERE "id" = :P0) as "sub" WHERE "id" > :P1", + ], + "variableMap": { + ":P0": 1, + ":P1": 2, + }, + "variableTypeHintMap": {}, +} +`; + +exports[`subquery sources from a select in mysql 1`] = ` +{ + "statements": [ + "SELECT * FROM (SELECT * FROM \`db\`.\`u\`) as \`s\`", + ], + "variableMap": {}, + "variableTypeHintMap": {}, +} +`; + +exports[`subquery sources from a select with its own limit 1`] = ` +{ + "statements": [ + "SELECT * FROM (SELECT * FROM "u" WHERE "a" = :P0 LIMIT :P1) as "s" WHERE "b" = :P2 LIMIT :P3", + ], + "variableMap": { + ":P0": "inner", + ":P1": 2, + ":P2": "outer", + ":P3": 9, + }, + "variableTypeHintMap": {}, +} +`; + +exports[`subquery sources from a sql template 1`] = ` +{ + "statements": [ + "SELECT * FROM (select * from u where id = :P0) as "sub"", + ], + "variableMap": { + ":P0": 1, + }, + "variableTypeHintMap": {}, +} +`; + +exports[`subquery sources from a sql template with type hints 1`] = ` +{ + "statements": [ + "SELECT * FROM (select :P0) as "s" WHERE "x" = :P1", + ], + "variableMap": { + ":P0": "a", + ":P1": "b", + }, + "variableTypeHintMap": { + ":P0": "UUID", + ":P1": "UUID", + }, +} +`; + +exports[`subquery sources rejects a bare select as from 1`] = ` +{ + "message": "'from' value is expected to be string or object.", +} +`; + +exports[`subquery sources rejects a bare sql template as from 1`] = ` +{ + "message": "'from' value is expected to be string or object.", +} +`; + +exports[`subquery sources rejects a number as the from source 1`] = ` +{ + "message": "Object value must be a SQL statement or string.", +} +`; + +exports[`subquery sources rejects a select as the table alias value 1`] = ` +{ + "message": "Table alias value is expected to be a string.", +} +`; + +exports[`subquery sources rejects a select as the table alias value in insert 1`] = ` +{ + "message": "Table alias value is expected to be a string.", +} +`; + +exports[`subquery sources rejects an insert as the from source 1`] = ` +{ + "message": "Object value must be a SQL statement or string.", +} +`; diff --git a/__tests__/rds-select.test.js b/__tests__/rds-select.test.js new file mode 100644 index 0000000..d999fd8 --- /dev/null +++ b/__tests__/rds-select.test.js @@ -0,0 +1,460 @@ +/* rds.select() column aliases, subquery `from` sources and joins */ + +import { checkResolverValid } from "./helpers"; + +const pg = (expr) => ` + export function request(ctx) { + return rds.createPgStatement(${expr}); + } + export function response(ctx) {} +`; + +const mysql = (expr) => ` + export function request(ctx) { + return rds.createMySQLStatement(${expr}); + } + export function response(ctx) {} +`; + +// a subquery source, an aliased column and a join used together, the way a resolver combines them +test("subquery source with aliased columns and a left join", async () => { + await checkResolverValid(pg(`rds.select({ + from: { item: rds.select({ table: "item", columns: ["sys_i", "name"], where: { name: { eq: "x" } } }) }, + columns: [{ sys_i: "item.sys_i" }, "item.name", { st: "s.label" }], + leftJoin: [{ table: { s: "domain.status" }, on: rds.sql\`s.id = item.status_id AND s.kind = \${"k"}\` }], + where: { "item.name": { ne: "y" } }, + })`), {}, "request"); +}); + +describe("column aliases", () => { + // like a table alias, the key is the alias and the value is the column + test("aliased columns", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", columns: [{ a: "b" }, { c: "x.y" }, "plain"] })`), {}, "request"); + }); + + test("an aliased star is quoted", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", columns: [{ a: "*" }] })`), {}, "request"); + }); + + test("aliased columns in mysql", async () => { + await checkResolverValid(mysql(`rds.select({ table: "t", columns: [{ x: "db.a" }] })`), {}, "request"); + }); + + // `returning` shares the column list rules + test("aliased returning columns", async () => { + await checkResolverValid(pg(`rds.insert({ table: "t", values: { a: 1 }, returning: [{ x: "a" }, "b"] })`), {}, "request"); + }); + + test("rejects an alias with two entries", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", columns: [{ a: "b", c: "d" }] })`), {}, "request"); + }); + + test("rejects an empty alias", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", columns: [{}] })`), {}, "request"); + }); + + test("rejects a number as the aliased column", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", columns: [{ a: 5 }] })`), {}, "request"); + }); + + test("rejects null as the aliased column", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", columns: [{ a: null }] })`), {}, "request"); + }); + + // unlike a `from` alias, a column alias takes no statement + test("rejects a sql template as the aliased column", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", columns: [{ n: rds.sql\`count(\${1})\` }] })`), {}, "request"); + }); + + test("rejects a select as the aliased column", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", columns: [{ n: rds.select({ table: "u" }) }] })`), {}, "request"); + }); + + test("rejects an array in the column list", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", columns: [["a"]] })`), {}, "request"); + }); +}); + +describe("subquery sources", () => { + test("from a select", async () => { + await checkResolverValid(pg(`rds.select({ from: { sub: rds.select({ table: "u", where: { id: { eq: 1 } } }) }, where: { id: { gt: 2 } } })`), {}, "request"); + }); + + // the subquery's variables are numbered first, before the outer statement's + test("from a select with its own limit", async () => { + await checkResolverValid(pg(`rds.select({ from: { s: rds.select({ table: "u", where: { a: { eq: "inner" } }, limit: 2 }) }, where: { b: { eq: "outer" } }, limit: 9 })`), {}, "request"); + }); + + test("from a sql template", async () => { + await checkResolverValid(pg(`rds.select({ from: { sub: rds.sql\`select * from u where id = \${1}\` } })`), {}, "request"); + }); + + test("from a sql template with type hints", async () => { + await checkResolverValid(pg(`rds.select({ from: { s: rds.sql\`select \${rds.typeHint.UUID("a")}\` }, where: { x: { eq: rds.typeHint.UUID("b") } } })`), {}, "request"); + }); + + test("from a nested subquery", async () => { + await checkResolverValid(pg(`rds.select({ from: { a: rds.select({ from: { b: rds.select({ table: "c" }) } }) } })`), {}, "request"); + }); + + test("from a select in mysql", async () => { + await checkResolverValid(mysql(`rds.select({ from: { s: rds.select({ table: "db.u" }) } })`), {}, "request"); + }); + + // a statement is only accepted under an alias + test("rejects a bare select as from", async () => { + await checkResolverValid(pg(`rds.select({ from: rds.select({ table: "u" }) })`), {}, "request"); + }); + + test("rejects a bare sql template as from", async () => { + await checkResolverValid(pg(`rds.select({ from: rds.sql\`u\` })`), {}, "request"); + }); + + test("rejects an insert as the from source", async () => { + await checkResolverValid(pg(`rds.select({ from: { s: rds.insert({ table: "u", values: { a: 1 } }) } })`), {}, "request"); + }); + + test("rejects a number as the from source", async () => { + await checkResolverValid(pg(`rds.select({ from: { s: 5 } })`), {}, "request"); + }); + + // `table` keeps accepting only a string, in select as in the other statements + test("rejects a select as the table alias value", async () => { + await checkResolverValid(pg(`rds.select({ table: { sub: rds.select({ table: "u" }) } })`), {}, "request"); + }); + + test("rejects a select as the table alias value in insert", async () => { + await checkResolverValid(pg(`rds.insert({ table: { sub: rds.select({ table: "u" }) }, values: { a: 1 } })`), {}, "request"); + }); +}); + +describe("joins", () => { + describe("join kinds", () => { + test("join", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", join: [{ table: "u", on: rds.sql\`t.id = u.tid\` }] })`), {}, "request"); + }); + + test("innerJoin", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", innerJoin: [{ table: "u" }] })`), {}, "request"); + }); + + test("leftJoin", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u" }] })`), {}, "request"); + }); + + test("leftOuterJoin", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftOuterJoin: [{ table: "u" }] })`), {}, "request"); + }); + + test("rightJoin", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", rightJoin: [{ table: "u" }] })`), {}, "request"); + }); + + test("rightOuterJoin", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", rightOuterJoin: [{ table: "u" }] })`), {}, "request"); + }); + + test("fullOuterJoin", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", fullOuterJoin: [{ table: "u" }] })`), {}, "request"); + }); + + test("crossJoin", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", crossJoin: [{ table: "u" }] })`), {}, "request"); + }); + + test("joinNatural", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", joinNatural: [{ table: "u" }] })`), {}, "request"); + }); + + test("innerJoinNatural", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", innerJoinNatural: [{ table: "u" }] })`), {}, "request"); + }); + + test("leftJoinNatural", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoinNatural: [{ table: "u" }] })`), {}, "request"); + }); + + test("leftOuterJoinNatural", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftOuterJoinNatural: [{ table: "u" }] })`), {}, "request"); + }); + + test("rightJoinNatural", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", rightJoinNatural: [{ table: "u" }] })`), {}, "request"); + }); + + test("rightOuterJoinNatural", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", rightOuterJoinNatural: [{ table: "u" }] })`), {}, "request"); + }); + + test("fullOuterJoinNatural", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", fullOuterJoinNatural: [{ table: "u" }] })`), {}, "request"); + }); + }); + + // a select applies a single join kind: the first one present in a fixed order, whatever order + // the keys were written in. AWS interleaves the natural kinds with the plain ones, so each test + // pins one adjacent pair of that order, writing the losing key first. + describe("join kind precedence", () => { + test("join wins over joinNatural", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", joinNatural: [{ table: "joinNatural" }], join: [{ table: "join" }] })`), {}, "request"); + }); + + test("joinNatural wins over innerJoinNatural", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", innerJoinNatural: [{ table: "innerJoinNatural" }], joinNatural: [{ table: "joinNatural" }] })`), {}, "request"); + }); + + test("innerJoinNatural wins over innerJoin", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", innerJoin: [{ table: "innerJoin" }], innerJoinNatural: [{ table: "innerJoinNatural" }] })`), {}, "request"); + }); + + test("innerJoin wins over crossJoin", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", crossJoin: [{ table: "crossJoin" }], innerJoin: [{ table: "innerJoin" }] })`), {}, "request"); + }); + + test("crossJoin wins over leftJoin", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "leftJoin" }], crossJoin: [{ table: "crossJoin" }] })`), {}, "request"); + }); + + test("leftJoin wins over leftJoinNatural", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoinNatural: [{ table: "leftJoinNatural" }], leftJoin: [{ table: "leftJoin" }] })`), {}, "request"); + }); + + test("leftJoinNatural wins over leftOuterJoin", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftOuterJoin: [{ table: "leftOuterJoin" }], leftJoinNatural: [{ table: "leftJoinNatural" }] })`), {}, "request"); + }); + + test("leftOuterJoin wins over leftOuterJoinNatural", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftOuterJoinNatural: [{ table: "leftOuterJoinNatural" }], leftOuterJoin: [{ table: "leftOuterJoin" }] })`), {}, "request"); + }); + + test("leftOuterJoinNatural wins over rightJoin", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", rightJoin: [{ table: "rightJoin" }], leftOuterJoinNatural: [{ table: "leftOuterJoinNatural" }] })`), {}, "request"); + }); + + test("rightJoin wins over rightJoinNatural", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", rightJoinNatural: [{ table: "rightJoinNatural" }], rightJoin: [{ table: "rightJoin" }] })`), {}, "request"); + }); + + test("rightJoinNatural wins over rightOuterJoin", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", rightOuterJoin: [{ table: "rightOuterJoin" }], rightJoinNatural: [{ table: "rightJoinNatural" }] })`), {}, "request"); + }); + + test("rightOuterJoin wins over rightOuterJoinNatural", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", rightOuterJoinNatural: [{ table: "rightOuterJoinNatural" }], rightOuterJoin: [{ table: "rightOuterJoin" }] })`), {}, "request"); + }); + + test("rightOuterJoinNatural wins over fullOuterJoin", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", fullOuterJoin: [{ table: "fullOuterJoin" }], rightOuterJoinNatural: [{ table: "rightOuterJoinNatural" }] })`), {}, "request"); + }); + + test("fullOuterJoin wins over fullOuterJoinNatural", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", fullOuterJoinNatural: [{ table: "fullOuterJoinNatural" }], fullOuterJoin: [{ table: "fullOuterJoin" }] })`), {}, "request"); + }); + + // an empty list still claims the join, so the later kind is dropped + test("an empty earlier kind suppresses a later one", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", join: [], leftJoin: [{ table: "u" }] })`), {}, "request"); + }); + + test("a null earlier kind is skipped", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", join: null, leftJoin: [{ table: "u" }] })`), {}, "request"); + }); + + // only the applied kind is validated + test("a malformed later kind is ignored", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", join: [{ table: "u" }], leftJoin: "x" })`), {}, "request"); + }); + }); + + describe("join items", () => { + test("several joins of one kind", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: rds.sql\`1=1\` }, { table: { v: "vv" }, on: rds.sql\`2=2\` }] })`), {}, "request"); + }); + + test("join a subquery", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ from: { s: rds.select({ table: "u" }) }, on: rds.sql\`s.id = t.id\` }] })`), {}, "request"); + }); + + test("join a table given as from", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ from: "u" }] })`), {}, "request"); + }); + + test("join in mysql", async () => { + await checkResolverValid(mysql(`rds.select({ table: "t", leftJoin: [{ table: { s: "db.u" }, on: rds.sql\`s.a = t.a\` }] })`), {}, "request"); + }); + + // a join sits between the source and the WHERE clause, and binds its variables in that order + test("variables are numbered source, joins, where, limit", async () => { + await checkResolverValid(pg(`rds.select({ + from: { s: rds.select({ table: "u", where: { a: { eq: "from" } } }) }, + leftJoin: [{ table: "v", on: { x: { eq: "join1" } } }, { table: "w", on: rds.sql\`y = \${"join2"}\` }], + where: { b: { eq: "where" } }, + limit: 3, + })`), {}, "request"); + }); + + test("join with every other select clause", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", columns: [{ n: "u.name" }], leftJoin: [{ table: "u", using: ["id"] }], where: { a: { eq: 1 } }, orderBy: [{ column: "u.name" }], limit: 1, offset: 2 })`), {}, "request"); + }); + + test("an empty join list renders nothing", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [] })`), {}, "request"); + }); + + // items that are not objects are skipped without an error + test("join items that are not objects are skipped", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: ["x", null, { table: "u" }, 5, ["y"], { table: "v" }] })`), {}, "request"); + }); + + // a join has no ON or USING requirement, whatever its kind + test("a natural join keeps its on clause", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", joinNatural: [{ table: "u", on: rds.sql\`a=b\` }] })`), {}, "request"); + }); + + test("a cross join keeps its using clause", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", crossJoin: [{ table: "u", using: ["id"] }] })`), {}, "request"); + }); + + // joins belong to select only + test("remove ignores joins", async () => { + await checkResolverValid(pg(`rds.remove({ table: "t", leftJoin: [{ table: "u" }] })`), {}, "request"); + }); + + test("rejects a join kind that is not an array", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: { table: "u" } })`), {}, "request"); + }); + + test("rejects a join with neither table nor from", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ on: rds.sql\`1=1\` }] })`), {}, "request"); + }); + + test("rejects a join with both table and from", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", from: "v" }] })`), {}, "request"); + }); + + test("rejects a join from given as an array", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ from: ["u"] }] })`), {}, "request"); + }); + + test("rejects a sql template as a join table alias value", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: { s: rds.sql\`select \${1}\` } }] })`), {}, "request"); + }); + + test("rejects an empty join table alias", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: {} }] })`), {}, "request"); + }); + + test("rejects on and using together", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: rds.sql\`1=1\`, using: ["id"] }] })`), {}, "request"); + }); + }); + + describe("using", () => { + test("using columns and aliases", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", using: ["id", { k: "kk" }] }] })`), {}, "request"); + }); + + test("an empty using list", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", using: [] }] })`), {}, "request"); + }); + + test("rejects using given as a string", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", using: "id" }] })`), {}, "request"); + }); + + test("rejects a number in using", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", using: [5] }] })`), {}, "request"); + }); + + test("rejects a using alias with two entries", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", using: [{ a: "b", c: "d" }] }] })`), {}, "request"); + }); + }); + + describe("on condition objects", () => { + // the values are bound as variables like a WHERE clause's, not read as column references + test("comparisons bind string values", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { "u.x": { eq: "t.x" }, "u.y": { gt: "t.y" } } }] })`), {}, "request"); + }); + + test("several comparisons on one column", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { a: { lt: "b", ge: "c" } } }] })`), {}, "request"); + }); + + test("an or group", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { "u.x": { eq: "t.x" }, or: [{ "u.y": { ne: "t.y" } }, { "u.z": { le: "t.z" } }] } }] })`), {}, "request"); + }); + + test("contains", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { a: { contains: "b" } } }] })`), {}, "request"); + }); + + test("attributeExists", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { a: { attributeExists: true } } }] })`), {}, "request"); + }); + + test("between strings", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { a: { between: ["b", "c"] } } }] })`), {}, "request"); + }); + + test("size against a string", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { a: { size: { eq: "b" } } } }] })`), {}, "request"); + }); + + test("a type hinted value", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { a: { eq: rds.typeHint.UUID("x") } } }] })`), {}, "request"); + }); + + test("in mysql", async () => { + await checkResolverValid(mysql(`rds.select({ table: "t", leftJoin: [{ table: { s: "db.u" }, on: { "s.a": { eq: "t.a" } } }] })`), {}, "request"); + }); + + test("an empty condition renders no ON", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: {} }] })`), {}, "request"); + }); + + test("a null on renders no ON", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: null }] })`), {}, "request"); + }); + + test("rejects a number", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { a: { eq: 3 } } }] })`), {}, "request"); + }); + + test("rejects a boolean", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { a: { eq: true } } }] })`), {}, "request"); + }); + + test("rejects a number in an or group", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { or: [{ a: { eq: 1 } }] } }] })`), {}, "request"); + }); + + test("rejects numbers in between", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { a: { between: [1, 2] } } }] })`), {}, "request"); + }); + + test("rejects a number in size", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { a: { size: { eq: 1 } } } }] })`), {}, "request"); + }); + + test("rejects a number in a later join", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { a: { eq: "x" } } }, { table: "v", on: { b: { eq: 2 } } }] })`), {}, "request"); + }); + + test("rejects a null value", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { a: { eq: null } } }] })`), {}, "request"); + }); + + test("rejects an unknown operator", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: { a: { foo: "b" } } }] })`), {}, "request"); + }); + + test("rejects a plain string", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: "a = b" }] })`), {}, "request"); + }); + + test("rejects an array", async () => { + await checkResolverValid(pg(`rds.select({ table: "t", leftJoin: [{ table: "u", on: [] }] })`), {}, "request"); + }); + }); +}); diff --git a/rds/index.js b/rds/index.js index 7c03887..644e1ee 100644 --- a/rds/index.js +++ b/rds/index.js @@ -88,6 +88,11 @@ function isSqlTemplate(value) { return (value != null) && (value.strings !== undefined) && (value.keys !== undefined); } +// what `select`, `insert`, `update` and `remove` return +function isStructuredStatement(value) { + return (value != null) && (value.type !== undefined) && (value.properties !== undefined); +} + /** * Every statement constructor validates its payload the same way, and does so when it is called @@ -133,6 +138,26 @@ const COMPARISON_OPERATORS = { le: '<=', }; +// The join keys a select accepts, in the order AWS considers them. A select applies a single kind: +// the first one present, whatever order the keys were written in. +const JOIN_KINDS = [ + ['join', 'JOIN'], + ['joinNatural', 'NATURAL JOIN'], + ['innerJoinNatural', 'NATURAL INNER JOIN'], + ['innerJoin', 'INNER JOIN'], + ['crossJoin', 'CROSS JOIN'], + ['leftJoin', 'LEFT JOIN'], + ['leftJoinNatural', 'NATURAL LEFT JOIN'], + ['leftOuterJoin', 'LEFT OUTER JOIN'], + ['leftOuterJoinNatural', 'NATURAL LEFT OUTER JOIN'], + ['rightJoin', 'RIGHT JOIN'], + ['rightJoinNatural', 'NATURAL RIGHT JOIN'], + ['rightOuterJoin', 'RIGHT OUTER JOIN'], + ['rightOuterJoinNatural', 'NATURAL RIGHT OUTER JOIN'], + ['fullOuterJoin', 'FULL OUTER JOIN'], + ['fullOuterJoinNatural', 'NATURAL FULL OUTER JOIN'], +]; + class StatementBuilder { constructor({ quoteChar, functionName, supportsReturning = true }) { this.quoteChar = quoteChar; @@ -146,6 +171,8 @@ class StatementBuilder { }; this.variableIndex = 0; + // set while an `on` condition object renders, where AWS binds only strings and type hints + this.bindingOnCondition = false; } render(statements) { @@ -159,7 +186,7 @@ class StatementBuilder { this.renderRawTemplateStatement(stmt); } else if (isSqlTemplate(stmt)) { this.renderTaggedTemplateStatement(stmt.strings, stmt.keys); - } else if ((stmt != null) && (stmt.type !== undefined) && (stmt.properties !== undefined)) { + } else if (isStructuredStatement(stmt)) { this.renderStructuredStatement(stmt.type, stmt.properties); } else { this.unsupportedStatement(); @@ -212,40 +239,9 @@ class StatementBuilder { renderStructuredStatement(type, properties) { switch (type) { - case "SELECT": { - const { columns, where, orderBy, limit, offset } = properties; - const parts = ["SELECT"]; - - // an absent column list means every column. Anything else is validated, so `columns: []` - // still leaves a dangling `SELECT`, like AWS - parts.push(columns == null ? '*' : this.renderColumnList(columns)); - - parts.push(`FROM ${this.resolveTableName(properties, true)}`); - parts.push(...this.buildWhereParts(where)); - - if (orderBy != null) { - if (!Array.isArray(orderBy)) { - throw codeError("orderBy expects an array."); - } - - // an empty sort list drops the whole clause, ORDER BY keyword included, like AWS - if (orderBy.length > 0) { - parts.push('ORDER BY', orderBy.map(item => this.renderOrderByItem(item)).join(', ')); - } - } - - // limit/offset are optional and may be passed as null; 0 is a valid value - if (limit != null) { - parts.push(`LIMIT ${this.renderRowCount(limit, 'limit')}`); - } - - if (offset != null) { - parts.push(`OFFSET ${this.renderRowCount(offset, 'offset')}`); - } - - this.result.statements.push(this.joinClauses(parts)); + case "SELECT": + this.result.statements.push(this.renderSelect(properties)); break; - } case "REMOVE": { const { where, returning, } = properties; const parts = [`DELETE FROM ${this.resolveTableName(properties)}`]; @@ -300,6 +296,103 @@ class StatementBuilder { } } + /** + * Render a select to its SQL text. A select is also a valid `from` source, so this returns the + * text rather than pushing it, and a subquery binds its variables before the outer statement's. + */ + renderSelect(properties) { + const { columns, where, orderBy, limit, offset } = properties; + const parts = ["SELECT"]; + + // an absent column list means every column. Anything else is validated, so `columns: []` + // still leaves a dangling `SELECT`, like AWS + parts.push(columns == null ? '*' : this.renderColumnList(columns)); + + parts.push(`FROM ${this.resolveTableName(properties, true)}`); + parts.push(...this.buildJoinParts(properties)); + parts.push(...this.buildWhereParts(where)); + + if (orderBy != null) { + if (!Array.isArray(orderBy)) { + throw codeError("orderBy expects an array."); + } + + // an empty sort list drops the whole clause, ORDER BY keyword included, like AWS + if (orderBy.length > 0) { + parts.push('ORDER BY', orderBy.map(item => this.renderOrderByItem(item)).join(', ')); + } + } + + // limit/offset are optional and may be passed as null; 0 is a valid value + if (limit != null) { + parts.push(`LIMIT ${this.renderRowCount(limit, 'limit')}`); + } + + if (offset != null) { + parts.push(`OFFSET ${this.renderRowCount(offset, 'offset')}`); + } + + return this.joinClauses(parts); + } + + buildJoinParts(properties) { + const kind = JOIN_KINDS.find(([key]) => properties[key] != null); + if (kind === undefined) { + return []; + } + + // only the applied kind is validated: a malformed later kind is ignored, like on AWS + const [key, keyword] = kind; + const joins = properties[key]; + if (!Array.isArray(joins)) { + throw codeError(`${key} expects an array.`); + } + + const parts = []; + for (const join of joins) { + // AWS skips an item that is not an object rather than rejecting it + if ((join == null) || (typeof join !== 'object') || Array.isArray(join)) { + continue; + } + + // a joined source follows the select's own `table`/`from` rules + parts.push(keyword, this.resolveTableName(join, true)); + + const { on, using } = join; + if ((on != null) && (using != null)) { + throw codeError("'on' and 'using' keys cannot be used together"); + } + + if (isSqlTemplate(on)) { + parts.push('ON', this.renderTemplate(on.strings, on.keys)); + } else if (on != null) { + if ((typeof on !== 'object') || Array.isArray(on)) { + throw codeError("ON values are expected to be SQL templates or a condition object."); + } + + // the condition renders like a WHERE clause, its values bound as variables rather than + // read as column references, but AWS binds only strings and type hints here. An empty + // condition drops the ON keyword too. + this.bindingOnCondition = true; + try { + const condition = this.buildWhereClause(on); + if (condition) { + parts.push('ON', condition); + } + } finally { + this.bindingOnCondition = false; + } + } + + if (using != null) { + // an empty list still renders, as `USING ()`, like AWS + parts.push(`USING (${this.renderColumnList(using)})`); + } + } + + return parts; + } + buildWhereParts(where) { if (where == null) { return []; @@ -371,12 +464,24 @@ class StatementBuilder { throw codeError("Expected column to be * or an array."); } - return columns.map(name => { - if (typeof name !== 'string') { + return columns.map(column => { + if (typeof column === 'string') { + return this.quoteIdentifier(column); + } + + if ((column == null) || (typeof column !== 'object') || Array.isArray(column)) { throw codeError("Invalid type in column array."); } - return this.quoteIdentifier(name); + // a single-entry alias object, read like a table alias: `{ n: "p.name" }` becomes + // `"p"."name" as "n"` + const [alias, name] = this.aliasEntry(column, "column"); + if (typeof name !== 'string') { + throw codeError("Column alias value is expected to be a string or rds.agg."); + } + + // unlike a bare `*`, an aliased one is quoted + return `${this.quoteSegments(name)} as ${this.quoteIdentifier(alias)}`; }).join(', '); } @@ -418,6 +523,10 @@ class StatementBuilder { } newVariable(value, addTypeHint = true) { + if (this.bindingOnCondition && (typeof value !== 'string') && !value.type) { + throw codeError("ON expects a string value comparisons."); + } + const name = `:P${this.variableIndex}`; if (value.type) { this.result.variableMap[name] = value.value; @@ -595,12 +704,15 @@ class StatementBuilder { } if (allowFrom && (table == null) && (from != null)) { - // `from` carries its own type message, and rejects the array `table` would too - if ((typeof from !== 'string') && ((typeof from !== 'object') || Array.isArray(from))) { + // `from` carries its own type message, and rejects the array `table` would too. A statement + // is only accepted as the value of an alias, never on its own. + const isAliasObject = (typeof from === 'object') && !Array.isArray(from) + && !isSqlTemplate(from) && !isStructuredStatement(from); + if ((typeof from !== 'string') && !isAliasObject) { throw codeError("'from' value is expected to be string or object."); } - return this.renderTableName(from); + return this.renderTableName(from, true); } if (table == null) { @@ -613,9 +725,10 @@ class StatementBuilder { /** * A table is named either by a string or by a single-entry alias object, which AWS renders with * the *value* as the table name and the *key* as the alias: `{ persons: "p" }` becomes - * `"p" as "persons"`. + * `"p" as "persons"`. Only a select's `from` (and a join's) may alias a subquery instead, given + * as a select or a `sql` template: `{ s: select(...) }` becomes `(SELECT ...) as "s"`. */ - renderTableName(name) { + renderTableName(name, allowSubquery = false) { if (typeof name === 'string') { return this.quoteIdentifier(name); } @@ -624,9 +737,34 @@ class StatementBuilder { throw codeError("table name is expected to be a string or alias."); } - const entries = Object.entries(name); + const [alias, actual] = this.aliasEntry(name, "table"); + const quotedAlias = this.quoteIdentifier(alias); + if (typeof actual === 'string') { + return `${this.quoteIdentifier(actual)} as ${quotedAlias}`; + } + + if (!allowSubquery) { + throw codeError("Table alias value is expected to be a string."); + } + + if (isSqlTemplate(actual)) { + return `(${this.renderTemplate(actual.strings, actual.keys)}) as ${quotedAlias}`; + } + + if (isStructuredStatement(actual) && (actual.type === "SELECT")) { + return `(${this.renderSelect(actual.properties)}) as ${quotedAlias}`; + } + + throw codeError("Object value must be a SQL statement or string."); + } + + /** + * The single `[alias, value]` entry of a table or column alias object. + */ + aliasEntry(aliasObject, kind) { + const entries = Object.entries(aliasObject); if (entries.length > 1) { - throw codeError("table alias is allowed only one key-value pair."); + throw codeError(`${kind} alias is allowed only one key-value pair.`); } if (entries.length === 0) { @@ -635,12 +773,7 @@ class StatementBuilder { throw codeError("java.util.NoSuchElementException"); } - const [alias, actual] = entries[0]; - if (typeof actual !== 'string') { - throw codeError("Table alias value is expected to be a string."); - } - - return `${this.quoteIdentifier(actual)} as ${this.quoteIdentifier(alias)}`; + return entries[0]; } quoteIdentifier(rawName) { @@ -650,6 +783,11 @@ class StatementBuilder { if (rawName === '*') { return rawName; } + + return this.quoteSegments(rawName); + } + + quoteSegments(rawName) { // Split schema/table-qualified identifiers (e.g. "schema.table" or "table.column") on `.` // and quote each segment individually, matching AWS AppSync (e.g. `"schema"."table"`) // rather than quoting the whole string as one literal identifier (`"schema.table"`).