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

package/test/odata/select.ts

@@ -1,119 +0,0 @@
-import test from './test.js';
-import { pilotFields } from './fields.js';
-const pilotFieldsStr = pilotFields.join(', ');
-
-test('/pilot?$select=name', (result, sqlEquals) => {
-	it('should select name from pilot', () => {
-		sqlEquals(
-			result,
-			`\
-SELECT "pilot"."name"
-FROM "pilot"`,
-		);
-	});
-});
-
-test('/pilot?$select=favourite_colour', (result, sqlEquals) => {
-	it('should select favourite_colour from pilot', () => {
-		sqlEquals(
-			result,
-			`\
-SELECT "pilot"."favourite colour" AS "favourite_colour"
-FROM "pilot"`,
-		);
-	});
-});
-
-test(
-	'/pilot(1)?$select=favourite_colour',
-	'GET',
-	[['Bind', 0]],
-	(result, sqlEquals) => {
-		it('should select from pilot with id', () => {
-			sqlEquals(
-				result,
-				`\
-SELECT "pilot"."favourite colour" AS "favourite_colour"
-FROM "pilot"
-WHERE "pilot"."id" IS NOT NULL AND "pilot"."id" = ?`,
-			);
-		});
-	},
-);
-
-test(
-	"/pilot('TextKey')?$select=favourite_colour",
-	'GET',
-	[['Bind', 0]],
-	(result, sqlEquals) => {
-		it('should select favourite colour from pilot "TextKey"', () => {
-			sqlEquals(
-				result,
-				`\
-SELECT "pilot"."favourite colour" AS "favourite_colour"
-FROM "pilot"
-WHERE "pilot"."id" IS NOT NULL AND "pilot"."id" = ?`,
-			);
-		});
-	},
-);
-
-test('/pilot?$select=trained__pilot/name', (result, sqlEquals) => {
-	it('should select name from pilot', () => {
-		sqlEquals(
-			result,
-			`\
-SELECT "pilot.trained-pilot"."name"
-FROM "pilot"
-LEFT JOIN "pilot" AS "pilot.trained-pilot" ON "pilot"."id" = "pilot.trained-pilot"."was trained by-pilot"`,
-		);
-	});
-});
-
-test('/pilot?$select=trained__pilot/name,age', (result, sqlEquals) => {
-	it('should select name, age from pilot', () => {
-		sqlEquals(
-			result,
-			`\
-SELECT "pilot.trained-pilot"."name", "pilot"."age"
-FROM "pilot"
-LEFT JOIN "pilot" AS "pilot.trained-pilot" ON "pilot"."id" = "pilot.trained-pilot"."was trained by-pilot"`,
-		);
-	});
-});
-
-test('/pilot?$select=*', (result, sqlEquals) => {
-	it('should select * from pilot', () => {
-		sqlEquals(
-			result,
-			`\
-SELECT ${pilotFieldsStr}
-FROM "pilot"`,
-		);
-	});
-});
-
-test('/pilot?$select=licence/id', (result, sqlEquals) => {
-	it('should select licence/id for pilots', () => {
-		sqlEquals(
-			result,
-			`\
-SELECT "pilot.licence"."id"
-FROM "pilot"
-LEFT JOIN "licence" AS "pilot.licence" ON "pilot"."licence" = "pilot.licence"."id"`,
-		);
-	});
-});
-
-test('/pilot?$select=can_fly__plane/plane/id', (result, sqlEquals) => {
-	it('should select can_fly__plane/plane/id for pilots', () => {
-		sqlEquals(
-			result,
-			`\
-SELECT "pilot.pilot-can fly-plane.plane"."id"
-FROM "pilot"
-LEFT JOIN "pilot-can fly-plane" AS "pilot.pilot-can fly-plane" ON "pilot"."id" = "pilot.pilot-can fly-plane"."pilot"
-LEFT JOIN "plane" AS "pilot.pilot-can fly-plane.plane" ON "pilot.pilot-can fly-plane"."can fly-plane" = "pilot.pilot-can fly-plane.plane"."id"`,
-		);
-	});
-});

package/test/odata/stress.ts

