@slonik/sql-tag 40.2.2

package/src/factories/createSqlTag.test/join.test.ts

@@ -0,0 +1,127 @@
+import { FragmentToken } from '../../tokens';
+import { createSqlTag } from '../createSqlTag';
+import test from 'ava';
+
+const sql = createSqlTag();
+
+test('creates a list of values', (t) => {
+  const query = sql.fragment`SELECT (${sql.join([1, 2, 3], sql.fragment`, `)})`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT ($slonik_1, $slonik_2, $slonik_3)',
+    type: FragmentToken,
+    values: [1, 2, 3],
+  });
+});
+
+test('creates a list of values using glue', (t) => {
+  const query = sql.fragment`SELECT ${sql.join(
+    [sql.fragment`TRUE`, sql.fragment`TRUE`],
+    sql.fragment` AND `,
+  )}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT TRUE AND TRUE',
+    type: FragmentToken,
+    values: [],
+  });
+});
+
+test('interpolates SQL tokens', (t) => {
+  const query = sql.fragment`SELECT (${sql.join(
+    [1, sql.fragment`foo`, 3],
+    sql.fragment`, `,
+  )})`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT ($slonik_1, foo, $slonik_2)',
+    type: FragmentToken,
+    values: [1, 3],
+  });
+});
+
+test('interpolates SQL tokens with bound values', (t) => {
+  const query = sql.fragment`SELECT ${sql.join(
+    [1, sql.fragment`to_timestamp(${2}), ${3}`, 4],
+    sql.fragment`, `,
+  )}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1, to_timestamp($slonik_2), $slonik_3, $slonik_4',
+    type: FragmentToken,
+    values: [1, 2, 3, 4],
+  });
+});
+
+test('offsets positional parameter indexes', (t) => {
+  const query = sql.fragment`SELECT ${1}, ${sql.join(
+    [1, sql.fragment`to_timestamp(${2}), ${3}`, 4],
+    sql.fragment`, `,
+  )}, ${3}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1, $slonik_2, to_timestamp($slonik_3), $slonik_4, $slonik_5, $slonik_6',
+    type: FragmentToken,
+    values: [1, 1, 2, 3, 4, 3],
+  });
+});
+
+test('supports bigint', (t) => {
+  const query = sql.fragment`SELECT ${1n}, ${sql.join(
+    [sql.fragment`to_timestamp(${2n})`, 3n],
+    sql.fragment`, `,
+  )}, ${4n}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1, to_timestamp($slonik_2), $slonik_3, $slonik_4',
+    type: FragmentToken,
+    values: [1n, 2n, 3n, 4n],
+  });
+});
+
+test('nests expressions', (t) => {
+  const query = sql.fragment`SELECT ${sql.join(
+    [
+      sql.fragment`(${sql.join([1, 2], sql.fragment`, `)})`,
+      sql.fragment`(${sql.join([3, 4], sql.fragment`, `)})`,
+    ],
+    sql.fragment`, `,
+  )}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT ($slonik_1, $slonik_2), ($slonik_3, $slonik_4)',
+    type: FragmentToken,
+    values: [1, 2, 3, 4],
+  });
+});
+
+test('binary join expressions', (t) => {
+  const data = Buffer.from('1f', 'hex');
+  const query = sql.fragment`SELECT (${sql.join(
+    ['a', sql.binary(data)],
+    sql.fragment`, `,
+  )})`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT ($slonik_1, $slonik_2)',
+    type: FragmentToken,
+    values: ['a', data],
+  });
+});
+
+test('throws is member is not a SQL token or a primitive value expression', (t) => {
+  const error = t.throws(() => {
+    sql.fragment`${sql.join(
+      [
+        // @ts-expect-error - intentional
+        () => {},
+      ],
+      sql.fragment`, `,
+    )}`;
+  });
+
+  t.is(
+    error?.message,
+    'Invalid list member type. Must be a SQL token or a primitive value expression.',
+  );
+});

package/src/factories/createSqlTag.test/json.test.ts

@@ -0,0 +1,106 @@
+import { FragmentToken } from '../../tokens';
+import { createSqlTag } from '../createSqlTag';
+import test from 'ava';
+
+const sql = createSqlTag();
+
+test('creates a value list (object)', (t) => {
+  const query = sql.fragment`SELECT ${sql.json({
+    foo: 'bar',
+  })}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::json',
+    type: FragmentToken,
+    values: ['{"foo":"bar"}'],
+  });
+});
+
+test('creates a value list (array)', (t) => {
+  const query = sql.fragment`SELECT ${sql.json([
+    {
+      foo: 'bar',
+    },
+  ])}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::json',
+    type: FragmentToken,
+    values: ['[{"foo":"bar"}]'],
+  });
+});
+
+test("stringifies NULL to 'null'::json", (t) => {
+  const query = sql.fragment`SELECT ${sql.json(null)}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::json',
+    type: FragmentToken,
+    values: ['null'],
+  });
+});
+
+test('JSON encodes string values', (t) => {
+  const query = sql.fragment`SELECT ${sql.json('example string')}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::json',
+    type: FragmentToken,
+    values: ['"example string"'],
+  });
+});
+
+test('JSON encodes numeric values', (t) => {
+  const query = sql.fragment`SELECT ${sql.json(1_234)}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::json',
+    type: FragmentToken,
+    values: ['1234'],
+  });
+});
+
+test('JSON encodes boolean values', (t) => {
+  const query = sql.fragment`SELECT ${sql.json(true)}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::json',
+    type: FragmentToken,
+    values: ['true'],
+  });
+});
+
+test('throws if payload is undefined', (t) => {
+  const error = t.throws(() => {
+    sql.fragment`SELECT ${sql.json(undefined)}`;
+  });
+
+  t.is(error?.message, 'JSON payload must not be undefined.');
+});
+
+test('throws if payload cannot be stringified (non-primitive object)', (t) => {
+  const error = t.throws(() => {
+    // @ts-expect-error - intentional
+    sql.fragment`SELECT ${sql.json(() => {})}`;
+  });
+
+  t.is(
+    error?.message,
+    'JSON payload must be a primitive value or a plain object.',
+  );
+});
+
+test('Object types with optional properties are allowed', (t) => {
+  type TypeWithOptionalProperty = { foo: string; opt?: string };
+  const testValue: TypeWithOptionalProperty = {
+    foo: 'bar',
+  };
+
+  const query = sql.fragment`SELECT ${sql.json(testValue)}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::json',
+    type: FragmentToken,
+    values: ['{"foo":"bar"}'],
+  });
+});

