@bifravst/aws-cdk-lambda-helpers 1.2.0 → 1.2.2

package/dist/layers/baseLayer/nodejs/node_modules/id128/index.d.ts

@@ -0,0 +1,167 @@
+/* eslint-disable @typescript-eslint/no-empty-interface */
+export {};
+
+// Utility Types
+
+interface ConstructorOf<C> {
+	new(...args: any[]): C;
+}
+
+// Id Types
+
+export interface Id {
+	readonly bytes: Uint8Array;
+	readonly [Symbol.toStringTag]: string;
+
+	clone(): this;
+
+	toCanonical(): string;
+	toRaw(): string;
+
+	compare(rhs: Id): number;
+	equal(rhs: Id): boolean;
+}
+
+export interface Uuid extends Id {
+	readonly variant: number;
+	readonly version: number;
+}
+
+export interface Ulid extends Id {
+	readonly time: Date;
+}
+
+export interface UlidMonotonic extends Id {
+	readonly time: Date;
+}
+
+export interface Uuid1 extends Uuid {
+	readonly clock_sequence: number;
+	readonly hires_time: number;
+	readonly node: Uint8Array;
+	readonly time: Date;
+}
+
+export interface Uuid4 extends Uuid {}
+
+export interface Uuid6 extends Uuid {
+	readonly clock_sequence: number;
+	readonly hires_time: number;
+	readonly node: Uint8Array;
+	readonly time: Date;
+}
+
+export interface UuidNil extends Uuid {}
+
+// Id Factories
+
+interface IdFactory<T> {
+	readonly name: string;
+	readonly type: ConstructorOf<T>;
+
+	construct(bytes: Uint8Array): T;
+	generate(options?: {}): T;
+	MIN(options?: {}): T;
+	MAX(options?: {}): T;
+
+	fromCanonical(canonical: string): T;
+	fromCanonicalTrusted(canonical: string): T;
+	fromRaw(raw: string): T;
+	fromRawTrusted(raw: string): T;
+
+	toCanonical(id: T): string;
+	toRaw(id: T): string;
+
+	compare(lhs: Id, rhs: Id): number;
+	equal(lhs: Id, rhs: Id): boolean;
+
+	isCanonical(canonical: string): boolean;
+	isRaw(raw: string): boolean;
+}
+
+interface VersionedIdFactory<T> extends IdFactory<T> {
+	readonly versioned_ids: Array<IdFactory<T>>;
+
+	MIN(options: VersionOption): T;
+	MAX(options: VersionOption): T;
+}
+
+interface NodeOption {
+	node?: Uint8Array | null;
+}
+
+interface TimeOption {
+	time?: Date | number | null;
+}
+
+interface VersionOption {
+	version: number;
+}
+
+export type AnyIdFactory = IdFactory<Id>;
+
+export interface UlidFactory extends IdFactory<Ulid> {
+	generate(options?: TimeOption): Ulid;
+}
+
+export interface UlidMonotonicFactory extends IdFactory<UlidMonotonic> {
+	generate(options?: TimeOption): UlidMonotonic;
+}
+
+export interface UuidFactory extends VersionedIdFactory<Uuid> {
+	generate(options: NodeOption & TimeOption & VersionOption): Uuid;
+}
+
+export interface Uuid1Factory extends IdFactory<Uuid1> {
+	generate(options?: NodeOption & TimeOption): Uuid1;
+}
+
+export interface Uuid4Factory extends IdFactory<Uuid4> {
+	generate(options?: {}): Uuid4;
+}
+
+export interface Uuid6Factory extends IdFactory<Uuid6> {
+	generate(options?: NodeOption & TimeOption): Uuid6;
+}
+
+export interface UuidNilFactory extends IdFactory<UuidNil> {
+	generate(options?: {}): UuidNil;
+}
+
+// Errors
+
+// NOTE: Actually extends Error, but typescript breaks instanceof support
+export interface Id128Error extends Function {
+	readonly name: string;
+	message: string;
+	stack?: string;
+}
+export interface ClockSequenceOverflow extends Id128Error {}
+export interface InvalidBytes extends Id128Error {}
+export interface InvalidEncoding extends Id128Error {}
+export interface InvalidEpoch extends Id128Error {}
+export interface UnsupportedVersion extends Id128Error {}
+
+// Exported Functions
+
+export function idCompare(lhs: Id, rhs: Id): number;
+export function idEqual(lhs: Id, rhs: Id): boolean;
+
+// Exported Constants
+
+export const Ulid: UlidFactory;
+export const UlidMonotonic: UlidMonotonicFactory;
+export const Uuid: UuidFactory;
+export const Uuid1: Uuid1Factory;
+export const Uuid4: Uuid4Factory;
+export const Uuid6: Uuid6Factory;
+export const UuidNil: UuidNilFactory;
+
+export namespace Exception {
+	const Id128Error: ConstructorOf<Id128Error>;
+	const ClockSequenceOverflow: ConstructorOf<ClockSequenceOverflow>;
+	const InvalidBytes: ConstructorOf<InvalidBytes>;
+	const InvalidEncoding: ConstructorOf<InvalidEncoding>;
+	const InvalidEpoch: ConstructorOf<InvalidEpoch>;
+	const UnsupportedVersion: ConstructorOf<UnsupportedVersion>;
+}

