@balena/abstract-sql-compiler 10.6.3-build-tests-update-66ee93652310d4add5b0c8c09843dc052d796f5e-1 → 11.0.0-build-11-x-9f16483079cd561a9fdaa741cd830c2c5eb2065a-1

package/src/AbstractSQLCompiler.ts

@@ -6,24 +6,28 @@ export const enum Engines {
 	/* eslint-enable @typescript-eslint/no-shadow */
 }
 
-import { AbstractSQLOptimiser } from './AbstractSQLOptimiser';
-import type { Binding, SqlResult } from './AbstractSQLRules2SQL';
-import { AbstractSQLRules2SQL } from './AbstractSQLRules2SQL';
-export { Binding, SqlResult } from './AbstractSQLRules2SQL';
+import { AbstractSQLOptimiser } from './AbstractSQLOptimiser.js';
+import type { Binding, SqlResult } from './AbstractSQLRules2SQL.js';
+import { AbstractSQLRules2SQL } from './AbstractSQLRules2SQL.js';
+export { Binding, SqlResult } from './AbstractSQLRules2SQL.js';
 import type { SbvrType } from '@balena/sbvr-types';
-import sbvrTypes from '@balena/sbvr-types';
-import { optimizeSchema, generateRuleSlug } from './AbstractSQLSchemaOptimiser';
+import $sbvrTypes from '@balena/sbvr-types';
+const { default: sbvrTypes } = $sbvrTypes;
+import {
+	optimizeSchema,
+	generateRuleSlug,
+} from './AbstractSQLSchemaOptimiser.js';
 import type {
 	ReferencedFields,
 	RuleReferencedFields,
 	ModifiedFields,
-} from './referenced-fields';
+} from './referenced-fields.js';
 import {
 	getReferencedFields,
 	getRuleReferencedFields,
 	getModifiedFields,
 	insertAffectedIdsBinds,
-} from './referenced-fields';
+} from './referenced-fields.js';
 
 export type { ReferencedFields, RuleReferencedFields, ModifiedFields };
 
@@ -234,14 +238,7 @@ export type CaseNode =
 	| ['Case', ...WhenNode[]]
 	| ['Case', ...WhenNode[], ElseNode];
 