package/src/factories/createSqlTag.test/jsonb.test.ts

@@ -0,0 +1,106 @@
+import { FragmentToken } from '../../tokens';
+import { createSqlTag } from '../createSqlTag';
+import test from 'ava';
+
+const sql = createSqlTag();
+
+test('creates a value list (object)', (t) => {
+  const query = sql.fragment`SELECT ${sql.jsonb({
+    foo: 'bar',
+  })}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::jsonb',
+    type: FragmentToken,
+    values: ['{"foo":"bar"}'],
+  });
+});
+
+test('creates a value list (array)', (t) => {
+  const query = sql.fragment`SELECT ${sql.jsonb([
+    {
+      foo: 'bar',
+    },
+  ])}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::jsonb',
+    type: FragmentToken,
+    values: ['[{"foo":"bar"}]'],
+  });
+});
+
+test("stringifies NULL to 'null'::jsonb", (t) => {
+  const query = sql.fragment`SELECT ${sql.jsonb(null)}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::jsonb',
+    type: FragmentToken,
+    values: ['null'],
+  });
+});
+
+test('JSON encodes string values', (t) => {
+  const query = sql.fragment`SELECT ${sql.jsonb('example string')}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::jsonb',
+    type: FragmentToken,
+    values: ['"example string"'],
+  });
+});
+
+test('JSON encodes numeric values', (t) => {
+  const query = sql.fragment`SELECT ${sql.jsonb(1_234)}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::jsonb',
+    type: FragmentToken,
+    values: ['1234'],
+  });
+});
+
+test('JSON encodes boolean values', (t) => {
+  const query = sql.fragment`SELECT ${sql.jsonb(true)}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::jsonb',
+    type: FragmentToken,
+    values: ['true'],
+  });
+});
+
+test('throws if payload is undefined', (t) => {
+  const error = t.throws(() => {
+    sql.fragment`SELECT ${sql.jsonb(undefined)}`;
+  });
+
+  t.is(error?.message, 'JSON payload must not be undefined.');
+});
+
+test('throws if payload cannot be stringified (non-primitive object)', (t) => {
+  const error = t.throws(() => {
+    // @ts-expect-error - intentional
+    sql.fragment`SELECT ${sql.jsonb(() => {})}`;
+  });
+
+  t.is(
+    error?.message,
+    'JSON payload must be a primitive value or a plain object.',
+  );
+});
+
+test('Object types with optional properties are allowed', (t) => {
+  type TypeWithOptionalProperty = { foo: string; opt?: string };
+  const testValue: TypeWithOptionalProperty = {
+    foo: 'bar',
+  };
+
+  const query = sql.fragment`SELECT ${sql.jsonb(testValue)}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::jsonb',
+    type: FragmentToken,
+    values: ['{"foo":"bar"}'],
+  });
+});

package/src/factories/createSqlTag.test/literalValue.test.ts

@@ -0,0 +1,17 @@
+import { FragmentToken } from '../../tokens';
+import { createSqlTag } from '../createSqlTag';
+import test from 'ava';
+
+const sql = createSqlTag();
+
+test('creates an object describing a query with an inlined literal value', (t) => {
+  const query = sql.fragment`CREATE USER foo WITH PASSWORD ${sql.literalValue(
+    'bar',
+  )}`;
+
+  t.deepEqual(query, {
+    sql: "CREATE USER foo WITH PASSWORD 'bar'",
+    type: FragmentToken,
+    values: [],
+  });
+});

package/src/factories/createSqlTag.test/sql.test.ts

@@ -0,0 +1,165 @@
+import { FragmentToken } from '../../tokens';
+import { createSqlTag } from '../createSqlTag';
+import anyTest, { type TestFn } from 'ava';
+import { ROARR } from 'roarr';
+
+const test = anyTest as TestFn<{
+  logs: unknown[];
+}>;
+
+const sql = createSqlTag();
+
+test.beforeEach((t) => {
+  t.context.logs = [];
+
+  ROARR.write = (message) => {
+    t.context.logs.push(JSON.parse(message));
+  };
+});
+
+test('creates an object describing a query', (t) => {
+  const query = sql.fragment`SELECT 1`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT 1',
+    type: FragmentToken,
+    values: [],
+  });
+});
+
+test('creates an object describing query value bindings', (t) => {
+  const query = sql.fragment`SELECT ${'foo'}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1',
+    type: FragmentToken,
+    values: ['foo'],
+  });
+});
+
+test('creates an object describing query value bindings (multiple)', (t) => {
+  const query = sql.fragment`SELECT ${'foo'}, ${'bar'}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1, $slonik_2',
+    type: FragmentToken,
+    values: ['foo', 'bar'],
+  });
+});
+
+test('nests sql templates', (t) => {
+  const query0 = sql.fragment`SELECT ${'foo'} FROM bar`;
+  const query1 = sql.fragment`SELECT ${'baz'} FROM (${query0})`;
+
+  t.deepEqual(query1, {
+    sql: 'SELECT $slonik_1 FROM (SELECT $slonik_2 FROM bar)',
+    type: FragmentToken,
+    values: ['baz', 'foo'],
+  });
+});
+
+test('throws if bound an undefined value', (t) => {
+  const error = t.throws(() => {
+    // @ts-expect-error - intentional
+    sql.fragment`SELECT ${undefined}`;
+  });
+
+  t.is(
+    error?.message,
+    'SQL tag cannot be bound to undefined value at index 1.',
+  );
+});
+
+// eslint-disable-next-line n/no-process-env
+if (process.env.ROARR_LOG === '1') {
+  // This test is only valid when ROARR_LOG=1.
+  // TODO find a way to test this without relying on environment variables.
+  test.serial('logs all bound values if one is undefined', (t) => {
+    t.throws(() => {
+      // @ts-expect-error - intentional
+      sql.fragment`SELECT ${undefined}`;
+    });
+
+    const targetMessage = t.context.logs.find((message: any) => {
+      return message.message === 'bound values';
+    }) as any;
+
+    t.truthy(targetMessage);
+
+    t.deepEqual(targetMessage.context.parts, ['SELECT ', '']);
+  });
+}
+
+test('the sql property is immutable', (t) => {
+  const query = sql.fragment`SELECT 1`;
+
+  t.throws(() => {
+    // @ts-expect-error This is intentional.
+    query.sql = 'SELECT 2';
+  });
+});
+
+/**
+ * https://github.com/gajus/slonik/pull/552
+ */
+test('copes with dollar-number in table name', (t) => {
+  const query0 = sql.fragment`discounted_to_$1 (offer_id INTEGER)`;
+  const query1 = sql.fragment`CREATE TABLE ${query0}`;
+
+  t.deepEqual(query1, {
+    sql: 'CREATE TABLE discounted_to_$1 (offer_id INTEGER)',
+    type: FragmentToken,
+    values: [],
+  });
+});
+
+/**
+ * https://github.com/gajus/slonik/pull/552
+ */
+test('copes with dollar-number in column name (CREATE TABLE)', (t) => {
+  const query0 = sql.fragment`offers (discounted_to_$1 BOOLEAN)`;
+  const query1 = sql.fragment`CREATE TABLE ${query0}`;
+
+  t.deepEqual(query1, {
+    sql: 'CREATE TABLE offers (discounted_to_$1 BOOLEAN)',
+    type: FragmentToken,
+    values: [],
+  });
+});
+
+/**
+ * https://github.com/gajus/slonik/pull/552
+ */
+test('copes with dollar-number in column name (SELECT)', (t) => {
+  const query0 = sql.fragment`"discounted_to_$1" IS TRUE`;
+  const query1 = sql.fragment`SELECT * FROM offers WHERE ${query0}`;
+
+  t.deepEqual(query1, {
+    sql: 'SELECT * FROM offers WHERE "discounted_to_$1" IS TRUE',
+    type: FragmentToken,
+    values: [],
+  });
+});
+
+/**
+ * https://github.com/gajus/slonik/pull/552
+ */
+test('copes with dollar-number in function definitions', (t) => {
+  // example function from https://www.postgresql.org/docs/current/sql-createfunction.html
+  const query0 = sql.fragment`add(integer, integer) RETURNS integer
+      AS 'select $1 + $2;'
+      LANGUAGE SQL
+      IMMUTABLE
+      RETURNS NULL ON NULL INPUT`;
+  const query1 = sql.fragment`CREATE FUNCTION ${query0}`;
+
+  t.deepEqual(query1, {
+    sql: `CREATE FUNCTION add(integer, integer) RETURNS integer
+      AS 'select $1 + $2;'
+      LANGUAGE SQL
+      IMMUTABLE
+      RETURNS NULL ON NULL INPUT`,
+    type: FragmentToken,
+    values: [],
+  });
+});

package/src/factories/createSqlTag.test/timestamp.test.ts

@@ -0,0 +1,29 @@
+import { FragmentToken } from '../../tokens';
+import { createSqlTag } from '../createSqlTag';
+import test from 'ava';
+
+const sql = createSqlTag();
+
+test('binds a timestamp', (t) => {
+  const query = sql.fragment`SELECT ${sql.timestamp(
+    new Date('2022-08-19T03:27:24.951Z'),
+  )}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT to_timestamp($slonik_1)',
+    type: FragmentToken,
+    values: ['1660879644.951'],
+  });
+});
+
+test('throws if not instance of Date', (t) => {
+  const error = t.throws(() => {
+    // @ts-expect-error - intentional
+    sql.fragment`SELECT ${sql.timestamp(1)}`;
+  });
+
+  t.is(
+    error?.message,
+    'Timestamp parameter value must be an instance of Date.',
+  );
+});

