@slonik/sql-tag 48.12.2 → 48.13.0

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

@@ -1,33 +1,30 @@
-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 object describing a query with inlined identifiers', (t) => {
-  const query = sql.fragment`SELECT ${'foo'} FROM ${sql.identifier(['bar'])}`;
+test("creates an object describing a query with inlined identifiers", (t) => {
+  const query = sql.fragment`SELECT ${"foo"} FROM ${sql.identifier(["bar"])}`;
 
   t.deepEqual(query, {
     sql: 'SELECT $slonik_1 FROM "bar"',
     type: FragmentToken,
-    values: ['foo'],
+    values: ["foo"],
   });
 });
 
-test('creates an object describing a query with inlined identifiers (specifier)', (t) => {
-  const query = sql.fragment`SELECT ${'foo'} FROM ${sql.identifier([
-    'bar',
-    'baz',
-  ])}`;
+test("creates an object describing a query with inlined identifiers (specifier)", (t) => {
+  const query = sql.fragment`SELECT ${"foo"} FROM ${sql.identifier(["bar", "baz"])}`;
 
   t.deepEqual(query, {
     sql: 'SELECT $slonik_1 FROM "bar"."baz"',
     type: FragmentToken,
-    values: ['foo'],
+    values: ["foo"],
   });
 });
 
-test('throws if an identifier name array member type is not a string', (t) => {
+test("throws if an identifier name array member type is not a string", (t) => {
   const error = t.throws(() => {
     sql.fragment`${sql.identifier([
       // @ts-expect-error - intentional
@@ -35,5 +32,5 @@ test('throws if an identifier name array member type is not a string', (t) => {
     ])}`;
   });
 
-  t.is(error?.message, 'Identifier name array member type must be a string.');
+  t.is(error?.message, "Identifier name array member type must be a string.");
 });

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

@@ -1,20 +1,20 @@
-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 empty make_interval invocation', (t) => {
+test("creates an empty make_interval invocation", (t) => {
   const query = sql.fragment`SELECT ${sql.interval({})}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT make_interval()',
+    sql: "SELECT make_interval()",
     type: FragmentToken,
     values: [],
   });
 });
 
-test('creates an interval', (t) => {
+test("creates an interval", (t) => {
   const query = sql.fragment`SELECT ${sql.interval({
     days: 4,
     hours: 5,
@@ -26,19 +26,19 @@ test('creates an interval', (t) => {
   })}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT make_interval(years => $slonik_1, months => $slonik_2, weeks => $slonik_3, days => $slonik_4, hours => $slonik_5, mins => $slonik_6, secs => $slonik_7)',
+    sql: "SELECT make_interval(years => $slonik_1, months => $slonik_2, weeks => $slonik_3, days => $slonik_4, hours => $slonik_5, mins => $slonik_6, secs => $slonik_7)",
     type: FragmentToken,
     values: [1, 2, 3, 4, 5, 6, 7],
   });
 });
 
-test('throws if contains unknown properties', (t) => {
+test("throws if contains unknown properties", (t) => {
   const error = t.throws(() => {
     sql.fragment`SELECT ${sql.interval({
       // @ts-expect-error - intentional
-      foo: 'bar',
+      foo: "bar",
     })}`;
   });
 
-  t.is(error?.message, 'Interval input must not contain unknown properties.');
+  t.is(error?.message, "Interval input must not contain unknown properties.");
 });

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

@@ -1,85 +1,82 @@
-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 a list of values', (t) => {
+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)',
+    sql: "SELECT ($slonik_1, $slonik_2, $slonik_3)",
     type: FragmentToken,
     values: [1, 2, 3],
   });
 });
 
-test('creates a list of values using glue', (t) => {
+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',
+    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`, `,
-  )})`;
+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)',
+    sql: "SELECT ($slonik_1, foo, $slonik_2)",
     type: FragmentToken,
     values: [1, 3],
   });
 });
 
-test('interpolates SQL tokens with bound values', (t) => {
+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',
+    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) => {
+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',
+    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) => {
+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',
+    sql: "SELECT $slonik_1, to_timestamp($slonik_2), $slonik_3, $slonik_4",
     type: FragmentToken,
     values: [1n, 2n, 3n, 4n],
   });
 });
 
-test('nests expressions', (t) => {
+test("nests expressions", (t) => {
   const query = sql.fragment`SELECT ${sql.join(
     [
       sql.fragment`(${sql.join([1, 2], sql.fragment`, `)})`,
@@ -89,27 +86,24 @@ test('nests expressions', (t) => {
   )}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT ($slonik_1, $slonik_2), ($slonik_3, $slonik_4)',
+    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`, `,
-  )})`;
+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)',
+    sql: "SELECT ($slonik_1, $slonik_2)",
     type: FragmentToken,
-    values: ['a', data],
+    values: ["a", data],
   });
 });
 
-test('throws is member is not a SQL token or a primitive value expression', (t) => {
+test("throws is member is not a SQL token or a primitive value expression", (t) => {
   const error = t.throws(() => {
     sql.fragment`${sql.join(
       [
@@ -122,6 +116,6 @@ test('throws is member is not a SQL token or a primitive value expression', (t)
 
   t.is(
     error?.message,
-    'Invalid list member type. Must be a SQL token or a primitive value expression.',
+    "Invalid list member type. Must be a SQL token or a primitive value expression.",
   );
 });

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

@@ -1,30 +1,30 @@
-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 a value list (object)', (t) => {
+test("creates a value list (object)", (t) => {
   const query = sql.fragment`SELECT ${sql.json({
-    foo: 'bar',
+    foo: "bar",
   })}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1::json',
+    sql: "SELECT $slonik_1::json",
     type: FragmentToken,
     values: ['{"foo":"bar"}'],
   });
 });
 
-test('creates a value list (array)', (t) => {
+test("creates a value list (array)", (t) => {
   const query = sql.fragment`SELECT ${sql.json([
     {
-      foo: 'bar',
+      foo: "bar",
     },
   ])}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1::json',
+    sql: "SELECT $slonik_1::json",
     type: FragmentToken,
     values: ['[{"foo":"bar"}]'],
   });
@@ -34,72 +34,69 @@ test("stringifies NULL to 'null'::json", (t) => {
   const query = sql.fragment`SELECT ${sql.json(null)}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1::json',
+    sql: "SELECT $slonik_1::json",
     type: FragmentToken,
-    values: ['null'],
+    values: ["null"],
   });
 });
 
-test('JSON encodes string values', (t) => {
-  const query = sql.fragment`SELECT ${sql.json('example string')}`;
+test("JSON encodes string values", (t) => {
+  const query = sql.fragment`SELECT ${sql.json("example string")}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1::json',
+    sql: "SELECT $slonik_1::json",
     type: FragmentToken,
     values: ['"example string"'],
   });
 });
 
