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

package/test/abstract-sql/schema-rule-to-check.ts

@@ -1,393 +0,0 @@
-import * as AbstractSQLCompiler from '../../out/abstract-sql-compiler.js';
-import { expect } from 'chai';
-
-const generateSchema = (
-	abstractSqlModel: AbstractSQLCompiler.AbstractSqlModel,
-) =>
-	AbstractSQLCompiler.postgres.compileSchema(
-		AbstractSQLCompiler.postgres.optimizeSchema(abstractSqlModel),
-	);
-
-it('should convert a basic rule to a check using NOT EXISTS', () => {
-	expect(
-		generateSchema({
-			synonyms: {},
-			relationships: {},
-			tables: {
-				test: {
-					name: 'test',
-					resourceName: 'test',
-					idField: 'id',
-					fields: [
-						{
-							fieldName: 'id',
-							dataType: 'Integer',
-							index: 'PRIMARY KEY',
-						},
-					],
-					indexes: [],
-					primitive: false,
-				},
-			},
-			rules: [
-				[
-					'Rule',
-					[
-						'Body',
-						[
-							'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']],
-											],
-										],
-									],
-								],
-							],
-						],
-					],
-					[
-						'StructuredEnglish',
-						'It is necessary that each test has an id that is greater than 0.',
-					],
-				],
-			],
-			lfInfo: { rules: {} },
-		}),
-	)
-		.to.have.property('createSchema')
-		.that.deep.equals([
-			`\
-CREATE TABLE IF NOT EXISTS "test" (
-	"id" INTEGER NULL PRIMARY KEY
-,	-- It is necessary that each test has an id that is greater than 0.
-CONSTRAINT "test$hkEwz3pzAqalNu6crijhhdWJ0ffUvqRGK8rMkQbViPg=" CHECK (0 < "id"
-AND "id" IS NOT NULL)
-);`,
-		]);
-});
-
-it('should convert a basic rule to a check using COUNT(*) = 0', () => {
-	expect(
-		generateSchema({
-			synonyms: {},
-			relationships: {},
-			tables: {
-				test: {
-					name: 'test',
-					resourceName: 'test',
-					idField: 'id',
-					fields: [
-						{
-							fieldName: 'id',
-							dataType: 'Integer',
-							index: 'PRIMARY KEY',
-						},
-					],
-					indexes: [],
-					primitive: false,
-				},
-			},
-			rules: [
-				[
-					'Rule',
-					[
-						'Body',
-						[
-							'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],
-						],
-					],
-					[
-						'StructuredEnglish',
-						'It is necessary that each test has an id that is greater than 0.',
-					],
-				],
-			],
-			lfInfo: { rules: {} },
-		}),
-	)
-		.to.have.property('createSchema')
-		.that.deep.equals([
-			`\
-CREATE TABLE IF NOT EXISTS "test" (
-	"id" INTEGER NULL PRIMARY KEY
-,	-- It is necessary that each test has an id that is greater than 0.
-CONSTRAINT "test$qEORqfvLM2D8/gu0ZEVfvrnt19+uBo55ipVGKTdmu0k=" CHECK (0 < "id"
-AND "id" IS NOT NULL)
-);`,
-		]);
-});
-
-it('should correctly shorten a converted check rule with a long name', () => {
-	expect(
-		generateSchema({
-			synonyms: {},
-			relationships: {},
-			tables: {
-				test_table_with_very_very_long_name: {
-					name: 'test_table_with_very_very_long_name',
-					resourceName: 'test_table_with_very_very_long_name',
-					idField: 'id',
-					fields: [
-						{
-							fieldName: 'id',
-							dataType: 'Integer',
-							index: 'PRIMARY KEY',
-						},
-					],
-					indexes: [],
-					primitive: false,
-				},
-			},
-			rules: [
-				[
-					'Rule',
-					[
-						'Body',
-						[
-							'Not',
-							[
-								'Exists',
-								[
-									'SelectQuery',
-									['Select', []],
-									[
-										'From',
-										[
-											'Alias',
-											['Table', 'test_table_with_very_very_long_name'],
-											'test_table_with_very_very_long_name.0',
-										],
-									],
-									[
-										'Where',
-										[
-											'Not',
-											[
-												'And',
-												[
-													'LessThan',
-													['Integer', 0],
-													[
-														'ReferencedField',
-														'test_table_with_very_very_long_name.0',
-														'id',
-													],
-												],
-												[
-													'Exists',
-													[
-														'ReferencedField',
-														'test_table_with_very_very_long_name.0',
-														'id',
-													],
-												],
-											],
-										],
-									],
-								],
-							],
-						],
-					],
-					[
-						'StructuredEnglish',
-						'It is necessary that each test_table_with_very_very_long_name has an id that is greater than 0.',
-					],
-				],
-			],
-			lfInfo: { rules: {} },
-		}),
-	)
-		.to.have.property('createSchema')
-		.that.deep.equals([
-			`\
-CREATE TABLE IF NOT EXISTS "test_table_with_very_very_long_name" (
-	"id" INTEGER NULL PRIMARY KEY
-,	-- It is necessary that each test_table_with_very_very_long_name has an id that is greater than 0.
-CONSTRAINT "test_table_with_very_very_long$9z+XEkP4EI1mhDQ8SiLulo2NLmenGY1C" CHECK (0 < "id"
-AND "id" IS NOT NULL)
-);`,
-		]);
-});
-
-it('should work with differing table/resource names using NOT EXISTS', () => {
-	expect(
-		generateSchema({
-			synonyms: {},
-			relationships: {},
-			tables: {
-				some_other_resource_name: {
-					name: 'test',
-					resourceName: 'some_other_resource_name',
-					idField: 'id',
-					fields: [
-						{
-							fieldName: 'id',
-							dataType: 'Integer',
-							index: 'PRIMARY KEY',
-						},
-					],
-					indexes: [],
-					primitive: false,
-				},
-			},
-			rules: [
-				[
-					'Rule',
-					[
-						'Body',
-						[
-							'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']],
-											],
-										],
-									],
-								],
-							],
-						],
-					],
-					[
-						'StructuredEnglish',
-						'It is necessary that each test has an id that is greater than 0.',
-					],
-				],
-			],
-			lfInfo: { rules: {} },
-		}),
-	)
-		.to.have.property('createSchema')
-		.that.deep.equals([
-			`\
-CREATE TABLE IF NOT EXISTS "test" (
-	"id" INTEGER NULL PRIMARY KEY
-,	-- It is necessary that each test has an id that is greater than 0.
-CONSTRAINT "test$hkEwz3pzAqalNu6crijhhdWJ0ffUvqRGK8rMkQbViPg=" CHECK (0 < "id"
-AND "id" IS NOT NULL)
-);`,
-		]);
-});
-
-it('should work with differing table/resource names using COUNT(*) = 0', () => {
-	expect(
-		generateSchema({
-			synonyms: {},
-			relationships: {},
-			tables: {
-				some_other_resource_name: {
-					name: 'test',
-					resourceName: 'some_other_resource_name',
-					idField: 'id',
-					fields: [
-						{
-							fieldName: 'id',
-							dataType: 'Integer',
-							index: 'PRIMARY KEY',
-						},
-					],
-					indexes: [],
-					primitive: false,
-				},
-			},
-			rules: [
-				[
-					'Rule',
-					[
-						'Body',
-						[
-							'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],
-						],
-					],
-					[
-						'StructuredEnglish',
-						'It is necessary that each test has an id that is greater than 0.',
-					],
-				],
-			],
-			lfInfo: { rules: {} },
-		}),
-	)
-		.to.have.property('createSchema')
-		.that.deep.equals([
-			`\
-CREATE TABLE IF NOT EXISTS "test" (
-	"id" INTEGER NULL PRIMARY KEY
-,	-- It is necessary that each test has an id that is greater than 0.
-CONSTRAINT "test$qEORqfvLM2D8/gu0ZEVfvrnt19+uBo55ipVGKTdmu0k=" CHECK (0 < "id"
-AND "id" IS NOT NULL)
-);`,
-		]);
-});

