@balena/abstract-sql-compiler 11.0.0-build-11-x-45529f014aa1c181f338c0f7348767f2990a9084-1 → 11.0.0

package/test/abstract-sql/get-rule-referenced-fields.ts

@@ -1,345 +0,0 @@
-import { expect } from 'chai';
-import * as AbstractSqlCompiler from '../../out/abstract-sql-compiler.js';
-
-describe('getRuleReferencedFields', () => {
-	it('should work with single table NOT EXISTS', () => {
-		expect(
-			AbstractSqlCompiler.postgres.getRuleReferencedFields([
-				'Not',
-				[
-					'Exists',
-					[
-						'SelectQuery',
-						['Select', []],
-						['From', ['Alias', ['Table', 'test'], 'test.0']],
-						[
-							'Where',
-							[
-								'Not',
-								[
-									'And',
-									[
-										'LessThan',
-										['Integer', 0],
-										['ReferencedField', 'test.0', 'id'],
-									],
-									['Exists', ['ReferencedField', 'test.0', 'id']],
-								],
-							],
-						],
-					],
-				],
-			]),
-		).to.deep.equal({
-			test: {
-				create: ['id'],
-				update: ['id'],
-				delete: [],
-			},
-		});
-	});
-	it('should work with single table COUNT(*) = 0', () => {
-		expect(
-			AbstractSqlCompiler.postgres.getRuleReferencedFields([
-				'Equals',
-				[
-					'SelectQuery',
-					['Select', [['Count', '*']]],
-					['From', ['Alias', ['Table', 'test'], 'test.0']],
-					[
-						'Where',
-						[
-							'Not',
-							[
-								'And',
-								[
-									'LessThan',
-									['Integer', 0],
-									['ReferencedField', 'test.0', 'id'],
-								],
-								['Exists', ['ReferencedField', 'test.0', 'id']],
-							],
-						],
-					],
-				],
-				['Number', 0],
-			]),
-		).to.deep.equal({
-			test: {
-				create: ['id'],
-				update: ['id'],
-				delete: [],
-			},
-		});
-	});
-
-	it('should work with multi table SELECT NOT EXISTS', () => {
-		expect(
-			AbstractSqlCompiler.postgres.getRuleReferencedFields([
-				'Not',
-				[
-					'Exists',
-					[
-						'SelectQuery',
-						['Select', []],
-						['From', ['Alias', ['Table', 'test'], 'test.0']],
-						['From', ['Alias', ['Table', 'test'], 'test.1']],
-						[
-							'Where',
-							[
-								'Not',
-								[
-									'And',
-									[
-										'LessThan',
-										['ReferencedField', 'test.1', 'id'],
-										['ReferencedField', 'test.0', 'id'],
-									],
-									['Exists', ['ReferencedField', 'test.0', 'id']],
-								],
-							],
-						],
-					],
-				],
-			]),
-		).to.deep.equal({
-			test: {
-				create: ['id'],
-				update: ['id'],
-				delete: [],
-			},
-		});
-	});
-
-	it('should work with single table SELECT EXISTS', () => {
-		expect(
-			AbstractSqlCompiler.postgres.getRuleReferencedFields([
-				'Exists',
-				[
-					'SelectQuery',
-					['Select', []],
-					['From', ['Alias', ['Table', 'test'], 'test.0']],
-					[
-						'Where',
-						[
-							'Not',
-							[
-								'And',
-								[
-									'LessThan',
-									['Integer', 0],
-									['ReferencedField', 'test.0', 'id'],
-								],
-								['Exists', ['ReferencedField', 'test.0', 'id']],
-							],
-						],
-					],
-				],
-			]),
-		).to.deep.equal({
-			test: {
-				create: [],
-				update: ['id'],
-				delete: ['id'],
-			},
-		});
-	});
-
-	it('should work with single table SELECT EXISTS for `Field`s', () => {
-		expect(
-			AbstractSqlCompiler.postgres.getRuleReferencedFields([
-				'Exists',
-				[
-					'SelectQuery',
-					['Select', []],
-					['From', ['Alias', ['Table', 'test'], 'test.0']],
-					[
-						'Where',
-						[
-							'Not',
-							[
-								'And',
-								['LessThan', ['Integer', 0], ['Field', 'id']],
-								['Exists', ['Field', 'id']],
-							],
-						],
-					],
-				],
-			]),
-		).to.deep.equal({
-			test: {
-				create: [],
-				update: ['id'],
-				delete: ['id'],
-			},
-		});
-	});
-
-	it('should work with single table SELECT NOT EXISTS for COUNT(*)', () => {
-		expect(
-			AbstractSqlCompiler.postgres.getRuleReferencedFields([
-				'NotExists',
-				[
-					'SelectQuery',
-					['Select', [['Count', '*']]],
-					['From', ['Table', 'test']],
-				],
-			]),
-		).to.deep.equal({
-			test: {
-				create: [''],
-				update: [''],
-				delete: [],
-			},
-		});
-	});
-
-	it('should work with nested NOT EXISTS', () => {
-		expect(
-			AbstractSqlCompiler.postgres.getRuleReferencedFields([
-				'Not',
-				[
-					'Exists',
-					[
-						'SelectQuery',
-						['Select', []],
-						['From', ['Alias', ['Table', 'test'], 'test.0']],
-						[
-							'Where',
-							[
-								'Not',
-								[
-									'Exists',
-									[
-										'SelectQuery',
-										['Select', []],
-										['From', ['Alias', ['Table', 'test2'], 'test2.0']],
-										[
-											'Where',
-											[
-												'Equals',
-												['ReferencedField', 'test.0', 'id'],
-												['ReferencedField', 'test2.0', 'test'],
-											],
-										],
-									],
-								],
-							],
-						],
-					],
-				],
-			]),
-		).to.deep.equal({
-			test: {
-				create: ['id'],
-				update: ['id'],
-				delete: [],
-			},
-			test2: {
-				create: [],
-				update: ['test'],
-				delete: ['test'],
-			},
-		});
-	});
-
-	it('should work with multiple FROMs for `Field`s', () => {
-		expect(
-			AbstractSqlCompiler.postgres.getRuleReferencedFields([
-				'Not',
-				[
-					'Exists',
-					[
-						'SelectQuery',
-						['Select', []],
-						['From', ['Alias', ['Table', 'test'], 'test.0']],
-						['From', ['Alias', ['Table', 'test2'], 'test2.0']],
-						['Where', ['Equals', ['Field', 'id'], ['Field', 'test']]],
-					],
-				],
-			]),
-		).to.deep.equal({
-			test: {
-				// We assume any unreferenced field can come from any of the scoped tables
-				create: ['id', 'test'],
-				update: ['id', 'test'],
-				delete: [],
-			},
-			test2: {
-				create: ['id', 'test'],
-				update: ['id', 'test'],
-				delete: [],
-			},
-		});
-	});
-
-	it('should work with nested NOT EXISTS', () => {
-		expect(
-			AbstractSqlCompiler.postgres.getRuleReferencedFields([
-				'Not',
-				[
-					'Exists',
-					[
-						'SelectQuery',
-						['Select', []],
-						['From', ['Alias', ['Table', 'test'], 'test.0']],
-						[
-							'Where',
-							[
-								'Not',
-								[
-									'Exists',
-									[
-										'SelectQuery',
-										['Select', [['Count', '*']]],
-										['From', ['Alias', ['Table', 'test2'], 'test2.0']],
-										[
-											'Where',
-											[
-												'Equals',
-												['ReferencedField', 'test.0', 'id'],
-												['ReferencedField', 'test2.0', 'test'],
-											],
-										],
-									],
-								],
-							],
-						],
-					],
-				],
-			]),
-		).to.deep.equal({
-			test: {
-				create: ['id'],
-				update: ['id'],
-				delete: [],
-			},
-			test2: {
-				create: [],
-				update: ['', 'test'],
-				delete: ['', 'test'],
-			},
-		});
-	});
-
-	it('HAVING clauses should not be subject to the operation typecheck optimization', () => {
-		expect(
-			AbstractSqlCompiler.postgres.getRuleReferencedFields([
-				'NotExists',
-				[
-					'SelectQuery',
-					['Select', []],
-					['From', ['Table', 'test']],
-					['GroupBy', [['ReferencedField', 'test', 'field']]],
-					['Having', ['GreaterThanOrEqual', ['Count', '*'], ['Number', 2]]],
-				],
-			]),
-		).to.deep.equal({
-			test: {
-				create: ['field', ''],
-				update: ['field', ''],
-				delete: [''],
-			},
-		});
-	});
-});

