@slonik/sql-tag 40.2.2

package/dist/utilities/hasOwnProperty.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A stricter type guard.
+ * @see https://tsplay.dev/WK8zGw
+ */
+export declare const hasOwnProperty: <X extends {}, Y extends PropertyKey>(object: X, property: Y) => object is Record<Y, unknown> & X;
+//# sourceMappingURL=hasOwnProperty.d.ts.map

package/dist/utilities/hasOwnProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasOwnProperty.d.ts","sourceRoot":"","sources":["../../src/utilities/hasOwnProperty.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,cAAc,gDACjB,CAAC,YACC,CAAC,qCAGZ,CAAC"}

package/dist/utilities/hasOwnProperty.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasOwnProperty = void 0;
+/**
+ * A stricter type guard.
+ * @see https://tsplay.dev/WK8zGw
+ */
+const hasOwnProperty = (object, property) => {
+    return Object.prototype.hasOwnProperty.call(object, property);
+};
+exports.hasOwnProperty = hasOwnProperty;
+//# sourceMappingURL=hasOwnProperty.js.map

package/dist/utilities/hasOwnProperty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasOwnProperty.js","sourceRoot":"","sources":["../../src/utilities/hasOwnProperty.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACI,MAAM,cAAc,GAAG,CAC5B,MAAS,EACT,QAAW,EACuB,EAAE;IACpC,OAAO,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AAChE,CAAC,CAAC;AALW,QAAA,cAAc,kBAKzB"}

package/dist/utilities/isPlainObject.d.ts

@@ -0,0 +1,2 @@
+export declare const isPlainObject: (subject: unknown) => boolean;
+//# sourceMappingURL=isPlainObject.d.ts.map

package/dist/utilities/isPlainObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPlainObject.d.ts","sourceRoot":"","sources":["../../src/utilities/isPlainObject.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,YAAa,OAAO,YAa7C,CAAC"}

package/dist/utilities/isPlainObject.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainObject = void 0;
+const isPlainObject = (subject) => {
+    if (typeof subject !== 'object' || subject === null) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(subject);
+    return ((prototype === null ||
+        prototype === Object.prototype ||
+        Object.getPrototypeOf(prototype) === null) &&
+        !(Symbol.toStringTag in subject) &&
+        !(Symbol.iterator in subject));
+};
+exports.isPlainObject = isPlainObject;
+//# sourceMappingURL=isPlainObject.js.map

package/dist/utilities/isPlainObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPlainObject.js","sourceRoot":"","sources":["../../src/utilities/isPlainObject.ts"],"names":[],"mappings":";;;AAAO,MAAM,aAAa,GAAG,CAAC,OAAgB,EAAE,EAAE;IAChD,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACpD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IACjD,OAAO,CACL,CAAC,SAAS,KAAK,IAAI;QACjB,SAAS,KAAK,MAAM,CAAC,SAAS;QAC9B,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,KAAK,IAAI,CAAC;QAC5C,CAAC,CAAC,MAAM,CAAC,WAAW,IAAI,OAAO,CAAC;QAChC,CAAC,CAAC,MAAM,CAAC,QAAQ,IAAI,OAAO,CAAC,CAC9B,CAAC;AACJ,CAAC,CAAC;AAbW,QAAA,aAAa,iBAaxB"}

package/dist/utilities/isPrimitiveValueExpression.d.ts

@@ -0,0 +1,2 @@
+export declare const isPrimitiveValueExpression: (maybe: unknown) => maybe is string | number | bigint | boolean | null;
+//# sourceMappingURL=isPrimitiveValueExpression.d.ts.map

package/dist/utilities/isPrimitiveValueExpression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPrimitiveValueExpression.d.ts","sourceRoot":"","sources":["../../src/utilities/isPrimitiveValueExpression.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B,UAC9B,OAAO,uDASf,CAAC"}

package/dist/utilities/isPrimitiveValueExpression.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPrimitiveValueExpression = void 0;
+const isPrimitiveValueExpression = (maybe) => {
+    return (typeof maybe === 'string' ||
+        typeof maybe === 'number' ||
+        typeof maybe === 'boolean' ||
+        typeof maybe === 'bigint' ||
+        maybe === null);
+};
+exports.isPrimitiveValueExpression = isPrimitiveValueExpression;
+//# sourceMappingURL=isPrimitiveValueExpression.js.map