-/**
- * @deprecated This gets converted to the `['Bind', [string, string]]` form during compilation
- */
-type BackCompatBindNode = ['Bind', string, string];
-export type BindNode =
-	| ['Bind', number | string]
-	| ['Bind', [string, string]]
-	| BackCompatBindNode;
+export type BindNode = ['Bind', number | string] | ['Bind', [string, string]];
 export type CastNode = ['Cast', AnyTypeNodes, string];
 export type CoalesceNode = [
 	'Coalesce',
@@ -380,11 +377,6 @@ export type FromTypeNodes =
 	| FromTypeNode[keyof FromTypeNode]
 	| AliasNode<FromTypeNode[keyof FromTypeNode]>;
 
-/**
- * @deprecated `FromTypeNodes` already includes aliased versions
- */
-export type AliasableFromTypeNodes = FromTypeNodes;
-
 export type SelectNode = ['Select', AnyTypeNodes[]];
 export type FromNode = ['From', FromTypeNodes];
 export type InnerJoinNode = ['Join', FromTypeNodes, OnNode?];
@@ -494,6 +486,7 @@ export interface AbstractSqlTable {
 	primitive: false | string;
 	triggers?: Trigger[];
 	checks?: Check[];
+	viewDefinition?: Omit<Definition, 'binds'>;
 	definition?: Definition;
 	modifyFields?: AbstractSqlTable['fields'];
 	modifyName?: AbstractSqlTable['name'];
@@ -754,7 +747,9 @@ const compileSchema = (
 	engine: Engines,
 	ifNotExists: boolean,
 ): SqlModel => {
-	abstractSqlModel = optimizeSchema(abstractSqlModel, false);
+	abstractSqlModel = optimizeSchema(abstractSqlModel, {
+		createCheckConstraints: false,
+	});
 
 	let ifNotExistsStr = '';
 	let orReplaceStr = '';
@@ -815,21 +810,24 @@ $$;`);
 		if (typeof table === 'string') {
 			return;
 		}
-		const { definition } = table;
-		if (definition != null) {
+		const { definition, viewDefinition } = table;
+		if (viewDefinition != null && definition != null) {
+			throw new Error('Cannot have both a definition and a viewDefinition');
+		}
+		if (definition != null || viewDefinition != null) {
 			if (table.fields.some(({ computed }) => computed != null)) {
 				throw new Error(
 					`Using computed fields alongside a custom table definition is unsupported, found for table resourceName: '${table.resourceName}', name: '${table.name}'`,
 				);
 			}
-			if (definition.binds != null && definition.binds.length > 0) {
-				// If there are any binds then it's a dynamic definition and cannot become a view
-				return;
-			}
-			let definitionAbstractSql = definition.abstractSql;
+		}
+		if (viewDefinition != null) {
+			let definitionAbstractSql = viewDefinition.abstractSql;
 			// If there are any resource nodes then it's a dynamic definition and cannot become a view
 			if (abstractSqlContainsNode(definitionAbstractSql, isResourceNode)) {
-				return;
+				throw new Error(
+					`Cannot create a view from a dynamic viewDefinition, found for table resourceName: '${table.resourceName}', name: '${table.name}'`,
+				);
 			}
 			if (isTableNode(definitionAbstractSql)) {
 				// If the definition is a table node we need to wrap it in a select query for the view creation

package/src/AbstractSQLOptimiser.ts

@@ -70,7 +70,6 @@ import type {
 	ReferencedFieldNode,
 	ReplaceNode,
 	StrictBooleanTypeNodes,
-	StrictDateTypeNodes,
 	StrictNumberTypeNodes,
 	StrictTextTypeNodes,
 	RightJoinNode,
@@ -104,9 +103,9 @@ import type {
 	EscapeForLikeNode,
 	EqualsAnyNode,
 	NotInNode,
-} from './AbstractSQLCompiler';
-import { isFieldTypeNode } from './AbstractSQLCompiler';
-import * as AbstractSQLRules2SQL from './AbstractSQLRules2SQL';
+} from './AbstractSQLCompiler.js';
+import { isFieldTypeNode } from './AbstractSQLCompiler.js';
+import * as AbstractSQLRules2SQL from './AbstractSQLRules2SQL.js';
 
 const {
 	isAbstractSqlQuery,
@@ -297,9 +296,7 @@ const BooleanValue = MatchValue<BooleanTypeNodes>(
 	isBooleanValue as typeof AbstractSQLRules2SQL.isBooleanValue,
 );
 
-const isDateValue = (type: unknown): type is 'Now' | StrictDateTypeNodes[0] => {
-	return type === 'Now' || AbstractSQLRules2SQL.isDateValue(type);
-};
+const { isDateValue } = AbstractSQLRules2SQL;
 const DateValue = MatchValue(isDateValue);
 
 const { isJSONValue } = AbstractSQLRules2SQL;
@@ -1219,21 +1216,13 @@ const typeRules = {
 			];
 		},
 	),
-	Bind: tryMatches<BindNode>(
-		Helper<OptimisationMatchFn<BindNode>>((args) => {
-			if (args.length !== 2) {
-				return false;
-			}
-			return ['Bind', args] as BindNode;
-		}),
-		(args) => {
-			if (noBinds) {
-				throw new SyntaxError('Cannot use a bind whilst they are disabled');
-			}
-			checkArgs('Bind', args, 1);
-			return ['Bind', ...args] as BindNode;
-		},
-	),
+	Bind: (args) => {
+		if (noBinds) {
+			throw new SyntaxError('Cannot use a bind whilst they are disabled');
+		}
+		checkArgs('Bind', args, 1);
+		return ['Bind', ...args] as BindNode;
+	},
 	Text,
 	Value: Text,
 	Date: matchArgs('Date', identity),
@@ -1531,11 +1520,6 @@ const typeRules = {
 	EscapeForLike: matchArgs<EscapeForLikeNode>('EscapeForLike', TextValue),
 
 	// Virtual functions
-	Now: rewriteMatch(
-		'Now',
-		[],
-		Helper<MatchFn<CurrentTimestampNode>>(() => ['CurrentTimestamp']),
-	),
 	Contains: rewriteMatch(
 		'Contains',
 		[TextValue, TextValue],

package/src/AbstractSQLRules2SQL.ts

@@ -1,4 +1,5 @@
-import sbvrTypes from '@balena/sbvr-types';
+import $sbvrTypes from '@balena/sbvr-types';
+const { default: sbvrTypes } = $sbvrTypes;
 import type {
 	AbstractSqlQuery,
 	AbstractSqlType,
@@ -17,8 +18,8 @@ import type {
 	StrictDurationTypeNodes,
 	StrictTextArrayTypeNodes,
 	StrictJSONTypeNodes,
-} from './AbstractSQLCompiler';
-import { Engines, isFieldTypeNode } from './AbstractSQLCompiler';
+} from './AbstractSQLCompiler.js';
+import { Engines, isFieldTypeNode } from './AbstractSQLCompiler.js';
 
 export type Binding =
 	| [string, any]

package/src/AbstractSQLSchemaOptimiser.ts

@@ -4,17 +4,18 @@ export const enum Engines {
 	websql = 'websql',
 }
 
-import { AbstractSQLOptimiser } from './AbstractSQLOptimiser';
-export { Binding, SqlResult } from './AbstractSQLRules2SQL';
-import sbvrTypes from '@balena/sbvr-types';
+import { AbstractSQLOptimiser } from './AbstractSQLOptimiser.js';
+export { Binding, SqlResult } from './AbstractSQLRules2SQL.js';
+import $sbvrTypes from '@balena/sbvr-types';
+const { default: sbvrTypes } = $sbvrTypes;
 import type {
 	AbstractSqlModel,
 	AbstractSqlQuery,
 	AbstractSqlType,
 	BooleanTypeNodes,
 	WhereNode,
-} from './AbstractSQLCompiler';
-import { isFromNode, isSelectQueryNode } from './AbstractSQLCompiler';
+} from './AbstractSQLCompiler.js';
+import { isFromNode, isSelectQueryNode } from './AbstractSQLCompiler.js';
 
 const countFroms = (n: AbstractSqlType[]) => {
 	let count = 0;
@@ -43,7 +44,7 @@ export const generateRuleSlug = (
 
 export const optimizeSchema = (
 	abstractSqlModel: AbstractSqlModel,
-	createCheckConstraints = true,
+	{ createCheckConstraints = true } = {},
 ): AbstractSqlModel => {
 	abstractSqlModel.rules = abstractSqlModel.rules
 		.map((rule): AbstractSqlQuery | undefined => {

package/src/referenced-fields.ts

@@ -48,7 +48,7 @@ import type {
 	ToJSONNode,
 	UnionQueryNode,
 	WhereNode,
-} from './AbstractSQLCompiler';
+} from './AbstractSQLCompiler.js';
 import {
 	isAliasNode,
 	isFromNode,
@@ -56,9 +56,9 @@ import {
 	isSelectQueryNode,
 	isTableNode,
 	isWhereNode,
-} from './AbstractSQLCompiler';
-import { AbstractSQLOptimiser } from './AbstractSQLOptimiser';
-import { isAbstractSqlQuery } from './AbstractSQLRules2SQL';
+} from './AbstractSQLCompiler.js';
+import { AbstractSQLOptimiser } from './AbstractSQLOptimiser.js';
+import { isAbstractSqlQuery } from './AbstractSQLRules2SQL.js';
 
 export interface ReferencedFields {
 	[alias: string]: string[];

package/test/abstract-sql/aggregate-json.ts

@@ -1,4 +1,4 @@
-import test from './test';
+import test from './test.js';
 
 describe('AggregateJSON', () => {
 	test(

package/test/abstract-sql/aggregate.ts

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import test from './test';
+import test from './test.js';
 
 describe('Count', () => {
 	test(['SelectQuery', ['Select', [['Count', '*']]]], (result, sqlEquals) => {
@@ -33,7 +33,10 @@ describe('Sum', () => {
 
 describe('Subtract now timestamp from now timestamp', () => {
 	test(
-		['SelectQuery', ['Select', [['Subtract', ['Now'], ['Now']]]]],
+		[
+			'SelectQuery',
+			['Select', [['Subtract', ['CurrentTimestamp'], ['CurrentTimestamp']]]],
+		],
 		(result, sqlEquals) => {
 			it('Subtract now timestamp from now timestamp', () => {
 				sqlEquals(result, 'SELECT CURRENT_TIMESTAMP - CURRENT_TIMESTAMP');
@@ -46,7 +49,10 @@ describe('Subtract Duration from now timestamp', () => {
 	test(
 		[
 			'SelectQuery',
-			['Select', [['Subtract', ['Now'], ['Duration', { day: 1 }]]]],
+			[
+				'Select',
+				[['Subtract', ['CurrentTimestamp'], ['Duration', { day: 1 }]]],
+			],
 		],
 		(result, sqlEquals) => {
 			it('Subtract Duration from now timestamp', () => {
@@ -58,16 +64,25 @@ describe('Subtract Duration from now timestamp', () => {
 
 // this is not allowed
 describe('Add now timestamp to now timestamp should fail', () => {
-	test.fail(['SelectQuery', ['Select', [['Add', ['Now'], ['Now']]]]], (err) => {
-		it('Add now timestamp to now timestamp should fail', () => {
-			expect(err).to.be.an('error');
-		});
-	});
+	test.fail(
+		[
+			'SelectQuery',
+			['Select', [['Add', ['CurrentTimestamp'], ['CurrentTimestamp']]]],
+		],
+		(err) => {
+			it('Add now timestamp to now timestamp should fail', () => {
+				expect(err).to.be.an('error');
+			});
+		},
+	);
 });
 
 describe('Add Duration to now timestamp', () => {
 	test(
-		['SelectQuery', ['Select', [['Add', ['Now'], ['Duration', { day: 1 }]]]]],
+		[
+			'SelectQuery',
+			['Select', [['Add', ['CurrentTimestamp'], ['Duration', { day: 1 }]]]],
+		],
 		(result, sqlEquals) => {
 			it('Add Duration to now timestamp', () => {
 				sqlEquals(result, `SELECT CURRENT_TIMESTAMP + INTERVAL '1 0:0:0.0'`);
@@ -85,7 +100,7 @@ describe('Substract DateTrunc datefield from now timestamp', () => {
 				[
 					[
 						'Subtract',
-						['Now'],
+						['CurrentTimestamp'],
 						[
 							'DateTrunc',
 							['EmbeddedText', 'milliseconds'],

package/test/abstract-sql/and-or-boolean-optimisations.ts

@@ -1,5 +1,5 @@
 import { stripIndent } from 'common-tags';
-import test from './test';
+import test from './test.js';
 
 describe('Unnecessary booleans should be removed', () => {
 	test(

package/test/abstract-sql/case-when-else.ts

@@ -1,5 +1,8 @@
-import type { CaseNode, SelectQueryNode } from '../../src/AbstractSQLCompiler';
-import test from './test';
+import type {
+	CaseNode,
+	SelectQueryNode,
+} from '../../out/AbstractSQLCompiler.js';
+import test from './test.js';
 
 const buildSelect = (withElse: boolean): SelectQueryNode => {
 	let caseNode: CaseNode = [

package/test/abstract-sql/cast.ts

@@ -1,4 +1,4 @@
-import test from './test';
+import test from './test.js';
 
 describe('Cast', () => {
 	test(

package/test/abstract-sql/coalesce.ts

@@ -1,4 +1,4 @@
-import test from './test';
+import test from './test.js';
 
 describe('Coalesce', () => {
 	test(

package/test/abstract-sql/comparisons.ts

@@ -1,5 +1,5 @@
 import { stripIndent } from 'common-tags';
-import test from './test';
+import test from './test.js';
 
 describe('Between', () => {
 	test(

package/test/abstract-sql/dates.ts

@@ -1,4 +1,4 @@
-import test from './test';
+import test from './test.js';
 
 describe('Year', () => {
 	test(
@@ -359,7 +359,13 @@ describe('SubtractDateDate', () => {
 			'SelectQuery',
 			[
 				'Select',
-				[['Multiply', ['SubtractDateDate', ['Now'], ['Now']], ['Number', 4]]],
+				[
+					[
+						'Multiply',
+						['SubtractDateDate', ['CurrentTimestamp'], ['CurrentTimestamp']],
+						['Number', 4],
+					],
+				],
 			],
 		],
 		(result, sqlEquals) => {
@@ -377,7 +383,7 @@ describe('SubtractDateDate', () => {
 				[
 					[
 						'Multiply',
-						['SubtractDateDate', ['Now'], ['Now']],
+						['SubtractDateDate', ['CurrentTimestamp'], ['CurrentTimestamp']],
 						['Subtract', ['Number', 4], ['Number', 5]],
 					],
 				],
@@ -403,7 +409,7 @@ describe('SubtractDateDate', () => {
 						'SubtractDateDate',
 						[
 							'AddDateDuration',
-							['Now'],
+							['CurrentTimestamp'],
 							[
 								'Duration',
 								{

package/test/abstract-sql/duration.ts

@@ -1,4 +1,4 @@
-import test from './test';
+import test from './test.js';
 
 describe('Totalseconds', () => {
 	test(

package/test/abstract-sql/empty-query-optimisations.ts

@@ -1,7 +1,7 @@
 import { stripIndent } from 'common-tags';
-import type { SelectQueryNode } from '../../src/AbstractSQLCompiler';
+import type { SelectQueryNode } from '../../out/AbstractSQLCompiler.js';
 
-import test from './test';
+import test from './test.js';
 
 describe('Empty queries should be optimized', () => {
 	const emptyQuery: SelectQueryNode = [

package/test/abstract-sql/functions_wrapper.ts

@@ -1,5 +1,5 @@
 import { stripIndent } from 'common-tags';
-import test from './test';
+import test from './test.js';
 
 describe('Date trunc function on ReferencedField for milliseconds', () => {
 	test(

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

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import * as AbstractSqlCompiler from '../../src/AbstractSQLCompiler';
+import * as AbstractSqlCompiler from '../../out/AbstractSQLCompiler.js';
 
 describe('getReferencedFields', () => {
 	it('should work with selected fields', () => {

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

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import * as AbstractSqlCompiler from '../../src/AbstractSQLCompiler';
+import * as AbstractSqlCompiler from '../../out/AbstractSQLCompiler.js';
 
 describe('getRuleReferencedFields', () => {
 	it('should work with single table NOT EXISTS', () => {

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

@@ -1,4 +1,4 @@
-import test from './test';
+import test from './test.js';
 
 describe('Insert boolean value', () => {
 	test(

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

@@ -1,4 +1,4 @@
-import test from './test';
+import test from './test.js';
 
 describe('IsDistinctFrom', () => {
 	test(

package/test/abstract-sql/joins.ts

@@ -1,5 +1,5 @@
 import { stripIndent } from 'common-tags';
-import test from './test';
+import test from './test.js';
 
 const joinTest = (
 	joinType: 'Join' | 'RightJoin' | 'LeftJoin' | 'FullJoin',

package/test/abstract-sql/json.ts

@@ -1,4 +1,4 @@
-import test from './test';
+import test from './test.js';
 
 describe('ExtractJSONPathAsText', () => {
 	test(

package/test/abstract-sql/math.ts

@@ -1,4 +1,4 @@
-import test from './test';
+import test from './test.js';
 
 describe('Add', () => {
 	test(

package/test/abstract-sql/nested-in-optimisations.ts

@@ -1,5 +1,5 @@
 import { stripIndent } from 'common-tags';
-import test from './test';
+import test from './test.js';
 
 describe('Nested OR EQUALs should create a single IN statement', () => {
 	test(

package/test/abstract-sql/not-not-optimisations.ts

@@ -1,5 +1,5 @@
 import { stripIndent } from 'common-tags';
-import test from './test';
+import test from './test.js';
 
 describe('NOT(NOT(...)) should cancel each other out', () => {
 	test(['Not', ['Not', ['Boolean', true]]], [], (result, sqlEquals) => {

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

@@ -1,4 +1,4 @@
-import * as AbstractSQLCompiler from '../..';
+import * as AbstractSQLCompiler from '../../out/AbstractSQLCompiler.js';
 import { expect } from 'chai';
 
 it('an empty abstractSql model should produce an empty schema', () => {

package/test/abstract-sql/schema-informative-reference.ts

@@ -1,4 +1,4 @@
-import * as AbstractSQLCompiler from '../..';
+import * as AbstractSQLCompiler from '../../out/AbstractSQLCompiler.js';
 import { expect } from 'chai';
 
 describe('generate informative reference schema', () => {

package/test/abstract-sql/schema-rule-optimization.ts

@@ -1,4 +1,4 @@
-import * as AbstractSQLCompiler from '../..';
+import * as AbstractSQLCompiler from '../../out/AbstractSQLCompiler.js';
 import { expect } from 'chai';
 
 const generateSchema = (

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

@@ -1,4 +1,4 @@
-import * as AbstractSQLCompiler from '../..';
+import * as AbstractSQLCompiler from '../../out/AbstractSQLCompiler.js';
 import { expect } from 'chai';
 
 const generateSchema = (

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

@@ -1,7 +1,7 @@
-import * as AbstractSQLCompiler from '../..';
+import * as AbstractSQLCompiler from '../../out/AbstractSQLCompiler.js';
 import { expect } from 'chai';
 
-it('a table with a static definition should produce a view', () => {
+it('a table with a static definition should not produce a view', () => {
 	expect(
 		AbstractSQLCompiler.postgres.compileSchema({
 			synonyms: {},
@@ -30,6 +30,41 @@ it('a table with a static definition should produce a view', () => {
 		.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,4 +1,4 @@
-import * as AbstractSQLCompiler from '../..';
+import * as AbstractSQLCompiler from '../../out/AbstractSQLCompiler.js';
 
 import { expect } from 'chai';
 import _ from 'lodash';

package/test/abstract-sql/text.ts

@@ -1,4 +1,4 @@
-import test from './test';
+import test from './test.js';
 
 describe('Concatenate', () => {
 	test(

package/test/odata/expand.ts

@@ -1,12 +1,12 @@
-import type { ExpectationFailFn, ExpectationSuccessFn } from './test';
-import test from './test';
+import type { ExpectationFailFn, ExpectationSuccessFn } from './test.js';
+import test from './test.js';
 import {
 	pilotFields,
 	aliasFields,
 	aliasLicenceFields,
 	aliasPlaneFields,
 	aliasPilotCanFlyPlaneFields,
-} from './fields';
+} from './fields.js';
 import _ from 'lodash';
 
 type TestFn = (

package/test/odata/filterby.ts

@@ -4,16 +4,20 @@
  * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
  */
 import { expect } from 'chai';
-import type { ExpectationSuccessFn } from './test';
-import test, { clientModel } from './test';
+import type { ExpectationSuccessFn } from './test.js';
+import test, { clientModel } from './test.js';
 import _ from 'lodash';
 import { odataNameToSqlName } from '@balena/odata-to-abstract-sql';
-import { pilotFields, teamFields, aliasPilotCanFlyPlaneFields } from './fields';
+import {
+	pilotFields,
+	teamFields,
+	aliasPilotCanFlyPlaneFields,
+} from './fields.js';
 import type {
 	Binding,
 	DurationNode,
 	SqlResult,
-} from '../../src/AbstractSQLCompiler';
+} from '../../out/AbstractSQLCompiler.js';
 
 const pilotFieldsStr = pilotFields.join(', ');
 const aliasPilotCanFlyPlaneFieldsStr = aliasPilotCanFlyPlaneFields.join(', ');