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

package/src/sbvr-api/hooks.ts

@@ -1,11 +1,10 @@
 import type { OptionalField, Resolvable } from './common-types';
 import type { Tx } from '../database-layer/db';
-import type { ODataRequest } from './uri-parser';
+import type { ODataRequest, ParsedODataRequest } from './uri-parser';
 import type { AnyObject } from 'pinejs-client-core';
 import type { TypedError } from 'typed-error';
 import type { SupportedMethod } from '@balena/odata-to-abstract-sql';
 
-import * as Bluebird from 'bluebird';
 import * as _ from 'lodash';
 import { settleMapSeries } from './control-flow';
 import * as memoize from 'memoizee';
@@ -16,6 +15,7 @@ import {
 	resolveSynonym,
 	getAbstractSqlModel,
 	api,
+	Response,
 } from './sbvr-utils';
 
 export interface HookReq {
@@ -34,7 +34,7 @@ export interface HookArgs {
 	req: HookReq;
 	request: ODataRequest;
 	api: PinejsClient;
-	tx?: Tx;
+	tx?: Tx | undefined;
 }
 export type HookResponse = PromiseLike<any> | null | void;
 
@@ -42,14 +42,18 @@ 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;
 			result: any;
-			data?: any;
+			/** This can be mutated to modify the response sent to the client */
+			response: Response;
 		},
 	) => HookResponse;
+	/** These are run in reverse translation order from newest to oldest */
 	'POSTRUN-ERROR'?: (
 		options: HookArgs & { error: TypedError | any },
 	) => HookResponse;