package/test/abstract-sql/insert-query.ts

@@ -1,22 +0,0 @@
-import test from './test.js';
-
-describe('Insert boolean value', () => {
-	test(
-		[
-			'InsertQuery',
-			['From', ['Table', 'test']],
-			['Fields', ['foo']],
-			['Values', [['Boolean', true]]],
-		],
-		(result, sqlEquals) => {
-			it('should produce a valid insert boolean statement', () => {
-				sqlEquals(
-					result,
-					`\
-INSERT INTO "test" ("foo")
-VALUES (TRUE)`,
-				);
-			});
-		},
-	);
-});

package/test/abstract-sql/is-distinct.ts

@@ -1,102 +0,0 @@
-import test from './test.js';
-
-describe('IsDistinctFrom', () => {
-	test(
-		[
-			'SelectQuery',
-			['Select', [['IsDistinctFrom', ['Field', 'a'], ['Field', 'b']]]],
-		],
-		(result, sqlEquals) => {
-			it('should produce a valid is distinct from statement', () => {
-				sqlEquals(
-					result,
-					'SELECT NOT("a" IS NOT NULL AND "b" IS NOT NULL AND "a" = "b" OR "a" IS NULL AND "b" IS NULL)',
-				);
-			});
-		},
-	);
-	test(
-		[
-			'SelectQuery',
-			['Select', [['IsDistinctFrom', ['Number', 1], ['Number', 2]]]],
-		],
-		(result, sqlEquals) => {
-			it('should optimize down to a !=', () => {
-				sqlEquals(result, 'SELECT 1 != 2');
-			});
-		},
-	);
-	test(
-		[
-			'SelectQuery',
-			['Select', [['IsDistinctFrom', ['Field', 'a'], ['Text', '2']]]],
-		],
-		[['Text', '2']],
-		(result, sqlEquals) => {
-			it('should produce a valid is distinct from statement', () => {
-				sqlEquals(result, 'SELECT NOT("a" IS NOT NULL AND "a" = $1)');
-			});
-		},
-	);
-
-	test(
-		['SelectQuery', ['Select', [['IsDistinctFrom', ['Field', 'a'], ['Null']]]]],
-		(result, sqlEquals) => {
-			it('should produce an is not null statement', () => {
-				sqlEquals(result, 'SELECT "a" IS NOT NULL');
-			});
-		},
-	);
-});
-
-describe('IsNotDistinctFrom', () => {
-	test(
-		[
-			'SelectQuery',
-			['Select', [['IsNotDistinctFrom', ['Field', 'a'], ['Field', 'b']]]],
-		],
-		(result, sqlEquals) => {
-			it('should produce a valid is not distinct from statement', () => {
-				sqlEquals(
-					result,
-					'SELECT "a" IS NOT NULL AND "b" IS NOT NULL AND "a" = "b" OR "a" IS NULL AND "b" IS NULL',
-				);
-			});
-		},
-	);
-	test(
-		[
-			'SelectQuery',
-			['Select', [['IsNotDistinctFrom', ['Number', 1], ['Number', 2]]]],
-		],
-		(result, sqlEquals) => {
-			it('should optimize down to an =', () => {
-				sqlEquals(result, 'SELECT 1 = 2');
-			});
-		},
-	);
-	test(
-		[
-			'SelectQuery',
-			['Select', [['IsNotDistinctFrom', ['Field', 'a'], ['Text', '2']]]],
-		],
-		[['Text', '2']],
-		(result, sqlEquals) => {
-			it('should produce a valid is not distinct from statement', () => {
-				sqlEquals(result, 'SELECT "a" IS NOT NULL AND "a" = $1');
-			});
-		},
-	);
-
-	test(
-		[
-			'SelectQuery',
-			['Select', [['IsNotDistinctFrom', ['Field', 'a'], ['Null']]]],
-		],
-		(result, sqlEquals) => {
-			it('should produce a valid is not distinct from statement', () => {
-				sqlEquals(result, 'SELECT "a" IS NULL');
-			});
-		},
-	);
-});

