@balena/pinejs 15.0.0-true-boolean-7896b116c446d891d7a0d5e4085c02a13bc9c725 → 15.0.1-build-migrations-clarify-marking-sbvr-optional-d6d0ded8eccc6eadb2492f4697918cf0afd00215-1

package/src/sbvr-api/translations.ts

@@ -0,0 +1,248 @@
+import * as _ from 'lodash';
+import {
+	AbstractSqlModel,
+	Relationship,
+	ReferencedFieldNode,
+	SelectNode,
+	AliasNode,
+	Definition,
+	RelationshipInternalNode,
+	RelationshipLeafNode,
+	SelectQueryNode,
+	NumberTypeNodes,
+	BooleanTypeNodes,
+	UnknownTypeNodes,
+	NullNode,
+} from '@balena/abstract-sql-compiler';
+import { Dictionary } from './common-types';
+
+export type AliasValidNodeType =
+	| ReferencedFieldNode
+	| SelectQueryNode
+	| NumberTypeNodes
+	| BooleanTypeNodes
+	| UnknownTypeNodes
+	| NullNode;
+const aliasFields = (
+	fromAbstractSqlModel: AbstractSqlModel,
+	toAbstractSqlModel: AbstractSqlModel,
+	fromResourceName: string,
+	toResource: string,
+	aliases: Dictionary<string | AliasValidNodeType>,
+): SelectNode[1] => {
+	const fromFieldNames = fromAbstractSqlModel.tables[
+		fromResourceName
+	].fields.map(({ fieldName }) => fieldName);
+	const nonexistentFields = _.difference(Object.keys(aliases), fromFieldNames);
+	if (nonexistentFields.length > 0) {
+		throw new Error(
+			`Tried to alias non-existent fields: '${nonexistentFields.join(', ')}'`,
+		);
+	}
+	const toFieldNames = toAbstractSqlModel.tables[toResource].fields.map(
+		({ fieldName }) => fieldName,
+	);
+	const checkToFieldExists = (fromFieldName: string, toFieldName: string) => {
+		if (!toFieldNames.includes(toFieldName)) {
+			throw new Error(
+				`Tried to alias '${fromFieldName}' to the non-existent target field: '${toFieldName}'`,
+			);
+		}
+	};
+	return fromFieldNames.map(
+		(fieldName): AliasNode<AliasValidNodeType> | ReferencedFieldNode => {
+			const alias = aliases[fieldName];
+			if (alias) {
+				if (typeof alias === 'string') {
+					checkToFieldExists(fieldName, alias);
+					return [
+						'Alias',
+						['ReferencedField', fromResourceName, alias],
+						fieldName,
+					];
+				}
+				return ['Alias', alias, fieldName];
+			}
+			checkToFieldExists(fieldName, fieldName);
+			return ['ReferencedField', fromResourceName, fieldName];
+		},
+	);
+};
+
+const aliasResource = (
+	fromAbstractSqlModel: AbstractSqlModel,
+	toAbstractSqlModel: AbstractSqlModel,
+	fromResourceName: string,
+	toResource: string,
+	aliases: Dictionary<string | AliasValidNodeType>,
+): Definition => {
+	if (!toAbstractSqlModel.tables[toResource]) {
+		throw new Error(`Tried to alias to a non-existent resource: ${toResource}`);
+	}
+	return {
+		abstractSql: [
+			'SelectQuery',
+			[
+				'Select',
+				aliasFields(
+					fromAbstractSqlModel,
+					toAbstractSqlModel,
+					fromResourceName,
+					toResource,
+					aliases,
+				),
+			],
+			['From', ['Alias', ['Resource', toResource], fromResourceName]],
+		],
+	};
+};
+
+const namespaceRelationships = (
+	relationships: Relationship,
+	alias: string,
+): void => {
+	for (const [key, relationship] of Object.entries(
+		relationships as RelationshipInternalNode,
+	)) {
+		if (key === '$') {
+			return;
+		}
+
+		let mapping = (relationship as RelationshipLeafNode).$;
+		if (mapping != null && mapping.length === 2) {
+			if (!key.includes('$')) {
+				mapping = _.cloneDeep(mapping);
+				mapping[1]![0] = `${mapping[1]![0]}$${alias}`;
+				(relationships as RelationshipInternalNode)[`${key}$${alias}`] = {
+					$: mapping,
+				};
+				delete (relationships as RelationshipInternalNode)[key];
+			}
+		}
+		namespaceRelationships(relationship, alias);
+	}
+};
+
+export const translateAbstractSqlModel = (
+	fromAbstractSqlModel: AbstractSqlModel,
+	toAbstractSqlModel: AbstractSqlModel,
+	fromVersion: string,
+	toVersion: string,
+	translationDefinitions: Dictionary<
+		| (Definition & { $toResource?: string })
+		| Dictionary<string | AliasValidNodeType>
+	> = {},
+): Dictionary<string> => {
+	const isDefinition = (
+		d: (typeof translationDefinitions)[string],
+	): d is Definition => 'abstractSql' in d;
+
+	const resourceRenames: Dictionary<string> = {};
+
+	fromAbstractSqlModel.rules = toAbstractSqlModel.rules;
+
+	const fromResourceKeys = Object.keys(fromAbstractSqlModel.tables);
+	const nonexistentTables = _.difference(
+		Object.keys(translationDefinitions),
+		fromResourceKeys,
+	);
+	if (nonexistentTables.length > 0) {
+		throw new Error(
+			`Tried to define non-existent resources: '${nonexistentTables.join(
+				', ',
+			)}'`,
+		);
+	}
+	for (const [synonym, canonicalForm] of Object.entries(
+		toAbstractSqlModel.synonyms,
+	)) {
+		// Don't double alias
+		if (synonym.includes('$')) {
+			fromAbstractSqlModel.synonyms[synonym] = canonicalForm;
+		} else {
+			fromAbstractSqlModel.synonyms[
+				`${synonym}$${toVersion}`
+			] = `${canonicalForm}$${toVersion}`;
+		}
+	}
+	const relationships = _.cloneDeep(toAbstractSqlModel.relationships);
+	namespaceRelationships(relationships, toVersion);
+	for (let [key, relationship] of Object.entries(relationships)) {
+		// Don't double alias
+		if (!key.includes('$')) {
+			key = `${key}$${toVersion}`;
+		}
+		fromAbstractSqlModel.relationships[key] = relationship;
+	}
+
+	// TODO: We also need to keep the original relationship refs to non $version resources
+
+	// Also alias for ourselves to allow explicit referencing
+	const aliasedFromRelationships = _.cloneDeep(
+		fromAbstractSqlModel.relationships,
+	);
+	namespaceRelationships(aliasedFromRelationships, fromVersion);
+	for (let [key, relationship] of Object.entries(aliasedFromRelationships)) {
+		// Don't double alias
+		if (!key.includes('$')) {
+			key = `${key}$${fromVersion}`;
+			fromAbstractSqlModel.relationships[key] = relationship;
+		}
+	}
+
+	for (let [key, table] of Object.entries(toAbstractSqlModel.tables)) {
+		// Don't double alias
+		if (!key.includes('$')) {
+			key = `${key}$${toVersion}`;
+		}
+		fromAbstractSqlModel.tables[key] = _.cloneDeep(table);
+	}
+
+	for (const key of fromResourceKeys) {
+		const translationDefinition = translationDefinitions[key];
+		const table = fromAbstractSqlModel.tables[key];
+		if (translationDefinition) {
+			const { $toResource, ...definition } = translationDefinition;
+			const hasToResource = typeof $toResource === 'string';
+			if (hasToResource) {
+				resourceRenames[key] = `${$toResource}`;
+			}
+			const toResource = hasToResource ? $toResource : `${key}$${toVersion}`;
+			// TODO: Should this use the toAbstractSqlModel?
+			const toTable = fromAbstractSqlModel.tables[toResource];
+			if (!toTable) {
+				if (hasToResource) {
+					throw new Error(`Unknown $toResource: '${toResource}'`);
+				} else {
+					throw new Error(`Missing $toResource: '${toResource}'`);
+				}
+			}
+			table.modifyFields = _.cloneDeep(toTable.modifyFields ?? toTable.fields);
+			table.modifyName = toTable.modifyName ?? toTable.name;
+			if (isDefinition(definition)) {
+				table.definition = definition;
+			} else {
+				table.definition = aliasResource(
+					fromAbstractSqlModel,
+					toAbstractSqlModel,
+					key,
+					toResource,
+					definition,
+				);
+			}
+		} else {
+			const toTable = fromAbstractSqlModel.tables[`${key}$${toVersion}`];
+			if (!toTable) {
+				throw new Error(`Missing translation for: '${key}'`);
+			}
+			table.modifyFields = _.cloneDeep(toTable.modifyFields ?? toTable.fields);
+			table.definition = {
+				abstractSql: ['Resource', `${key}$${toVersion}`],
+			};
+		}
+		// Also alias the current version so it can be explicitly referenced
+		fromAbstractSqlModel.tables[`${key}$${fromVersion}`] = table;
+	}
+
+	return resourceRenames;
+};

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