package/dist/layers/baseLayer/nodejs/node_modules/id128/index.js

@@ -0,0 +1,49 @@
+const { Ulid } = require('./src/id/ulid');
+const { UlidMonotonic } = require('./src/id/ulid-monotonic');
+const { Uuid } = require('./src/id/uuid');
+const { Uuid1 } = require('./src/id/uuid-1');
+const { Uuid4 } = require('./src/id/uuid-4');
+const { Uuid6 } = require('./src/id/uuid-6');
+const { UuidNil } = require('./src/id/uuid-nil');
+
+const Crockford32Coder = require('./src/coder/crockford32');
+const HexCoder = require('./src/coder/hex');
+const UuidCoder = require('./src/coder/uuid');
+
+const { IdFactory } = require('./src/factory/id');
+const { VersionedIdFactory } = require('./src/factory/versioned-id');
+const Exception = require('./src/common/exception');
+
+const namespace = {
+	idCompare: function(lhs, rhs) { return lhs.compare(rhs); },
+	idEqual: function(lhs, rhs) { return lhs.equal(rhs); },
+	Exception,
+	Ulid: new IdFactory({
+		id: Ulid,
+		canonical_coder: Crockford32Coder,
+		raw_coder: HexCoder,
+	}),
+	UlidMonotonic: new IdFactory({
+		id: UlidMonotonic,
+		canonical_coder: Crockford32Coder,
+		raw_coder: HexCoder,
+	}),
+	Uuid: new VersionedIdFactory({
+		abstract_id: Uuid,
+		versioned_ids: [
+			Uuid1,
+			Uuid4,
+			Uuid6,
+			UuidNil,
+		],
+		canonical_coder: UuidCoder,
+		raw_coder: HexCoder,
+	}),
+};
+
+namespace.Uuid.versioned_ids.reduce(
+	(ns, uuid) => Object.assign(ns, {[uuid.name]: uuid}),
+	namespace
+);
+
+module.exports = namespace;

package/dist/layers/baseLayer/nodejs/node_modules/id128/package.json