package/dist/utilities/isPrimitiveValueExpression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPrimitiveValueExpression.js","sourceRoot":"","sources":["../../src/utilities/isPrimitiveValueExpression.ts"],"names":[],"mappings":";;;AAAO,MAAM,0BAA0B,GAAG,CACxC,KAAc,EACsC,EAAE;IACtD,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,OAAO,KAAK,KAAK,QAAQ;QACzB,OAAO,KAAK,KAAK,SAAS;QAC1B,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI,CACf,CAAC;AACJ,CAAC,CAAC;AAVW,QAAA,0BAA0B,8BAUrC"}

package/dist/utilities/isSqlToken.d.ts

@@ -0,0 +1,3 @@
+import { type SqlToken as SqlTokenType } from '../types';
+export declare const isSqlToken: (subject: unknown) => subject is SqlTokenType;
+//# sourceMappingURL=isSqlToken.d.ts.map

package/dist/utilities/isSqlToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSqlToken.d.ts","sourceRoot":"","sources":["../../src/utilities/isSqlToken.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,QAAQ,IAAI,YAAY,EAAE,MAAM,UAAU,CAAC;AAoBzD,eAAO,MAAM,UAAU,YAAa,OAAO,4BAgB1C,CAAC"}

package/dist/utilities/isSqlToken.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSqlToken = void 0;
+const tokens_1 = require("../tokens");
+const hasOwnProperty_1 = require("./hasOwnProperty");
+const errors_1 = require("@slonik/errors");
+const Tokens = [
+    tokens_1.ArrayToken,
+    tokens_1.BinaryToken,
+    tokens_1.ComparisonPredicateToken,
+    tokens_1.DateToken,
+    tokens_1.FragmentToken,
+    tokens_1.IdentifierToken,
+    tokens_1.IntervalToken,
+    tokens_1.JsonBinaryToken,
+    tokens_1.JsonToken,
+    tokens_1.ListToken,
+    tokens_1.QueryToken,
+    tokens_1.TimestampToken,
+    tokens_1.UnnestToken,
+];
+const isSqlToken = (subject) => {
+    if (typeof subject !== 'object' || subject === null) {
+        return false;
+    }
+    if (!(0, hasOwnProperty_1.hasOwnProperty)(subject, 'type')) {
+        throw new errors_1.UnexpectedStateError('Expected token to include "type" property.');
+    }
+    if (typeof subject.type !== 'string') {
+        throw new errors_1.UnexpectedStateError('Expected type to be string.');
+    }
+    return Tokens.includes(subject.type);
+};
+exports.isSqlToken = isSqlToken;
+//# sourceMappingURL=isSqlToken.js.map

package/dist/utilities/isSqlToken.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSqlToken.js","sourceRoot":"","sources":["../../src/utilities/isSqlToken.ts"],"names":[],"mappings":";;;AAAA,sCAcmB;AAEnB,qDAAkD;AAClD,2CAAsD;AAEtD,MAAM,MAAM,GAAG;IACb,mBAAU;IACV,oBAAW;IACX,iCAAwB;IACxB,kBAAS;IACT,sBAAa;IACb,wBAAe;IACf,sBAAa;IACb,wBAAe;IACf,kBAAS;IACT,kBAAS;IACT,mBAAU;IACV,uBAAc;IACd,oBAAW;CACH,CAAC;AAEJ,MAAM,UAAU,GAAG,CAAC,OAAgB,EAA2B,EAAE;IACtE,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACpD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IAAI,CAAC,IAAA,+BAAc,EAAC,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC;QACrC,MAAM,IAAI,6BAAoB,CAC5B,4CAA4C,CAC7C,CAAC;IACJ,CAAC;IAED,IAAI,OAAO,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QACrC,MAAM,IAAI,6BAAoB,CAAC,6BAA6B,CAAC,CAAC;IAChE,CAAC;IAED,OAAQ,MAA4B,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAC9D,CAAC,CAAC;AAhBW,QAAA,UAAU,cAgBrB"}

package/dist/utilities/safeStringify.d.ts

@@ -0,0 +1,2 @@
+export declare const safeStringify: (subject: unknown, replacer?: Array<number | string> | ((key: string, value: unknown) => unknown) | null | undefined, space?: number | string) => string;
+//# sourceMappingURL=safeStringify.d.ts.map

package/dist/utilities/safeStringify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeStringify.d.ts","sourceRoot":"","sources":["../../src/utilities/safeStringify.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,aAAa,YACf,OAAO,aAEZ,MAAM,MAAM,GAAG,MAAM,CAAC,GACtB,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,GAC1C,IAAI,GACJ,SAAS,UACL,MAAM,GAAG,MAAM,KACtB,MAQF,CAAC"}