-test('JSON encodes numeric values', (t) => {
+test("JSON encodes numeric values", (t) => {
   const query = sql.fragment`SELECT ${sql.json(1_234)}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1::json',
+    sql: "SELECT $slonik_1::json",
     type: FragmentToken,
-    values: ['1234'],
+    values: ["1234"],
   });
 });
 
-test('JSON encodes boolean values', (t) => {
+test("JSON encodes boolean values", (t) => {
   const query = sql.fragment`SELECT ${sql.json(true)}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1::json',
+    sql: "SELECT $slonik_1::json",
     type: FragmentToken,
-    values: ['true'],
+    values: ["true"],
   });
 });
 
-test('throws if payload is undefined', (t) => {
+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.');
+  t.is(error?.message, "JSON payload must not be undefined.");
 });
 
-test('throws if payload cannot be stringified (non-primitive object)', (t) => {
+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.',
-  );
+  t.is(error?.message, "JSON payload must be a primitive value or a plain object.");
 });
 
-test('Object types with optional properties are allowed', (t) => {
+test("Object types with optional properties are allowed", (t) => {
   type TypeWithOptionalProperty = { foo: string; opt?: string };
   const testValue: TypeWithOptionalProperty = {
-    foo: 'bar',
+    foo: "bar",
   };
 
   const query = sql.fragment`SELECT ${sql.json(testValue)}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1::json',
+    sql: "SELECT $slonik_1::json",
     type: FragmentToken,
     values: ['{"foo":"bar"}'],
   });

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

@@ -1,30 +1,30 @@
-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 a value list (object)', (t) => {
+test("creates a value list (object)", (t) => {
   const query = sql.fragment`SELECT ${sql.jsonb({
-    foo: 'bar',
+    foo: "bar",
   })}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1::jsonb',
+    sql: "SELECT $slonik_1::jsonb",
     type: FragmentToken,
     values: ['{"foo":"bar"}'],
   });
 });
 
