@slonik/sql-tag 48.12.3 → 48.13.0

package/src/sqlFragmentFactories/createUnnestSqlFragment.ts

@@ -1,15 +1,11 @@
-import { FragmentToken } from '../tokens.js';
-import type {
-  PrimitiveValueExpression,
-  SqlFragmentToken,
-  UnnestSqlToken,
-} from '../types.js';
-import { countArrayDimensions } from '../utilities/countArrayDimensions.js';
-import { escapeIdentifier } from '../utilities/escapeIdentifier.js';
-import { formatSlonikPlaceholder } from '../utilities/formatSlonikPlaceholder.js';
-import { isPrimitiveValueExpression } from '../utilities/isPrimitiveValueExpression.js';
-import { stripArrayNotation } from '../utilities/stripArrayNotation.js';
-import { InvalidInputError } from '@slonik/errors';
+import { FragmentToken } from "../tokens.js";
+import type { PrimitiveValueExpression, SqlFragmentToken, UnnestSqlToken } from "../types.js";
+import { countArrayDimensions } from "../utilities/countArrayDimensions.js";
+import { escapeIdentifier } from "../utilities/escapeIdentifier.js";
+import { formatSlonikPlaceholder } from "../utilities/formatSlonikPlaceholder.js";
+import { isPrimitiveValueExpression } from "../utilities/isPrimitiveValueExpression.js";
+import { stripArrayNotation } from "../utilities/stripArrayNotation.js";
+import { InvalidInputError } from "@slonik/errors";
 
 export const createUnnestSqlFragment = (
   token: UnnestSqlToken,
@@ -32,21 +28,21 @@ export const createUnnestSqlFragment = (
     let columnType = columnTypes[columnIndex];
     let columnTypeIsIdentifier;
 
-    if (typeof typeMember === 'string') {
+    if (typeof typeMember === "string") {
       columnType = typeMember;
       columnTypeIsIdentifier = false;
     } else if (Array.isArray(typeMember)) {
       columnType = typeMember
         .map((identifierName) => {
-          if (typeof identifierName !== 'string') {
+          if (typeof identifierName !== "string") {
             throw new InvalidInputError(
-              'sql.unnest column identifier name array member type must be a string (type name identifier) or a SQL token.',
+              "sql.unnest column identifier name array member type must be a string (type name identifier) or a SQL token.",
             );
           }
 
           return escapeIdentifier(identifierName);
         })
-        .join('.');
+        .join(".");
       columnTypeIsIdentifier = true;
     } else {
       columnType = typeMember.sql;
@@ -55,11 +51,11 @@ export const createUnnestSqlFragment = (
 
     unnestSqlTokens.push(
       formatSlonikPlaceholder(++placeholderIndex) +
-        '::' +
+        "::" +
         (columnTypeIsIdentifier
           ? stripArrayNotation(columnType)
           : escapeIdentifier(stripArrayNotation(columnType))) +
-        '[]'.repeat(countArrayDimensions(columnType) + 1),
+        "[]".repeat(countArrayDimensions(columnType) + 1),
     );
 
     unnestBindings[columnIndex] = [];
@@ -70,17 +66,12 @@ export const createUnnestSqlFragment = (
   let lastTupleSize;
 
   for (const tupleValues of token.tuples) {
-    if (
-      typeof lastTupleSize === 'number' &&
-      lastTupleSize !== tupleValues.length
-    ) {
-      throw new Error(
-        'Each tuple in a list of tuples must have an equal number of members.',
-      );
+    if (typeof lastTupleSize === "number" && lastTupleSize !== tupleValues.length) {
+      throw new Error("Each tuple in a list of tuples must have an equal number of members.");
     }
 
     if (tupleValues.length !== columnTypes.length) {
-      throw new Error('Column types length must match tuple member length.');
+      throw new Error("Column types length must match tuple member length.");
     }
 
     lastTupleSize = tupleValues.length;
@@ -94,14 +85,14 @@ export const createUnnestSqlFragment = (
         !Buffer.isBuffer(tupleValue)
       ) {
         throw new InvalidInputError(
-          'Invalid unnest tuple member type. Must be a primitive value expression.',
+          "Invalid unnest tuple member type. Must be a primitive value expression.",
         );
       }
 
       const tupleBindings = unnestBindings[tupleColumnIndex++];
 
       if (!tupleBindings) {
-        throw new Error('test');
+        throw new Error("test");
       }
 
       tupleBindings.push(tupleValue);
@@ -110,7 +101,7 @@ export const createUnnestSqlFragment = (
 
   values.push(...unnestBindings);
 
-  const sql = 'unnest(' + unnestSqlTokens.join(', ') + ')';
+  const sql = "unnest(" + unnestSqlTokens.join(", ") + ")";
 
   return {
     sql,

package/src/sqlFragmentFactories/createUuidSqlFragment.ts

@@ -1,7 +1,7 @@
-import { FragmentToken } from '../tokens.js';
-import type { SqlFragmentToken, UuidSqlToken } from '../types.js';
-import { formatSlonikPlaceholder } from '../utilities/formatSlonikPlaceholder.js';
-import { InvalidInputError } from '@slonik/errors';
+import { FragmentToken } from "../tokens.js";
+import type { SqlFragmentToken, UuidSqlToken } from "../types.js";
+import { formatSlonikPlaceholder } from "../utilities/formatSlonikPlaceholder.js";
+import { InvalidInputError } from "@slonik/errors";
 
 export type UUID = `${string}-${string}-${string}-${string}-${string}`;
 
@@ -17,11 +17,11 @@ export const createUuidSqlFragment = (
   greatestParameterPosition: number,
 ): SqlFragmentToken => {
   if (!isValidUuid(token.uuid)) {
-    throw new InvalidInputError('UUID parameter value must be a valid UUID.');
+    throw new InvalidInputError("UUID parameter value must be a valid UUID.");
   }
 
   return {
-    sql: formatSlonikPlaceholder(greatestParameterPosition + 1) + '::uuid',
+    sql: formatSlonikPlaceholder(greatestParameterPosition + 1) + "::uuid",
     type: FragmentToken,
     values: [token.uuid],
   };

package/src/tokens.ts

@@ -1,16 +1,14 @@
-export const ArrayToken = Symbol.for('SLONIK_TOKEN_ARRAY');
-export const BinaryToken = Symbol.for('SLONIK_TOKEN_BINARY');
-export const ComparisonPredicateToken = Symbol.for(
-  'SLONIK_TOKEN_COMPARISON_PREDICATE',
-);
-export const DateToken = Symbol.for('SLONIK_TOKEN_DATE');
-export const FragmentToken = Symbol.for('SLONIK_TOKEN_FRAGMENT');
-export const IdentifierToken = Symbol.for('SLONIK_TOKEN_IDENTIFIER');
-export const IntervalToken = Symbol.for('SLONIK_TOKEN_INTERVAL');
-export const JsonBinaryToken = Symbol.for('SLONIK_TOKEN_JSON_BINARY');
-export const JsonToken = Symbol.for('SLONIK_TOKEN_JSON');
-export const ListToken = Symbol.for('SLONIK_TOKEN_LIST');
-export const QueryToken = Symbol.for('SLONIK_TOKEN_QUERY');
-export const TimestampToken = Symbol.for('SLONIK_TOKEN_TIMESTAMP');
-export const UnnestToken = Symbol.for('SLONIK_TOKEN_UNNEST');
-export const UuidToken = Symbol.for('SLONIK_TOKEN_UUID');
+export const ArrayToken = Symbol.for("SLONIK_TOKEN_ARRAY");
+export const BinaryToken = Symbol.for("SLONIK_TOKEN_BINARY");
+export const ComparisonPredicateToken = Symbol.for("SLONIK_TOKEN_COMPARISON_PREDICATE");
+export const DateToken = Symbol.for("SLONIK_TOKEN_DATE");
+export const FragmentToken = Symbol.for("SLONIK_TOKEN_FRAGMENT");
+export const IdentifierToken = Symbol.for("SLONIK_TOKEN_IDENTIFIER");
+export const IntervalToken = Symbol.for("SLONIK_TOKEN_INTERVAL");
+export const JsonBinaryToken = Symbol.for("SLONIK_TOKEN_JSON_BINARY");
+export const JsonToken = Symbol.for("SLONIK_TOKEN_JSON");
+export const ListToken = Symbol.for("SLONIK_TOKEN_LIST");
+export const QueryToken = Symbol.for("SLONIK_TOKEN_QUERY");
+export const TimestampToken = Symbol.for("SLONIK_TOKEN_TIMESTAMP");
+export const UnnestToken = Symbol.for("SLONIK_TOKEN_UNNEST");
+export const UuidToken = Symbol.for("SLONIK_TOKEN_UUID");

package/src/types.ts

@@ -1,8 +1,8 @@
-import type * as tokens from './tokens.js';
-import type { PrimitiveValueExpression } from '@slonik/types';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type * as tokens from "./tokens.js";
+import type { PrimitiveValueExpression } from "@slonik/types";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 
-export { type PrimitiveValueExpression } from '@slonik/types';
+export { type PrimitiveValueExpression } from "@slonik/types";
 
 export type ArraySqlToken<T extends TypeNameIdentifier = TypeNameIdentifier> = {
   readonly memberType: SqlFragmentToken | T;
@@ -95,74 +95,55 @@ export type SqlFragmentToken = {
   readonly values: readonly PrimitiveValueExpression[];
 };
 
-export type SqlTag<
-  Z extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>,
-> = {
-  array: <T extends TypeNameIdentifier>(
-    values: readonly PrimitiveValueExpression[],
-    memberType: SqlFragmentToken | T,
-  ) => ArraySqlToken<T>;
-  binary: (data: Buffer) => BinarySqlToken;
-  date: (date: Date) => DateSqlToken;
-  fragment: (
-    template: TemplateStringsArray,
-    ...values: ValueExpression[]
-  ) => SqlFragmentToken;
-  identifier: (names: readonly string[]) => IdentifierSqlToken;
-  interval: (interval: IntervalInput) => IntervalSqlToken;
-  join: (
-    members: readonly ValueExpression[],
-    glue: SqlFragmentToken,
-  ) => ListSqlToken;
-  json: (value: SerializableValue) => JsonSqlToken;
-  jsonb: (value: SerializableValue) => JsonBinarySqlToken;
-  literalValue: (value: string) => SqlFragmentToken;
-  /**
-   * Creates a named prepared statement. The statement name is used by PostgreSQL
-   * to cache the query plan, which can improve performance for frequently executed queries.
-   * @example
-   * ```ts
-   * const query = sql.prepared('get_user_by_id', z.object({ id: z.number(), name: z.string() }))`
-   *   SELECT id, name FROM users WHERE id = ${userId}
-   * `;
-   * ```
-   */
-  prepared: <Y extends StandardSchemaV1>(
-    statementName: string,
-    parser: Y,
-  ) => (
-    template: TemplateStringsArray,
-    ...values: ValueExpression[]
-  ) => QuerySqlToken<Y>;
-  timestamp: (date: Date) => TimestampSqlToken;
-  type: <Y extends StandardSchemaV1>(
-    parser: Y,
-  ) => (
-    template: TemplateStringsArray,
-    ...values: ValueExpression[]
-  ) => QuerySqlToken<Y>;
-  typeAlias: <K extends keyof Z>(
-    typeAlias: K,
-  ) => (
-    template: TemplateStringsArray,
-    ...values: ValueExpression[]
-  ) => QuerySqlToken<Z[K]>;
-  unnest: (
-    // Value might be ReadonlyArray<ReadonlyArray<PrimitiveValueExpression>>,
-    // or it can be infinitely nested array, e.g.
-    // https://github.com/gajus/slonik/issues/44
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    tuples: ReadonlyArray<readonly any[]>,
-    columnTypes:
-      | Array<[...string[], TypeNameIdentifier]>
-      | Array<SqlFragmentToken | TypeNameIdentifier>,
-  ) => UnnestSqlToken;
-  unsafe: (
-    template: TemplateStringsArray,
-    ...values: ValueExpression[]
-  ) => QuerySqlToken;
-  uuid: (uuid: string) => UuidSqlToken;
-};
+export type SqlTag<Z extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>> =
+  {
+    array: <T extends TypeNameIdentifier>(
+      values: readonly PrimitiveValueExpression[],
+      memberType: SqlFragmentToken | T,
+    ) => ArraySqlToken<T>;
+    binary: (data: Buffer) => BinarySqlToken;
+    date: (date: Date) => DateSqlToken;
+    fragment: (template: TemplateStringsArray, ...values: ValueExpression[]) => SqlFragmentToken;
+    identifier: (names: readonly string[]) => IdentifierSqlToken;
+    interval: (interval: IntervalInput) => IntervalSqlToken;
+    join: (members: readonly ValueExpression[], glue: SqlFragmentToken) => ListSqlToken;
+    json: (value: SerializableValue) => JsonSqlToken;
+    jsonb: (value: SerializableValue) => JsonBinarySqlToken;
+    literalValue: (value: string) => SqlFragmentToken;
+    /**
+     * Creates a named prepared statement. The statement name is used by PostgreSQL
+     * to cache the query plan, which can improve performance for frequently executed queries.
+     * @example
+     * ```ts
+     * const query = sql.prepared('get_user_by_id', z.object({ id: z.number(), name: z.string() }))`
+     *   SELECT id, name FROM users WHERE id = ${userId}
+     * `;
+     * ```
+     */
+    prepared: <Y extends StandardSchemaV1>(
+      statementName: string,
+      parser: Y,
+    ) => (template: TemplateStringsArray, ...values: ValueExpression[]) => QuerySqlToken<Y>;
+    timestamp: (date: Date) => TimestampSqlToken;
+    type: <Y extends StandardSchemaV1>(
+      parser: Y,
+    ) => (template: TemplateStringsArray, ...values: ValueExpression[]) => QuerySqlToken<Y>;
+    typeAlias: <K extends keyof Z>(
+      typeAlias: K,
+    ) => (template: TemplateStringsArray, ...values: ValueExpression[]) => QuerySqlToken<Z[K]>;
+    unnest: (
+      // Value might be ReadonlyArray<ReadonlyArray<PrimitiveValueExpression>>,
+      // or it can be infinitely nested array, e.g.
+      // https://github.com/gajus/slonik/issues/44
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      tuples: ReadonlyArray<readonly any[]>,
+      columnTypes:
+        | Array<[...string[], TypeNameIdentifier]>
+        | Array<SqlFragmentToken | TypeNameIdentifier>,
+    ) => UnnestSqlToken;
+    unsafe: (template: TemplateStringsArray, ...values: ValueExpression[]) => QuerySqlToken;
+    uuid: (uuid: string) => UuidSqlToken;
+  };
 
 export type SqlToken =
   | ArraySqlToken<TypeNameIdentifier>
@@ -189,17 +170,17 @@ export type TimestampSqlToken = {
  * experience with auto suggestions for commonly used type name identifiers.
  */
 export type TypeNameIdentifier =
-  | 'bool'
-  | 'bytea'
-  | 'float4'
-  | 'float8'
-  | 'int2'
-  | 'int4'
-  | 'int8'
-  | 'json'
-  | 'text'
-  | 'timestamptz'
-  | 'uuid'
+  | "bool"
+  | "bytea"
+  | "float4"
+  | "float8"
+  | "int2"
+  | "int4"
+  | "int8"
+  | "json"
+  | "text"
+  | "timestamptz"
+  | "uuid"
   | string;
 
 export type UnnestSqlToken = {
@@ -215,7 +196,4 @@ export type UuidSqlToken = {
   readonly uuid: `${string}-${string}-${string}-${string}-${string}`;
 };
 
-export type ValueExpression =
-  | PrimitiveValueExpression
-  | SqlFragmentToken
-  | SqlToken;
+export type ValueExpression = PrimitiveValueExpression | SqlFragmentToken | SqlToken;

package/src/utilities/countArrayDimensions.test.ts

@@ -1,8 +1,8 @@
-import { countArrayDimensions } from './countArrayDimensions.js';
-import test from 'ava';
+import { countArrayDimensions } from "./countArrayDimensions.js";
+import test from "ava";
 
-test('returns the number of array dimensions', (t) => {
-  t.is(countArrayDimensions('foo'), 0);
-  t.is(countArrayDimensions('foo[]'), 1);
-  t.is(countArrayDimensions('foo[][]'), 2);
+test("returns the number of array dimensions", (t) => {
+  t.is(countArrayDimensions("foo"), 0);
+  t.is(countArrayDimensions("foo[]"), 1);
+  t.is(countArrayDimensions("foo[][]"), 2);
 });

package/src/utilities/countArrayDimensions.ts

@@ -2,7 +2,7 @@ export const countArrayDimensions = (identifierName: string): number => {
   let tail = identifierName.trim();
   let arrayDimensionCount = 0;
 
-  while (tail.endsWith('[]')) {
+  while (tail.endsWith("[]")) {
     arrayDimensionCount++;
 
     tail = tail.trim().slice(0, -2);

package/src/utilities/escapeIdentifier.test.ts

@@ -1,8 +1,8 @@
-import { escapeIdentifier } from './escapeIdentifier.js';
-import test from 'ava';
+import { escapeIdentifier } from "./escapeIdentifier.js";
+import test from "ava";
 
-test('escapes SQL identifiers', (t) => {
-  t.is(escapeIdentifier('foo'), '"foo"');
-  t.is(escapeIdentifier('foo bar'), '"foo bar"');
+test("escapes SQL identifiers", (t) => {
+  t.is(escapeIdentifier("foo"), '"foo"');
+  t.is(escapeIdentifier("foo bar"), '"foo bar"');
   t.is(escapeIdentifier('"foo"'), '"""foo"""');
 });

package/src/utilities/escapeLiteralValue.test.ts

@@ -1,9 +1,9 @@
-import { escapeLiteralValue } from './escapeLiteralValue.js';
-import test from 'ava';
+import { escapeLiteralValue } from "./escapeLiteralValue.js";
+import test from "ava";
 
-test('escapes SQL literal value', (t) => {
-  t.is(escapeLiteralValue('foo'), "'foo'");
-  t.is(escapeLiteralValue('foo bar'), "'foo bar'");
-  t.is(escapeLiteralValue('"foo"'), '\'"foo"\'');
-  t.is(escapeLiteralValue('foo\\bar'), "E'foo\\\\bar'");
+test("escapes SQL literal value", (t) => {
+  t.is(escapeLiteralValue("foo"), "'foo'");
+  t.is(escapeLiteralValue("foo bar"), "'foo bar'");
+  t.is(escapeLiteralValue('"foo"'), "'\"foo\"'");
+  t.is(escapeLiteralValue("foo\\bar"), "E'foo\\\\bar'");
 });

package/src/utilities/escapeLiteralValue.ts

@@ -8,7 +8,7 @@ export const escapeLiteralValue = (subject: string): string => {
   for (const character of subject) {
     if (character === "'") {
       escaped += character + character;
-    } else if (character === '\\') {
+    } else if (character === "\\") {
       escaped += character + character;
       hasBackslash = true;
     } else {
@@ -19,7 +19,7 @@ export const escapeLiteralValue = (subject: string): string => {
   escaped += "'";
 
   if (hasBackslash === true) {
-    escaped = 'E' + escaped;
+    escaped = "E" + escaped;
   }
 
   return escaped;

package/src/utilities/formatSlonikPlaceholder.ts

@@ -11,5 +11,5 @@
  * This way, we can safely detect placeholders that are part of a nested fragment.
  */
 export const formatSlonikPlaceholder = (index: number) => {
-  return '$slonik_' + String(index);
+  return "$slonik_" + String(index);
 };

package/src/utilities/isPlainObject.ts

@@ -1,5 +1,5 @@
 export const isPlainObject = (subject: unknown) => {
-  if (typeof subject !== 'object' || subject === null) {
+  if (typeof subject !== "object" || subject === null) {
     return false;
   }
 

package/src/utilities/isPrimitiveValueExpression.ts

@@ -2,10 +2,10 @@ export const isPrimitiveValueExpression = (
   maybe: unknown,
 ): maybe is bigint | boolean | null | number | string => {
   return (
-    typeof maybe === 'string' ||
-    typeof maybe === 'number' ||
-    typeof maybe === 'boolean' ||
-    typeof maybe === 'bigint' ||
+    typeof maybe === "string" ||
+    typeof maybe === "number" ||
+    typeof maybe === "boolean" ||
+    typeof maybe === "bigint" ||
     maybe === null
   );
 };

package/src/utilities/isSqlToken.ts

@@ -13,10 +13,10 @@ import {
   TimestampToken,
   UnnestToken,
   UuidToken,
-} from '../tokens.js';
-import type { SqlToken as SqlTokenType } from '../types.js';
-import { hasOwnProperty } from './hasOwnProperty.js';
-import { UnexpectedStateError } from '@slonik/errors';
+} from "../tokens.js";
+import type { SqlToken as SqlTokenType } from "../types.js";
+import { hasOwnProperty } from "./hasOwnProperty.js";
+import { UnexpectedStateError } from "@slonik/errors";
 
 const Tokens = [
   ArrayToken,
@@ -39,10 +39,8 @@ const tokenNames = new Set(
   Tokens.map((token) => {
     const tokenTypeName = Symbol.keyFor(token);
 
-    if (typeof tokenTypeName !== 'string') {
-      throw new UnexpectedStateError(
-        'Expected token type be a symbol with inferrable key',
-      );
+    if (typeof tokenTypeName !== "string") {
+      throw new UnexpectedStateError("Expected token type be a symbol with inferrable key");
     }
 
     return tokenTypeName;
@@ -50,23 +48,23 @@ const tokenNames = new Set(
 );
 
 export const isSqlToken = (subject: unknown): subject is SqlTokenType => {
-  if (typeof subject !== 'object' || subject === null) {
+  if (typeof subject !== "object" || subject === null) {
     return false;
   }
 
-  if (!hasOwnProperty(subject, 'type')) {
+  if (!hasOwnProperty(subject, "type")) {
     return false;
   }
 
   const tokenType = subject.type;
 
-  if (typeof tokenType !== 'symbol') {
+  if (typeof tokenType !== "symbol") {
     return false;
   }
 
   const tokenTypeName = Symbol.keyFor(tokenType);
 
-  if (typeof tokenTypeName !== 'string') {
+  if (typeof tokenTypeName !== "string") {
     return false;
   }
 

package/src/utilities/safeStringify.ts

@@ -1,8 +1,8 @@
-import { configure } from 'safe-stable-stringify';
+import { configure } from "safe-stable-stringify";
 
 const stringify = configure({
   bigint: true,
-  circularValue: '[Circular]',
+  circularValue: "[Circular]",
   strict: true,
 });
 
@@ -16,7 +16,7 @@ export const safeStringify = (subject: unknown): string => {
   const result = stringify(subject);
 
   if (result === undefined) {
-    throw new Error('Expected result to be string');
+    throw new Error("Expected result to be string");
   }
 
   return result;

package/src/utilities/stripArrayNotation.test.ts

@@ -1,8 +1,8 @@
-import { stripArrayNotation } from './stripArrayNotation.js';
-import test from 'ava';
+import { stripArrayNotation } from "./stripArrayNotation.js";
+import test from "ava";
 
-test('strips array notation', (t) => {
-  t.is(stripArrayNotation('foo'), 'foo');
-  t.is(stripArrayNotation('foo[]'), 'foo');
-  t.is(stripArrayNotation('foo[][]'), 'foo');
+test("strips array notation", (t) => {
+  t.is(stripArrayNotation("foo"), "foo");
+  t.is(stripArrayNotation("foo[]"), "foo");
+  t.is(stripArrayNotation("foo[][]"), "foo");
 });

package/src/utilities/stripArrayNotation.ts

@@ -1,7 +1,7 @@
 export const stripArrayNotation = (identifierName: string): string => {
   let tail = identifierName.trim();
 
-  while (tail.endsWith('[]')) {
+  while (tail.endsWith("[]")) {
     tail = tail.trim().slice(0, -2);
   }