@@ -0,0 +1,68 @@
+{
+	"name": "id128",
+	"description": "Collection of 128-bit Id generators",
+	"version": "1.6.6",
+	"author": "Aaron Cohen <aarondcohen@gmail.com>",
+	"license": "MIT",
+	"main": "index.js",
+	"types": "index.d.ts",
+	"files": [
+		"index.d.ts",
+		"index.js",
+		"src/",
+		"utils.js"
+	],
+	"homepage": "https://github.com/aarondcohen/id128#id128",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/aarondcohen/id128.git"
+	},
+	"bugs": {
+		"url": "https://github.com/aarondcohen/id128/issues"
+	},
+	"browser": {
+		"./src/common/machine.js": "./src/common/fake-machine.js",
+		"./src/common/random-bytes.js": "./src/common/random-bytes-browser.js"
+	},
+	"scripts": {
+		"benchmark": "NODE_PATH='./src/' node benchmark/stats.js",
+		"call": "NODE_PATH='./src/' node",
+		"dtslint": "dtslint types",
+		"test": "NODE_PATH='./src/' mocha",
+		"test-all": "NODE_PATH='./src/' mocha test/*"
+	},
+	"engines": {
+		"node": ">=v6.9.0"
+	},
+	"devDependencies": {
+		"benchmarkify": "github:aarondcohen/benchmarkify",
+		"chai": "*",
+		"dtslint": "^3.4.1",
+		"mocha": "*",
+		"sinon": "*"
+	},
+	"keywords": [
+		"128-bit",
+		"crockford32",
+		"guid",
+		"id",
+		"monotonic",
+		"random",
+		"rfc-4122",
+		"rfc4122",
+		"uid",
+		"ulid",
+		"unique",
+		"universal",
+		"uuid",
+		"uuid-v1",
+		"uuid-v4",
+		"uuid-v6",
+		"uuid1",
+		"uuid4",
+		"uuid6",
+		"uuidv1",
+		"uuidv4",
+		"uuidv6"
+	]
+}

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/coder/base.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const {
+	InvalidEncoding,
+	InvalidBytes,
+} = require('../common/exception');
+
+const _valid_encoding_pattern = Symbol('valid_encoding_pattern');
+
+class BaseCoder {
+	constructor({
+		valid_encoding_pattern,
+	} = {}) {
+		this[_valid_encoding_pattern] = valid_encoding_pattern;
+	}
+
+	decode(encoding) {
+		if (this.isValidEncoding(encoding)) {
+			return this.decodeTrusted(encoding);
+		}
+		else {
+			throw new InvalidEncoding(`Encoding [${encoding}] does not satisfy ${this[_valid_encoding_pattern]}`);
+		}
+	}
+
+	decodeTrusted(encoding) { return ByteArray.generateRandomFilled() }
+
+	encode(bytes) {
+		if (this.isValidBytes(bytes)) {
+			return this.encodeTrusted(bytes);
+		}
+		else {
+			throw new InvalidBytes('Requires a 16-byte Uint8Array');
+		}
+
+	}
+
+	encodeTrusted(bytes) { return '' }
+
+	isValidBytes(bytes) {
+		return true
+			&& (bytes instanceof Uint8Array)
+			&& bytes.length === 16;
+	}
+
+	isValidEncoding(encoding) {
+		return true
+			&& (typeof encoding === 'string' || encoding instanceof String)
+			&& this[_valid_encoding_pattern].test(encoding);
+	}
+}
+
+module.exports = { BaseCoder };

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/coder/crockford32.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const { BaseCoder } = require('./base');
+
+const ALPHABET = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+const MAX_QUINTET = 0b11111;
+
+const CHAR_TO_QUINTET = Array.from(ALPHABET).reduce(
+	(acc, chr, idx) => (acc[chr] = acc[chr.toLowerCase()] = idx, acc),
+	{
+		'I': ALPHABET.indexOf('1'),
+		'i': ALPHABET.indexOf('1'),
+		'L': ALPHABET.indexOf('1'),
+		'l': ALPHABET.indexOf('1'),
+		'O': ALPHABET.indexOf('0'),
+		'o': ALPHABET.indexOf('0'),
+		'U': ALPHABET.indexOf('V'),
+		'u': ALPHABET.indexOf('V'),
+	}
+);
+const QUINTET_TO_CHAR = Array.from(ALPHABET);
+
+function _charToQuintet(chr) {
+	return CHAR_TO_QUINTET[chr];
+}
+
+function _quintetToChar(quintet) {
+	return QUINTET_TO_CHAR[quintet & MAX_QUINTET];
+}
+
+class Crockford32Coder extends BaseCoder {
+	constructor() {
+		super({
+			valid_encoding_pattern: /^[0-7][^\W_]{25}$/,
+		});
+	}
+
+	decodeTrusted(encoding) {
+		const bytes = new Uint8Array(16);
+		const quintets = [];
+
+		for (let idx = 0, end = encoding.length; idx < end; ++idx) {
+			quintets.push(_charToQuintet(encoding[idx]));
+		}
+
+		//Note: unrolled for performance
+		bytes[0] = quintets[0] << 5 | quintets[1];
+
+		bytes[1] = quintets[2] << 3 | quintets[3] >> 2;
+		bytes[2] = quintets[3] << 6 | quintets[4] << 1 | quintets[5] >> 4;
+		bytes[3] = quintets[5] << 4 | quintets[6] >> 1;
+		bytes[4] = quintets[6] << 7 | quintets[7] << 2 | quintets[8] >> 3;
+		bytes[5] = quintets[8] << 5 | quintets[9];
+
+		bytes[6] = quintets[10] << 3 | quintets[11] >> 2;
+		bytes[7] = quintets[11] << 6 | quintets[12] << 1 | quintets[13] >> 4;
+		bytes[8] = quintets[13] << 4 | quintets[14] >> 1;
+		bytes[9] = quintets[14] << 7 | quintets[15] << 2 | quintets[16] >> 3;
+		bytes[10] = quintets[16] << 5 | quintets[17];
+
+		bytes[11] = quintets[18] << 3 | quintets[19] >> 2;
+		bytes[12] = quintets[19] << 6 | quintets[20] << 1 | quintets[21] >> 4;
+		bytes[13] = quintets[21] << 4 | quintets[22] >> 1;
+		bytes[14] = quintets[22] << 7 | quintets[23] << 2 | quintets[24] >> 3;
+		bytes[15] = quintets[24] << 5 | quintets[25];
+
+		return bytes;
+	}
+
+	encodeTrusted(bytes) {
+		//Note: unrolled for performance
+		let quintets = [
+			(bytes[0] >> 5),
+			(bytes[0]),
+
+			(bytes[1] >> 3),
+			(bytes[1] << 2 | bytes[2] >> 6),
+			(bytes[2] >> 1),
+			(bytes[2] << 4 | bytes[3] >> 4),
+			(bytes[3] << 1 | bytes[4] >> 7),
+			(bytes[4] >> 2),
+			(bytes[4] << 3 | bytes[5] >> 5),
+			(bytes[5]),
+
+			(bytes[6] >> 3),
+			(bytes[6] << 2 | bytes[7] >> 6),
+			(bytes[7] >> 1),
+			(bytes[7] << 4 | bytes[8] >> 4),
+			(bytes[8] << 1 | bytes[9] >> 7),
+			(bytes[9] >> 2),
+			(bytes[9] << 3 | bytes[10] >> 5),
+			(bytes[10]),
+
+			(bytes[11] >> 3),
+			(bytes[11] << 2 | bytes[12] >> 6),
+			(bytes[12] >> 1),
+			(bytes[12] << 4 | bytes[13] >> 4),
+			(bytes[13] << 1 | bytes[14] >> 7),
+			(bytes[14] >> 2),
+			(bytes[14] << 3 | bytes[15] >> 5),
+			(bytes[15]),
+		];
+
+		//Note: Massive performance losses occured when
+		// using the more legible Array.map and Array.join
+		let encoding = '';
+		for (let idx = 0, end = quintets.length; idx < end; ++idx) {
+			encoding += _quintetToChar(quintets[idx]);
+		}
+		return encoding;
+	}
+}
+
+module.exports = new Crockford32Coder;

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/coder/hex.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const { BaseCoder } = require('./base');
+
+const ALPHABET = '0123456789ABCDEF';
+
+const BYTE_TO_HEX = Array
+	.from({ length: ALPHABET.length * ALPHABET.length })
+	.map((_, key) => (
+		''
+		+ ALPHABET.charAt(key / ALPHABET.length)
+		+ ALPHABET.charAt(key % ALPHABET.length)
+	));
+
+const HEX_TO_BYTE = Array.from(ALPHABET).reduce(
+	(mapping, hex, idx) => Object.assign(mapping, {
+		[hex.toUpperCase()]: idx,
+		[hex.toLowerCase()]: idx,
+	}),
+	Object.create(null)
+);
+
+class HexCoder extends BaseCoder {
+	constructor() {
+		super({
+			valid_encoding_pattern: /^[0-9A-Fa-f]{32}$/,
+		});
+	}
+
+	decodeTrusted(encoding) {
+		let bytes = new Uint8Array(16);
+
+		for (
+			let
+				dst = 0,
+				hi_hex = true,
+				src = 0,
+				end = encoding.length;
+			src < end;
+			++src
+		) {
+			const hex = encoding[src];
+			if (hi_hex) {
+				bytes[dst] = HEX_TO_BYTE[hex] << 4;
+			} else {
+				bytes[dst++] |= HEX_TO_BYTE[hex];
+			}
+			hi_hex = !hi_hex;
+		}
+
+		return bytes;
+	}
+
+	encodeTrusted(bytes) {
+		let encoding = '';
+		for (let idx = 0, end = bytes.length; idx < end; ++idx) {
+			encoding += BYTE_TO_HEX[bytes[idx]];
+		}
+		return encoding;
+	}
+}
+
+module.exports = new HexCoder;

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/coder/uuid.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const { BaseCoder } = require('./base');
+
+const ALPHABET = '0123456789ABCDEF';
+
+const BYTE_TO_HEX = Array
+	.from({ length: ALPHABET.length * ALPHABET.length })
+	.map((_, key) => (
+		''
+		+ ALPHABET.charAt(key / ALPHABET.length)
+		+ ALPHABET.charAt(key % ALPHABET.length)
+	));
+
+const HEX_TO_BYTE = Array.from(ALPHABET).reduce(
+	(mapping, hex, idx) => Object.assign(mapping, {
+		[hex.toUpperCase()]: idx,
+		[hex.toLowerCase()]: idx,
+	}),
+	Object.create(null)
+);
+
+class UuidCoder extends BaseCoder {
+	constructor() {
+		super({
+			valid_encoding_pattern: /^[0-9A-Fa-f]{4}(?:-?[0-9A-Fa-f]{4}){7}$/,
+		});
+	}
+
+	decodeTrusted(encoding) {
+		let bytes = new Uint8Array(16);
+
+		for (
+			let
+				dst = 0,
+				hi_hex = true,
+				src = 0,
+				end = encoding.length;
+			src < end;
+			++src
+		) {
+			const hex = encoding[src];
+			if(hex !== '-') {
+				if (hi_hex) {
+					bytes[dst] = HEX_TO_BYTE[hex] << 4;
+				} else {
+					bytes[dst++] |= HEX_TO_BYTE[hex];
+				}
+				hi_hex = ! hi_hex;
+			}
+		}
+
+		return bytes;
+	}
+
+	encodeTrusted(bytes) {
+		let idx = -1;
+		const encoding = (''
+			+ BYTE_TO_HEX[bytes[++idx]] + BYTE_TO_HEX[bytes[++idx]]
+			+ BYTE_TO_HEX[bytes[++idx]] + BYTE_TO_HEX[bytes[++idx]]
+			+ '-'
+			+ BYTE_TO_HEX[bytes[++idx]] + BYTE_TO_HEX[bytes[++idx]]
+			+ '-'
+			+ BYTE_TO_HEX[bytes[++idx]] + BYTE_TO_HEX[bytes[++idx]]
+			+ '-'
+			+ BYTE_TO_HEX[bytes[++idx]] + BYTE_TO_HEX[bytes[++idx]]
+			+ '-'
+			+ BYTE_TO_HEX[bytes[++idx]] + BYTE_TO_HEX[bytes[++idx]]
+			+ BYTE_TO_HEX[bytes[++idx]] + BYTE_TO_HEX[bytes[++idx]]
+			+ BYTE_TO_HEX[bytes[++idx]] + BYTE_TO_HEX[bytes[++idx]]
+		);
+		return encoding;
+	}
+}
+
+module.exports = new UuidCoder;
+

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/common/byte-array.js

