@balena/pinejs 16.0.0-build--batch-09b8c466600d7df13e6df3eacabaf463d96f652f-1 → 16.0.0-build-fisehara-update-sbvr-types-b58e72aca3193964afac96c955fde178fe39d077-1

package/src/bin/sbvr-compiler.ts

@@ -1,24 +1,21 @@
 import { version, writeAll, writeSqlModel } from './utils';
-
-import type * as SbvrUtils from '../sbvr-api/sbvr-utils';
-
 import { program } from 'commander';
 import * as fs from 'fs';
 
 const getSE = (inputFile: string) => fs.readFileSync(inputFile, 'utf8');
 
-const parse = (inputFile: string, outputFile?: string) => {
-	const { generateLfModel } =
-		require('../sbvr-api/sbvr-utils') as typeof SbvrUtils;
+const parse = async (inputFile: string, outputFile?: string) => {
+	const { generateLfModel } = await import('../sbvr-api/sbvr-utils.js');
 	const seModel = getSE(inputFile);
 	const result = generateLfModel(seModel);
 	const json = JSON.stringify(result, null, 2);
 	writeAll(json, outputFile);
 };
 
-const transform = (inputFile: string, outputFile?: string) => {
-	const { generateLfModel, generateAbstractSqlModel } =
-		require('../sbvr-api/sbvr-utils') as typeof SbvrUtils;
+const transform = async (inputFile: string, outputFile?: string) => {
+	const { generateLfModel, generateAbstractSqlModel } = await import(
+		'../sbvr-api/sbvr-utils.js'
+	);
 	const seModel = getSE(inputFile);
 	const lfModel = generateLfModel(seModel);
 	const result = generateAbstractSqlModel(lfModel);
@@ -26,9 +23,8 @@ const transform = (inputFile: string, outputFile?: string) => {
 	writeAll(json, outputFile);
 };
 
-const runCompile = (inputFile: string, outputFile?: string) => {
-	const { generateModels } =
-		require('../sbvr-api/sbvr-utils') as typeof SbvrUtils;
+const runCompile = async (inputFile: string, outputFile?: string) => {
+	const { generateModels } = await import('../sbvr-api/sbvr-utils.js');
 	const seModel = getSE(inputFile);
 	const models = generateModels(
 		{ apiRoot: 'sbvr-compiler', modelText: seModel },
@@ -38,16 +34,16 @@ const runCompile = (inputFile: string, outputFile?: string) => {
 	writeSqlModel(models.sql, outputFile);
 };
 
-const generateTypes = (inputFile: string, outputFile?: string) => {
-	const { generateModels } =
-		require('../sbvr-api/sbvr-utils') as typeof SbvrUtils;
+const generateTypes = async (inputFile: string, outputFile?: string) => {
+	const { generateModels } = await import('../sbvr-api/sbvr-utils.js');
 	const seModel = getSE(inputFile);
 	const models = generateModels(
 		{ apiRoot: 'sbvr-compiler', modelText: seModel },
 		program.opts().engine,
 	);
-	const { abstractSqlToTypescriptTypes } =
-		require('@balena/abstract-sql-to-typescript') as typeof import('@balena/abstract-sql-to-typescript');
+	const { abstractSqlToTypescriptTypes } = await import(
+		'@balena/abstract-sql-to-typescript'
+	);
 	const types = abstractSqlToTypescriptTypes(models.abstractSql);
 
 	writeAll(types, outputFile);
@@ -93,4 +89,4 @@ if (process.argv.length === 2) {
 	program.help();
 }
 
-program.parse(process.argv);
+void program.parseAsync(process.argv);

package/src/bin/utils.ts

@@ -10,7 +10,6 @@ import * as fs from 'fs';
 import * as path from 'path';
 import '../server-glue/sbvr-loader';
 
-// tslint:disable:no-var-requires
 export const { version } = JSON.parse(
 	fs.readFileSync(require.resolve('../../package.json'), 'utf8'),
 );
@@ -83,6 +82,7 @@ export const getAbstractSqlModelFromFile = (
 		throw new Error('Unrecognised config file');
 	}
 	const { generateLfModel, generateAbstractSqlModel } =
+		// eslint-disable-next-line @typescript-eslint/no-var-requires
 		require('../sbvr-api/sbvr-utils') as typeof SbvrUtils;
 	let lfModel;
 	try {

package/src/config-loader/config-loader.ts

@@ -12,8 +12,8 @@ import type {
 } from '../sbvr-api/common-types';
 
 import {
-	Migration,
-	Migrations,
+	type Migration,
+	type Migrations,
 	defaultMigrationCategory,
 	MigrationCategories,
 	isSyncMigration,
@@ -21,13 +21,20 @@ import {
 } from '../migrator/utils';
 
 import * as fs from 'fs';
-import * as _ from 'lodash';
+import _ from 'lodash';
 import * as path from 'path';
 
 import * as sbvrUtils from '../sbvr-api/sbvr-utils';
 
 import * as permissions from '../sbvr-api/permissions';
-import { AliasValidNodeType } from '../sbvr-api/translations';
+import {
+	getDefaultHandler,
+	getUploaderMiddlware,
+	type WebResourceHandler,
+	setupUploadHooks,
+	setupWebresourceHandler,
+} from '../webresource-handler';
+import type { AliasValidNodeType } from '../sbvr-api/translations';
 
 export type SetupFunction = (
 	app: Express.Application,
@@ -64,6 +71,7 @@ export interface User {
 export interface Config {
 	models: Model[];
 	users?: User[];
+	webResourceHandler?: WebResourceHandler;
 }
 
 const getOrCreate = async (
@@ -195,16 +203,37 @@ export const setup = (app: Express.Application) => {
 						);
 
 						const apiRoute = `/${model.apiRoot}/*`;
+						const webResourceHandler =
+							data.webResourceHandler ?? getDefaultHandler();
+
+						setupWebresourceHandler(webResourceHandler);
+						const fileUploadMiddleware =
+							getUploaderMiddlware(webResourceHandler);
 						app
 							.route(apiRoute)
 							.options((_req, res) => res.status(200).end())
 							.get(sbvrUtils.handleODataRequest)
 							.put(sbvrUtils.handleODataRequest)
-							.post(sbvrUtils.handleODataRequest)
-							.patch(sbvrUtils.handleODataRequest)
+							.post(fileUploadMiddleware, sbvrUtils.handleODataRequest)
+							.patch(fileUploadMiddleware, sbvrUtils.handleODataRequest)
 							.merge(sbvrUtils.handleODataRequest)
 							.delete(sbvrUtils.handleODataRequest);
 
+						const loadedModel = sbvrUtils.getModel(model.apiRoot!);
+						if (translateTo == null) {
+							const resourceNames = Object.values(
+								loadedModel.abstractSql.tables,
+							)
+								.filter((table) =>
+									table.fields.some((f) => f.dataType === 'WebResource'),
+								)
+								.map((table) => table.name);
+
+							for (const resource of new Set(resourceNames)) {
+								setupUploadHooks(webResourceHandler, model.apiRoot!, resource);
+							}
+						}
+
 						console.info(
 							'Successfully executed ' + model.modelName + ' model.',
 						);
@@ -251,7 +280,8 @@ export const setup = (app: Express.Application) => {
 	};
 	const loadConfigFile = async (configPath: string): Promise<Config> => {
 		console.info('Loading config:', configPath);
-		return await import(configPath);
+		const { default: configObj } = await import(configPath);
+		return configObj;
 	};
 
 	const loadApplicationConfig = async (config: string | Config | undefined) => {
@@ -350,9 +380,12 @@ export const setup = (app: Express.Application) => {
 								switch (fileExtension) {
 									case '.coffee':
 									case '.ts':
-									case '.js':
-										const loadeMigration = nodeRequire(filePath);
-										const migration = loadeMigration.default ?? loadeMigration;
+									case '.js': {
+										const { default: loadedMigration } = await import(filePath);
+										const migration =
+											// This second check for `.default` is because it might be a commonjs file that was compiled from typescript with `export default`
+											// and typescript will add the `.default` but so will the `import()`
+											loadedMigration.default ?? loadedMigration;
 
 										if (
 											!isAsyncMigration(migration) &&
@@ -365,6 +398,7 @@ export const setup = (app: Express.Application) => {
 
 										assignMigrationWithCategory(migrationKey, migration);
 										break;
+									}
 									case '.sql':
 										if (migrationCategory === MigrationCategories.async) {
 											console.error(

package/src/config-loader/env.ts

@@ -50,7 +50,7 @@ export const cache = {
 };
 
 import { boolVar } from '@balena/env-parsing';
-import * as memoize from 'memoizee';
+import memoize from 'memoizee';
 import memoizeWeak = require('memoizee/weak');
 export const createCache = <T extends (...args: any[]) => any>(
 	cacheName: keyof typeof cache,

package/src/data-server/sbvr-server.js

@@ -48,7 +48,7 @@ const serverIsOnAir = async (_req, _res, next) => {
 };
 
 /** @type {import('../config-loader/config-loader').Config} */
-export let config = {
+export const config = {
 	models: [
 		{
 			modelName: 'ui',
@@ -267,6 +267,8 @@ export async function setup(app, sbvrUtils, db) {
 							try {
 								await tx.executeSql(query);
 							} catch (err) {
+								// TODO: Consider changing this to a custom Error
+								// eslint-disable-next-line no-throw-literal
 								throw [query, err];
 							}
 						}

package/src/database-layer/db.ts

@@ -6,7 +6,7 @@ import type { Dictionary, Resolvable } from '../sbvr-api/common-types';
 
 import { Engines } from '@balena/abstract-sql-compiler';
 import { EventEmitter } from 'eventemitter3';
-import * as _ from 'lodash';
+import _ from 'lodash';
 import { TypedError } from 'typed-error';
 import * as env from '../config-loader/env';
 import { fromCallback, timeout } from '../sbvr-api/control-flow';
@@ -168,7 +168,7 @@ const atomicExecuteSql: Database['executeSql'] = async function (
 };
 
 const asyncTryFn = (fn: () => any) => {
-	Promise.resolve().then(fn);
+	void Promise.resolve().then(fn);
 };
 
 type RejectedFunctions = (message: string) => {
@@ -189,7 +189,7 @@ const getRejectedFunctions: RejectedFunctions = env.DEBUG
 				executeSql: rejectFn,
 				rollback: rejectFn,
 			};
-	  }
+		}
 	: (message) => {
 			const rejectFn = async () => {
 				throw new TransactionClosedError(message);
@@ -198,7 +198,7 @@ const getRejectedFunctions: RejectedFunctions = env.DEBUG
 				executeSql: rejectFn,
 				rollback: rejectFn,
 			};
-	  };
+		};
 
 const onEnd: Tx['on'] = (name: string, fn: () => void) => {
 	if (name === 'end') {
@@ -215,7 +215,10 @@ class AutomaticClose {
 	private automaticCloseTimeout: ReturnType<typeof setTimeout>;
 	private automaticClose: () => void;
 	private pending: false | number = 0;
-	constructor(tx: Tx, private stackTraceErr?: Error) {
+	constructor(
+		tx: Tx,
+		private stackTraceErr?: Error,
+	) {
 		this.automaticClose = () => {
 			console.error(
 				`Transaction still open after ${env.db.timeoutMS}ms without an execute call.`,
@@ -223,7 +226,7 @@ class AutomaticClose {
 			if (this.stackTraceErr) {
 				console.error(this.stackTraceErr.stack);
 			}
-			tx.rollback();
+			void tx.rollback();
 		};
 		this.automaticCloseTimeout = setTimeout(
 			this.automaticClose,
@@ -400,10 +403,13 @@ export abstract class Tx {
 	protected abstract _rollback(): Promise<void>;
 	protected abstract _commit(): Promise<void>;
 
+	// TODO: Re-enable the lint rule once eslint properly supports abstract class base implementations
 	public async getTxLevelLock(
+		/* eslint-disable @typescript-eslint/no-unused-vars */
 		_namespaceKey: string,
 		_key: number,
 		_blocking: boolean = true,
+		/* eslint-enable @typescript-eslint/no-unused-vars */
 	): Promise<boolean> {
 		throw new Error(
 			'The getTxLevelLock method is not implemented for the current engine.',
@@ -462,7 +468,6 @@ const createTransaction = (createFunc: CreateTransactionFn): TransactionFn => {
 
 let maybePg: typeof Pg | undefined;
 try {
-	// tslint:disable-next-line:no-var-requires
 	maybePg = require('pg');
 } catch (e) {
 	// Ignore errors
@@ -497,7 +502,7 @@ if (maybePg != null) {
 			const p = new pg.Pool(config);
 			if (PG_SCHEMA != null) {
 				p.on('connect', (client) => {
-					client.query({ text: `SET search_path TO "${PG_SCHEMA}"` });
+					void client.query({ text: `SET search_path TO "${PG_SCHEMA}"` });
 				});
 			}
 			p.on('connect', (client) => {
@@ -519,6 +524,7 @@ if (maybePg != null) {
 		let pool: Pg.Pool;
 		let replica: Pg.Pool;
 		if (typeof connectString === 'string') {
+			// eslint-disable-next-line @typescript-eslint/no-var-requires
 			const pgConnectionString: typeof PgConnectionString = require('pg-connection-string');
 			// We have to cast because of the use of null vs undefined
 			const config = pgConnectionString.parse(connectString) as Pg.PoolConfig;
@@ -540,12 +546,12 @@ if (maybePg != null) {
 			rowCount,
 			rows,
 		}: {
-			rowCount: number;
+			rowCount: number | null;
 			rows: Row[];
 		}): Result => {
 			return {
 				rows,
-				rowsAffected: rowCount,
+				rowsAffected: rowCount ?? 0,
 				insertId: rows?.[0]?.id,
 			};
 		};
@@ -617,9 +623,9 @@ if (maybePg != null) {
 					);
 					this.db.release();
 				} catch (err: any) {
-					err = wrapDatabaseError(err);
-					this.db.release(err);
-					throw err;
+					const errorToReturn = wrapDatabaseError(err);
+					this.db.release(errorToReturn);
+					throw errorToReturn;
 				}
 			}
 
@@ -686,13 +692,13 @@ if (maybePg != null) {
 			transaction: createTransaction(async (stackTraceErr) => {
 				const client = await pool.connect();
 				const tx = new PostgresTx(client, false, stackTraceErr);
-				tx.executeSql('START TRANSACTION;');
+				void tx.executeSql('START TRANSACTION;');
 				return tx;
 			}),
 			readTransaction: createTransaction(async (stackTraceErr) => {
 				const client = await replica.connect();
 				const tx = new PostgresTx(client, false, stackTraceErr);
-				tx.executeSql('START TRANSACTION READ ONLY;');
+				void tx.executeSql('START TRANSACTION READ ONLY;');
 				return tx.asReadOnly();
 			}),
 			...alwaysExport,
@@ -702,7 +708,6 @@ if (maybePg != null) {
 
 let maybeMysql: typeof Mysql | undefined;
 try {
-	// tslint:disable-next-line:no-var-requires
 	maybeMysql = require('mysql');
 } catch (e) {
 	// Ignore errors
@@ -809,14 +814,14 @@ if (maybeMysql != null) {
 				const client = await getConnectionAsync();
 				const close = () => client.release();
 				const tx = new MySqlTx(client, close, false, stackTraceErr);
-				tx.executeSql('START TRANSACTION;');
+				void tx.executeSql('START TRANSACTION;');
 				return tx;
 			}),
 			readTransaction: createTransaction(async (stackTraceErr) => {
 				const client = await getConnectionAsync();
 				const close = () => client.release();
 				const tx = new MySqlTx(client, close, false, stackTraceErr);
-				tx.executeSql('START TRANSACTION READ ONLY;');
+				void tx.executeSql('START TRANSACTION READ ONLY;');
 				return tx.asReadOnly();
 			}),
 			...alwaysExport,
@@ -935,7 +940,6 @@ if (typeof window !== 'undefined' && window.openDatabase != null) {
 			// allowing us to use async calls within the API.
 			private asyncRecurse = () => {
 				let args: AsyncQuery | undefined;
-				// tslint:disable-next-line no-conditional-assignment
 				while ((args = this.queue.pop())) {
 					console.debug('Running', args[0]);
 					this.tx.executeSql(args[0], args[1], args[2], args[3]);

package/src/express-emulator/express.js

@@ -1,4 +1,4 @@
-import * as _ from 'lodash';
+import _ from 'lodash';
 
 /**
  * @typedef {Partial<Window> & {GLOBAL_PERMISSIONS?: string[]}} ExtendedWindow
@@ -34,10 +34,10 @@ const app = (function () {
 		/** @type {string} */ match,
 		/** @type import('express').Handler[] */ ...middleware
 	) {
-		//Strip wildcard
+		// Strip wildcard
 		let paramName;
 		match = match.toLowerCase();
-		const newMatch = match.replace(/[\/\*]*$/, '');
+		const newMatch = match.replace(/[/*]*$/, '');
 		if (newMatch !== match) {
 			match = newMatch;
 			paramName = '*';
@@ -59,6 +59,8 @@ const app = (function () {
 		/** @type any */ body = '',
 	) {
 		if (!handlers[method]) {
+			// TODO: Consider changing this to a custom Error
+			// eslint-disable-next-line no-throw-literal
 			throw [404, null, null];
 		}
 		const req = {

package/src/extended-sbvr-parser/extended-sbvr-parser.ts

@@ -1,5 +1,5 @@
 import { SBVRParser } from '@balena/sbvr-parser';
-// tslint:disable-next-line:no-var-requires
+// eslint-disable-next-line @typescript-eslint/no-var-requires
 const Types: string = require('@balena/sbvr-types/Type.sbvr');
 import { version as sbvrParserVersion } from '@balena/sbvr-parser/package.json';
 import { version } from '@balena/sbvr-parser/package.json';

package/src/http-transactions/transactions.js

@@ -1,10 +1,10 @@
-import * as _ from 'lodash';
 import { odataNameToSqlName } from '@balena/odata-to-abstract-sql';
-// @ts-ignore
+// @ts-expect-error b/c TS doesn't know what the result of requiring an sbvr file would be
+// eslint-disable-next-line @typescript-eslint/no-var-requires
 const transactionModel = require('./transaction.sbvr');
 
 /** @type {import('../config-loader/config-loader').Config} */
-export let config = {
+export const config = {
 	models: [
 		{
 			apiRoot: 'transaction',
@@ -130,7 +130,12 @@ WHERE "conditional field"."conditional resource" = ?;`,
 								modelField.dataType === 'ForeignKey' &&
 								Number.isNaN(Number(fieldValue))
 							) {
-								if (!placeholders.hasOwnProperty(fieldValue)) {
+								if (
+									!Object.prototype.hasOwnProperty.call(
+										placeholders,
+										fieldValue,
+									)
+								) {
 									throw new Error('Cannot resolve placeholder' + fieldValue);
 								} else {
 									try {
@@ -170,7 +175,7 @@ WHERE "conditional resource"."transaction" = ?;\
 							resolve = $resolve;
 							reject = $reject;
 						});
-						// @ts-ignore
+						// @ts-expect-error we use resolve & reject before they are assigned b/c we treat them as a deferred.
 						placeholders[placeholder] = { promise, resolve, reject };
 					}
 				}

package/src/migrator/async.ts

@@ -1,7 +1,7 @@
 import type { Tx } from '../database-layer/db';
 import type { Model } from '../config-loader/config-loader';
 
-import * as _ from 'lodash';
+import _ from 'lodash';
 import * as sbvrUtils from '../sbvr-api/sbvr-utils';
 
 type ApiRootModel = Model & { apiRoot: string };
@@ -12,18 +12,18 @@ type InitialMigrationStatus = MigrationStatus &
 	>;
 
 import {
-	MigrationTuple,
+	type MigrationTuple,
 	getExecutedMigrations,
 	migratorEnv,
 	lockMigrations,
 	initMigrationStatus,
 	readMigrationStatus,
 	updateMigrationStatus,
-	RunnableAsyncMigrations,
+	type RunnableAsyncMigrations,
 	getRunnableAsyncMigrations,
 	filterAndSortPendingMigrations,
-	MigrationStatus,
-	BaseAsyncMigration,
+	type MigrationStatus,
+	type BaseAsyncMigration,
 } from './utils';
 import { booleanToEnabledString } from '../config-loader/env';
 
@@ -220,7 +220,8 @@ const $run = async (
 									// skip execution
 									if (migrationState.last_run_time) {
 										const durationSinceLastRun =
-											Date.now() - migrationState.last_run_time.getTime();
+											Date.now() -
+											new Date(migrationState.last_run_time).getTime();
 										const delayMs = migrationState.is_backing_off
 											? initMigrationState.backoffDelayMS
 											: initMigrationState.delayMS;

package/src/migrator/sync.ts

@@ -1,20 +1,21 @@
 import {
-	MigrationTuple,
+	type MigrationTuple,
 	MigrationError,
+	type MigrationExecutionResult,
 	setExecutedMigrations,
 	getExecutedMigrations,
 	lockMigrations,
-	RunnableMigrations,
+	type RunnableMigrations,
 	filterAndSortPendingMigrations,
 	getRunnableSyncMigrations,
 } from './utils';
 import type { Tx } from '../database-layer/db';
 import type { Config, Model } from '../config-loader/config-loader';
 
-import * as _ from 'lodash';
+import _ from 'lodash';
 import * as sbvrUtils from '../sbvr-api/sbvr-utils';
 
-// tslint:disable-next-line:no-var-requires
+// eslint-disable-next-line @typescript-eslint/no-var-requires
 const modelText = require('./migrations.sbvr');
 
 type ApiRootModel = Model & { apiRoot: string };
@@ -45,7 +46,10 @@ export const postRun = async (tx: Tx, model: ApiRootModel): Promise<void> => {
 	}
 };
 
-export const run = async (tx: Tx, model: ApiRootModel): Promise<void> => {
+export const run = async (
+	tx: Tx,
+	model: ApiRootModel,
+): Promise<MigrationExecutionResult> => {
 	const { migrations } = model;
 	if (migrations == null || _.isEmpty(migrations)) {
 		return;
@@ -58,7 +62,7 @@ const $run = async (
 	tx: Tx,
 	model: ApiRootModel,
 	migrations: RunnableMigrations,
-): Promise<void> => {
+): Promise<MigrationExecutionResult> => {
 	const modelName = model.apiRoot;
 
 	// migrations only run if the model has been executed before,
@@ -68,7 +72,6 @@ const $run = async (
 		(sbvrUtils.api.migrations?.logger.info ?? console.info)(
 			`First time model '${modelName}' has executed, skipping migrations`,
 		);
-
 		return await setExecutedMigrations(tx, modelName, Object.keys(migrations));
 	}
 	await lockMigrations({ tx, modelName, blocking: true }, async () => {

package/src/migrator/utils.ts

@@ -3,7 +3,7 @@ import type { Resolvable } from '../sbvr-api/common-types';
 
 import { createHash } from 'crypto';
 import { Engines } from '@balena/abstract-sql-compiler';
-import * as _ from 'lodash';
+import _ from 'lodash';
 import { TypedError } from 'typed-error';
 import { migrator as migratorEnv } from '../config-loader/env';
 export { migrator as migratorEnv } from '../config-loader/env';
@@ -32,12 +32,12 @@ export type AsyncMigrationFn = (
 	sbvrUtils: SbvrUtils,
 ) => Resolvable<number>;
 
-type AddFn<T extends {}, x extends 'sync' | 'async'> = T & {
+type AddFn<T extends object, 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 & {
+type AddSql<T extends object, x extends 'sync' | 'async'> = T & {
 	[key in `${x}Fn`]?: undefined;
 } & {
 	[key in `${x}Sql`]: string;
@@ -105,6 +105,12 @@ export type MigrationStatus = {
 	is_backing_off: boolean;
 };
 
+export type MigrationExecutionResult =
+	| undefined
+	| {
+			pendingUnsetMigrations: string[];
+	  };
+
 export const getRunnableAsyncMigrations = (
 	$migrations: Migrations,
 ): RunnableAsyncMigrations | undefined => {
@@ -270,9 +276,9 @@ export const setExecutedMigrations = async (
 	tx: Tx,
 	modelName: string,
 	executedMigrations: string[],
-): Promise<void> => {
+): Promise<MigrationExecutionResult> => {
 	if (!(await migrationTablesExist(tx))) {
-		return;
+		return { pendingUnsetMigrations: executedMigrations };
 	}
 
 	const stringifiedMigrations = await sbvrUtils.sbvrTypes.JSON.validate(

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

@@ -3,9 +3,9 @@ import type {
 	AbstractSqlTable,
 } from '@balena/abstract-sql-compiler';
 
-import sbvrTypes, { SbvrType } from '@balena/sbvr-types';
+import sbvrTypes, { type SbvrType } from '@balena/sbvr-types';
 
-// tslint:disable-next-line:no-var-requires
+// eslint-disable-next-line @typescript-eslint/no-var-requires
 const { version }: { version: string } = require('../../package.json');
 
 const getResourceName = (resourceName: string): string =>

package/src/passport-pinejs/mount-login-router.ts

@@ -0,0 +1,46 @@
+import * as passportPinejs from './passport-pinejs';
+import type { Express } from 'express';
+import { PinejsSessionStore } from '../pinejs-session-store/pinejs-session-store';
+import type { setup } from '../config-loader/config-loader';
+
+export const mountLoginRouter = async (
+	configLoader: ReturnType<typeof setup>,
+	expressApp: Express,
+) => {
+	await Promise.all([
+		configLoader.loadConfig(passportPinejs.config),
+		configLoader.loadConfig(PinejsSessionStore.config),
+	]);
+
+	if (
+		typeof process === 'undefined' ||
+		process == null ||
+		!process.env.DISABLE_DEFAULT_AUTH
+	) {
+		expressApp.post(
+			'/login',
+			passportPinejs.login((err, user, req, res) => {
+				if (err) {
+					console.error('Error logging in', err);
+					res.status(500).end();
+				} else if (user === false) {
+					if (req.xhr === true) {
+						res.status(401).end();
+					} else {
+						res.redirect('/login.html');
+					}
+				} else {
+					if (req.xhr === true) {
+						res.status(200).end();
+					} else {
+						res.redirect('/');
+					}
+				}
+			}),
+		);
+
+		expressApp.get('/logout', passportPinejs.logout, (_req, res) => {
+			res.redirect('/');
+		});
+	}
+};