package/dist/utilities/safeStringify.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeStringify = void 0;
+const safe_stable_stringify_1 = require("safe-stable-stringify");
+const stringify = (0, safe_stable_stringify_1.configure)({
+    bigint: true,
+    circularValue: '[Circular]',
+    strict: true,
+});
+const safeStringify = (subject, replacer, space) => {
+    const result = stringify(subject, replacer, space);
+    if (result === undefined) {
+        throw new Error('Expected result to be string');
+    }
+    return result;
+};
+exports.safeStringify = safeStringify;
+//# sourceMappingURL=safeStringify.js.map

package/dist/utilities/safeStringify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeStringify.js","sourceRoot":"","sources":["../../src/utilities/safeStringify.ts"],"names":[],"mappings":";;;AAAA,iEAAkD;AAElD,MAAM,SAAS,GAAG,IAAA,iCAAS,EAAC;IAC1B,MAAM,EAAE,IAAI;IACZ,aAAa,EAAE,YAAY;IAC3B,MAAM,EAAE,IAAI;CACb,CAAC,CAAC;AAEI,MAAM,aAAa,GAAG,CAC3B,OAAgB,EAChB,QAIa,EACb,KAAuB,EACf,EAAE;IACV,MAAM,MAAM,GAAG,SAAS,CAAC,OAAO,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;IAEnD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;IAClD,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAhBW,QAAA,aAAa,iBAgBxB"}

package/dist/utilities/stripArrayNotation.d.ts

@@ -0,0 +1,2 @@
+export declare const stripArrayNotation: (identifierName: string) => string;
+//# sourceMappingURL=stripArrayNotation.d.ts.map

package/dist/utilities/stripArrayNotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripArrayNotation.d.ts","sourceRoot":"","sources":["../../src/utilities/stripArrayNotation.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,mBAAoB,MAAM,KAAG,MAQ3D,CAAC"}

package/dist/utilities/stripArrayNotation.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripArrayNotation = void 0;
+const stripArrayNotation = (identifierName) => {
+    let tail = identifierName.trim();
+    while (tail.endsWith('[]')) {
+        tail = tail.trim().slice(0, -2);
+    }
+    return tail;
+};
+exports.stripArrayNotation = stripArrayNotation;
+//# sourceMappingURL=stripArrayNotation.js.map

package/dist/utilities/stripArrayNotation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripArrayNotation.js","sourceRoot":"","sources":["../../src/utilities/stripArrayNotation.ts"],"names":[],"mappings":";;;AAAO,MAAM,kBAAkB,GAAG,CAAC,cAAsB,EAAU,EAAE;IACnE,IAAI,IAAI,GAAG,cAAc,CAAC,IAAI,EAAE,CAAC;IAEjC,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3B,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAClC,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AARW,QAAA,kBAAkB,sBAQ7B"}

package/dist/utilities/stripArrayNotation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stripArrayNotation.test.d.ts.map

package/dist/utilities/stripArrayNotation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripArrayNotation.test.d.ts","sourceRoot":"","sources":["../../src/utilities/stripArrayNotation.test.ts"],"names":[],"mappings":""}

package/dist/utilities/stripArrayNotation.test.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const stripArrayNotation_1 = require("./stripArrayNotation");
+const ava_1 = __importDefault(require("ava"));
+(0, ava_1.default)('strips array notation', (t) => {
+    t.is((0, stripArrayNotation_1.stripArrayNotation)('foo'), 'foo');
+    t.is((0, stripArrayNotation_1.stripArrayNotation)('foo[]'), 'foo');
+    t.is((0, stripArrayNotation_1.stripArrayNotation)('foo[][]'), 'foo');
+});
+//# sourceMappingURL=stripArrayNotation.test.js.map