@@ -1,93 +0,0 @@
-import test from './test.js';
-import _ from 'lodash';
-import { pilotFields } from './fields.js';
-const pilotFieldsStr = pilotFields.join(', ');
-
-const filterIDs = _.range(1, 5000);
-const filterBindsInString = _.map(filterIDs, () => '?').join(', ');
-const filterBindsOrString = _.map(
-	filterIDs,
-	() => '"pilot"."id" IS NOT NULL AND "pilot"."id" = ?',
-).join('\nOR ');
-const filterBindsNandString = _.map(
-	filterIDs,
-	() => 'NOT("pilot"."id" IS NOT NULL AND "pilot"."id" = ?)',
-).join('\nAND ');
-
-const filterBinds = filterIDs.map((_n, i) => ['Bind', i] as const);
-
-let filterString = `id in (${filterIDs.join(', ')})`;
-test(
-	'/pilot?$filter=' + filterString,
-	'GET',
-	filterBinds,
-	(result, sqlEquals) => {
-		it('should select from pilot with a long IN clause', () => {
-			sqlEquals(
-				result,
-				`\
-SELECT ${pilotFieldsStr}
-FROM "pilot"
-WHERE "pilot"."id" IN (` +
-					filterBindsInString +
-					')',
-			);
-		});
-	},
-);
-
-filterString = `not(id in (${filterIDs.join(', ')}))`;
-test(
-	'/pilot?$filter=' + filterString,
-	'GET',
-	filterBinds,
-	(result, sqlEquals) => {
-		it('should select from pilot with a long NOT IN clause', () => {
-			sqlEquals(
-				result,
-				`\
-SELECT ${pilotFieldsStr}
-FROM "pilot"
-WHERE "pilot"."id" NOT IN (` +
-					filterBindsInString +
-					')',
-			);
-		});
-	},
-);
-
-filterString = filterIDs.map((i) => 'id eq ' + i).join(' or ');
-test(
-	'/pilot?$filter=' + filterString,
-	'GET',
-	filterBinds,
-	(result, sqlEquals) => {
-		it('should select from pilot with a long IN clause', () => {
-			sqlEquals(
-				result,
-				`\
-SELECT ${pilotFieldsStr}
-FROM "pilot"
-WHERE (${filterBindsOrString})`,
-			);
-		});
-	},
-);
-
-filterString = filterIDs.map((i) => 'id ne ' + i).join(' and ');
-test(
-	'/pilot?$filter=' + filterString,
-	'GET',
-	filterBinds,
-	(result, sqlEquals) => {
-		it('should select from pilot with a long NOT IN clause', () => {
-			sqlEquals(
-				result,
-				`\
-SELECT ${pilotFieldsStr}
-FROM "pilot"
-WHERE ${filterBindsNandString}`,
-			);
-		});
-	},
-);

package/test/odata/test.ts