@@ -0,0 +1,26 @@
+const { randomBytes } = require('./random-bytes');
+
+const MAX_BYTES = 16;
+
+class ByteArray {
+	compare(lhs, rhs) {
+		const mismatch_idx =
+			lhs.findIndex((byt, idx) => (byt !== rhs[idx]));
+		return ~mismatch_idx
+			&& Math.sign(lhs[mismatch_idx] - rhs[mismatch_idx]);
+	}
+
+	generateOneFilled() {
+		return new Uint8Array(MAX_BYTES).fill(0xFF);
+	}
+
+	generateRandomFilled() {
+		return randomBytes(MAX_BYTES);
+	}
+
+	generateZeroFilled() {
+		return new Uint8Array(MAX_BYTES).fill(0);
+	}
+}
+
+module.exports = new ByteArray;

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/common/epoch-converter.js

@@ -0,0 +1,32 @@
+const { InvalidEpoch } = require('./exception');
+
+const MIN_MS = 0;
+const MAX_MS = Math.pow(2, 48);
+
+class EpochConverter {
+	fromEpoch(origin_ms, epoch_ms) {
+		return new Date(epoch_ms + origin_ms);
+	}
+
+	toEpoch(origin_ms, time = null) {
+		const coerced_ms =
+			time === null ? Date.now() :
+			Number.isInteger(time) ? time :
+			time instanceof Date ? time.getTime() :
+				(() => {
+					throw new InvalidEpoch(`Failed to coerce time [${time}] to epoch`);
+				})();
+
+		const epoch_ms = coerced_ms - origin_ms;
+
+		if (epoch_ms < MIN_MS || epoch_ms >= MAX_MS) {
+			const min_iso = new Date(MIN_MS + origin_ms).toISOString();
+			const max_iso = new Date(MAX_MS - 1 + origin_ms).toISOString();
+			throw new InvalidEpoch(`Epoch must be between ${min_iso} and ${max_iso}`);
+		}
+
+		return epoch_ms;
+	}
+}
+
+module.exports = new EpochConverter;

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/common/exception.js

@@ -0,0 +1,18 @@
+class Id128Error extends Error {
+	get name() { return this.constructor.name }
+}
+
+class ClockSequenceOverflow extends Id128Error {}
+class InvalidBytes extends Id128Error {}
+class InvalidEncoding extends Id128Error {}
+class InvalidEpoch extends Id128Error {}
+class UnsupportedVersion extends Id128Error {}
+
+module.exports = {
+	Id128Error,
+	ClockSequenceOverflow,
+	InvalidBytes,
+	InvalidEncoding,
+	InvalidEpoch,
+	UnsupportedVersion,
+};

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/common/fake-machine.js

@@ -0,0 +1,26 @@
+const { randomBytes } = require('./random-bytes');
+
+const _mac_address = Symbol('mac-address');
+
+class FakeMachine {
+	constructor() {
+		this.reset();
+	}
+
+	get mac_address() {
+		let mac_address = this[_mac_address];
+
+		if (! mac_address) {
+			mac_address = this[_mac_address] = randomBytes(6);
+			mac_address[0] |= 0b00000001;
+		}
+
+		return mac_address;
+	}
+
+	reset() {
+		this[_mac_address] = null;
+	}
+}
+
+module.exports = new FakeMachine;