package/dist/utilities/stripArrayNotation.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripArrayNotation.test.js","sourceRoot":"","sources":["../../src/utilities/stripArrayNotation.test.ts"],"names":[],"mappings":";;;;;AAAA,6DAA0D;AAC1D,8CAAuB;AAEvB,IAAA,aAAI,EAAC,uBAAuB,EAAE,CAAC,CAAC,EAAE,EAAE;IAClC,CAAC,CAAC,EAAE,CAAC,IAAA,uCAAkB,EAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;IACvC,CAAC,CAAC,EAAE,CAAC,IAAA,uCAAkB,EAAC,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC;IACzC,CAAC,CAAC,EAAE,CAAC,IAAA,uCAAkB,EAAC,SAAS,CAAC,EAAE,KAAK,CAAC,CAAC;AAC7C,CAAC,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,88 @@
+{
+  "author": {
+    "email": "gajus@gajus.com",
+    "name": "Gajus Kuizinas",
+    "url": "http://gajus.com"
+  },
+  "ava": {
+    "extensions": [
+      "ts"
+    ],
+    "files": [
+      "src/**/*.test.ts"
+    ],
+    "require": [
+      "ts-node/register/transpile-only"
+    ]
+  },
+  "dependencies": {
+    "@slonik/errors": "^40.2.2",
+    "roarr": "^7.21.1",
+    "safe-stable-stringify": "^2.4.3",
+    "serialize-error": "^8.0.0"
+  },
+  "description": "A Node.js PostgreSQL client with strict types, detailed logging and assertions.",
+  "devDependencies": {
+    "@types/node": "^18.15.3",
+    "ava": "^5.3.1",
+    "cspell": "^8.6.0",
+    "eslint": "^8.57.0",
+    "eslint-config-canonical": "^42.8.1",
+    "nyc": "^15.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.4.3",
+    "zod": "^3.22.4"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "./src",
+    "./dist"
+  ],
+  "keywords": [
+    "postgresql",
+    "promise",
+    "types"
+  ],
+  "license": "BSD-3-Clause",
+  "main": "./dist/index.js",
+  "name": "@slonik/sql-tag",
+  "nyc": {
+    "all": true,
+    "exclude": [
+      "src/bin",
+      "src/queries/*.ts",
+      "**/*.d.ts"
+    ],
+    "include": [
+      "src/**/*.ts"
+    ],
+    "reporter": [
+      "html",
+      "text-summary"
+    ],
+    "require": [
+      "ts-node/register/transpile-only"
+    ],
+    "silent": true,
+    "sourceMap": false
+  },
+  "peerDependencies": {
+    "zod": "^3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gajus/slonik"
+  },
+  "scripts": {
+    "build": "rm -fr ./dist && tsc --project ./tsconfig.json",
+    "lint": "npm run lint:cspell && npm run lint:eslint && npm run lint:tsc",
+    "lint:cspell": "cspell . --no-progress --gitignore",
+    "lint:eslint": "eslint --cache ./src",
+    "lint:tsc": "tsc --noEmit",
+    "test": "nyc ava --verbose --serial"
+  },
+  "types": "./dist/index.d.ts",
+  "version": "40.2.2"
+}

package/src/Logger.ts

@@ -0,0 +1,5 @@
+import { Roarr } from 'roarr';
+
+export const Logger = Roarr.child({
+  package: 'slonik',
+});

package/src/declarations.d.ts

@@ -0,0 +1,8 @@
+declare module 'pg-cursor';
+declare module 'pg/lib/type-overrides' {
+  const TypeOverrides: new () => {
+    setTypeParser: (type: string, parser: (value: string) => unknown) => void;
+  };
+
+  export default TypeOverrides;
+}

package/src/factories/createPrimitiveValueExpressions.ts

@@ -0,0 +1,43 @@
+import { Logger } from '../Logger';
+import { type PrimitiveValueExpression } from '../types';
+import { safeStringify } from '../utilities/safeStringify';
+import { UnexpectedStateError } from '@slonik/errors';
+
+const log = Logger.child({
+  namespace: 'createPrimitiveValueExpressions',
+});
+
+export const createPrimitiveValueExpressions = (
+  values: readonly unknown[],
+): readonly PrimitiveValueExpression[] => {
+  const primitiveValueExpressions: Array<
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    any[] | Buffer | boolean | number | string | bigint | null
+  > = [];
+
+  for (const value of values) {
+    if (
+      Array.isArray(value) ||
+      Buffer.isBuffer(value) ||
+      typeof value === 'string' ||
+      typeof value === 'number' ||
+      typeof value === 'boolean' ||
+      typeof value === 'bigint' ||
+      value === null
+    ) {
+      primitiveValueExpressions.push(value);
+    } else {
+      log.warn(
+        {
+          value: JSON.parse(safeStringify(value)),
+          values: JSON.parse(safeStringify(values)),
+        },
+        'unexpected value expression',
+      );
+
+      throw new UnexpectedStateError('Unexpected value expression.');
+    }
+  }
+
+  return primitiveValueExpressions;
+};

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