@@ -97,7 +101,13 @@ class SideEffectHook<T extends HookFn> extends Hook<T> {
 
 	public registerRollback(fn: RollbackAction): void {
 		if (this.rolledBack) {
-			Bluebird.try(fn);
+			(async () => {
+				try {
+					await fn();
+				} catch {
+					// Ignore any errors in the rollback callback
+				}
+			})();
 		} else {
 			this.rollbackFns.push(fn);
 		}
@@ -117,15 +127,21 @@ class SideEffectHook<T extends HookFn> extends Hook<T> {
 
 // The execution order of rollback actions is unspecified
 export const rollbackRequestHooks = <T extends InstantiatedHooks>(
-	hooks: T | undefined,
+	hooksList: Array<[modelName: string, hooks: T]> | undefined,
 ): void => {
-	if (hooks == null) {
+	if (hooksList == null) {
 		return;
 	}
-	settleMapSeries(_(hooks).flatMap().compact().value(), async (hook) => {
-		if (hook instanceof SideEffectHook) {
-			await hook.rollback();
-		}
+	const sideEffectHooks = hooksList
+		.flatMap(([, v]): Array<Hook<HookFn>> => Object.values(v).flat())
+		.filter(
+			(hook): hook is SideEffectHook<HookFn> => hook instanceof SideEffectHook,
+		);
+	if (sideEffectHooks.length === 0) {
+		return;
+	}
+	settleMapSeries(sideEffectHooks, async (hook) => {
+		await hook.rollback();
 	});
 };
 
@@ -162,38 +178,65 @@ const getResourceHooks = (vocabHooks: VocabHooks, resourceName?: string) => {
 const getVocabHooks = (
 	methodHooks: MethodHooks,
 	vocabulary: string,
-	resourceName?: string,
+	resourceName: string | undefined,
+	includeAllVocab: boolean,
 ) => {
 	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(
-		getResourceHooks(methodHooks[vocabulary], resourceName),
+		vocabHooks,
 		getResourceHooks(methodHooks['all'], resourceName),
 	);
 };
 const getMethodHooks = memoize(
-	(method: SupportedMethod, vocabulary: string, resourceName?: string) =>
+	(
+		method: SupportedMethod,
+		vocabulary: string,
+		resourceName: string | undefined,
+		includeAllVocab: boolean,
+	) =>
 		mergeHooks(
-			getVocabHooks(apiHooks[method], vocabulary, resourceName),
-			getVocabHooks(apiHooks['all'], vocabulary, resourceName),
+			getVocabHooks(
+				apiHooks[method],
+				vocabulary,
+				resourceName,
+				includeAllVocab,
+			),
+			getVocabHooks(apiHooks['all'], vocabulary, resourceName, includeAllVocab),
 		),
 	{ primitive: true },
 );
 export const getHooks = (
 	request: Pick<
-		OptionalField<ODataRequest, 'resourceName'>,
+		OptionalField<ParsedODataRequest, 'resourceName'>,
 		'resourceName' | 'method' | 'vocabulary'
 	>,
+	includeAllVocab: boolean,
 ): InstantiatedHooks => {
 	let { resourceName } = request;
 	if (resourceName != null) {
 		resourceName = resolveSynonym(
-			request as Pick<ODataRequest, 'resourceName' | 'method' | 'vocabulary'>,
-		);
+			request as Pick<
+				ParsedODataRequest,
+				'resourceName' | 'method' | 'vocabulary'
+			>,
+		)
+			// Remove version suffixes
+			.replace(/\$.*$/, '');
 	}
 	return instantiateHooks(
-		getMethodHooks(request.method, request.vocabulary, resourceName),
+		getMethodHooks(
+			request.method,
+			request.vocabulary,
+			resourceName,
+			includeAllVocab,
+		),
 	);
 };
 getHooks.clear = () => getMethodHooks.clear();
@@ -325,54 +368,84 @@ export const addPureHook = (
 	});
 };
 
-const defineApi = (args: HookArgs) => {
-	const { request, req, tx } = args;
-	const { vocabulary } = request;
+const defineApi = (modelName: string, args: HookArgs) => {
+	const { req, tx } = args;
 	Object.defineProperty(args, 'api', {
 		get: _.once(() =>
-			api[vocabulary].clone({
+			api[modelName].clone({
 				passthrough: { req, tx },
 			}),
 		),
 	});
 };
 
+type RunHookArgs<T extends keyof Hooks> = Omit<
+	Parameters<NonNullable<Hooks[T]>>[0],
+	'api'
+>;
+const getReadOnlyArgs = <T extends keyof Hooks>(
+	modelName: string,
+	args: RunHookArgs<T>,
+): RunHookArgs<T> => {
+	if (args.tx == null || args.tx.isReadOnly()) {
+		// If we don't have a tx then read-only/writable is irrelevant
+		return args;
+	}
+	let readOnlyArgs: typeof args;
+	readOnlyArgs = { ...args, tx: args.tx.asReadOnly() };
+	if ((args as HookArgs).request != null) {
+		defineApi(modelName, readOnlyArgs as HookArgs);
+	}
+	return readOnlyArgs;
+};
+
 export const runHooks = async <T extends keyof Hooks>(
 	hookName: T,
-	hooksList: InstantiatedHooks | undefined,
-	args: Omit<Parameters<NonNullable<Hooks[T]>>[0], 'api'>,
+	/**
+	 * 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,
+	args: RunHookArgs<T>,
 ) => {
 	if (hooksList == null) {
 		return;
 	}
-	const hooks = hooksList[hookName];
-	if (hooks == null || hooks.length === 0) {
+	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) {
 		return;
 	}
-
-	let readOnlyArgs: typeof args;
-	if (args.tx != null) {
-		readOnlyArgs = { ...args, tx: args.tx.asReadOnly() };
-	} else {
-		// If we don't have a tx then read-only/writable is irrelevant
-		readOnlyArgs = args;
+	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);
-		if (args !== readOnlyArgs) {
-			// Only try to define a separate read-only api if it's different
-			defineApi(readOnlyArgs 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);
 		}
-	}
 
-	await Promise.all(
-		(hooks as Array<Hook<HookFn>>).map(async (hook) => {
-			if (hook.readOnlyTx) {
-				await hook.run(readOnlyArgs);
-			} else {
-				await hook.run(args);
-			}
-		}),
-	);
+		await Promise.all(
+			(modelHooks as Array<Hook<HookFn>>).map(async (hook) => {
+				if (hook.readOnlyTx) {
+					modelReadOnlyArgs ??= getReadOnlyArgs(modelName, modelArgs);
+					await hook.run(modelReadOnlyArgs);
+				} else {
+					await hook.run(modelArgs);
+				}
+			}),
+		);
+	}
 };

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

@@ -1,7 +1,7 @@
 declare module '@balena/abstract-sql-compiler' {
 	interface AbstractSqlTable {
 		fetchProcessingFields?: {
-			[field: string]: NonNullable<typeof sbvrTypes[string]['fetchProcessing']>;
+			[field: string]: NonNullable<SbvrType['fetchProcessing']>;
 		};
 		localFields?: {
 			[odataName: string]: true;
@@ -16,7 +16,7 @@ import type {
 import type { Result, Row } from '../database-layer/db';
 
 import { sqlNameToODataName } from '@balena/odata-to-abstract-sql';
-import * as sbvrTypes from '@balena/sbvr-types';
+import sbvrTypes, { SbvrType } from '@balena/sbvr-types';
 import * as _ from 'lodash';
 import { resolveNavigationResource, resolveSynonym } from './sbvr-utils';
 
@@ -36,20 +36,20 @@ const checkForExpansion = async (
 	if (typeof field === 'string') {
 		try {
 			field = JSON.parse(field);
-		} catch (_e) {
+		} catch {
 			// If we can't JSON.parse the field then we use it directly.
 		}
 	}
 
+	const mappingResourceName = resolveNavigationResource(
+		{
+			abstractSqlModel,
+			vocabulary: vocab,
+			resourceName: parentResourceName,
+		},
+		fieldName,
+	);
 	if (Array.isArray(field)) {
-		const mappingResourceName = resolveNavigationResource(
-			{
-				abstractSqlModel,
-				vocabulary: vocab,
-				resourceName: parentResourceName,
-			},
-			fieldName,
-		);
 		const expandedField = await process(
 			vocab,
 			abstractSqlModel,
@@ -59,14 +59,6 @@ const checkForExpansion = async (
 		);
 		row[fieldName] = expandedField;
 	} else {
-		const mappingResourceName = resolveNavigationResource(
-			{
-				abstractSqlModel,
-				vocabulary: vocab,
-				resourceName: parentResourceName,
-			},
-			fieldName,
-		);
 		row[fieldName] = {
 			__id: field,
 		};
@@ -96,8 +88,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;
 			}
@@ -109,12 +100,16 @@ const getFetchProcessingFields = (table: AbstractSqlTable) => {
 	return (table.fetchProcessingFields ??= _(table.fields)
 		.filter(
 			({ dataType }) =>
-				sbvrTypes[dataType] != null &&
-				sbvrTypes[dataType].fetchProcessing != null,
+				(sbvrTypes[dataType as keyof typeof sbvrTypes] as SbvrType)
+					?.fetchProcessing != null,
 		)
 		.map(({ fieldName, dataType }) => {
 			const odataName = sqlNameToODataName(fieldName);
-			return [odataName, sbvrTypes[dataType].fetchProcessing];
+			return [
+				odataName,
+				(sbvrTypes[dataType as keyof typeof sbvrTypes] as SbvrType)
+					.fetchProcessing,
+			];
 		})
 		.fromPairs()
 		.value());
@@ -160,16 +155,16 @@ export const process = async (
 	);
 
 	const odataIdField = sqlNameToODataName(table.idField);
-	rows.forEach((row) => {
-		processedFields.forEach((fieldName) => {
+	for (const row of rows) {
+		for (const fieldName of processedFields) {
 			row[fieldName] = fetchProcessingFields[fieldName](row[fieldName]);
-		});
+		}
 		if (includeMetadata) {
 			row.__metadata = {
 				uri: resourceURI(vocab, resourceName, row[odataIdField]),
 			};
 		}
-	});
+	}
 
 	if (expandableFields.length > 0) {
 		await Promise.all(