package/test/abstract-sql/schema-views.ts

@@ -1,73 +0,0 @@
-import * as AbstractSQLCompiler from '../../out/abstract-sql-compiler.js';
-import { expect } from 'chai';
-
-it('a table with a static definition should not produce a view', () => {
-	expect(
-		AbstractSQLCompiler.postgres.compileSchema({
-			synonyms: {},
-			relationships: {},
-			tables: {
-				test: {
-					name: 'test',
-					resourceName: 'test',
-					idField: 'id',
-					fields: [
-						{
-							fieldName: 'id',
-							dataType: 'Integer',
-							index: 'PRIMARY KEY',
-						},
-					],
-					indexes: [],
-					primitive: false,
-					definition: { abstractSql: ['Table', 'other table'] },
-				},
-			},
-			rules: [],
-			lfInfo: { rules: {} },
-		}),
-	)
-		.to.have.property('createSchema')
-		.that.deep.equals([
-			`\
-CREATE TABLE IF NOT EXISTS "test" (
-	"id" INTEGER NULL PRIMARY KEY
-);`,
-		]);
-});
-
-it('a table with a view definition should produce a view', () => {
-	expect(
-		AbstractSQLCompiler.postgres.compileSchema({
-			synonyms: {},
-			relationships: {},
-			tables: {
-				test: {
-					name: 'test',
-					resourceName: 'test',
-					idField: 'id',
-					fields: [
-						{
-							fieldName: 'id',
-							dataType: 'Integer',
-							index: 'PRIMARY KEY',
-						},
-					],
-					indexes: [],
-					primitive: false,
-					viewDefinition: { abstractSql: ['Table', 'other table'] },
-				},
-			},
-			rules: [],
-			lfInfo: { rules: {} },
-		}),
-	)
-		.to.have.property('createSchema')
-		.that.deep.equals([
-			`\
-CREATE OR REPLACE VIEW "test" AS (
-	SELECT *
-	FROM "other table"
-);`,
-		]);
-});