@@ -0,0 +1,107 @@
+import { FragmentToken } from '../../tokens';
+import { createSqlTag } from '../createSqlTag';
+import test from 'ava';
+
+const sql = createSqlTag();
+
+test('binds an empty array', (t) => {
+  const query = sql.fragment`SELECT ${sql.array([], 'int4')}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::"int4"[]',
+    type: FragmentToken,
+    values: [[]],
+  });
+});
+
+test('binds bigint', (t) => {
+  const query = sql.fragment`SELECT ${sql.array(
+    // eslint-disable-next-line unicorn/numeric-separators-style
+    [9007199254740999n],
+    'int8',
+  )}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::"int8"[]',
+    type: FragmentToken,
+    // eslint-disable-next-line unicorn/numeric-separators-style
+    values: [[BigInt(9007199254740999n)]],
+  });
+});
+
+test('binds an array with multiple values', (t) => {
+  const query = sql.fragment`SELECT ${sql.array([1, 2, 3], 'int4')}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::"int4"[]',
+    type: FragmentToken,
+    values: [[1, 2, 3]],
+  });
+});
+
+test('binds an array with bytea values', (t) => {
+  const query = sql.fragment`SELECT ${sql.array(
+    [Buffer.from('foo')],
+    'bytea',
+  )}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::"bytea"[]',
+    type: FragmentToken,
+    values: [[Buffer.from('foo')]],
+  });
+});
+
+test('offsets positional parameter indexes', (t) => {
+  const query = sql.fragment`SELECT ${1}, ${sql.array(
+    [1, 2, 3],
+    'int4',
+  )}, ${3}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1, $slonik_2::"int4"[], $slonik_3',
+    type: FragmentToken,
+    values: [1, [1, 2, 3], 3],
+  });
+});
+
+test('binds a SQL token', (t) => {
+  const query = sql.fragment`SELECT ${sql.array(
+    [1, 2, 3],
+    sql.fragment`int[]`,
+  )}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1::int[]',
+    type: FragmentToken,
+    values: [[1, 2, 3]],
+  });
+});
+
+test('throws if array member is not a primitive value expression', (t) => {
+  const error = t.throws(() => {
+    sql.fragment`SELECT ${sql.array(
+      [
+        // @ts-expect-error - intentional
+        () => {},
+      ],
+      'int',
+    )}`;
+  });
+
+  t.is(
+    error?.message,
+    'Invalid array member type. Must be a primitive value expression.',
+  );
+});
+
+test('throws if memberType is not a string or SqlToken of different type than "SLONIK_TOKEN_FRAGMENT"', (t) => {
+  const error = t.throws(() => {
+    sql.fragment`SELECT ${sql.array([1, 2, 3], sql.identifier(['int']))}`;
+  });
+
+  t.is(
+    error?.message,
+    'Unsupported `memberType`. `memberType` must be a string or SqlToken of "SLONIK_TOKEN_FRAGMENT" type.',
+  );
+});

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

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

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

@@ -0,0 +1,39 @@
+import { FragmentToken } from '../../tokens';
+import { createSqlTag } from '../createSqlTag';
+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'])}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1 FROM "bar"',
+    type: FragmentToken,
+    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',
+  ])}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT $slonik_1 FROM "bar"."baz"',
+    type: FragmentToken,
+    values: ['foo'],
+  });
+});
+
+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
+      () => {},
+    ])}`;
+  });
+
+  t.is(error?.message, 'Identifier name array member type must be a string.');
+});

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

@@ -0,0 +1,44 @@
+import { FragmentToken } from '../../tokens';
+import { createSqlTag } from '../createSqlTag';
+import test from 'ava';
+
+const sql = createSqlTag();
+
+test('creates an empty make_interval invocation', (t) => {
+  const query = sql.fragment`SELECT ${sql.interval({})}`;
+
+  t.deepEqual(query, {
+    sql: 'SELECT make_interval()',
+    type: FragmentToken,
+    values: [],
+  });
+});
+
+test('creates an interval', (t) => {
+  const query = sql.fragment`SELECT ${sql.interval({
+    days: 4,
+    hours: 5,
+    minutes: 6,
+    months: 2,
+    seconds: 7,
+    weeks: 3,
+    years: 1,
+  })}`;
+
+  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)',
+    type: FragmentToken,
+    values: [1, 2, 3, 4, 5, 6, 7],
+  });
+});
+
+test('throws if contains unknown properties', (t) => {
+  const error = t.throws(() => {
+    sql.fragment`SELECT ${sql.interval({
+      // @ts-expect-error - intentional
+      foo: 'bar',
+    })}`;
+  });
+
+  t.is(error?.message, 'Interval input must not contain unknown properties.');
+});