@slonik/sql-tag 48.12.2 → 48.13.0

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

@@ -1,9 +1,9 @@
-import { FragmentToken } from '../../tokens.js';
-import { createSqlTag } from '../createSqlTag.js';
-import { InvalidInputError } from '@slonik/errors';
-import anyTest from 'ava';
-import type { TestFn } from 'ava';
-import { ROARR } from 'roarr';
+import { FragmentToken } from "../../tokens.js";
+import { createSqlTag } from "../createSqlTag.js";
+import { InvalidInputError } from "@slonik/errors";
+import anyTest from "ava";
+import type { TestFn } from "ava";
+import { ROARR } from "roarr";
 
 const test = anyTest as TestFn<{
   logs: unknown[];
@@ -19,7 +19,7 @@ test.beforeEach((t) => {
   };
 });
 
-test('throws error if called as a function', (t) => {
+test("throws error if called as a function", (t) => {
   const error = t.throws(() => {
     // @ts-expect-error - intentional
     sql.fragment([`SELECT 1`]);
@@ -28,97 +28,94 @@ test('throws error if called as a function', (t) => {
   t.true(error instanceof InvalidInputError);
 });
 
-test('creates an object describing a query', (t) => {
+test("creates an object describing a query", (t) => {
   const query = sql.fragment`SELECT 1`;
 
   t.deepEqual(query, {
-    sql: 'SELECT 1',
+    sql: "SELECT 1",
     type: FragmentToken,
     values: [],
   });
 });
 
-test('creates an object describing query value bindings', (t) => {
-  const query = sql.fragment`SELECT ${'foo'}`;
+test("creates an object describing query value bindings", (t) => {
+  const query = sql.fragment`SELECT ${"foo"}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1',
+    sql: "SELECT $slonik_1",
     type: FragmentToken,
-    values: ['foo'],
+    values: ["foo"],
   });
 });
 
-test('creates an object describing query value bindings (multiple)', (t) => {
-  const query = sql.fragment`SELECT ${'foo'}, ${'bar'}`;
+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',
+    sql: "SELECT $slonik_1, $slonik_2",
     type: FragmentToken,
-    values: ['foo', 'bar'],
+    values: ["foo", "bar"],
   });
 });
 
-test('nests sql templates', (t) => {
-  const query0 = sql.fragment`SELECT ${'foo'} FROM bar`;
-  const query1 = sql.fragment`SELECT ${'baz'} FROM (${query0})`;
+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)',
+    sql: "SELECT $slonik_1 FROM (SELECT $slonik_2 FROM bar)",
     type: FragmentToken,
-    values: ['baz', 'foo'],
+    values: ["baz", "foo"],
   });
 });
 
-test('throws if bound an undefined value', (t) => {
+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.',
-  );
+  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') {
+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) => {
+  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';
+      return message.message === "bound values";
     }) as any;
 
     t.truthy(targetMessage);
 
-    t.deepEqual(targetMessage.context.parts, ['SELECT ', '']);
+    t.deepEqual(targetMessage.context.parts, ["SELECT ", ""]);
   });
 }
 
-test('the sql property is immutable', (t) => {
+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';
+    query.sql = "SELECT 2";
   });
 });
 
 /**
  * https://github.com/gajus/slonik/pull/552
  */
-test('copes with dollar-number in table name', (t) => {
+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)',
+    sql: "CREATE TABLE discounted_to_$1 (offer_id INTEGER)",
     type: FragmentToken,
     values: [],
   });
@@ -127,12 +124,12 @@ test('copes with dollar-number in table name', (t) => {
 /**
  * https://github.com/gajus/slonik/pull/552
  */
-test('copes with dollar-number in column name (CREATE TABLE)', (t) => {
+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)',
+    sql: "CREATE TABLE offers (discounted_to_$1 BOOLEAN)",
     type: FragmentToken,
     values: [],
   });
@@ -141,7 +138,7 @@ test('copes with dollar-number in column name (CREATE TABLE)', (t) => {
 /**
  * https://github.com/gajus/slonik/pull/552
  */
-test('copes with dollar-number in column name (SELECT)', (t) => {
+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}`;
 
@@ -155,7 +152,7 @@ test('copes with dollar-number in column name (SELECT)', (t) => {
 /**
  * https://github.com/gajus/slonik/pull/552
  */
-test('copes with dollar-number in function definitions', (t) => {
+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;'
@@ -175,11 +172,11 @@ test('copes with dollar-number in function definitions', (t) => {
   });
 });
 
-test('interpolates literal boolean values', (t) => {
+test("interpolates literal boolean values", (t) => {
   const query = sql.fragment`SELECT ${true}, ${false}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1, $slonik_2',
+    sql: "SELECT $slonik_1, $slonik_2",
     type: FragmentToken,
     values: [true, false],
   });

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

@@ -1,29 +1,24 @@
-import { FragmentToken } from '../../tokens.js';
-import { createSqlTag } from '../createSqlTag.js';
-import test from 'ava';
+import { FragmentToken } from "../../tokens.js";
+import { createSqlTag } from "../createSqlTag.js";
+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'),
-  )}`;
+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)',
+    sql: "SELECT to_timestamp($slonik_1)",
     type: FragmentToken,
-    values: ['1660879644.951'],
+    values: ["1660879644.951"],
   });
 });
 
-test('throws if not instance of Date', (t) => {
+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.',
-  );
+  t.is(error?.message, "Timestamp parameter value must be an instance of Date.");
 });

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

@@ -1,10 +1,10 @@
-import { createSqlTag } from '../createSqlTag.js';
-import test from 'ava';
-import { z } from 'zod';
+import { createSqlTag } from "../createSqlTag.js";
+import test from "ava";
+import { z } from "zod";
 
 const sql = createSqlTag();
 
-test('describes zod object associated with the query', (t) => {
+test("describes zod object associated with the query", (t) => {
   const zodObject = z.object({
     id: z.number(),
   });

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

@@ -1,8 +1,8 @@
-import { createSqlTag } from '../createSqlTag.js';
-import anyTest from 'ava';
-import type { TestFn } from 'ava';
-import { ROARR } from 'roarr';
-import { z } from 'zod';
+import { createSqlTag } from "../createSqlTag.js";
+import anyTest from "ava";
+import type { TestFn } from "ava";
+import { ROARR } from "roarr";
+import { z } from "zod";
 
 const test = anyTest as TestFn<{
   logs: unknown[];
@@ -16,7 +16,7 @@ test.beforeEach((t) => {
   };
 });
 
-test('describes zod object associated with the query', (t) => {
+test("describes zod object associated with the query", (t) => {
   const typeAliases = {
     id: z.object({
       id: z.number(),
@@ -27,14 +27,14 @@ test('describes zod object associated with the query', (t) => {
     typeAliases,
   });
 
-  const query = sql.typeAlias('id')`
+  const query = sql.typeAlias("id")`
     SELECT 1 id
   `;
 
   t.is(query.parser, typeAliases.id);
 });
 
-test('cannot alias unknown fields', (t) => {
+test("cannot alias unknown fields", (t) => {
   const typeAliases = {
     id: z.object({
       id: z.number(),
@@ -47,7 +47,7 @@ test('cannot alias unknown fields', (t) => {
 
   t.throws(() => {
     // @ts-expect-error - intentional
-    sql.typeAlias('void')`
+    sql.typeAlias("void")`
       SELECT 1 id
     `;
   });

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

@@ -1,16 +1,16 @@
-import { FragmentToken } from '../../tokens.js';
-import { createSqlTag } from '../createSqlTag.js';
-import test from 'ava';
+import { FragmentToken } from "../../tokens.js";
+import { createSqlTag } from "../createSqlTag.js";
+import test from "ava";
 
 const sql = createSqlTag();
 
-test('creates an unnest expression using primitive values (type name identifier)', (t) => {
+test("creates an unnest expression using primitive values (type name identifier)", (t) => {
   const query = sql.fragment`SELECT * FROM ${sql.unnest(
     [
       [1, 2, 3],
       [4, 5, 6],
     ],
-    ['int4', 'int4', 'int4'],
+    ["int4", "int4", "int4"],
   )}`;
 
   t.deepEqual(query, {
@@ -24,7 +24,7 @@ test('creates an unnest expression using primitive values (type name identifier)
   });
 });
 
-test('creates an unnest expression using primitive values (sql token)', (t) => {
+test("creates an unnest expression using primitive values (sql token)", (t) => {
   const query = sql.fragment`SELECT * FROM ${sql.unnest(
     [
       [1, 2, 3],
@@ -34,7 +34,7 @@ test('creates an unnest expression using primitive values (sql token)', (t) => {
   )}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT * FROM unnest($slonik_1::integer[], $slonik_2::integer[], $slonik_3::integer[])',
+    sql: "SELECT * FROM unnest($slonik_1::integer[], $slonik_2::integer[], $slonik_3::integer[])",
     type: FragmentToken,
     values: [
       [1, 4],
@@ -44,15 +44,15 @@ test('creates an unnest expression using primitive values (sql token)', (t) => {
   });
 });
 
-test('treats type as sql.identifier', (t) => {
+test("treats type as sql.identifier", (t) => {
   const query = sql.fragment`SELECT bar, baz FROM ${sql.unnest(
     [
       [1, 3],
       [2, 4],
     ],
     [
-      ['foo', 'int4'],
-      ['foo', 'int4'],
+      ["foo", "int4"],
+      ["foo", "int4"],
     ],
   )} AS foo(bar, baz)`;
 
@@ -66,13 +66,13 @@ test('treats type as sql.identifier', (t) => {
   });
 });
 
-test('creates an unnest expression using arrays', (t) => {
+test("creates an unnest expression using arrays", (t) => {
   const query = sql.fragment`SELECT * FROM ${sql.unnest(
     [
       [1, 2, 3],
       [4, 5, 6],
     ],
-    ['int4', 'int4', 'int4'],
+    ["int4", "int4", "int4"],
   )}`;
 
   t.deepEqual(query, {
@@ -86,13 +86,13 @@ test('creates an unnest expression using arrays', (t) => {
   });
 });
 
-test('creates incremental alias names if no alias names are provided', (t) => {
+test("creates incremental alias names if no alias names are provided", (t) => {
   const query = sql.fragment`SELECT * FROM ${sql.unnest(
     [
       [1, 2, 3],
       [4, 5, 6],
     ],
-    ['int4', 'int4', 'int4'],
+    ["int4", "int4", "int4"],
   )}`;
 
   t.deepEqual(query, {
@@ -106,11 +106,8 @@ test('creates incremental alias names if no alias names are provided', (t) => {
   });
 });
 
-test('recognizes an array of arrays array', (t) => {
-  const query = sql.fragment`SELECT * FROM ${sql.unnest(
-    [[[[1], [2], [3]]]],
-    ['int4[]'],
-  )}`;
+test("recognizes an array of arrays array", (t) => {
+  const query = sql.fragment`SELECT * FROM ${sql.unnest([[[[1], [2], [3]]]], ["int4[]"])}`;
 
   t.deepEqual(query, {
     sql: 'SELECT * FROM unnest($slonik_1::"int4"[][])',
@@ -119,50 +116,44 @@ test('recognizes an array of arrays array', (t) => {
   });
 });
 
-test('throws if tuple member is not a primitive value expression', (t) => {
+test("throws if tuple member is not a primitive value expression", (t) => {
   const error = t.throws(() => {
     sql.fragment`SELECT * FROM ${sql.unnest(
       [
         [() => {}, 2, 3],
         [4, 5],
       ],
-      ['int4', 'int4', 'int4'],
+      ["int4", "int4", "int4"],
     )}`;
   });
 
-  t.is(
-    error?.message,
-    'Invalid unnest tuple member type. Must be a primitive value expression.',
-  );
+  t.is(error?.message, "Invalid unnest tuple member type. Must be a primitive value expression.");
 });
 
-test('throws if tuple member length varies in a list of tuples', (t) => {
+test("throws if tuple member length varies in a list of tuples", (t) => {
   const error = t.throws(() => {
     sql.fragment`SELECT * FROM ${sql.unnest(
       [
         [1, 2, 3],
         [4, 5],
       ],
-      ['int4', 'int4', 'int4'],
+      ["int4", "int4", "int4"],
     )}`;
   });
 
-  t.is(
-    error?.message,
-    'Each tuple in a list of tuples must have an equal number of members.',
-  );
+  t.is(error?.message, "Each tuple in a list of tuples must have an equal number of members.");
 });
 
-test('throws if tuple member length does not match column types length', (t) => {
+test("throws if tuple member length does not match column types length", (t) => {
   const error = t.throws(() => {
     sql.fragment`SELECT * FROM ${sql.unnest(
       [
         [1, 2, 3],
         [4, 5, 6],
       ],
-      ['int4', 'int4'],
+      ["int4", "int4"],
     )}`;
   });
 
-  t.is(error?.message, 'Column types length must match tuple member length.');
+  t.is(error?.message, "Column types length must match tuple member length.");
 });

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

@@ -1,25 +1,23 @@
-import { FragmentToken } from '../../tokens.js';
-import { createSqlTag } from '../createSqlTag.js';
-import test from 'ava';
+import { FragmentToken } from "../../tokens.js";
+import { createSqlTag } from "../createSqlTag.js";
+import test from "ava";
 
 const sql = createSqlTag();
 
-test('binds a uuid', (t) => {
-  const query = sql.fragment`SELECT ${sql.uuid(
-    '00000000-0000-0000-0000-000000000000',
-  )}`;
+test("binds a uuid", (t) => {
+  const query = sql.fragment`SELECT ${sql.uuid("00000000-0000-0000-0000-000000000000")}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1::uuid',
+    sql: "SELECT $slonik_1::uuid",
     type: FragmentToken,
-    values: ['00000000-0000-0000-0000-000000000000'],
+    values: ["00000000-0000-0000-0000-000000000000"],
   });
 });
 
-test('throws if not valid uuid', (t) => {
+test("throws if not valid uuid", (t) => {
   const error = t.throws(() => {
-    sql.fragment`SELECT ${sql.uuid('1')}`;
+    sql.fragment`SELECT ${sql.uuid("1")}`;
   });
 
-  t.is(error?.message, 'UUID parameter value must be a valid UUID.');
+  t.is(error?.message, "UUID parameter value must be a valid UUID.");
 });

package/src/factories/createSqlTag.ts

@@ -1,5 +1,5 @@
-import { Logger } from '../Logger.js';
-import type { UUID } from '../sqlFragmentFactories/createUuidSqlFragment.js';
+import { Logger } from "../Logger.js";
+import type { UUID } from "../sqlFragmentFactories/createUuidSqlFragment.js";
 import {
   ArrayToken,
   BinaryToken,
@@ -14,7 +14,7 @@ import {
   TimestampToken,
   UnnestToken,
   UuidToken,
-} from '../tokens.js';
+} from "../tokens.js";
 import type {
   ArraySqlToken,
   PrimitiveValueExpression,
@@ -22,32 +22,27 @@ import type {
   SqlTag,
   TypeNameIdentifier,
   ValueExpression,
-} from '../types.js';
-import { escapeLiteralValue } from '../utilities/escapeLiteralValue.js';
-import { formatSlonikPlaceholder } from '../utilities/formatSlonikPlaceholder.js';
-import { isPrimitiveValueExpression } from '../utilities/isPrimitiveValueExpression.js';
-import { isSqlToken } from '../utilities/isSqlToken.js';
-import { safeStringify } from '../utilities/safeStringify.js';
-import { createSqlTokenSqlFragment } from './createSqlTokenSqlFragment.js';
-import { InvalidInputError } from '@slonik/errors';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import { z } from 'zod';
+} from "../types.js";
+import { escapeLiteralValue } from "../utilities/escapeLiteralValue.js";
+import { formatSlonikPlaceholder } from "../utilities/formatSlonikPlaceholder.js";
+import { isPrimitiveValueExpression } from "../utilities/isPrimitiveValueExpression.js";
+import { isSqlToken } from "../utilities/isSqlToken.js";
+import { safeStringify } from "../utilities/safeStringify.js";
+import { createSqlTokenSqlFragment } from "./createSqlTokenSqlFragment.js";
+import { InvalidInputError } from "@slonik/errors";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import { z } from "zod";
 
 const log = Logger.child({
-  namespace: 'sql',
+  namespace: "sql",
 });
 
-const createFragment = (
-  parts: TemplateStringsArray,
-  values: readonly ValueExpression[],
-) => {
+const createFragment = (parts: TemplateStringsArray, values: readonly ValueExpression[]) => {
   if (!Array.isArray(parts.raw) || !Object.isFrozen(parts.raw)) {
-    throw new InvalidInputError(
-      'Function must be called as a template literal.',
-    );
+    throw new InvalidInputError("Function must be called as a template literal.");
   }
 
-  let rawSql = '';
+  let rawSql = "";
 
   const parameterValues: PrimitiveValueExpression[] = [];
 
@@ -69,21 +64,16 @@ const createFragment = (
           parts: JSON.parse(safeStringify(parts)),
           values: JSON.parse(safeStringify(values)),
         },
-        'bound values',
+        "bound values",
       );
 
-      throw new InvalidInputError(
-        `SQL tag cannot be bound to undefined value at index ${index}.`,
-      );
+      throw new InvalidInputError(`SQL tag cannot be bound to undefined value at index ${index}.`);
     } else if (isPrimitiveValueExpression(token)) {
       rawSql += formatSlonikPlaceholder(parameterValues.length + 1);
 
       parameterValues.push(token);
     } else if (isSqlToken(token)) {
-      const sqlFragment = createSqlTokenSqlFragment(
-        token,
-        parameterValues.length,
-      );
+      const sqlFragment = createSqlTokenSqlFragment(token, parameterValues.length);
 
       rawSql += sqlFragment.sql;
 
@@ -97,10 +87,10 @@ const createFragment = (
           index,
           offendingToken: JSON.parse(safeStringify(token)),
         },
-        'unexpected value expression',
+        "unexpected value expression",
       );
 
-      throw new TypeError('Unexpected value expression.');
+      throw new TypeError("Unexpected value expression.");
     }
   }
 
@@ -189,10 +179,7 @@ export const createSqlTag = <
       });
     },
     prepared: (statementName, parser) => {
-      return (
-        parts: TemplateStringsArray,
-        ...args: readonly ValueExpression[]
-      ) => {
+      return (parts: TemplateStringsArray, ...args: readonly ValueExpression[]) => {
         return Object.freeze({
           ...createFragment(parts, args),
           name: statementName,
@@ -208,10 +195,7 @@ export const createSqlTag = <
       });
     },
     type: (parser) => {
-      return (
-        parts: TemplateStringsArray,
-        ...args: readonly ValueExpression[]
-      ) => {
+      return (parts: TemplateStringsArray, ...args: readonly ValueExpression[]) => {
         return Object.freeze({
           ...createFragment(parts, args),
           parser,
@@ -221,15 +205,10 @@ export const createSqlTag = <
     },
     typeAlias: (parserAlias) => {
       if (!typeAliases?.[parserAlias]) {
-        throw new Error(
-          'Type alias "' + String(parserAlias) + '" does not exist.',
-        );
+        throw new Error('Type alias "' + String(parserAlias) + '" does not exist.');
       }
 
-      return (
-        parts: TemplateStringsArray,
-        ...args: readonly ValueExpression[]
-      ) => {
+      return (parts: TemplateStringsArray, ...args: readonly ValueExpression[]) => {
         return Object.freeze({
           ...createFragment(parts, args),
           parser: typeAliases[parserAlias],