package/test/abstract-sql/test.ts

@@ -1,192 +0,0 @@
-import * as AbstractSQLCompiler from '../../out/abstract-sql-compiler.js';
-
-import { expect } from 'chai';
-import _ from 'lodash';
-
-type ExpectedBindings = Array<
-	AbstractSQLCompiler.Binding | AbstractSQLCompiler.Binding[]
->;
-const bindingsTest = function (
-	actualBindings: AbstractSQLCompiler.Binding[],
-	expectedBindings: AbstractSQLCompiler.Binding[] | false = false,
-) {
-	if (expectedBindings === false) {
-		it('should not have any bindings', () => {
-			expect(actualBindings).to.be.empty;
-		});
-	} else {
-		it('should have matching bindings', () => {
-			expect(actualBindings).to.deep.equal(expectedBindings);
-		});
-	}
-};
-
-type SqlEquals = (
-	actual:
-		| AbstractSQLCompiler.SqlResult
-		| AbstractSQLCompiler.SqlResult[]
-		| string,
-	expected: string,
-) => void;
-const equals: SqlEquals = (actual, expected) => {
-	if (typeof actual !== 'string') {
-		if (Array.isArray(actual)) {
-			throw new Error('Expected a single query, got multiple');
-		}
-		actual = actual.query;
-	}
-	expect(actual).to.equal(expected);
-};
-const sqlEquals = {
-	websql: equals,
-	mysql: equals,
-	postgres(actual, expected) {
-		let num = 1;
-		while (_.includes(expected, '?')) {
-			expected = expected.replace('?', '$' + num);
-			num++;
-		}
-		equals(actual, expected);
-	},
-} satisfies Record<string, SqlEquals>;
-
-type ExpectationSuccessFn = (
-	result:
-		| AbstractSQLCompiler.SqlResult
-		| [AbstractSQLCompiler.SqlResult, AbstractSQLCompiler.SqlResult],
-	sqlEquals: SqlEquals,
-) => void;
-type ExpectationFailFn = (result: Error) => void;
-type ExpectationFn<ExpectFail extends boolean> = ExpectFail extends true
-	? ExpectationFailFn
-	: ExpectationSuccessFn;
-
-function runExpectation<ExpectFail extends boolean>(
-	describe: Mocha.SuiteFunction,
-	engine: keyof typeof sqlEquals,
-	expectFailure: ExpectFail,
-	input: AbstractSQLCompiler.AbstractSqlQuery,
-	expectedBindings: ExpectedBindings | false,
-	expectation: ExpectationFn<ExpectFail>,
-): void;
-function runExpectation<ExpectFail extends boolean>(
-	describe: Mocha.SuiteFunction,
-	engine: keyof typeof sqlEquals,
-	expectFailure: ExpectFail,
-	input: AbstractSQLCompiler.AbstractSqlQuery,
-	expectation: ExpectationFn<ExpectFail>,
-): void;
-function runExpectation<ExpectFail extends boolean>(
-	describe: Mocha.SuiteFunction,
-	engine: keyof typeof sqlEquals,
-	expectFailure: ExpectFail,
-	input: AbstractSQLCompiler.AbstractSqlQuery,
-	...args:
-		| [expectation: ExpectationFn<ExpectFail>]
-		| [
-				expectedBindings: ExpectedBindings | false,
-				expectation: ExpectationFn<ExpectFail>,
-		  ]
-): void {
-	let expectedBindings: ExpectedBindings | false = false;
-	let expectation: ExpectationFn<ExpectFail>;
-	switch (args.length) {
-		case 1:
-			[expectation] = args;
-			break;
-		case 2:
-			[expectedBindings, expectation] = args;
-			break;
-	}
-
-	describe('Parsing ' + JSON.stringify(input), function () {
-		let result;
-		try {
-			result = AbstractSQLCompiler[engine].compileRule(input);
-		} catch (e: any) {
-			if (!expectFailure) {
-				throw e;
-			}
-			(expectation as ExpectationFailFn)(e);
-			return;
-		}
-		if (expectFailure) {
-			throw new Error("Expected failure but didn't get one");
-		}
-		if (Array.isArray(result)) {
-			for (let i = 0; i < result.length; i++) {
-				const actualResult = result[i];
-				if (expectedBindings === false) {
-					bindingsTest(actualResult.bindings, false);
-				} else if (expectedBindings[0][0] === 'Bind') {
-					bindingsTest(
-						actualResult.bindings,
-						expectedBindings as AbstractSQLCompiler.Binding[],
-					);
-				} else {
-					bindingsTest(
-						actualResult.bindings,
-						expectedBindings[i] as AbstractSQLCompiler.Binding[],
-					);
-				}
-			}
-		} else {
-			bindingsTest(
-				result.bindings,
-				expectedBindings as AbstractSQLCompiler.Binding[],
-			);
-		}
-		(expectation as ExpectationSuccessFn)(result, sqlEquals[engine]);
-	});
-}
-
-interface BoundRunExpectation<ExpectFail extends boolean> {
-	(
-		input: AbstractSQLCompiler.AbstractSqlQuery,
-		expectedBindings: ExpectedBindings | false,
-		expectation: ExpectationFn<ExpectFail>,
-	): void;
-	(
-		input: AbstractSQLCompiler.AbstractSqlQuery,
-		expectation: ExpectationFn<ExpectFail>,
-	): void;
-	(
-		input: AbstractSQLCompiler.AbstractSqlQuery,
-		...args:
-			| [expectation: ExpectationFn<ExpectFail>]
-			| [
-					expectedBindings: ExpectedBindings | false,
-					expectation: ExpectationFn<ExpectFail>,
-			  ]
-	): void;
-}
-
-type MochaBoundRunExpectation = BoundRunExpectation<false> & {
-	fail: BoundRunExpectation<true>;
-	skip: BoundRunExpectation<false>;
-	only: BoundRunExpectation<false>;
-};
-const bindRunExpectation = function (engine: keyof typeof sqlEquals) {
-	const bound: MochaBoundRunExpectation = runExpectation.bind(
-		null,
-		describe,
-		engine,
-		false,
-	);
-	bound.fail = runExpectation.bind(null, describe, engine, true);
-	bound.skip = runExpectation.bind(null, describe.skip, engine, false);
-	// eslint-disable-next-line no-only-tests/no-only-tests -- this is a false positive
-	bound.only = runExpectation.bind(null, describe.only, engine, false);
-	return bound;
-};
-
-const testFn = bindRunExpectation('postgres') as MochaBoundRunExpectation & {
-	postgres: MochaBoundRunExpectation;
-	mysql: MochaBoundRunExpectation;
-	websql: MochaBoundRunExpectation;
-};
-testFn.postgres = bindRunExpectation('postgres');
-testFn.mysql = bindRunExpectation('mysql');
-testFn.websql = bindRunExpectation('websql');
-
-export default testFn;