package/test/abstract-sql/joins.ts

@@ -1,84 +0,0 @@
-import { stripIndent } from 'common-tags';
-import test from './test.js';
-
-const joinTest = (
-	joinType: 'Join' | 'RightJoin' | 'LeftJoin' | 'FullJoin',
-	sqlJoinType: string,
-) => {
-	describe(joinType, () => {
-		test(
-			[
-				'SelectQuery',
-				[
-					'Select',
-					[
-						['ReferencedField', 'table', 'field1'],
-						['ReferencedField', 'table2', 'field2'],
-					],
-				],
-				['From', ['Table', 'table']],
-				[
-					joinType,
-					['Table', 'table2'],
-					[
-						'On',
-						[
-							'Equals',
-							['ReferencedField', 'table', 'field1'],
-							['ReferencedField', 'table2', 'field2'],
-						],
-					],
-				],
-			],
-			(result, sqlEquals) => {
-				it('should produce a valid join statement', () => {
-					sqlEquals(
-						result,
-						stripIndent`
-							SELECT "table"."field1", "table2"."field2"
-							FROM "table"
-							${sqlJoinType} "table2" ON "table"."field1" = "table2"."field2"
-						`,
-					);
-				});
-			},
-		);
-	});
-};
-
-joinTest('Join', 'JOIN');
-
-joinTest('RightJoin', 'RIGHT JOIN');
-
-joinTest('LeftJoin', 'LEFT JOIN');
-
-joinTest('FullJoin', 'FULL JOIN');
-
-describe('CrossJoin', () => {
-	test(
-		[
-			'SelectQuery',
-			[
-				'Select',
-				[
-					['ReferencedField', 'table', 'field1'],
-					['ReferencedField', 'table2', 'field2'],
-				],
-			],
-			['From', ['Table', 'table']],
-			['CrossJoin', ['Table', 'table2']],
-		],
-		(result, sqlEquals) => {
-			it('should produce a valid join statement', () => {
-				sqlEquals(
-					result,
-					stripIndent`
-						SELECT "table"."field1", "table2"."field2"
-						FROM "table"
-						CROSS JOIN "table2"
-					`,
-				);
-			});
-		},
-	);
-});

