@balena/pinejs 15.0.0-true-boolean-911aca4062d3132ad3c34712014739b6849fa13a → 15.0.0

package/src/migrator/utils.ts

@@ -0,0 +1,458 @@
+import type { Result, Tx } from '../database-layer/db';
+import type { Resolvable } from '../sbvr-api/common-types';
+
+import { createHash } from 'crypto';
+import { Engines } from '@balena/abstract-sql-compiler';
+import * as _ from 'lodash';
+import { TypedError } from 'typed-error';
+import { migrator as migratorEnv } from '../config-loader/env';
+export { migrator as migratorEnv } from '../config-loader/env';
+import { PINEJS_ADVISORY_LOCK } from '../config-loader/env';
+import { delay } from '../sbvr-api/control-flow';
+
+// tslint:disable-next-line:no-var-requires
+export const modelText = require('./migrations.sbvr');
+export const migrations: Migrations = {
+	'15.0.0-data-types': async (tx, { db }) => {
+		switch (db.engine) {
+			case 'mysql':
+				await tx.executeSql(`\
+					ALTER TABLE "migration"
+					MODIFY "executed migrations" JSON NOT NULL;`);
+				await tx.executeSql(`\
+					ALTER TABLE "migration status"
+					MODIFY "is backing off" BOOLEAN NOT NULL;`);
+				break;
+			case 'postgres':
+				await tx.executeSql(`\
+					ALTER TABLE "migration"
+					ALTER COLUMN "executed migrations" SET DATA TYPE JSONB USING "executed migrations"::JSONB;`);
+				await tx.executeSql(`\
+					ALTER TABLE "migration status"
+					ALTER COLUMN "is backing off" DROP DEFAULT,
+					ALTER COLUMN "is backing off" SET DATA TYPE BOOLEAN USING "is backing off"::BOOLEAN,
+					ALTER COLUMN "is backing off" SET DEFAULT FALSE;`);
+				break;
+			// No need to migrate for websql
+		}
+	},
+};
+
+import * as sbvrUtils from '../sbvr-api/sbvr-utils';
+export enum MigrationCategories {
+	'sync' = 'sync',
+	'async' = 'async',
+}
+export const defaultMigrationCategory = MigrationCategories.sync;
+export type CategorizedMigrations = {
+	[key in MigrationCategories]: RunnableMigrations;
+};
+
+type SbvrUtils = typeof sbvrUtils;
+export type MigrationTuple = [string, Migration];
+export type MigrationFn = (tx: Tx, sbvrUtils: SbvrUtils) => Resolvable<void>;
+export type RunnableMigrations = { [key: string]: Migration };
+export type RunnableAsyncMigrations = { [key: string]: AsyncMigration };
+export type Migrations = CategorizedMigrations | RunnableMigrations;
+export type AsyncMigrationFn = (
+	tx: Tx,
+	options: { batchSize: number },
+	sbvrUtils: SbvrUtils,
+) => Resolvable<number>;
+
+type AddFn<T extends {}, x extends 'sync' | 'async'> = T & {
+	[key in `${x}Fn`]: key extends 'syncFn' ? MigrationFn : AsyncMigrationFn;
+} & {
+	[key in `${x}Sql`]?: undefined;
+};
+type AddSql<T extends {}, x extends 'sync' | 'async'> = T & {
+	[key in `${x}Fn`]?: undefined;
+} & {
+	[key in `${x}Sql`]: string;
+};
+
+export type BaseAsyncMigration = {
+	type?: MigrationCategories.async;
+	delayMS?: number | undefined;
+	backoffDelayMS?: number | undefined;
+	errorThreshold?: number | undefined;
+	asyncBatchSize?: number | undefined;
+	finalize?: boolean | undefined;
+};
+export type AsyncMigration =
+	| AddFn<BaseAsyncMigration, 'async' | 'sync'>
+	| AddSql<BaseAsyncMigration, 'async' | 'sync'>
+	| AddFn<AddSql<BaseAsyncMigration, 'async'>, 'sync'>
+	| AddFn<AddSql<BaseAsyncMigration, 'sync'>, 'async'>;
+
+export function isAsyncMigration(
+	migration: string | MigrationFn | AsyncMigration | RunnableMigrations,
+): migration is AsyncMigration {
+	return (
+		((typeof (migration as AsyncMigration).asyncFn === 'function' ||
+			typeof (migration as AsyncMigration).asyncSql === 'string') &&
+			(typeof (migration as AsyncMigration).syncFn === 'function' ||
+				typeof (migration as AsyncMigration).syncSql === 'string')) ||
+		(migration as AsyncMigration).type === MigrationCategories.async
+	);
+}
+
+export function isSyncMigration(
+	migration: string | MigrationFn | RunnableMigrations | AsyncMigration,
+): migration is MigrationFn {
+	return typeof migration === 'function' || typeof migration === 'string';
+}
+export function areCategorizedMigrations(
+	$migrations: Migrations,
+): $migrations is CategorizedMigrations {
+	const containsCategories = Object.keys(MigrationCategories).some(
+		(key) => key in $migrations,
+	);
+	if (
+		containsCategories &&
+		Object.keys($migrations).some((key) => !(key in MigrationCategories))
+	) {
+		throw new Error(
+			'Mixing categorized and uncategorized migrations is not supported',
+		);
+	}
+	return containsCategories;
+}
+
+export type Migration = string | MigrationFn | AsyncMigration;
+export class MigrationError extends TypedError {}
+
+export type MigrationStatus = {
+	migration_key: string;
+	start_time: Date;
+	last_run_time: Date | null;
+	run_count: number;
+	migrated_row_count: number;
+	error_count: number;
+	converged_time: Date | undefined;
+	is_backing_off: boolean;
+};
+
+export const getRunnableAsyncMigrations = (
+	$migrations: Migrations,
+): RunnableAsyncMigrations | undefined => {
+	if ($migrations[MigrationCategories.async]) {
+		if (
+			Object.values($migrations[MigrationCategories.async]).some(
+				(migration) => !isAsyncMigration(migration),
+			) ||
+			typeof $migrations[MigrationCategories.async] !== 'object'
+		) {
+			throw new Error(
+				`All loaded async migrations need to be of type: ${MigrationCategories.async}`,
+			);
+		}
+		return $migrations[MigrationCategories.async] as RunnableAsyncMigrations;
+	}
+};
+
+// migration loader should either get migrations from model
+// or from the filepath
+export const getRunnableSyncMigrations = (
+	$migrations: Migrations,
+): RunnableMigrations => {
+	if (areCategorizedMigrations($migrations)) {
+		const runnableMigrations: RunnableMigrations = {};
+		for (const [category, categoryMigrations] of Object.entries($migrations)) {
+			if (category in MigrationCategories) {
+				for (const [key, migration] of Object.entries(
+					categoryMigrations as Migrations,
+				)) {
+					if (isAsyncMigration(migration)) {
+						if (migration.finalize) {
+							runnableMigrations[key] = migration.syncFn ?? migration.syncSql;
+						}
+					} else if (isSyncMigration(migration)) {
+						runnableMigrations[key] = migration;
+					}
+				}
+			}
+		}
+		return runnableMigrations;
+	}
+	return $migrations;
+};
+
+// turns {"key1": migration, "key3": migration, "key2": migration}
+// into  [["key1", migration], ["key2", migration], ["key3", migration]]
+export const filterAndSortPendingMigrations = (
+	$migrations: NonNullable<RunnableMigrations | RunnableAsyncMigrations>,
+	executedMigrations: string[],
+): MigrationTuple[] =>
+	(_($migrations).omit(executedMigrations) as _.Object<typeof $migrations>)
+		.toPairs()
+		.sortBy(([migrationKey]) => migrationKey)
+		.value();
+
+// Tagged template to convert binds from `?` format to the necessary output format,
+// eg `$1`/`$2`/etc for postgres
+export const binds = (strings: TemplateStringsArray, ...bindNums: number[]) =>
+	strings
+		.map((str, i) => {
+			if (i === bindNums.length) {
+				return str;
+			}
+			if (i + 1 !== bindNums[i]) {
+				throw new SyntaxError('Migration sql binds must be sequential');
+			}
+			if (sbvrUtils.db.engine === Engines.postgres) {
+				return str + `$${bindNums[i]}`;
+			}
+			return str + `?`;
+		})
+		.join('');
+
+/**
+ * Lock mechanism that tries to write model name to the migration lock table
+ * This creates an index write lock on this row. This lock is never persisted
+ * as the lock is hold only in the transaction and is delete at the end of the
+ * transaction.
+ *
+ * Disadvantage is that no blocking-wait queue can be generated on this lock mechanism
+ * It's database engine agnostic and works also for webSQL
+ */
+const $lockMigrations = async <T>(
+	tx: Tx,
+	modelName: string,
+	fn: () => Promise<T>,
+): Promise<T | undefined> => {
+	try {
+		await tx.executeSql(
+			binds`
+DELETE FROM "migration lock"
+WHERE "model name" = ${1}
+AND "created at" < ${2}`,
+			[modelName, new Date(Date.now() - migratorEnv.lockTimeout)],
+		);
+		await tx.executeSql(
+			binds`
+INSERT INTO "migration lock" ("model name")
+VALUES (${1})`,
+			[modelName],
+		);
+	} catch (err: any) {
+		await delay(migratorEnv.lockFailDelay);
+		throw err;
+	}
+	try {
+		return await fn();
+	} finally {
+		try {
+			await tx.executeSql(
+				binds`
+DELETE FROM "migration lock"
+WHERE "model name" = ${1}`,
+				[modelName],
+			);
+		} catch {
+			// We ignore errors here as it's mostly likely caused by the migration failing and
+			// rolling back the transaction, and if we rethrow here we'll overwrite the real error
+			// making it much harder for users to see what went wrong and fix it
+		}
+	}
+};
+
+export const lockMigrations = async <T>(
+	options: { tx: Tx; modelName: string; blocking: boolean },
+	fn: () => Promise<T>,
+): Promise<T | undefined> => {
+	if (!(await migrationTablesExist(options.tx))) {
+		return;
+	}
+
+	if (sbvrUtils.db.engine === Engines.websql) {
+		return $lockMigrations(options.tx, options.modelName, fn);
+	} else if (sbvrUtils.db.engine === Engines.mysql) {
+		// right now the mysql locks are not testable
+		// pinejs generates models that are not executable on mysql databases
+		return $lockMigrations(options.tx, options.modelName, fn);
+	} else if (sbvrUtils.db.engine === Engines.postgres) {
+		// getTxLevelLock expects a 4 byte integer as the lock key.
+		// Therefore the model name is hashed and the first 4 bytes are taken as the Integer representation.
+		const modelKey: number = createHash('shake128', { outputLength: 4 })
+			.update('resin')
+			.digest()
+			.readInt32BE();
+		const lockStatus = await options.tx.getTxLevelLock(
+			PINEJS_ADVISORY_LOCK.namespaceKey,
+			modelKey,
+			options.blocking,
+		);
+
+		if (lockStatus) {
+			return await fn();
+		}
+	} else {
+		// we report any error here, as no error should happen at all
+		throw new Error(`unknown database engine for getting migration locks`);
+	}
+};
+
+export const setExecutedMigrations = async (
+	tx: Tx,
+	modelName: string,
+	executedMigrations: string[],
+): Promise<void> => {
+	if (!(await migrationTablesExist(tx))) {
+		return;
+	}
+
+	const stringifiedMigrations = await sbvrUtils.sbvrTypes.JSON.validate(
+		executedMigrations,
+		true,
+	);
+
+	const { rowsAffected } = await tx.executeSql(
+		binds`
+UPDATE "migration"
+SET "model name" = ${1},
+"executed migrations" = ${2}
+WHERE "migration"."model name" = ${3}`,
+		[modelName, stringifiedMigrations, modelName],
+	);
+
+	if (rowsAffected === 0) {
+		await tx.executeSql(
+			binds`
+INSERT INTO "migration" ("model name", "executed migrations")
+VALUES (${1}, ${2})`,
+			[modelName, stringifiedMigrations],
+		);
+	}
+};
+
+export const getExecutedMigrations = async (
+	tx: Tx,
+	modelName: string,
+): Promise<string[]> => {
+	if (!(await migrationTablesExist(tx))) {
+		return [];
+	}
+
+	const { rows } = await tx.executeSql(
+		binds`
+SELECT "migration"."executed migrations" AS "executed_migrations"
+FROM "migration"
+WHERE "migration"."model name" = ${1}`,
+		[modelName],
+	);
+
+	const data = rows[0];
+	if (data == null) {
+		return [];
+	}
+	return sbvrUtils.sbvrTypes.JSON.fetchProcessing(data.executed_migrations);
+};
+
+export const migrationTablesExist = async (tx: Tx) => {
+	const tables = ['migration', 'migration lock', 'migration status'];
+	const where = tables.map((tableName) => `name = '${tableName}'`).join(' OR ');
+	const result = await tx.tableList(where);
+	return result.rows.length === tables.length;
+};
+
+export const initMigrationStatus = async (
+	tx: Tx,
+	migrationStatus: MigrationStatus,
+): Promise<Result | undefined> => {
+	try {
+		return await tx.executeSql(
+			binds`
+INSERT INTO "migration status" ("migration key", "start time", "is backing off", "run count")
+SELECT ${1}, ${2}, ${3}, ${4}
+WHERE NOT EXISTS (SELECT 1 FROM "migration status" WHERE "migration key" = ${5})
+`,
+			[
+				migrationStatus['migration_key'],
+				migrationStatus['start_time'],
+				migrationStatus['is_backing_off'],
+				migrationStatus['run_count'],
+				migrationStatus['migration_key'],
+			],
+		);
+	} catch (err: any) {
+		// we report any error here, as no error should happen at all
+		throw new Error(`unknown error in init migration status: ${err}`);
+	}
+};
+
+// Update all fields of migration status for cross-instance sync
+export const updateMigrationStatus = async (
+	tx: Tx,
+	migrationStatus: MigrationStatus,
+): Promise<Result | undefined> => {
+	try {
+		return await tx.executeSql(
+			binds`
+UPDATE "migration status"
+SET
+"run count"	= ${1},
+"last run time" = ${2},
+"migrated row count" = ${3},
+"error count" = ${4},
+"converged time" = ${5},
+"is backing off" = ${6}
+WHERE "migration status"."migration key" = ${7};`,
+			[
+				migrationStatus['run_count'],
+				migrationStatus['last_run_time'],
+				migrationStatus['migrated_row_count'],
+				migrationStatus['error_count'],
+				migrationStatus['converged_time'],
+				migrationStatus['is_backing_off'],
+				migrationStatus['migration_key'],
+			],
+		);
+	} catch (err: any) {
+		// we report any error here, as no error should happen at all
+		throw new Error(`unknown error in update migration status: ${err}`);
+	}
+};
+
+export const readMigrationStatus = async (
+	tx: Tx,
+	migrationKey: string,
+): Promise<MigrationStatus | undefined> => {
+	try {
+		const { rows } = await tx.executeSql(
+			binds`
+SELECT *
+FROM "migration status"
+WHERE "migration status"."migration key" = ${1}
+LIMIT 1;`,
+			[migrationKey],
+		);
+
+		const data = rows[0];
+		if (data == null) {
+			return;
+		}
+
+		return {
+			migration_key: data['migration key'],
+			start_time: sbvrUtils.sbvrTypes['Date Time'].fetchProcessing(
+				data['start time'],
+			),
+			last_run_time: sbvrUtils.sbvrTypes['Date Time'].fetchProcessing(
+				data['last run time'],
+			),
+			run_count: data['run count'],
+			migrated_row_count: data['migrated row count'],
+			error_count: data['error count'],
+			converged_time: sbvrUtils.sbvrTypes['Date Time'].fetchProcessing(
+				data['converged time'],
+			),
+			is_backing_off: sbvrUtils.sbvrTypes.Boolean.fetchProcessing(
+				data['is backing off'],
+			),
+		};
+	} catch (err: any) {
+		// we report any error here, as no error should happen at all
+		throw new Error(`unknown error in read migration status: ${err}`);
+	}
+};

