feat: Add Snowflake adapter

.changeset/grumpy-games-care.md

@@ -0,0 +1,5 @@
+---
+"@sejohnson/tql": minor
+---
+
+feat: Snowflake adapter v0

.changeset/pre.json

@@ -0,0 +1,11 @@
+{
+  "mode": "exit",
+  "tag": "next",
+  "initialVersions": {
+    "@sejohnson/tql": "2.0.0"
+  },
+  "changesets": [
+    "grumpy-games-care",
+    "rotten-grapes-battle"
+  ]
+}

.changeset/rotten-grapes-battle.md

@@ -0,0 +1,5 @@
+---
+"@sejohnson/tql": patch
+---
+
+fix: Export the API

packages/tql-template/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @sejohnson/tql
 
+## 2.1.0-next.1
+
+### Patch Changes
+
+- 5de1a42: fix: Export the API
+
+## 2.1.0-next.0
+
+### Minor Changes
+
+- dca2627: feat: Snowflake adapter v0
+
 ## 2.0.0
 
 ### Major Changes

packages/tql-template/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sejohnson/tql",
-	"version": "2.0.0",
+	"version": "2.1.0-next.1",
 	"description": "A flexible, multi-dialect tagged template SQL query builder.",
 	"repository": {
 		"directory": "./packages/tql-template",

packages/tql-template/src/dialects/postgres.spec.ts

@@ -72,7 +72,7 @@ describe('tql dialect: Postgres', () => {
 				input: 'with.injection" FROM users; SELECT * FROM privileged_information;--',
 				output: '"with"."injection"" FROM users; SELECT * FROM privileged_information;--"',
 			},
-		])('escapes identifiers', ({ input, output }) => {
+		])('escapes single identifiers', ({ input, output }) => {
 			const dialect = d();
 			dialect.identifiers(new TqlIdentifiers(input));
 			expect(queryBuilder.params).toEqual([]);
@@ -97,7 +97,7 @@ describe('tql dialect: Postgres', () => {
 				input: ['with.injection" FROM users; SELECT * FROM privileged_information;--', 'blah'],
 				output: '"with"."injection"" FROM users; SELECT * FROM privileged_information;--", "blah"',
 			},
-		])('escapes identifiers', ({ input, output }) => {
+		])('escapes multiple identifiers', ({ input, output }) => {
 			const dialect = d();
 			dialect.identifiers(new TqlIdentifiers(input));
 			expect(queryBuilder.params).toEqual([]);

packages/tql-template/src/dialects/snowflake.spec.ts

@@ -0,0 +1,286 @@
+import { it, describe, expect, beforeEach, vi } from 'vitest';
+import { SnowflakeDialect } from './snowflake.js';
+import { TqlTemplateString, TqlParameter, TqlIdentifiers, TqlList, TqlValues, TqlSet } from '../nodes.js';
+import { createQueryBuilder } from '../utils.js';
+import { TqlError } from '../error.js';
+
+describe('tql dialect: Snowflake', () => {
+	let queryBuilder: ReturnType<typeof createQueryBuilder>;
+	let d: () => SnowflakeDialect;
+
+	beforeEach(() => {
+		const qb = createQueryBuilder();
+		qb.appendToParams = vi.fn().mockImplementation(qb.appendToParams);
+		qb.appendToQuery = vi.fn().mockImplementation(qb.appendToQuery);
+		queryBuilder = qb;
+		d = (): SnowflakeDialect => new SnowflakeDialect(qb.appendToQuery, qb.appendToParams);
+	});
+
+	describe('templateString', () => {
+		it('appends the string', () => {
+			const dialect = d();
+			dialect.templateString(new TqlTemplateString('hi'));
+			expect(queryBuilder.params).toEqual([]);
+			expect(queryBuilder.query).toBe('hi');
+		});
+	});
+
+	describe('parameter', () => {
+		it('appends the parameter', () => {
+			const dialect = d();
+			const parameterValue = 'vercelliott';
+			dialect.parameter(new TqlParameter(parameterValue));
+			expect(queryBuilder.params).toEqual([parameterValue]);
+			expect(queryBuilder.query).toBe(':1');
+		});
+
+		it("does not change the type of the parameter value, even if it's exotic", () => {
+			const dialect = d();
+			const parameterValue = { name: 'dispelliott' };
+			dialect.parameter(new TqlParameter(parameterValue));
+			expect(queryBuilder.params).toEqual([parameterValue]);
+			expect(queryBuilder.query).toBe(':1');
+		});
+
+		it("increments the parameter value according to what's returned from appendToQuery", () => {
+			const dialect = d();
+			const parameter1Value = 'retelliott';
+			const parameter2Value = 'quelliott';
+			dialect.parameter(new TqlParameter(parameter1Value));
+			dialect.parameter(new TqlParameter(parameter2Value));
+			expect(queryBuilder.params).toEqual([parameter1Value, parameter2Value]);
+			expect(queryBuilder.query).toBe(':1:2');
+		});
+	});
+
+	describe('identifiers', () => {
+		it('adds a single identifier to the query', () => {
+			const dialect = d();
+			const identifier = 'name';
+			dialect.identifiers(new TqlIdentifiers(identifier));
+			expect(queryBuilder.params).toEqual([identifier]);
+			expect(queryBuilder.query).toBe('IDENTIFIER(:1)');
+		});
+
+		it.each([
+			{ input: 'with"quotes' },
+			{
+				input: 'dotted.identifiers',
+			},
+			{
+				input: 'with.injection" FROM users; SELECT * FROM privileged_information;--',
+			},
+		])('escapes single identifiers', ({ input }) => {
+			const dialect = d();
+			dialect.identifiers(new TqlIdentifiers(input));
+			expect(queryBuilder.params).toEqual([input]);
+			expect(queryBuilder.query).toBe('IDENTIFIER(:1)');
+		});
+
+		it('adds multiple identifiers to the query', () => {
+			const dialect = d();
+			const identifier = 'name';
+			dialect.identifiers(new TqlIdentifiers([identifier, identifier, identifier]));
+			expect(queryBuilder.params).toEqual(['name', 'name', 'name']);
+			expect(queryBuilder.query).toBe('IDENTIFIER(:1), IDENTIFIER(:2), IDENTIFIER(:3)');
+		});
+
+		it.each([
+			{ input: ['with"quotes', 'with"quotes'] },
+			{
+				input: ['dotted.identifiers'],
+			},
+			{
+				input: ['with.injection" FROM users; SELECT * FROM privileged_information;--', 'blah'],
+			},
+		])('escapes multiple identifiers', ({ input }) => {
+			const dialect = d();
+			dialect.identifiers(new TqlIdentifiers(input));
+			expect(queryBuilder.params).toEqual(input);
+			expect(queryBuilder.query).toBe(input.length === 1 ? 'IDENTIFIER(:1)' : 'IDENTIFIER(:1), IDENTIFIER(:2)');
+		});
+	});
+
+	describe('list', () => {
+		it('adds items to a comma-separated list', () => {
+			const dialect = d();
+			const items = [1, 'hi', { complex: 'type' }];
+			dialect.list(new TqlList(items));
+			expect(queryBuilder.params).toEqual(items);
+			expect(queryBuilder.query).toBe('(:1, :2, :3)');
+		});
+	});
+
+	describe('values', () => {
+		describe('single object', () => {
+			it('correctly constructs the clause', () => {
+				const dialect = d();
+				const item = { name: 'vercelliott', email: '[email protected]' };
+				dialect.values(new TqlValues(item));
+				expect(queryBuilder.params).toEqual(['name', 'email', item.name, item.email]);
+				expect(queryBuilder.query).toBe('(IDENTIFIER(:1), IDENTIFIER(:2)) VALUES (:3, :4)');
+			});
+
+			it('avoids SQL injection from identifiers and values', () => {
+				const dialect = d();
+				const key1 = 'name"; SELECT * FROM privileged_information; --';
+				const key2 = 'email';
+				const item = {
+					[key1]: 'vercelliott; SELECT * FROM privileged_information; --',
+					[key2]: '[email protected]',
+				};
+				dialect.values(new TqlValues(item));
+				expect(queryBuilder.params).toEqual([key1, key2, item[key1], item[key2]]);
+				expect(queryBuilder.query).toBe('(IDENTIFIER(:1), IDENTIFIER(:2)) VALUES (:3, :4)');
+			});
+
+			it('retains complex types', () => {
+				const dialect = d();
+				const item = {
+					name: 'vercelliott',
+					email: '[email protected]',
+					address: { street: 'go away' },
+				};
+				dialect.values(new TqlValues(item));
+				expect(queryBuilder.params).toEqual(['name', 'email', 'address', item.name, item.email, item.address]);
+				expect(queryBuilder.query).toBe('(IDENTIFIER(:1), IDENTIFIER(:2), IDENTIFIER(:3)) VALUES (:4, :5, :6)');
+			});
+		});
+
+		describe('multiple objects', () => {
+			it('correctly constructs the clause', () => {
+				const dialect = d();
+				const items = [
+					{ name: 'vercelliott', email: '[email protected]' },
+					{ name: 'farewelliott', email: '[email protected]' },
+				];
+				dialect.values(new TqlValues(items));
+				expect(queryBuilder.params).toEqual([
+					'name',
+					'email',
+					items[0].name,
+					items[0].email,
+					items[1].name,
+					items[1].email,
+				]);
+				expect(queryBuilder.query).toBe('(IDENTIFIER(:1), IDENTIFIER(:2)) VALUES (:3, :4), (:5, :6)');
+			});
+
+			it('correctly constructs the clause when objects have different key orders', () => {
+				const dialect = d();
+				const items = [
+					{ name: 'vercelliott', email: '[email protected]' },
+					{ email: '[email protected]', name: 'farewelliott' },
+				];
+				dialect.values(new TqlValues(items));
+				expect(queryBuilder.params).toEqual([
+					'name',
+					'email',
+					items[0].name,
+					items[0].email,
+					items[1].name,
+					items[1].email,
+				]);
+				expect(queryBuilder.query).toBe('(IDENTIFIER(:1), IDENTIFIER(:2)) VALUES (:3, :4), (:5, :6)');
+			});
+
+			it('avoids SQL injection from identifiers and values', () => {
+				const dialect = d();
+				const key1 = 'name"; SELECT * FROM privileged_information; --';
+				const key2 = 'email';
+				const items = [
+					{
+						[key1]: 'vercelliott; SELECT * FROM privileged_information; --',
+						[key2]: '[email protected]',
+					},
+					{
+						[key2]: '[email protected]',
+						[key1]: 'vercelliott; SELECT * FROM privileged_information; --',
+					},
+				];
+				dialect.values(new TqlValues(items));
+				expect(queryBuilder.params).toEqual([
+					key1,
+					key2,
+					items[0]['name"; SELECT * FROM privileged_information; --'],
+					items[0].email,
+					items[1]['name"; SELECT * FROM privileged_information; --'],
+					items[1].email,
+				]);
+				expect(queryBuilder.query).toBe('(IDENTIFIER(:1), IDENTIFIER(:2)) VALUES (:3, :4), (:5, :6)');
+			});
+
+			it('retains complex types', () => {
+				const dialect = d();
+				const items = [
+					{
+						name: 'carouselliott',
+						email: '[email protected]',
+						address: { street: 'go away' },
+					},
+					{
+						name: 'parallelliott',
+						email: '[email protected]',
+						address: { street: 'go away' },
+					},
+				];
+				dialect.values(new TqlValues(items));
+				expect(queryBuilder.params).toEqual([
+					'name',
+					'email',
+					'address',
+					items[0].name,
+					items[0].email,
+					items[0].address,
+					items[1].name,
+					items[1].email,
+					items[1].address,
+				]);
+				expect(queryBuilder.query).toBe(
+					'(IDENTIFIER(:1), IDENTIFIER(:2), IDENTIFIER(:3)) VALUES (:4, :5, :6), (:7, :8, :9)',
+				);
+			});
+
+			it('throws when subsequent value objects have missing keys', () => {
+				const dialect = d();
+				const items = [{ name: 'excelliott', email: '[email protected]' }, { name: 'luddite' }];
+				let error: TqlError<'values_records_mismatch'> | null = null;
+				try {
+					dialect.values(new TqlValues(items));
+				} catch (e) {
+					error = e;
+				}
+				expect(error).toBeInstanceOf(TqlError);
+				expect(error?.code).toBe('values_records_mismatch');
+			});
+		});
+	});
+
+	describe('set', () => {
+		it('correctly constructs the clause', () => {
+			const dialect = d();
+			const setRecord = { name: 'vercelliott', 'address.zip': '00000' };
+			dialect.set(new TqlSet(setRecord));
+			expect(queryBuilder.params).toEqual(['name', 'vercelliott', 'address.zip', '00000']);
+			expect(queryBuilder.query).toBe('SET IDENTIFIER(:1) = :2, IDENTIFIER(:3) = :4');
+		});
+
+		it('avoids SQL injection from identifiers and values', () => {
+			const dialect = d();
+			const key1 = 'name"; SELECT * FROM privileged_information; --';
+			const key2 = 'email';
+			const item = {
+				[key1]: 'vercelliott; SELECT * FROM privileged_information; --',
+				[key2]: '[email protected]',
+			};
+			dialect.set(new TqlSet(item));
+			expect(queryBuilder.params).toEqual([
+				key1,
+				item['name"; SELECT * FROM privileged_information; --'],
+				key2,
+				item.email,
+			]);
+			expect(queryBuilder.query).toBe('SET IDENTIFIER(:1) = :2, IDENTIFIER(:3) = :4');
+		});
+	});
+});