package/test/abstract-sql/json.ts

@@ -1,58 +0,0 @@
-import test from './test.js';
-
-describe('ExtractJSONPathAsText', () => {
-	test(
-		[
-			'SelectQuery',
-			[
-				'Select',
-				[
-					[
-						'ExtractJSONPathAsText',
-						['ReferencedField', 'foo', 'bar'],
-						['TextArray'],
-					],
-				],
-			],
-		],
-		(result, sqlEquals) => {
-			it('should produce a valid select with given empty text array', () => {
-				sqlEquals(result, `SELECT "foo"."bar" #>> CAST(ARRAY[] as TEXT[])`);
-			});
-		},
-	);
-	test(
-		[
-			'SelectQuery',
-			[
-				'Select',
-				[
-					[
-						'ExtractJSONPathAsText',
-						['ReferencedField', 'foo', 'bar'],
-						['TextArray', ['EmbeddedText', 'buz'], ['EmbeddedText', 'baz']],
-					],
-				],
-			],
-		],
-		(result, sqlEquals) => {
-			it('should produce a valid select with given populated text array', () => {
-				sqlEquals(result, `SELECT "foo"."bar" #>> ARRAY['buz', 'baz']`);
-			});
-		},
-	);
-});
-
-describe('ToJSON', () => {
-	test(
-		[
-			'SelectQuery',
-			['Select', [['ToJSON', ['ReferencedField', 'foo', 'bar']]]],
-		],
-		(result, sqlEquals) => {
-			it('should produce a valid to_json select statement', () => {
-				sqlEquals(result, 'SELECT TO_JSON("foo"."bar")');
-			});
-		},
-	);
-});