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

package/src/sbvr-api/control-flow.ts

@@ -1,28 +1,33 @@
 import type { Resolvable } from './common-types';
 
 import * as _ from 'lodash';
+import { TypedError } from 'typed-error';
 
 export type MappingFunction = <T, U>(
 	a: T[],
 	fn: (v: T) => Resolvable<U>,
 ) => Promise<Array<U | Error>>;
 
+export const mapSeries = async <T, U>(a: T[], fn: (v: T) => Resolvable<U>) => {
+	const results: U[] = [];
+	for (const p of a) {
+		results.push(await fn(p));
+	}
+	return results;
+};
+
 // The settle version of `Promise.mapSeries`
 export const settleMapSeries: MappingFunction = async <T, U>(
 	a: T[],
 	fn: (v: T) => Resolvable<U>,
-) => {
-	const results: Array<U | Error> = [];
-	for (const p of a) {
+) =>
+	await mapSeries(a, async (p) => {
 		try {
-			const result = await fn(p);
-			results.push(result);
-		} catch (err) {
-			results.push(ensureError(err));
+			return await fn(p);
+		} catch (err: any) {
+			return ensureError(err);
 		}
-	}
-	return results;
-};
+	});
 
 // This is used to guarantee that we convert a `.catch` result into an error, so that later code checking `_.isError` will work as expected
 const ensureError = (err: any): Error => {
@@ -44,7 +49,7 @@ const mapTill: MappingFunction = async <T, U>(
 		try {
 			const result = await fn(p);
 			results.push(result);
-		} catch (err) {
+		} catch (err: any) {
 			results.push(ensureError(err));
 			break;
 		}
@@ -64,3 +69,32 @@ export const getMappingFn = (headers?: {
 		return mapTill;
 	}
 };
+
+export const delay = (ms: number) =>
+	new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+export const fromCallback = <T>(
+	resolver: (callback: (err: any, result?: T) => void) => void,
+): Promise<T> =>
+	new Promise<T>((resolve, reject) => {
+		resolver((err, result?: T) => {
+			if (err) {
+				reject(err);
+			} else {
+				resolve(result as T);
+			}
+		});
+	});
+
+export class TimeoutError extends TypedError {}
+export const timeout = async <T>(
+	promise: Promise<T>,
+	ms: number,
+	msg = 'operation timed out',
+): Promise<T> =>
+	await Promise.race([
+		promise,
+		delay(ms).then(() => {
+			throw new TimeoutError(msg);
+		}),
+	]);

package/src/sbvr-api/errors.ts

@@ -1,4 +1,4 @@
-import type { AnyObject } from './common-types';
+import type { AnyObject, Tail } from './common-types';
 
 import { TypedError } from 'typed-error';
 
@@ -16,6 +16,9 @@ export class HttpError extends TypedError {
 		public status: number,
 		error: string | Error = '',
 		public body?: string | AnyObject,
+		public headers?: {
+			[headerName: string]: any;
+		},
 	) {
 		super(error);
 	}
@@ -25,231 +28,233 @@ export class HttpError extends TypedError {
 	}
 }
 
+type HttpErrorTailArgs = Tail<ConstructorParameters<typeof HttpError>>;
+
 export class BadRequestError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(400, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(400, ...args);
 	}
 }
 
 export class UnauthorizedError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(401, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(401, ...args);
 	}
 }
 
 export class PaymentRequired extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(402, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(402, ...args);
 	}
 }
 
 export class ForbiddenError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(403, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(403, ...args);
 	}
 }
 
 export class NotFoundError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(404, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(404, ...args);
 	}
 }
 
 export class MethodNotAllowedError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(405, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(405, ...args);
 	}
 }
 
 export class NotAcceptableError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(406, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(406, ...args);
 	}
 }
 
 export class ProxyAuthenticationRequiredError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(407, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(407, ...args);
 	}
 }
 
 export class RequestTimeoutError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(408, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(408, ...args);
 	}
 }
 
 export class ConflictError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(409, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(409, ...args);
 	}
 }
 
 export class GoneError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(410, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(410, ...args);
 	}
 }
 
 export class LengthRequiredError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(411, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(411, ...args);
 	}
 }
 
 export class PreconditionFailedError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(412, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(412, ...args);
 	}
 }
 
 export class PayloadTooLargeError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(413, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(413, ...args);
 	}
 }
 
 export class URITooLongError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(414, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(414, ...args);
 	}
 }
 
 export class UnsupportedMediaTypeError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(415, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(415, ...args);
 	}
 }
 
 export class RequestedRangeNotSatisfiableError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(416, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(416, ...args);
 	}
 }
 
 export class ExpectationFailedError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(417, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(417, ...args);
 	}
 }
 
 export class MisdirectedRequestError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(421, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(421, ...args);
 	}
 }
 
 export class UnprocessableEntityError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(422, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(422, ...args);
 	}
 }
 
 export class LockedError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(423, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(423, ...args);
 	}
 }
 
 export class FailedDependencyError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(424, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(424, ...args);
 	}
 }
 
 export class UpgradeRequiredError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(426, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(426, ...args);
 	}
 }
 
 export class PreconditionRequiredError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(428, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(428, ...args);
 	}
 }
 
 export class TooManyRequestsError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(429, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(429, ...args);
 	}
 }
 
 export class RequestHeaderFieldsTooLargeError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(431, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(431, ...args);
 	}
 }
 
 export class UnavailableForLegalReasonsError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(451, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(451, ...args);
 	}
 }
 
 export class InternalRequestError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(500, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(500, ...args);
 	}
 }
 
 export class NotImplementedError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(501, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(501, ...args);
 	}
 }
 
 export class BadGatewayError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(502, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(502, ...args);
 	}
 }
 
 export class ServiceUnavailableError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(503, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(503, ...args);
 	}
 }
 
 export class GatewayTimeoutError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(504, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(504, ...args);
 	}
 }
 
 export class HTTPVersionNotSupportedError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(505, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(505, ...args);
 	}
 }
 
 export class VariantAlsoNegotiatesError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(506, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(506, ...args);
 	}
 }
 
 export class InsufficientStorageError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(507, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(507, ...args);
 	}
 }
 
 export class LoopDetectedError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(508, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(508, ...args);
 	}
 }
 
 export class NotExtendedError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(510, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(510, ...args);
 	}
 }
 
 export class NetworkAuthenticationRequiredError extends HttpError {
-	constructor(error?: string | Error, body?: string | AnyObject) {
-		super(511, error, body);
+	constructor(...args: HttpErrorTailArgs) {
+		super(511, ...args);
 	}
 }
 

package/src/sbvr-api/express-extension.ts

@@ -2,7 +2,12 @@
 
 // tslint:disable-next-line:no-namespace
 declare namespace Express {
-	export interface Request {
+	type PineUser = import('./sbvr-utils').User;
+
+	// tslint:disable-next-line:no-empty-interface
+	interface User extends PineUser {}
+	interface Request {
+		user?: User;
 		apiKey?: import('./sbvr-utils').ApiKey;
 	}
 }