@@ -13,7 +13,6 @@ import * as ODataParser from '@balena/odata-parser';
 export const SyntaxError = ODataParser.SyntaxError;
 import { OData2AbstractSQL } from '@balena/odata-to-abstract-sql';
 import * as _ from 'lodash';
-import * as memoize from 'memoizee';
 import memoizeWeak = require('memoizee/weak');
 
 export { BadRequestError, ParsingError, TranslationError } from './errors';
@@ -38,28 +37,33 @@ export interface UnparsedRequest {
 	_isChangeSet?: boolean;
 }
 
-export interface ODataRequest {
+export interface ParsedODataRequest {
 	method: SupportedMethod;
 	url: string;
+	vocabulary: string;
+	resourceName: string;
+	originalResourceName: string;
+	values: AnyObject;
 	odataQuery: ODataQuery;
 	odataBinds: OdataBinds;
-	values: AnyObject;
+	custom: AnyObject;
+	id?: number | undefined;
+	_defer?: boolean;
+}
+export interface ODataRequest extends ParsedODataRequest {
+	translateVersions: string[];
 	abstractSqlModel?: AbstractSQLCompiler.AbstractSqlModel;
+	finalAbstractSqlModel?: AbstractSQLCompiler.AbstractSqlModel;
 	abstractSqlQuery?: AbstractSQLCompiler.AbstractSqlQuery;
 	sqlQuery?: AbstractSQLCompiler.SqlResult | AbstractSQLCompiler.SqlResult[];
-	resourceName: string;
-	vocabulary: string;
-	_defer?: boolean;
-	id?: number;
-	custom: AnyObject;
 	tx?: Tx;
 	modifiedFields?: ReturnType<
 		AbstractSQLCompiler.EngineInstance['getModifiedFields']
 	>;
 	affectedIds?: number[];
 	pendingAffectedIds?: Promise<number[]>;
-	hooks?: InstantiatedHooks;
-	engine?: AbstractSQLCompiler.Engines;
+	hooks?: Array<[string, InstantiatedHooks]>;
+	engine: AbstractSQLCompiler.Engines;
 }
 
 // Converts a value to its string representation and tries to parse is as an
@@ -87,9 +91,8 @@ export const memoizedParseOdata = (() => {
 		return odata;
 	};
 
-	const _memoizedParseOdata = memoize(parseOdata, {
+	const _memoizedParseOdata = env.createCache('parseOData', parseOdata, {
 		primitive: true,
-		max: env.cache.parseOData.max,
 	});
 	return (url: string) => {
 		const queryParamsIndex = url.indexOf('?');
@@ -98,12 +101,12 @@ export const memoizedParseOdata = (() => {
 				// Try to cache based on parameter aliases if there might be some
 				const parameterAliases = new URLSearchParams();
 				const queryParams = new URLSearchParams(url.slice(queryParamsIndex));
-				Array.from(queryParams.entries()).forEach(([key, value]) => {
+				for (const [key, value] of Array.from(queryParams.entries())) {
 					if (key.startsWith('@')) {
 						parameterAliases.append(key, value);
 						queryParams.delete(key);
 					}
-				});
+				}
 				const parameterAliasesString = parameterAliases.toString();
 				if (parameterAliasesString !== '') {
 					const parsed = _.cloneDeep(
@@ -121,7 +124,9 @@ export const memoizedParseOdata = (() => {
 						},
 					);
 					parsed.tree.options ??= {};
-					for (const key of Object.keys(parsedParams.tree)) {
+					for (const key of Object.keys(
+						parsedParams.tree,
+					) as ODataParser.BindKey[]) {
 						parsed.tree.options[key] = parsedParams.tree[key];
 						parsed.binds[key] = parsedParams.binds[key];
 					}
@@ -144,12 +149,16 @@ export const memoizedParseOdata = (() => {
 
 export const memoizedGetOData2AbstractSQL = memoizeWeak(
 	(abstractSqlModel: AbstractSQLCompiler.AbstractSqlModel) => {
-		return new OData2AbstractSQL(abstractSqlModel);
+		return new OData2AbstractSQL(abstractSqlModel, undefined, {
+			// Use minimized aliases when not in debug mode for smaller queries
+			minimizeAliases: !env.DEBUG,
+		});
 	},
 );
 
 const memoizedOdata2AbstractSQL = (() => {
-	const $memoizedOdata2AbstractSQL = memoizeWeak(
+	const $memoizedOdata2AbstractSQL = env.createCache(
+		'odataToAbstractSql',
 		(
 			abstractSqlModel: AbstractSQLCompiler.AbstractSqlModel,
 			odataQuery: ODataQuery,
@@ -158,9 +167,8 @@ const memoizedOdata2AbstractSQL = (() => {
 			existingBindVarsLength: number,
 		) => {
 			try {
-				const odata2AbstractSQL = memoizedGetOData2AbstractSQL(
-					abstractSqlModel,
-				);
+				const odata2AbstractSQL =
+					memoizedGetOData2AbstractSQL(abstractSqlModel);
 				const abstractSql = odata2AbstractSQL.match(
 					odataQuery,
 					method,
@@ -200,9 +208,20 @@ const memoizedOdata2AbstractSQL = (() => {
 					existingBindVarsLength
 				);
 			},
-			max: env.cache.odataToAbstractSql.max,
+			weak: true,
 		},
 	);
+	const cachedProps = [
+		'$select',
+		'$filter',
+		'$expand',
+		'$orderby',
+		'$top',
+		'$skip',
+		'$count',
+		'$inlinecount',
+		'$format',
+	].map(_.toPath);
 
 	return (
 		request: Pick<
@@ -224,18 +243,7 @@ const memoizedOdata2AbstractSQL = (() => {
 		if (odataQuery.options) {
 			odataQuery = {
 				...odataQuery,
-				options: _.pick(
-					odataQuery.options,
-					'$select',
-					'$filter',
-					'$expand',
-					'$orderby',
-					'$top',
-					'$skip',
-					'$count',
-					'$inlinecount',
-					'$format',
-				) as ODataOptions,
+				options: _.pick(odataQuery.options, cachedProps) as ODataOptions,
 			};
 		}
 		const { tree, extraBodyVars, extraBindVars } = $memoizedOdata2AbstractSQL(
@@ -255,23 +263,26 @@ export const metadataEndpoints = ['$metadata', '$serviceroot'];
 
 export async function parseOData(
 	b: UnparsedRequest & { _isChangeSet?: false },
-): Promise<ODataRequest>;
+): Promise<ParsedODataRequest>;
 export async function parseOData(
 	b: UnparsedRequest & { _isChangeSet: true },
-): Promise<ODataRequest[]>;
+): Promise<ParsedODataRequest[]>;
 export async function parseOData(
 	b: UnparsedRequest,
-): Promise<ODataRequest | ODataRequest[]>;
+): Promise<ParsedODataRequest | ParsedODataRequest[]>;
 export async function parseOData(
 	b: UnparsedRequest,
-): Promise<ODataRequest | ODataRequest[]> {
+): Promise<ParsedODataRequest | ParsedODataRequest[]> {
 	try {
 		if (b._isChangeSet && b.changeSet != null) {
 			// We sort the CS set once, we must assure that requests which reference
 			// other requests in the changeset are placed last. Once they are sorted
 			// Map will guarantee retrival of results in insertion order
 			const sortedCS = _.sortBy(b.changeSet, (el) => el.url[0] !== '/');
-			const csReferences = new Map<ODataRequest['id'], ODataRequest>();
+			const csReferences = new Map<
+				ParsedODataRequest['id'],
+				ParsedODataRequest
+			>();
 			for (const cs of sortedCS) {
 				parseODataChangeset(csReferences, cs);
 			}
@@ -285,14 +296,15 @@ export async function parseOData(
 				url,
 				vocabulary: apiRoot,
 				resourceName: odata.tree.resource,
-				odataBinds: odata.binds,
-				odataQuery: odata.tree,
+				originalResourceName: odata.tree.resource,
 				values: b.data ?? {},
+				odataQuery: odata.tree,
+				odataBinds: odata.binds,
 				custom: {},
 				_defer: false,
 			};
 		}
-	} catch (err) {
+	} catch (err: any) {
 		if (err instanceof ODataParser.SyntaxError) {
 			throw new BadRequestError(`Malformed url: '${b.url}'`);
 		}
@@ -305,10 +317,13 @@ export async function parseOData(
 }
 
 const parseODataChangeset = (
-	csReferences: Map<ODataRequest['id'], ODataRequest>,
+	csReferences: Map<ParsedODataRequest['id'], ParsedODataRequest>,
 	b: UnparsedRequest,
 ): void => {
-	const contentId: ODataRequest['id'] = mustExtractHeader(b, 'content-id');
+	const contentId: ParsedODataRequest['id'] = mustExtractHeader(
+		b,
+		'content-id',
+	);
 
 	if (csReferences.has(contentId)) {
 		throw new BadRequestError('Content-Id must be unique inside a changeset');
@@ -339,11 +354,12 @@ const parseODataChangeset = (
 		defer = true;
 	}
 
-	const parseResult: ODataRequest = {
+	const parseResult: ParsedODataRequest = {
 		method: b.method as SupportedMethod,
 		url,
 		vocabulary: apiRoot,
 		resourceName: odata.tree.resource,
+		originalResourceName: odata.tree.resource,
 		odataBinds: odata.binds,
 		odataQuery: odata.tree,
 		values: b.data ?? {},
@@ -355,13 +371,11 @@ const parseODataChangeset = (
 };
 
 const splitApiRoot = (url: string) => {
-	const urlParts = url.split('/');
-	const apiRoot = urlParts[1];
+	const [, apiRoot, ...urlParts] = url.split('/');
 	if (apiRoot == null) {
 		throw new ParsingError(`No such api root: ${apiRoot}`);
 	}
-	url = '/' + urlParts.slice(2).join('/');
-	return { url, apiRoot };
+	return { url: '/' + urlParts.join('/'), apiRoot };
 };
 
 const mustExtractHeader = (
@@ -385,7 +399,7 @@ export const translateUri = <
 		| 'vocabulary'
 		| 'resourceName'
 		| 'abstractSqlModel'
-	>
+	>,
 >(
 	request: T & {
 		abstractSqlQuery?: ODataRequest['abstractSqlQuery'];

package/src/sbvr-api/user.sbvr

@@ -51,6 +51,8 @@ Term:       api key
 Fact type:  api key has key
 	Necessity: each api key has exactly one key
 	Necessity: each key is of exactly one api key
+Fact type: api key has expiry date
+	Necessity: each api key has at most one expiry date.
 Fact type:  api key has role
 	Note: An 'api key' will inherit all the 'permissions' that the 'role' has.
 Fact type:  api key has permission

package/src/server-glue/module.ts

@@ -4,9 +4,11 @@ import './sbvr-loader';
 
 import * as dbModule from '../database-layer/db';
 import * as configLoader from '../config-loader/config-loader';
-import * as migrator from '../migrator/migrator';
+import * as migrator from '../migrator/sync';
+import * as migratorUtils from '../migrator/utils';
 
 import * as sbvrUtils from '../sbvr-api/sbvr-utils';
+import { PINEJS_ADVISORY_LOCK } from '../config-loader/env';
 
 export * as dbModule from '../database-layer/db';
 export { PinejsSessionStore } from '../pinejs-session-store/pinejs-session-store';
@@ -17,12 +19,9 @@ export * as env from '../config-loader/env';
 export * as types from '../sbvr-api/common-types';
 export * as hooks from '../sbvr-api/hooks';
 export type { configLoader as ConfigLoader };
-export type { migrator as Migrator };
+export type { migratorUtils as Migrator };
 
-let envDatabaseOptions: {
-	engine: string;
-	params: string;
-};
+let envDatabaseOptions: dbModule.DatabaseOptions<string>;
 if (dbModule.engines.websql != null) {
 	envDatabaseOptions = {
 		engine: 'websql',
@@ -45,13 +44,20 @@ if (dbModule.engines.websql != null) {
 	};
 }
 
-export const init = async (
+export const init = async <T extends string>(
 	app: Express.Application,
 	config?: string | configLoader.Config,
-	databaseOptions = envDatabaseOptions,
+	databaseOptions:
+		| dbModule.DatabaseOptions<T>
+		| typeof envDatabaseOptions = envDatabaseOptions,
 ): Promise<ReturnType<typeof configLoader.setup>> => {
 	try {
 		const db = dbModule.connect(databaseOptions);
+		// register a pinejs unique lock namespace
+		dbModule.registerTransactionLockNamespace(
+			PINEJS_ADVISORY_LOCK.namespaceKey,
+			PINEJS_ADVISORY_LOCK.namespaceId,
+		);
 		await sbvrUtils.setup(app, db);
 		const cfgLoader = await configLoader.setup(app);
 		await cfgLoader.loadConfig(migrator.config);
@@ -73,8 +79,8 @@ export const init = async (
 		await Promise.all(promises);
 
 		return cfgLoader;
-	} catch (err) {
-		console.error('Error initialising server', err, err.stack);
+	} catch (err: any) {
+		console.error('Error initialising server', err);
 		process.exit(1);
 	}
 };

package/src/server-glue/server.ts

@@ -95,17 +95,17 @@ export const initialised = Pinejs.init(app)
 				'/login',
 				passportPinejs.login((err, user, req, res) => {
 					if (err) {
-						console.error('Error logging in', err, err.stack);
-						res.sendStatus(500);
+						console.error('Error logging in', err);
+						res.status(500).end();
 					} else if (user === false) {
 						if (req.xhr === true) {
-							res.sendStatus(401);
+							res.status(401).end();
 						} else {
 							res.redirect('/login.html');
 						}
 					} else {
 						if (req.xhr === true) {
-							res.sendStatus(200);
+							res.status(200).end();
 						} else {
 							res.redirect('/');
 						}
@@ -123,6 +123,6 @@ export const initialised = Pinejs.init(app)
 		});
 	})
 	.catch((err) => {
-		console.error('Error initialising server', err, err.stack);
+		console.error('Error initialising server', err);
 		process.exit(1);
 	});

package/tsconfig.dev.json

@@ -6,6 +6,7 @@
 	"include": [
 		"build/**/*",
 		"src/**/*",
+		"test/**/*",
 		"typings/**/*.d.ts"
 	]
 }

package/tsconfig.json

@@ -3,7 +3,6 @@
 		"module": "commonjs",
 		"strict": true,
 		"strictFunctionTypes": false,
-		"strictPropertyInitialization": false,
 		"noImplicitThis": false,
 		"noUnusedParameters": true,
 		"noUnusedLocals": true,
@@ -12,7 +11,7 @@
 		"removeComments": true,
 		"rootDir": "src",
 		"sourceMap": true,
-		"target": "es2018",
+		"target": "es2021",
 		"declaration": true,
 		"skipLibCheck": true,
 		"resolveJsonModule": true,

package/typings/lf-to-abstract-sql.d.ts

@@ -1,22 +1,19 @@
 declare module '@balena/lf-to-abstract-sql' {
+	import type sbvrTypes from '@balena/sbvr-types';
+	import type { LFModel } from '@balena/sbvr-parser';
+	import type { AbstractSqlModel } from '@balena/abstract-sql-compiler';
 	export const LF2AbstractSQL: {
 		createInstance: () => {
-			match: (
-				lfModel: LFModel,
-				rule: 'Process',
-			) => AbstractSQLCompiler.AbstractSqlModel;
+			match: (lfModel: LFModel, rule: 'Process') => AbstractSqlModel;
 			addTypes: (types: typeof sbvrTypes) => void;
 			reset: () => void;
 		};
 	};
 	export const LF2AbstractSQLPrep: {
 		match: (lfModel: LFModel, rule: 'Process') => LFModel;
-		_extend({}): typeof LF2AbstractSQL.LF2AbstractSQLPrep;
+		_extend({}): typeof LF2AbstractSQLPrep;
 	};
 	export const createTranslator: (
 		types: typeof sbvrTypes,
-	) => (
-		lfModel: LFModel,
-		rule: 'Process',
-	) => AbstractSQLCompiler.AbstractSqlModel;
+	) => (lfModel: LFModel, rule: 'Process') => AbstractSqlModel;
 }

package/typings/memoizee.d.ts

@@ -5,7 +5,7 @@ declare module 'memoizee/weak' {
 	type RestArgs<T> = T extends (arg1: any, ...args: infer U) => any ? U : any[];
 
 	// tslint:disable-next-line ban-types
-	interface MemoizeWeakOptions<F extends Function> {
+	export interface MemoizeWeakOptions<F extends Function> {
 		length?: number | false;
 		maxAge?: number;
 		max?: number;

package/.github/CODEOWNERS

@@ -1 +0,0 @@
-* @balena-io/pinejs