@@ -1,297 +0,0 @@
-import fs from 'node:fs';
-import ODataParser from '@balena/odata-parser';
-import { OData2AbstractSQL } from '@balena/odata-to-abstract-sql';
-import $sbvrTypes from '@balena/sbvr-types';
-const { default: sbvrTypes } = $sbvrTypes;
-// @ts-expect-error @balena/sbvr-parser doesn't have types
-import { SBVRParser } from '@balena/sbvr-parser';
-// @ts-expect-error @balena/lf-to-abstract-sql doesn't have types
-import LF2AbstractSQL from '@balena/lf-to-abstract-sql';
-
-const sbvrModel = await fs.promises.readFile(
-	new URL(import.meta.resolve('../model.sbvr')),
-	'utf8',
-);
-const typeVocab = await fs.promises.readFile(
-	new URL(import.meta.resolve('@balena/sbvr-types/Type.sbvr')),
-	'utf8',
-);
-
-import * as AbstractSQLCompiler from '../../out/abstract-sql-compiler.js';
-
-import { expect } from 'chai';
-import _ from 'lodash';
-
-const generateClientModel = function (input: string) {
-	const sbvrParser = SBVRParser.createInstance();
-	sbvrParser.enableReusingMemoizations(sbvrParser._sideEffectingRules);
-	sbvrParser.AddCustomAttribute('Database ID Field:');
-	sbvrParser.AddCustomAttribute('Database Table Name:');
-	sbvrParser.AddBuiltInVocab(typeVocab);
-
-	const LF2AbstractSQLTranslator = LF2AbstractSQL.createTranslator(sbvrTypes);
-
-	const lf = sbvrParser.matchAll(input, 'Process');
-	const abstractSql = LF2AbstractSQLTranslator(lf, 'Process');
-	return abstractSql;
-};
-
-export const clientModel = generateClientModel(sbvrModel);
-const odata2AbstractSQL = new OData2AbstractSQL(clientModel);
-
-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 ReadonlyBinding = Readonly<AbstractSQLCompiler.Binding>;
-type ExpectedBindings = ReadonlyArray<
-	ReadonlyBinding | readonly ReadonlyBinding[]
->;
-
-export type ExpectationSuccessFn = (
-	result:
-		| AbstractSQLCompiler.SqlResult
-		| [AbstractSQLCompiler.SqlResult, AbstractSQLCompiler.SqlResult],
-	sqlEquals: SqlEquals,
-) => void;
-export 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: string,
-	method: ODataParser.SupportedMethod,
-	expectedBindings: ExpectedBindings | false,
-	body: Record<string, unknown>,
-	expectation: ExpectationFn<ExpectFail>,
-): void;
-function runExpectation<ExpectFail extends boolean>(
-	describe: Mocha.SuiteFunction,
-	engine: keyof typeof sqlEquals,
-	expectFailure: ExpectFail,
-	input: string,
-	method: ODataParser.SupportedMethod,
-	expectedBindings: ExpectedBindings | false,
-	expectation: ExpectationFn<ExpectFail>,
-): void;
-function runExpectation<ExpectFail extends boolean>(
-	describe: Mocha.SuiteFunction,
-	engine: keyof typeof sqlEquals,
-	expectFailure: ExpectFail,
-	input: string,
-	method: ODataParser.SupportedMethod,
-	expectation: ExpectationFn<ExpectFail>,
-): void;
-function runExpectation<ExpectFail extends boolean>(
-	describe: Mocha.SuiteFunction,
-	engine: keyof typeof sqlEquals,
-	expectFailure: ExpectFail,
-	input: string,
-	expectation: ExpectationFn<ExpectFail>,
-): void;
-function runExpectation<ExpectFail extends boolean>(
-	describe: Mocha.SuiteFunction,
-	engine: keyof typeof sqlEquals,
-	expectFailure: ExpectFail,
-	input: string,
-	...args:
-		| [expectation: ExpectationFn<ExpectFail>]
-		| [
-				method: ODataParser.SupportedMethod,
-				expectation: ExpectationFn<ExpectFail>,
-		  ]
-		| [
-				method: ODataParser.SupportedMethod,
-				expectedBindings: ExpectedBindings | false,
-				expectation: ExpectationFn<ExpectFail>,
-		  ]
-		| [
-				method: ODataParser.SupportedMethod,
-				expectedBindings: ExpectedBindings | false,
-				body: Record<string, unknown>,
-				expectation: ExpectationFn<ExpectFail>,
-		  ]
-): void {
-	let method: ODataParser.SupportedMethod = 'GET';
-	let expectedBindings: ExpectedBindings | false = false;
-	let body: Record<string, unknown> = {};
-	let expectation: ExpectationFn<ExpectFail>;
-	switch (args.length) {
-		case 1:
-			[expectation] = args;
-			break;
-		case 2:
-			[method, expectation] = args;
-			break;
-		case 3:
-			[method, expectedBindings, expectation] = args;
-			break;
-		case 4:
-			[method, expectedBindings, body, expectation] = args;
-			break;
-	}
-
-	describe(
-		'Parsing ' + method + ' ' + _.truncate(input, { length: 100 }),
-		function () {
-			let result;
-			try {
-				const odataAST = ODataParser.parse(input);
-				const { tree, extraBodyVars } = odata2AbstractSQL.match(
-					odataAST.tree,
-					method,
-					_.keys(body),
-					0,
-				);
-				_.assign(body, extraBodyVars);
-				result = AbstractSQLCompiler[engine].compileRule(tree);
-			} catch (e: any) {
-				if (!expectFailure) {
-					throw e;
-				}
-				(expectation as ExpectationFailFn)(e);
-				return;
-			}
-			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: string,
-		method: ODataParser.SupportedMethod,
-		expectedBindings: ExpectedBindings | false,
-		body: Record<string, unknown>,
-		expectation: ExpectationFn<ExpectFail>,
-	): void;
-	(
-		input: string,
-		method: ODataParser.SupportedMethod,
-		expectedBindings: ExpectedBindings | false,
-		expectation: ExpectationFn<ExpectFail>,
-	): void;
-	(
-		input: string,
-		method: ODataParser.SupportedMethod,
-		expectation: ExpectationFn<ExpectFail>,
-	): void;
-	(input: string, expectation: ExpectationFn<ExpectFail>): void;
-	(
-		input: string,
-		...args:
-			| [expectation: ExpectationFn<ExpectFail>]
-			| [
-					method: ODataParser.SupportedMethod,
-					expectation: ExpectationFn<ExpectFail>,
-			  ]
-			| [
-					method: ODataParser.SupportedMethod,
-					expectedBindings: ExpectedBindings | false,
-					expectation: ExpectationFn<ExpectFail>,
-			  ]
-			| [
-					method: ODataParser.SupportedMethod,
-					expectedBindings: ExpectedBindings | false,
-					body: Record<string, unknown>,
-					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;