-test('creates a value list (array)', (t) => {
+test("creates a value list (array)", (t) => {
   const query = sql.fragment`SELECT ${sql.jsonb([
     {
-      foo: 'bar',
+      foo: "bar",
     },
   ])}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1::jsonb',
+    sql: "SELECT $slonik_1::jsonb",
     type: FragmentToken,
     values: ['[{"foo":"bar"}]'],
   });
@@ -34,72 +34,69 @@ test("stringifies NULL to 'null'::jsonb", (t) => {
   const query = sql.fragment`SELECT ${sql.jsonb(null)}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1::jsonb',
+    sql: "SELECT $slonik_1::jsonb",
     type: FragmentToken,
-    values: ['null'],
+    values: ["null"],
   });
 });
 
-test('JSON encodes string values', (t) => {
-  const query = sql.fragment`SELECT ${sql.jsonb('example string')}`;
+test("JSON encodes string values", (t) => {
+  const query = sql.fragment`SELECT ${sql.jsonb("example string")}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1::jsonb',
+    sql: "SELECT $slonik_1::jsonb",
     type: FragmentToken,
     values: ['"example string"'],
   });
 });
 
-test('JSON encodes numeric values', (t) => {
+test("JSON encodes numeric values", (t) => {
   const query = sql.fragment`SELECT ${sql.jsonb(1_234)}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1::jsonb',
+    sql: "SELECT $slonik_1::jsonb",
     type: FragmentToken,
-    values: ['1234'],
+    values: ["1234"],
   });
 });
 
-test('JSON encodes boolean values', (t) => {
+test("JSON encodes boolean values", (t) => {
   const query = sql.fragment`SELECT ${sql.jsonb(true)}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1::jsonb',
+    sql: "SELECT $slonik_1::jsonb",
     type: FragmentToken,
-    values: ['true'],
+    values: ["true"],
   });
 });
 
-test('throws if payload is undefined', (t) => {
+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.');
+  t.is(error?.message, "JSON payload must not be undefined.");
 });
 
-test('throws if payload cannot be stringified (non-primitive object)', (t) => {
+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.',
-  );
+  t.is(error?.message, "JSON payload must be a primitive value or a plain object.");
 });
 
-test('Object types with optional properties are allowed', (t) => {
+test("Object types with optional properties are allowed", (t) => {
   type TypeWithOptionalProperty = { foo: string; opt?: string };
   const testValue: TypeWithOptionalProperty = {
-    foo: 'bar',
+    foo: "bar",
   };
 
   const query = sql.fragment`SELECT ${sql.jsonb(testValue)}`;
 
   t.deepEqual(query, {
-    sql: 'SELECT $slonik_1::jsonb',
+    sql: "SELECT $slonik_1::jsonb",
     type: FragmentToken,
     values: ['{"foo":"bar"}'],
   });

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

@@ -1,13 +1,11 @@
-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 object describing a query with an inlined literal value', (t) => {
-  const query = sql.fragment`CREATE USER foo WITH PASSWORD ${sql.literalValue(
-    'bar',
-  )}`;
+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'",