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

package/src/sbvr-api/sbvr-utils.ts

@@ -63,7 +63,6 @@ import {
 	rollbackRequestHooks,
 	getHooks,
 	runHooks,
-	InstantiatedHooks,
 } from './hooks';
 export {
 	HookReq,
@@ -93,7 +92,6 @@ import {
 export { resolveOdataBind } from './abstract-sql';
 import * as odataResponse from './odata-response';
 import { env } from '../server-glue/module';
-import { translateAbstractSqlModel } from './translations';
 
 const LF2AbstractSQLTranslator = LF2AbstractSQL.createTranslator(sbvrTypes);
 const LF2AbstractSQLTranslatorVersion = `${LF2AbstractSQLVersion}+${sbvrTypesVersion}`;
@@ -104,18 +102,14 @@ export type ExecutableModel =
 
 interface CompiledModel {
 	vocab: string;
-	translateTo?: string;
-	resourceRenames?: ReturnType<typeof translateAbstractSqlModel>;
 	se?: string | undefined;
 	lf?: LFModel | undefined;
 	abstractSql: AbstractSQLCompiler.AbstractSqlModel;
-	sql?: AbstractSQLCompiler.SqlModel;
+	sql: AbstractSQLCompiler.SqlModel;
 	odataMetadata: ReturnType<typeof generateODataMetadata>;
 }
 const models: {
-	[vocabulary: string]: CompiledModel & {
-		versions: string[];
-	};
+	[vocabulary: string]: CompiledModel;
 } = {};
 
 export interface Actor {
@@ -129,7 +123,7 @@ export interface User extends Actor {
 
 export interface ApiKey extends Actor {
 	key: string;
-	actor?: number;
+	actor: number;
 }
 
 export interface Response {
@@ -240,7 +234,7 @@ const prettifyConstraintError = (
 					break;
 				case 'postgres':
 					const resourceName = resolveSynonym(request);
-					const abstractSqlModel = getFinalAbstractSqlModel(request);
+					const abstractSqlModel = getAbstractSqlModel(request);
 					matches = new RegExp(
 						'"' + abstractSqlModel.tables[resourceName].name + '_(.*?)_key"',
 					).exec(err.message);
@@ -273,7 +267,7 @@ const prettifyConstraintError = (
 					break;
 				case 'postgres':
 					const resourceName = resolveSynonym(request);
-					const abstractSqlModel = getFinalAbstractSqlModel(request);
+					const abstractSqlModel = getAbstractSqlModel(request);
 					const tableName = abstractSqlModel.tables[resourceName].name;
 					matches = new RegExp(
 						'"' +
@@ -305,7 +299,7 @@ const prettifyConstraintError = (
 
 		if (err instanceof db.CheckConstraintError) {
 			const resourceName = resolveSynonym(request);
-			const abstractSqlModel = getFinalAbstractSqlModel(request);
+			const abstractSqlModel = getAbstractSqlModel(request);
 			const table = abstractSqlModel.tables[resourceName];
 			if (table.checks) {
 				switch (db.engine) {
@@ -380,12 +374,8 @@ export const validateModel = async (
 		'abstractSqlQuery' | 'modifiedFields' | 'method' | 'vocabulary'
 	>,
 ): Promise<void> => {
-	const { sql } = models[modelName];
-	if (!sql) {
-		throw new Error(`Tried to validate a virtual model: '${modelName}'`);
-	}
 	await Promise.all(
-		sql.rules.map(async (rule) => {
+		models[modelName].sql.rules.map(async (rule) => {
 			if (!isRuleAffected(rule, request)) {
 				// If none of the fields intersect we don't need to run the rule! :D
 				return;
@@ -436,19 +426,11 @@ export const generateSqlModel = (
 		() => AbstractSQLCompiler[targetDatabaseEngine].compileSchema(abstractSql),
 	);
 
-export function generateModels(
-	model: ExecutableModel & { translateTo?: undefined },
-	targetDatabaseEngine: AbstractSQLCompiler.Engines,
-): RequiredField<CompiledModel, 'sql'>;
-export function generateModels(
+export const generateModels = (
 	model: ExecutableModel,
 	targetDatabaseEngine: AbstractSQLCompiler.Engines,
-): CompiledModel;
-export function generateModels(
-	model: ExecutableModel,
-	targetDatabaseEngine: AbstractSQLCompiler.Engines,
-): CompiledModel {
-	const { apiRoot: vocab, modelText: se, translateTo, translations } = model;
+): CompiledModel => {
+	const { apiRoot: vocab, modelText: se } = model;
 	let { abstractSql: maybeAbstractSql } = model;
 
 	let lf: ReturnType<typeof generateLfModel> | undefined;
@@ -476,41 +458,16 @@ export function generateModels(
 		() => generateODataMetadata(vocab, abstractSql),
 	);
 
-	let sql: AbstractSQLCompiler.SqlModel | undefined;
-	let resourceRenames: ReturnType<typeof translateAbstractSqlModel> | undefined;
-
-	if (translateTo != null) {
-		resourceRenames = translateAbstractSqlModel(
-			abstractSql,
-			models[translateTo].abstractSql,
-			model.apiRoot,
-			translateTo,
-			translations,
-		);
-	} else {
-		for (const [key, table] of Object.entries(abstractSql.tables)) {
-			// Alias the current version so it can be explicitly referenced
-			abstractSql.tables[`${key}$${model.apiRoot}`] = { ...table };
-		}
-		try {
-			sql = generateSqlModel(abstractSql, targetDatabaseEngine);
-		} catch (e) {
-			console.error(`Error compiling model '${vocab}':`, e);
-			throw new Error(`Error compiling model '${vocab}': ` + e);
-		}
+	let sql: ReturnType<AbstractSQLCompiler.EngineInstance['compileSchema']>;
+	try {
+		sql = generateSqlModel(abstractSql, targetDatabaseEngine);
+	} catch (e) {
+		console.error(`Error compiling model '${vocab}':`, e);
+		throw new Error(`Error compiling model '${vocab}': ` + e);
 	}
 
-	return {
-		vocab,
-		translateTo,
-		resourceRenames,
-		se,
-		lf,
-		abstractSql,
-		sql,
-		odataMetadata,
-	};
-}
+	return { vocab, se, lf, abstractSql, sql, odataMetadata };
+};
 
 export const executeModel = (
 	tx: Db.Tx,
@@ -529,42 +486,30 @@ export const executeModels = async (
 				await syncMigrator.run(tx, model);
 				const compiledModel = generateModels(model, db.engine);
 
-				if (compiledModel.sql) {
-					// Create tables related to terms and fact types
-					// Run statements sequentially, as the order of the CREATE TABLE statements matters (eg. for foreign keys).
-					for (const createStatement of compiledModel.sql.createSchema) {
-						const promise = tx.executeSql(createStatement);
-						if (db.engine === 'websql') {
-							promise.catch((err) => {
-								console.warn(
-									"Ignoring errors in the create table statements for websql as it doesn't support CREATE IF NOT EXISTS",
-									err,
-								);
-							});
-						}
-						await promise;
+				// Create tables related to terms and fact types
+				// Run statements sequentially, as the order of the CREATE TABLE statements matters (eg. for foreign keys).
+				for (const createStatement of compiledModel.sql.createSchema) {
+					const promise = tx.executeSql(createStatement);
+					if (db.engine === 'websql') {
+						promise.catch((err) => {
+							console.warn(
+								"Ignoring errors in the create table statements for websql as it doesn't support CREATE IF NOT EXISTS",
+								err,
+							);
+						});
 					}
+					await promise;
 				}
 				await syncMigrator.postRun(tx, model);
 
 				odataResponse.prepareModel(compiledModel.abstractSql);
 				deepFreeze(compiledModel.abstractSql);
-
-				const versions = [apiRoot];
-				if (compiledModel.translateTo != null) {
-					versions.push(...models[compiledModel.translateTo].versions);
-				}
-				models[apiRoot] = {
-					...compiledModel,
-					versions,
-				};
+				models[apiRoot] = compiledModel;
 
 				// Validate the [empty] model according to the rules.
 				// This may eventually lead to entering obligatory data.
 				// For the moment it blocks such models from execution.
-				if (compiledModel.sql) {
-					await validateModel(tx, apiRoot);
-				}
+				await validateModel(tx, apiRoot);
 
 				// TODO: Can we do this without the cast?
 				api[apiRoot] = new PinejsClient('/' + apiRoot + '/') as LoggingClient;
@@ -624,7 +569,10 @@ export const executeModels = async (
 					let uri = '/dev/model';
 					const body: AnyObject = {
 						is_of__vocabulary: model.vocab,
-						model_value: model[modelType],
+						model_value:
+							typeof model[modelType] === 'string'
+								? { value: model[modelType] }
+								: model[modelType],
 						model_type: modelType,
 					};
 					const id = result?.[0]?.id;
@@ -666,30 +614,27 @@ const cleanupModel = (vocab: string) => {
 };
 
 export const deleteModel = async (vocabulary: string) => {
-	const { sql } = models[vocabulary];
-	if (sql) {
-		await db.transaction(async (tx) => {
-			const dropStatements: Array<Promise<any>> = sql.dropSchema.map(
-				(dropStatement) => tx.executeSql(dropStatement),
-			);
-			await Promise.all(
-				dropStatements.concat([
-					api.dev.delete({
-						resource: 'model',
-						passthrough: {
-							tx,
-							req: permissions.root,
-						},
-						options: {
-							$filter: {
-								is_of__vocabulary: vocabulary,
-							},
+	await db.transaction(async (tx) => {
+		const dropStatements: Array<Promise<any>> = models[
+			vocabulary
+		].sql.dropSchema.map((dropStatement) => tx.executeSql(dropStatement));
+		await Promise.all(
+			dropStatements.concat([
+				api.dev.delete({
+					resource: 'model',
+					passthrough: {
+						tx,
+						req: permissions.root,
+					},
+					options: {
+						$filter: {
+							is_of__vocabulary: vocabulary,
 						},
-					}),
-				]),
-			);
-		});
-	}
+					},
+				}),
+			]),
+		);
+	});
 	await cleanupModel(vocabulary);
 };
 
@@ -982,28 +927,12 @@ export const getAbstractSqlModel = (
 	return (request.abstractSqlModel ??= models[request.vocabulary].abstractSql);
 };
 
-const getFinalAbstractSqlModel = (
-	request: Pick<
-		uriParser.ODataRequest,
-		'translateVersions' | 'finalAbstractSqlModel'
-	>,
-): AbstractSQLCompiler.AbstractSqlModel => {
-	const finalModel = _.last(request.translateVersions)!;
-	return (request.finalAbstractSqlModel ??= models[finalModel].abstractSql);
-};
-
 const getIdField = (
 	request: Pick<
 		uriParser.ODataRequest,
-		| 'translateVersions'
-		| 'finalAbstractSqlModel'
-		| 'abstractSqlModel'
-		| 'resourceName'
-		| 'vocabulary'
+		'vocabulary' | 'abstractSqlModel' | 'resourceName'
 	>,
-) =>
-	// TODO: Should resolveSynonym also be using the finalAbstractSqlModel?
-	getFinalAbstractSqlModel(request).tables[resolveSynonym(request)].idField;
+) => getAbstractSqlModel(request).tables[resolveSynonym(request)].idField;
 
 export const getAffectedIds = async (
 	args: HookArgs & {
@@ -1046,18 +975,17 @@ const $getAffectedIds = async ({
 	// We reparse to make sure we get a clean odataQuery, without permissions already added
 	// And we use the request's url rather than the req for things like batch where the req url is ../$batch
 	const parsedRequest: uriParser.ParsedODataRequest &
-		Partial<Pick<uriParser.ODataRequest, 'engine' | 'translateVersions'>> =
+		Partial<Pick<uriParser.ODataRequest, 'engine'>> =
 		await uriParser.parseOData({
 			method: request.method,
 			url: `/${request.vocabulary}${request.url}`,
 		});
 
 	parsedRequest.engine = request.engine;
-	parsedRequest.translateVersions = request.translateVersions;
 	// Mark that the engine is required now that we've set it
 	let affectedRequest: uriParser.ODataRequest = parsedRequest as RequiredField<
 		typeof parsedRequest,
-		'engine' | 'translateVersions'
+		'engine'
 	>;
 	const abstractSqlModel = getAbstractSqlModel(affectedRequest);
 	const resourceName = resolveSynonym(affectedRequest);
@@ -1100,18 +1028,10 @@ const runODataRequest = (req: Express.Request, vocabulary: string) => {
 
 	// Get the hooks for the current method/vocabulary as we know it,
 	// in order to run PREPARSE hooks, before parsing gets us more info
-	const { versions } = models[vocabulary];
-	const reqHooks = versions.map((version): [string, InstantiatedHooks] => [
-		version,
-		getHooks(
-			{
-				method: req.method as SupportedMethod,
-				vocabulary: version,
-			},
-			// Only include the `all` vocab for the first model version
-			version === versions[0],
-		),
-	]);
+	const reqHooks = getHooks({
+		method: req.method as SupportedMethod,
+		vocabulary,
+	});
 
 	const transactions: Db.Tx[] = [];
 	const tryCancelRequest = () => {
@@ -1154,49 +1074,23 @@ const runODataRequest = (req: Express.Request, vocabulary: string) => {
 
 			const prepareRequest = async (
 				parsedRequest: uriParser.ParsedODataRequest &
-					Partial<Pick<uriParser.ODataRequest, 'engine' | 'translateVersions'>>,
+					Partial<Pick<uriParser.ODataRequest, 'engine'>>,
 			): Promise<uriParser.ODataRequest> => {
 				parsedRequest.engine = db.engine;
-				parsedRequest.translateVersions = [...versions];
-				// Mark that the engine/translateVersions is required now that we've set it
+				// Mark that the engine is required now that we've set it
 				const $request: uriParser.ODataRequest = parsedRequest as RequiredField<
 					typeof parsedRequest,
-					'engine' | 'translateVersions'
+					'engine'
 				>;
+				// Get the full hooks list now that we can.
+				$request.hooks = getHooks($request);
 				// Add/check the relevant permissions
 				try {
-					$request.hooks = [];
-					for (const version of versions) {
-						// We get the hooks list between each `runHooks` so that any resource renames will be used
-						// when getting hooks for later versions
-						const hooks: [string, InstantiatedHooks] = [
-							version,
-							getHooks(
-								{
-									resourceName: $request.resourceName,
-									vocabulary: version,
-									method: $request.method,
-								},
-								// Only include the `all` vocab for the first model version
-								version === versions[0],
-							),
-						];
-						$request.hooks.push(hooks);
-						await runHooks('POSTPARSE', [hooks], {
-							req,
-							request: $request,
-							tx: req.tx,
-						});
-						const { resourceRenames } = models[version];
-						if (resourceRenames) {
-							const resourceName = resolveSynonym($request);
-							if (resourceRenames[resourceName]) {
-								$request.resourceName = sqlNameToODataName(
-									resourceRenames[resourceName],
-								);
-							}
-						}
-					}
+					await runHooks('POSTPARSE', $request.hooks, {
+						req,
+						request: $request,
+						tx: req.tx,
+					});
 					const translatedRequest = await uriParser.translateUri($request);
 					return await compileRequest(translatedRequest);
 				} catch (err: any) {
@@ -1531,12 +1425,9 @@ const checkReadOnlyRequests = (request: uriParser.ODataRequest) => {
 		return true;
 	}
 	// If there are hooks then check that they're all read-only
-	return hooks.every(([, versionedHooks]) =>
-		Object.values(versionedHooks).every((hookTypeHooks) => {
-			return (
-				hookTypeHooks == null || hookTypeHooks.every((hook) => hook.readOnlyTx)
-			);
-		}),
+	return Object.values(hooks).every(
+		(hookTypeHooks) =>
+			hookTypeHooks == null || hookTypeHooks.every((hook) => hook.readOnlyTx),
 	);
 };
 
@@ -1631,7 +1522,7 @@ const respondGet = async (
 		const d = await odataResponse.process(
 			vocab,
 			getAbstractSqlModel(request),
-			request.originalResourceName,
+			request.resourceName,
 			result.rows,
 			{ includeMetadata: metadata === 'full' },
 		);
@@ -1680,7 +1571,7 @@ const runPost = async (
 	if (rowsAffected === 0) {
 		throw new PermissionError();
 	}
-	await validateModel(tx, _.last(request.translateVersions)!, request);
+	await validateModel(tx, request.vocabulary, request);
 
 	return insertId;
 };
@@ -1692,11 +1583,7 @@ const respondPost = async (
 	tx: Db.Tx,
 ): Promise<Response> => {
 	const vocab = request.vocabulary;
-	const location = odataResponse.resourceURI(
-		vocab,
-		request.originalResourceName,
-		id,
-	);
+	const location = odataResponse.resourceURI(vocab, request.resourceName, id);
 	if (env.DEBUG) {
 		api[vocab].logger.log('Insert ID: ', request.resourceName, id);
 	}
@@ -1754,7 +1641,7 @@ const runPut = async (
 		({ rowsAffected } = await runQuery(tx, request, undefined, idField));
 	}
 	if (rowsAffected > 0) {
-		await validateModel(tx, _.last(request.translateVersions)!, request);
+		await validateModel(tx, request.vocabulary, request);
 	}
 	return undefined;
 };
@@ -1792,7 +1679,7 @@ const runDelete = async (
 		getIdField(request),
 	);
 	if (rowsAffected > 0) {
-		await validateModel(tx, _.last(request.translateVersions)!, request);
+		await validateModel(tx, request.vocabulary, request);
 	}
 
 	return undefined;
@@ -1812,6 +1699,31 @@ export const executeStandardModels = async (tx: Db.Tx): Promise<void> => {
 					ALTER TABLE "model"
 					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 "model"
+								MODIFY "model value" JSON NOT NULL;
+
+								UPDATE "model"
+								SET "model value" = CAST('{"value":' || CAST("model value" AS CHAR) || '}' AS JSON)
+								WHERE "model type" IN ('se', 'odataMetadata')
+								AND CAST("model value" AS CHAR) LIKE '"%';`);
+							break;
+						case 'postgres':
+							await $tx.executeSql(`\
+								ALTER TABLE "model"
+								ALTER COLUMN "model value" SET DATA TYPE JSONB USING "model value"::JSONB;
+
+								UPDATE "model"
+								SET "model value" = CAST('{"value":' || CAST("model value" AS TEXT) || '}' AS JSON)
+								WHERE "model type" IN ('se', 'odataMetadata')
+								AND CAST("model value" AS TEXT) LIKE '"%';`);
+							break;
+						// No need to migrate for websql
+					}
+				},
 			},
 		});
 		await executeModels(tx, permissions.config.models);

package/src/sbvr-api/uri-parser.ts

@@ -42,7 +42,6 @@ export interface ParsedODataRequest {
 	url: string;
 	vocabulary: string;
 	resourceName: string;
-	originalResourceName: string;
 	values: AnyObject;
 	odataQuery: ODataQuery;
 	odataBinds: OdataBinds;
@@ -51,9 +50,7 @@ export interface ParsedODataRequest {
 	_defer?: boolean;
 }
 export interface ODataRequest extends ParsedODataRequest {
-	translateVersions: string[];
 	abstractSqlModel?: AbstractSQLCompiler.AbstractSqlModel;
-	finalAbstractSqlModel?: AbstractSQLCompiler.AbstractSqlModel;
 	abstractSqlQuery?: AbstractSQLCompiler.AbstractSqlQuery;
 	sqlQuery?: AbstractSQLCompiler.SqlResult | AbstractSQLCompiler.SqlResult[];
 	tx?: Tx;
@@ -62,7 +59,7 @@ export interface ODataRequest extends ParsedODataRequest {
 	>;
 	affectedIds?: number[];
 	pendingAffectedIds?: Promise<number[]>;
-	hooks?: Array<[string, InstantiatedHooks]>;
+	hooks?: InstantiatedHooks;
 	engine: AbstractSQLCompiler.Engines;
 }
 
@@ -147,7 +144,8 @@ export const memoizedParseOdata = (() => {
 
 export const memoizedGetOData2AbstractSQL = memoizeWeak(
 	(abstractSqlModel: AbstractSQLCompiler.AbstractSqlModel) => {
-		return new OData2AbstractSQL(abstractSqlModel, undefined, {
+		// TODO: REMOVE THIS, it's temporary due to mismatched abstract-sql-compiler versions
+		return new OData2AbstractSQL(abstractSqlModel as any, undefined, {
 			// Use minimized aliases when not in debug mode for smaller queries
 			minimizeAliases: !env.DEBUG,
 		});
@@ -294,7 +292,6 @@ export async function parseOData(
 				url,
 				vocabulary: apiRoot,
 				resourceName: odata.tree.resource,
-				originalResourceName: odata.tree.resource,
 				values: b.data ?? {},
 				odataQuery: odata.tree,
 				odataBinds: odata.binds,
@@ -357,7 +354,6 @@ const parseODataChangeset = (
 		url,
 		vocabulary: apiRoot,
 		resourceName: odata.tree.resource,
-		originalResourceName: odata.tree.resource,
 		odataBinds: odata.binds,
 		odataQuery: odata.tree,
 		values: b.data ?? {},
@@ -423,7 +419,8 @@ export const translateUri = <
 				return true;
 			},
 		});
-		request.abstractSqlQuery = abstractSqlQuery;
+		// TODO: REMOVE THIS, it's temporary due to mismatched abstract-sql-compiler versions
+		request.abstractSqlQuery = abstractSqlQuery as any;
 		return request;
 	}
 	return request;

package/tsconfig.json

@@ -11,7 +11,7 @@
 		"removeComments": true,
 		"rootDir": "src",
 		"sourceMap": true,
-		"target": "es2019",
+		"target": "es2021",
 		"declaration": true,
 		"skipLibCheck": true,
 		"resolveJsonModule": true,

package/out/sbvr-api/translations.d.ts

@@ -1,6 +0,0 @@
-import { AbstractSqlModel, ReferencedFieldNode, Definition, SelectQueryNode, NumberTypeNodes, BooleanTypeNodes, UnknownTypeNodes, NullNode } from '@balena/abstract-sql-compiler';
-import { Dictionary } from './common-types';
-export type AliasValidNodeType = ReferencedFieldNode | SelectQueryNode | NumberTypeNodes | BooleanTypeNodes | UnknownTypeNodes | NullNode;
-export declare const translateAbstractSqlModel: (fromAbstractSqlModel: AbstractSqlModel, toAbstractSqlModel: AbstractSqlModel, fromVersion: string, toVersion: string, translationDefinitions?: Dictionary<(Definition & {
-    $toResource?: string;
-}) | Dictionary<string | AliasValidNodeType>>) => Dictionary<string>;