@balena/pinejs 14.60.0-build-translated-models-85baf731130de328e2067a26c40b37309cdb1ac5-1 → 15.0.0-build-15-x-4681209f5dd8d896491fb5ed64aea47df511c14d-1

package/src/http-transactions/transactions.js

@@ -3,6 +3,7 @@ import { odataNameToSqlName } from '@balena/odata-to-abstract-sql';
 // @ts-ignore
 const transactionModel = require('./transaction.sbvr');
 
+/** @type {import('../config-loader/config-loader').Config} */
 export let config = {
 	models: [
 		{
@@ -24,6 +25,23 @@ ADD COLUMN IF NOT EXISTS "modified at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT N
 ALTER TABLE "transaction"
 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 "lock"
+								MODIFY "is exclusive" BOOLEAN NOT NULL,
+								MODIFY "is under lock" BOOLEAN NOT NULL;`);
+							break;
+						case 'postgres':
+							await tx.executeSql(`\
+								ALTER TABLE "lock"
+								ALTER COLUMN "is exclusive" SET DATA TYPE BOOLEAN USING b::BOOLEAN,
+								ALTER COLUMN "is under lock" SET DATA TYPE BOOLEAN USING b::BOOLEAN;`);
+							break;
+						// No need to migrate for websql
+					}
+				},
 			},
 		},
 	],

package/src/migrator/utils.ts

@@ -12,6 +12,23 @@ 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;`);
+				break;
+			case 'postgres':
+				await tx.executeSql(`\
+					ALTER TABLE "migration"
+					ALTER COLUMN "executed migrations" SET DATA TYPE JSONB USING b::JSONB;`);
+				break;
+			// No need to migrate for websql
+		}
+	},
+};
 
 import * as sbvrUtils from '../sbvr-api/sbvr-utils';
 export enum MigrationCategories {
@@ -73,14 +90,14 @@ export function isSyncMigration(
 	return typeof migration === 'function' || typeof migration === 'string';
 }
 export function areCategorizedMigrations(
-	migrations: Migrations,
-): migrations is CategorizedMigrations {
+	$migrations: Migrations,
+): $migrations is CategorizedMigrations {
 	const containsCategories = Object.keys(MigrationCategories).some(
-		(key) => key in migrations,
+		(key) => key in $migrations,
 	);
 	if (
 		containsCategories &&
-		Object.keys(migrations).some((key) => !(key in MigrationCategories))
+		Object.keys($migrations).some((key) => !(key in MigrationCategories))
 	) {
 		throw new Error(
 			'Mixing categorized and uncategorized migrations is not supported',
@@ -104,31 +121,31 @@ export type MigrationStatus = {
 };
 
 export const getRunnableAsyncMigrations = (
-	migrations: Migrations,
+	$migrations: Migrations,
 ): RunnableAsyncMigrations | undefined => {
-	if (migrations[MigrationCategories.async]) {
+	if ($migrations[MigrationCategories.async]) {
 		if (
-			Object.values(migrations[MigrationCategories.async]).some(
+			Object.values($migrations[MigrationCategories.async]).some(
 				(migration) => !isAsyncMigration(migration),
 			) ||
-			typeof migrations[MigrationCategories.async] !== 'object'
+			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;
+		return $migrations[MigrationCategories.async] as RunnableAsyncMigrations;
 	}
 };
 
 // migration loader should either get migrations from model
 // or from the filepath
 export const getRunnableSyncMigrations = (
-	migrations: Migrations,
+	$migrations: Migrations,
 ): RunnableMigrations => {
-	if (areCategorizedMigrations(migrations)) {
+	if (areCategorizedMigrations($migrations)) {
 		const runnableMigrations: RunnableMigrations = {};
-		for (const [category, categoryMigrations] of Object.entries(migrations)) {
+		for (const [category, categoryMigrations] of Object.entries($migrations)) {
 			if (category in MigrationCategories) {
 				for (const [key, migration] of Object.entries(
 					categoryMigrations as Migrations,
@@ -145,16 +162,16 @@ export const getRunnableSyncMigrations = (
 		}
 		return runnableMigrations;
 	}
-	return migrations;
+	return $migrations;
 };
 
 // turns {"key1": migration, "key3": migration, "key2": migration}
 // into  [["key1", migration], ["key2", migration], ["key3", migration]]
 export const filterAndSortPendingMigrations = (
-	migrations: NonNullable<RunnableMigrations | RunnableAsyncMigrations>,
+	$migrations: NonNullable<RunnableMigrations | RunnableAsyncMigrations>,
 	executedMigrations: string[],
 ): MigrationTuple[] =>
-	(_(migrations).omit(executedMigrations) as _.Object<typeof migrations>)
+	(_($migrations).omit(executedMigrations) as _.Object<typeof $migrations>)
 		.toPairs()
 		.sortBy(([migrationKey]) => migrationKey)
 		.value();
@@ -313,8 +330,10 @@ WHERE "migration"."model name" = ${1}`,
 	if (data == null) {
 		return [];
 	}
-
-	return JSON.parse(data.executed_migrations) as string[];
+	if (typeof data.executed_migrations === 'string') {
+		return JSON.parse(data.executed_migrations);
+	}
+	return data.executed_migrations;
 };
 
 export const migrationTablesExist = async (tx: Tx) => {
@@ -338,7 +357,7 @@ WHERE NOT EXISTS (SELECT 1 FROM "migration status" WHERE "migration key" = ${5})
 			[
 				migrationStatus['migration_key'],
 				migrationStatus['start_time'],
-				migrationStatus['is_backing_off'] ? 1 : 0,
+				migrationStatus['is_backing_off'],
 				migrationStatus['run_count'],
 				migrationStatus['migration_key'],
 			],
@@ -372,7 +391,7 @@ WHERE "migration status"."migration key" = ${7};`,
 				migrationStatus['migrated_row_count'],
 				migrationStatus['error_count'],
 				migrationStatus['converged_time'],
-				migrationStatus['is_backing_off'] ? 1 : 0,
+				migrationStatus['is_backing_off'],
 				migrationStatus['migration_key'],
 			],
 		);
@@ -409,7 +428,8 @@ LIMIT 1;`,
 			migrated_row_count: data['migrated row count'],
 			error_count: data['error count'],
 			converged_time: data['converged time'],
-			is_backing_off: data['is backing off'] === 1,
+			is_backing_off:
+				data['is backing off'] === true || data['is backing off'] === 1,
 		};
 	} catch (err: any) {
 		// we report any error here, as no error should happen at all

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

@@ -173,6 +173,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 b::JSONB;`);
+								break;
+							// No need to migrate for websql
+						}
+					},
 				},
 			},
 		],

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

@@ -95,8 +95,7 @@ export const getAndCheckBindValues = async (
 
 					const sqlTableName = odataNameToSqlName(tableName);
 					const sqlFieldName = odataNameToSqlName(fieldName);
-					const table = sqlModelTables[sqlTableName];
-					const maybeField = (table.modifyFields ?? table.fields).find(
+					const maybeField = sqlModelTables[sqlTableName].fields.find(
 						(f) => f.fieldName === sqlFieldName,
 					);
 					if (maybeField == null) {

package/src/sbvr-api/hooks.ts

@@ -42,9 +42,7 @@ export interface Hooks {
 	PREPARSE?: (options: Omit<HookArgs, 'request' | 'api'>) => HookResponse;
 	POSTPARSE?: (options: HookArgs) => HookResponse;
 	PRERUN?: (options: HookArgs & { tx: Tx }) => HookResponse;
-	/** These are run in reverse translation order from newest to oldest */
 	POSTRUN?: (options: HookArgs & { tx: Tx; result: any }) => HookResponse;
-	/** These are run in reverse translation order from newest to oldest */
 	PRERESPOND?: (
 		options: HookArgs & {
 			tx: Tx;
@@ -55,7 +53,6 @@ export interface Hooks {
 			data?: any;
 		},
 	) => HookResponse;
-	/** These are run in reverse translation order from newest to oldest */
 	'POSTRUN-ERROR'?: (
 		options: HookArgs & { error: TypedError | any },
 	) => HookResponse;
@@ -129,13 +126,13 @@ class SideEffectHook<T extends HookFn> extends Hook<T> {
 
 // The execution order of rollback actions is unspecified
 export const rollbackRequestHooks = <T extends InstantiatedHooks>(
-	hooksList: Array<[modelName: string, hooks: T]> | undefined,
+	hooks: T | undefined,
 ): void => {
-	if (hooksList == null) {
+	if (hooks == null) {
 		return;
 	}
-	const sideEffectHooks = hooksList
-		.flatMap(([, v]): Array<Hook<HookFn>> => Object.values(v).flat())
+	const sideEffectHooks = Object.values(hooks)
+		.flatMap((v): Array<Hook<HookFn>> => v)
 		.filter(
 			(hook): hook is SideEffectHook<HookFn> => hook instanceof SideEffectHook,
 		);
@@ -180,37 +177,21 @@ const getResourceHooks = (vocabHooks: VocabHooks, resourceName?: string) => {
 const getVocabHooks = (
 	methodHooks: MethodHooks,
 	vocabulary: string,
-	resourceName: string | undefined,
-	includeAllVocab: boolean,
+	resourceName?: string,
 ) => {
 	if (methodHooks == null) {
 		return {};
 	}
-	const vocabHooks = getResourceHooks(methodHooks[vocabulary], resourceName);
-	if (!includeAllVocab) {
-		// Do not include `vocabulary='all'` hooks, useful for translated vocabularies
-		return vocabHooks;
-	}
 	return mergeHooks(
-		vocabHooks,
+		getResourceHooks(methodHooks[vocabulary], resourceName),
 		getResourceHooks(methodHooks['all'], resourceName),
 	);
 };
 const getMethodHooks = memoize(
-	(
-		method: SupportedMethod,
-		vocabulary: string,
-		resourceName: string | undefined,
-		includeAllVocab: boolean,
-	) =>
+	(method: SupportedMethod, vocabulary: string, resourceName?: string) =>
 		mergeHooks(
-			getVocabHooks(
-				apiHooks[method],
-				vocabulary,
-				resourceName,
-				includeAllVocab,
-			),
-			getVocabHooks(apiHooks['all'], vocabulary, resourceName, includeAllVocab),
+			getVocabHooks(apiHooks[method], vocabulary, resourceName),
+			getVocabHooks(apiHooks['all'], vocabulary, resourceName),
 		),
 	{ primitive: true },
 );
@@ -219,7 +200,6 @@ export const getHooks = (
 		OptionalField<ParsedODataRequest, 'resourceName'>,
 		'resourceName' | 'method' | 'vocabulary'
 	>,
-	includeAllVocab: boolean,
 ): InstantiatedHooks => {
 	let { resourceName } = request;
 	if (resourceName != null) {
@@ -228,17 +208,10 @@ export const getHooks = (
 				ParsedODataRequest,
 				'resourceName' | 'method' | 'vocabulary'
 			>,
-		)
-			// Remove version suffixes
-			.replace(/\$.*$/, '');
+		);
 	}
 	return instantiateHooks(
-		getMethodHooks(
-			request.method,
-			request.vocabulary,
-			resourceName,
-			includeAllVocab,
-		),
+		getMethodHooks(request.method, request.vocabulary, resourceName),
 	);
 };
 getHooks.clear = () => getMethodHooks.clear();
@@ -370,11 +343,12 @@ export const addPureHook = (
 	});
 };
 
-const defineApi = (modelName: string, args: HookArgs) => {
-	const { req, tx } = args;
+const defineApi = (args: HookArgs) => {
+	const { request, req, tx } = args;
+	const { vocabulary } = request;
 	Object.defineProperty(args, 'api', {
 		get: _.once(() =>
-			api[modelName].clone({
+			api[vocabulary].clone({
 				passthrough: { req, tx },
 			}),
 		),
@@ -386,7 +360,6 @@ type RunHookArgs<T extends keyof Hooks> = Omit<
 	'api'
 >;
 const getReadOnlyArgs = <T extends keyof Hooks>(
-	modelName: string,
 	args: RunHookArgs<T>,
 ): RunHookArgs<T> => {
 	if (args.tx == null || args.tx.isReadOnly()) {
@@ -396,58 +369,38 @@ const getReadOnlyArgs = <T extends keyof Hooks>(
 	let readOnlyArgs: typeof args;
 	readOnlyArgs = { ...args, tx: args.tx.asReadOnly() };
 	if ((args as HookArgs).request != null) {
-		defineApi(modelName, readOnlyArgs as HookArgs);
+		defineApi(readOnlyArgs as HookArgs);
 	}
 	return readOnlyArgs;
 };
 
 export const runHooks = async <T extends keyof Hooks>(
 	hookName: T,
-	/**
-	 * A list of modelName/hooks to run in order, which will be reversed for hooks after the "RUN" stage,
-	 * ie POSTRUN/PRERESPOND/POSTRUN-ERROR
-	 */
-	hooksList: Array<[modelName: string, hooks: InstantiatedHooks]> | undefined,
+	hooksList: InstantiatedHooks | undefined,
 	args: RunHookArgs<T>,
 ) => {
 	if (hooksList == null) {
 		return;
 	}
-	const hooks = hooksList
-		.map(([modelName, $hooks]): [string, InstantiatedHooks[T] | undefined] => [
-			modelName,
-			$hooks[hookName],
-		])
-		.filter(
-			(v): v is [string, InstantiatedHooks[T]] =>
-				v[1] != null && v[1].length > 0,
-		);
-	if (hooks.length === 0) {
+	const hooks = hooksList[hookName];
+	if (hooks == null || hooks.length === 0) {
 		return;
 	}
-	if (['POSTRUN', 'PRERESPOND', 'POSTRUN-ERROR'].includes(hookName)) {
-		// Any hooks after we "run" the query are executed in reverse order from newest to oldest
-		// as they'll be translating the query results from "latest" backwards to the model that
-		// was actually requested
-		hooks.reverse();
+
+	if ((args as HookArgs).request != null) {
+		defineApi(args as HookArgs);
 	}
 
-	for (const [modelName, modelHooks] of hooks) {
-		const modelArgs = { ...args };
-		let modelReadOnlyArgs: typeof modelArgs;
-		if ((args as HookArgs).request != null) {
-			defineApi(modelName, modelArgs as HookArgs);
-		}
+	let readOnlyArgs: RunHookArgs<T>;
 
-		await Promise.all(
-			(modelHooks as Array<Hook<HookFn>>).map(async (hook) => {
-				if (hook.readOnlyTx) {
-					modelReadOnlyArgs ??= getReadOnlyArgs(modelName, args);
-					await hook.run(modelReadOnlyArgs);
-				} else {
-					await hook.run(modelArgs);
-				}
-			}),
-		);
-	}
+	await Promise.all(
+		(hooks as Array<Hook<HookFn>>).map(async (hook) => {
+			if (hook.readOnlyTx) {
+				readOnlyArgs ??= getReadOnlyArgs(args);
+				await hook.run(readOnlyArgs);
+			} else {
+				await hook.run(args);
+			}
+		}),
+	);
 };

package/src/sbvr-api/odata-response.ts

@@ -90,8 +90,7 @@ const getLocalFields = (table: AbstractSqlTable) => {
 	if (table.localFields == null) {
 		table.localFields = {};
 		for (const { fieldName, dataType } of table.fields) {
-			// TODO-MAJOR: This should also include ConceptType fields
-			if (dataType !== 'ForeignKey') {
+			if (!['ForeignKey', 'ConceptType'].includes(dataType)) {
 				const odataName = sqlNameToODataName(fieldName);
 				table.localFields[odataName] = true;
 			}

package/src/sbvr-api/permissions.ts

@@ -140,7 +140,7 @@ const $parsePermissions = env.createCache(
 	},
 );
 
-const rewriteODataBinds = (
+const rewriteBinds = (
 	{ tree, extraBinds }: { tree: ODataQuery; extraBinds: ODataBinds },
 	odataBinds: ODataBinds,
 ): ODataQuery => {
@@ -163,7 +163,7 @@ const parsePermissions = (
 	odataBinds: ODataBinds,
 ): ODataQuery => {
 	const odata = $parsePermissions(filter);
-	return rewriteODataBinds(odata, odataBinds);
+	return rewriteBinds(odata, odataBinds);
 };
 
 // Traverses all values in `check`, actions for the following data types:
@@ -862,9 +862,7 @@ const rewriteRelationship = memoizeWeak(
 								foundCanAccessLink = true;
 							}
 							// return a true expression to not select the relationship, which might be virtual
-							// this should be a boolean expression, but needs to be a subquery in case it
-							// is wrapped in an `or` or `and`
-							return ['Equals', ['Boolean', true], ['Boolean', true]];
+							return ['Boolean', true];
 						};
 
 						try {
@@ -1050,7 +1048,6 @@ const getBoundConstrainedMemoizer = memoizeWeak(
 									sqlNameToODataName(permissionsTable.name),
 								),
 							);
-
 							return permissionsTable;
 						},
 					},
@@ -1447,26 +1444,13 @@ const checkApiKey = async (
 	apiKey: string,
 	tx?: Tx,
 ): Promise<PermissionReq['apiKey']> => {
-	let permissions: string[];
-	try {
-		permissions = await getApiKeyPermissions(apiKey, tx);
-	} catch (err: any) {
-		console.warn('Error with API key:', err);
-		// Ignore errors getting the api key and just use an empty permissions object.
-		permissions = [];
-	}
-	let actor;
-	if (permissions.length > 0) {
-		actor = await getApiKeyActorId(apiKey, tx);
-	}
-	const resolvedApiKey: PermissionReq['apiKey'] = {
+	const permissions = await getApiKeyPermissions(apiKey, tx);
+	const actor = await getApiKeyActorId(apiKey, tx);
+	return {
 		key: apiKey,
 		permissions,
+		actor,
 	};
-	if (actor != null) {
-		resolvedApiKey.actor = actor;
-	}
-	return resolvedApiKey;
 };
 
 export const resolveAuthHeader = async (
@@ -1475,11 +1459,6 @@ export const resolveAuthHeader = async (
 	// TODO: Consider making tx the second argument in the next major
 	tx?: Tx,
 ): Promise<PermissionReq['apiKey']> => {
-	// TODO-MAJOR: remove this check
-	if (req.apiKey != null) {
-		return;
-	}
-
 	const auth = req.header('Authorization');
 	if (!auth) {
 		return;
@@ -1525,11 +1504,6 @@ export const resolveApiKey = async (
 	// TODO: Consider making tx the second argument in the next major
 	tx?: Tx,
 ): Promise<PermissionReq['apiKey']> => {
-	// TODO-MAJOR: remove this check
-	if (req.apiKey != null) {
-		return;
-	}
-
 	const apiKey =
 		req.params[paramName] ?? req.body[paramName] ?? req.query[paramName];
 	if (apiKey == null) {
@@ -1539,9 +1513,6 @@ export const resolveApiKey = async (
 };
 
 export const customApiKeyMiddleware = (paramName = 'apikey') => {
-	if (paramName == null) {
-		paramName = 'apikey';
-	}
 	return async (
 		req: HookReq | Express.Request,
 		_res?: Express.Response,
@@ -1633,32 +1604,18 @@ const getReqPermissions = async (
 	req: PermissionReq,
 	odataBinds: ODataBinds = [],
 ) => {
-	const [guestPermissions] = await Promise.all([
-		(async () => {
-			if (
-				guestPermissionsInitialized === false &&
-				(req.user === root.user || req.user === rootRead.user)
-			) {
-				// In the case that guest permissions are not initialized yet and the query is being made with root permissions
-				// then we need to bypass `getGuestPermissions` as it will cause an infinite loop back to here.
-				// Therefore to break that loop we just ignore guest permissions.
-				return [];
-			}
-			return await getGuestPermissions();
-		})(),
-		(async () => {
-			// TODO: Remove this extra actor ID lookup making actor non-optional and updating open-balena-api.
-			if (
-				req.apiKey != null &&
-				req.apiKey.actor == null &&
-				req.apiKey.permissions != null &&
-				req.apiKey.permissions.length > 0
-			) {
-				const actorId = await getApiKeyActorId(req.apiKey.key);
-				req.apiKey!.actor = actorId;
-			}
-		})(),
-	]);
+	const guestPermissions = await (async () => {
+		if (
+			guestPermissionsInitialized === false &&
+			(req.user === root.user || req.user === rootRead.user)
+		) {
+			// In the case that guest permissions are not initialized yet and the query is being made with root permissions
+			// then we need to bypass `getGuestPermissions` as it will cause an infinite loop back to here.
+			// Therefore to break that loop we just ignore guest permissions.
+			return [];
+		}
+		return await getGuestPermissions();
+	})();
 
 	let actorPermissions: string[] = [];
 	const addActorPermissions = (actorId: number, perms: string[]) => {
@@ -1679,8 +1636,7 @@ export const addPermissions = async (
 	req: PermissionReq,
 	request: ODataRequest & { permissionType?: PermissionCheck },
 ): Promise<void> => {
-	const { resourceName, odataQuery, odataBinds } = request;
-	const vocabulary = _.last(request.translateVersions)!;
+	const { vocabulary, resourceName, odataQuery, odataBinds } = request;
 	let abstractSqlModel = sbvrUtils.getAbstractSqlModel(request);
 
 	let { permissionType } = request;
@@ -1803,10 +1759,6 @@ export const setup = () => {
 					0,
 					-'#canAccess'.length,
 				);
-				request.originalResourceName = request.originalResourceName.slice(
-					0,
-					-'#canAccess'.length,
-				);
 				const resourceName = sbvrUtils.resolveSynonym(request);
 				const resourceTable = abstractSqlModel.tables[resourceName];
 				if (resourceTable == null) {