package/src/odata-metadata/odata-metadata-generator.ts

@@ -3,7 +3,7 @@ import type {
 	AbstractSqlTable,
 } from '@balena/abstract-sql-compiler';
 
-import * as sbvrTypes from '@balena/sbvr-types';
+import sbvrTypes, { SbvrType } from '@balena/sbvr-types';
 
 // tslint:disable-next-line:no-var-requires
 const { version }: { version: string } = require('../../package.json');
@@ -21,17 +21,14 @@ const forEachUniqueTable = <T>(
 	const usedTableNames: { [tableName: string]: true } = {};
 
 	const result = [];
-	for (const key in model) {
-		if (model.hasOwnProperty(key)) {
-			const table = model[key];
-			if (
-				typeof table !== 'string' &&
-				!table.primitive &&
-				!usedTableNames[table.name]
-			) {
-				usedTableNames[table.name] = true;
-				result.push(callback(key, table));
-			}
+	for (const [key, table] of Object.entries(model)) {
+		if (
+			typeof table !== 'string' &&
+			!table.primitive &&
+			!usedTableNames[table.name]
+		) {
+			usedTableNames[table.name] = true;
+			result.push(callback(key, table));
 		}
 	}
 	return result;
@@ -42,12 +39,12 @@ export const generateODataMetadata = (
 	abstractSqlModel: AbstractSqlModel,
 ) => {
 	const complexTypes: { [fieldType: string]: string } = {};
-	const resolveDataType = (fieldType: string): string => {
+	const resolveDataType = (fieldType: keyof typeof sbvrTypes): string => {
 		if (sbvrTypes[fieldType] == null) {
 			console.error('Could not resolve type', fieldType);
 			throw new Error('Could not resolve type' + fieldType);
 		}
-		const { complexType } = sbvrTypes[fieldType].types.odata;
+		const { complexType } = (sbvrTypes[fieldType] as SbvrType).types.odata;
 		if (complexType != null) {
 			complexTypes[fieldType] = complexType;
 		}
@@ -104,7 +101,7 @@ export const generateODataMetadata = (
 					fields
 						.filter(({ dataType }) => dataType !== 'ForeignKey')
 						.map(({ dataType, fieldName, required }) => {
-							dataType = resolveDataType(dataType);
+							dataType = resolveDataType(dataType as keyof typeof sbvrTypes);
 							fieldName = getResourceName(fieldName);
 							return `<Property Name="${fieldName}" Type="${dataType}" Nullable="${!required}" />`;
 						})

package/src/passport-pinejs/passport-pinejs.ts

@@ -2,6 +2,7 @@ import type * as Express from 'express';
 import type * as Passport from 'passport';
 import type * as PassportLocal from 'passport-local';
 import type * as ConfigLoader from '../config-loader/config-loader';
+import type { User } from '../sbvr-api/sbvr-utils';
 
 import * as permissions from '../sbvr-api/permissions';
 
@@ -9,7 +10,7 @@ import * as permissions from '../sbvr-api/permissions';
 export let login: (
 	fn: (
 		err: any,
-		user: {} | undefined,
+		user: {} | null | false | undefined,
 		req: Express.Request,
 		res: Express.Response,
 		next: Express.NextFunction,
@@ -46,26 +47,27 @@ const setup: ConfigLoader.SetupFunction = async (app: Express.Application) => {
 			done(null, user);
 		});
 
-		passport.deserializeUser((user, done) => {
+		passport.deserializeUser<User>((user, done) => {
 			done(null, user);
 		});
 
 		passport.use(new LocalStrategy(checkPassword));
 
 		login = (fn) => (req, res, next) =>
-			passport.authenticate('local', (err: any, user?: {}) => {
-				if (err || user == null) {
+			passport.authenticate('local', ((err, user) => {
+				if (err || user == null || user === false) {
 					fn(err, user, req, res, next);
 					return;
 				}
 				req.login(user, (error) => {
 					fn(error, user, req, res, next);
 				});
-			})(req, res, next);
+			}) as Passport.AuthenticateCallback)(req, res, next);
 
 		logout = (req, _res, next) => {
-			req.logout();
-			next();
+			req.logout((error) => {
+				error ? next(error) : next();
+			});
 		};
 	} else {
 		let loggedIn = false;

package/src/pinejs-session-store/pinejs-session-store.ts

@@ -146,7 +146,6 @@ export class PinejsSessionStore extends Store {
 				},
 				options: {
 					$count: {
-						$select: 'session_id',
 						$filter: {
 							expiry_time: {
 								$ge: Date.now(),
@@ -173,6 +172,21 @@ export class PinejsSessionStore extends Store {
 						ALTER TABLE "session"
 						ADD COLUMN IF NOT EXISTS "modified at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL;
 					`,
+					'15.0.0-data-types': async (tx, sbvrUtils) => {
+						switch (sbvrUtils.db.engine) {
+							case 'mysql':
+								await tx.executeSql(`\
+									ALTER TABLE "session"
+									MODIFY "data" JSON NOT NULL;`);
+								break;
+							case 'postgres':
+								await tx.executeSql(`\
+									ALTER TABLE "session"
+									ALTER COLUMN "data" SET DATA TYPE JSONB USING "data"::JSONB;`);
+								break;
+							// No need to migrate for websql
+						}
+					},
 				},
 			},
 		],

package/src/sbvr-api/abstract-sql.ts

@@ -1,6 +1,7 @@
 import * as _ from 'lodash';
 
 import * as AbstractSQLCompiler from '@balena/abstract-sql-compiler';
+import type { BindKey } from '@balena/odata-parser';
 import {
 	ODataBinds,
 	odataNameToSqlName,
@@ -8,7 +9,6 @@ import {
 } from '@balena/odata-to-abstract-sql';
 import deepFreeze = require('deep-freeze');
 import * as memoize from 'memoizee';
-import memoizeWeak = require('memoizee/weak');
 import * as env from '../config-loader/env';
 import { BadRequestError, SqlCompilationError } from './errors';
 import * as sbvrUtils from './sbvr-utils';
@@ -16,14 +16,13 @@ import { ODataRequest } from './uri-parser';
 
 const getMemoizedCompileRule = memoize(
 	(engine: AbstractSQLCompiler.Engines) =>
-		memoizeWeak(
+		env.createCache(
+			'abstractSqlCompiler',
 			(abstractSqlQuery: AbstractSQLCompiler.AbstractSqlQuery) => {
-				const sqlQuery = AbstractSQLCompiler[engine].compileRule(
-					abstractSqlQuery,
-				);
-				const modifiedFields = AbstractSQLCompiler[engine].getModifiedFields(
-					abstractSqlQuery,
-				);
+				const sqlQuery =
+					AbstractSQLCompiler[engine].compileRule(abstractSqlQuery);
+				const modifiedFields =
+					AbstractSQLCompiler[engine].getModifiedFields(abstractSqlQuery);
 				if (modifiedFields != null) {
 					deepFreeze(modifiedFields);
 				}
@@ -32,7 +31,7 @@ const getMemoizedCompileRule = memoize(
 					modifiedFields,
 				};
 			},
-			{ max: env.cache.abstractSqlCompiler.max },
+			{ weak: true },
 		),
 	{ primitive: true },
 );
@@ -49,7 +48,7 @@ export const compileRequest = (request: ODataRequest) => {
 			);
 			request.sqlQuery = sqlQuery;
 			request.modifiedFields = modifiedFields;
-		} catch (err) {
+		} catch (err: any) {
 			sbvrUtils.api[request.vocabulary].logger.error(
 				'Failed to compile abstract sql: ',
 				request.abstractSqlQuery,
@@ -97,7 +96,8 @@ export const getAndCheckBindValues = async (
 
 					const sqlTableName = odataNameToSqlName(tableName);
 					const sqlFieldName = odataNameToSqlName(fieldName);
-					const maybeField = sqlModelTables[sqlTableName].fields.find(
+					const table = sqlModelTables[sqlTableName];
+					const maybeField = (table.modifyFields ?? table.fields).find(
 						(f) => f.fieldName === sqlFieldName,
 					);
 					if (maybeField == null) {
@@ -124,7 +124,7 @@ export const getAndCheckBindValues = async (
 						throw new Error('Invalid binding');
 					}
 					let dataType;
-					[dataType, value] = odataBinds[bindValue];
+					[dataType, value] = odataBinds[bindValue as BindKey];
 					field = { dataType };
 				} else {
 					throw new Error(`Unknown binding: ${binding}`);
@@ -141,7 +141,7 @@ export const getAndCheckBindValues = async (
 
 			try {
 				return await AbstractSQLCompiler[engine].dataTypeValidate(value, field);
-			} catch (err) {
+			} catch (err: any) {
 				throw new BadRequestError(`"${fieldName}" ${err.message}`);
 			}
 		}),
@@ -175,7 +175,10 @@ const checkModifiedFields = (
 };
 export const isRuleAffected = (
 	rule: AbstractSQLCompiler.SqlRule,
-	request?: ODataRequest,
+	request?: Pick<
+		ODataRequest,
+		'abstractSqlQuery' | 'modifiedFields' | 'method' | 'vocabulary'
+	>,
 ) => {
 	// If there is no abstract sql query then nothing was modified
 	if (request?.abstractSqlQuery == null) {

package/src/sbvr-api/common-types.ts

@@ -1,4 +1,4 @@
-export { AnyObject } from 'pinejs-client-core';
+export { AnyObject, Dictionary } from 'pinejs-client-core';
 
 type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
 export type RequiredField<T, F extends keyof T> = Overwrite<
@@ -10,3 +10,4 @@ export type OptionalField<T, F extends keyof T> = Overwrite<
 	Partial<Pick<T, F>>
 >;
 export type Resolvable<R> = R | PromiseLike<R>;
+export type Tail<T extends any[]> = T extends [any, ...infer U] ? U : never;