package/src/factories/createSqlTag.test/type.test.ts

@@ -0,0 +1,17 @@
+import { createSqlTag } from '../createSqlTag';
+import test from 'ava';
+import { z } from 'zod';
+
+const sql = createSqlTag();
+
+test('describes zod object associated with the query', (t) => {
+  const zodObject = z.object({
+    id: z.number(),
+  });
+
+  const query = sql.type(zodObject)`
+    SELECT 1 id
+  `;
+
+  t.is(query.parser, zodObject);
+});

package/src/factories/createSqlTag.test/typeAlias.test.ts

@@ -0,0 +1,53 @@
+import { createSqlTag } from '../createSqlTag';
+import anyTest, { type TestFn } from 'ava';
+import { ROARR } from 'roarr';
+import { z } from 'zod';
+
+const test = anyTest as TestFn<{
+  logs: unknown[];
+}>;
+
+test.beforeEach((t) => {
+  t.context.logs = [];
+
+  ROARR.write = (message) => {
+    t.context.logs.push(JSON.parse(message));
+  };
+});
+
+test('describes zod object associated with the query', (t) => {
+  const typeAliases = {
+    id: z.object({
+      id: z.number(),
+    }),
+  };
+
+  const sql = createSqlTag({
+    typeAliases,
+  });
+
+  const query = sql.typeAlias('id')`
+    SELECT 1 id
+  `;
+
+  t.is(query.parser, typeAliases.id);
+});
+
+test('cannot alias unknown fields', (t) => {
+  const typeAliases = {
+    id: z.object({
+      id: z.number(),
+    }),
+  };
+
+  const sql = createSqlTag({
+    typeAliases,
+  });
+
+  t.throws(() => {
+    // @ts-expect-error - intentional
+    sql.typeAlias('void')`
+      SELECT 1 id
+    `;
+  });
+});