@bifravst/aws-cdk-lambda-helpers 1.2.1 → 1.2.3

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

@@ -0,0 +1,37 @@
+const Os = require('os');
+const { randomBytes } = require('./random-bytes');
+
+const _mac_address = Symbol('mac-address');
+
+class Machine {
+	constructor() {
+		this.reset();
+	}
+
+	get mac_address() {
+		let mac_address = this[_mac_address];
+
+		if (! mac_address) {
+			const { mac } = Object.values(Os.networkInterfaces())
+				.reduce((memo, arr) => memo.concat(arr), [])
+				.find((iface) => ! iface.internal && iface.mac)
+				|| {};
+
+			mac_address = this[_mac_address] = mac
+				? Uint8Array.from(mac.split(':'), (hex) => Number.parseInt(hex, 16))
+				: randomBytes(6);
+
+			if (! mac) {
+				mac_address[0] |= 0b00000001;
+			}
+		}
+
+		return mac_address;
+	}
+
+	reset() {
+		this[_mac_address] = null;
+	}
+}
+
+module.exports = new Machine;

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/common/random-bytes-browser.js

@@ -0,0 +1,9 @@
+const Crypto = self.crypto;
+
+function randomBytes(size) {
+	const bytes = new Uint8Array(size);
+	Crypto.getRandomValues(bytes);
+	return bytes;
+};
+
+module.exports = { randomBytes };

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/common/random-bytes.js

@@ -0,0 +1,17 @@
+const Crypto = require('crypto');
+
+const BUFFER_SIZE = 4096 /* typical page size */ - 96 /* Empty buffer overhead */;
+
+const buffer = new Uint8Array(BUFFER_SIZE)
+let offset = BUFFER_SIZE;
+
+function randomBytes(size) {
+	if (offset + size >= BUFFER_SIZE) {
+		offset = 0;
+		Crypto.randomFillSync(buffer)
+	}
+
+	return buffer.slice(offset, offset += size);
+}
+
+module.exports = { randomBytes };

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/factory/id.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const _id = Symbol('id');
+const _canonical_coder = Symbol('canonical_coder');
+const _raw_coder = Symbol('raw_coder');
+
+class IdFactory {
+	constructor({
+		id,
+		canonical_coder,
+		raw_coder,
+	} = {}) {
+		this[_id] = class extends id {
+			static get name() { return id.name; }
+			static get [Symbol.species]() { return id; }
+			get [Symbol.toStringTag]() { return `${id.name} ${this.toRaw()}`; }
+			toCanonical() { return canonical_coder.encodeTrusted(this.bytes); }
+			toRaw() { return raw_coder.encodeTrusted(this.bytes); }
+		};
+		this[_canonical_coder] = canonical_coder;
+		this[_raw_coder] = raw_coder;
+	}
+
+	// Properties
+
+	get name() { return this[_id].name; }
+	get type() { return this[_id][Symbol.species]; }
+
+	// Generators
+
+	construct(bytes) {
+		return new this[_id](bytes);
+	}
+
+	generate() {
+		return this[_id].generate(...arguments);
+	}
+
+	MIN() {
+		return this[_id].MIN(...arguments);
+	}
+
+	MAX() {
+		return this[_id].MAX(...arguments);
+	}
+
+	// Coders
+
+	fromCanonical(canonical) {
+		return this.construct(this[_canonical_coder].decode(canonical));
+	}
+
+	fromCanonicalTrusted(canonical) {
+		return this.construct(this[_canonical_coder].decodeTrusted(canonical));
+	}
+
+	fromRaw(raw) {
+		return this.construct(this[_raw_coder].decode(raw));
+	}
+
+	fromRawTrusted(raw) {
+		return this.construct(this[_raw_coder].decodeTrusted(raw));
+	}
+
+	toCanonical(id) {
+		return this[_canonical_coder].encode(id.bytes);
+	}
+
+	toRaw(id) {
+		return this[_raw_coder].encode(id.bytes);
+	}
+
+	// Comparators
+
+	compare(lhs, rhs) {
+		console.warn("Deprecated: use generic idCompare instead.")
+		return lhs.compare(rhs);
+	}
+
+	equal(lhs, rhs) {
+		console.warn("Deprecated: use generic idEqual instead.")
+		return lhs.equal(rhs);
+	}
+
+	// Verifiers
+
+	isCanonical(canonical) {
+		return this[_canonical_coder].isValidEncoding(canonical);
+	}
+
+	isRaw(raw) {
+		return this[_raw_coder].isValidEncoding(raw);
+	}
+}
+
+module.exports = { IdFactory };

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/factory/versioned-id.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const { IdFactory } = require('./id');
+const { UnsupportedVersion } = require('../common/exception');
+
+const _id_by_version = Symbol('id_by_version');
+
+function detect(factory, { version } = {}) {
+	return factory[_id_by_version][version]
+		|| (() => { throw new UnsupportedVersion(
+			`No support for version [${version}]`
+		) })();
+}
+
+class VersionedIdFactory extends IdFactory {
+	constructor({
+		abstract_id,
+		versioned_ids,
+		canonical_coder,
+		raw_coder,
+	}) {
+		super({
+			id: abstract_id,
+			canonical_coder,
+			raw_coder,
+		});
+
+		this[_id_by_version] = versioned_ids.reduce(
+			(mapping, id) => Object.assign(mapping, {
+				[id.MIN().version]: new IdFactory({
+					id,
+					canonical_coder,
+					raw_coder,
+				})
+			}),
+			Object.create(null),
+		);
+	}
+
+	get versioned_ids() {
+		return Object.values(this[_id_by_version]);
+	}
+
+	// Generators
+
+	construct(bytes) {
+		const id = super.construct(bytes);
+		const version = id.version;
+
+		try {
+			return detect(this, { version }).construct(bytes);
+		}
+		catch (error) {
+			if (error instanceof UnsupportedVersion) { return id }
+			else { throw error }
+		}
+	}
+
+	generate() {
+		return detect(this, ...arguments).generate(...arguments);
+	}
+
+	MIN() {
+		return detect(this, ...arguments).MIN();
+	}
+
+	MAX() {
+		return detect(this, ...arguments).MAX();
+	}
+}
+
+module.exports = { VersionedIdFactory };

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

@@ -0,0 +1,39 @@
+'use strict';
+
+const ByteArray = require('../common/byte-array');
+
+const _bytes = Symbol('bytes');
+
+class BaseId {
+	//Constructors
+
+	constructor(bytes) {
+		this[_bytes] = bytes;
+	}
+
+	clone() {
+		return new this.constructor(this.bytes.slice());
+	}
+
+	// Accessors
+
+	get bytes() {
+		return this[_bytes];
+	}
+
+	get [Symbol.toStringTag]() {
+		return this.constructor.name;
+	}
+
+	// Comparators
+
+	compare(rhs) {
+		return ByteArray.compare(this.bytes, rhs.bytes);
+	}
+
+	equal(rhs) {
+		return this.compare(rhs) === 0;
+	}
+}
+
+module.exports = { BaseId };

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/id/ulid-monotonic.js

@@ -0,0 +1,71 @@
+const { Ulid, setTime } = require('./ulid');
+const ByteArray = require('../common/byte-array');
+const EpochConverter = require('../common/epoch-converter');
+const { ClockSequenceOverflow } = require('../common/exception');
+
+const TIME_OFFSET = 0;
+const CLOCK_SEQUENCE_OFFSET = 6;
+const RANDOM_OFFSET = 8;
+
+const EPOCH_ORIGIN_MS = 0;
+
+let _previous_id;
+let _previous_time;
+
+function incrementClockSequence(bytes) {
+	for (
+		let
+			idx = RANDOM_OFFSET - 1,
+			end = CLOCK_SEQUENCE_OFFSET - 1;
+		idx > end;
+		--idx
+	) {
+		if (bytes[idx] === 0xFF) {
+			bytes[idx] = 0;
+		} else {
+			++bytes[idx];
+			return;
+		}
+	}
+
+	throw new ClockSequenceOverflow('Exhausted clock sequence');
+};
+
+function reserveClockSequence(bytes) {
+	bytes[CLOCK_SEQUENCE_OFFSET] &= 0b01111111;
+};
+
+function restoreClockSequence(bytes) {
+	for (let idx = TIME_OFFSET; idx < RANDOM_OFFSET; ++idx) {
+		bytes[idx] = _previous_id.bytes[idx];
+	}
+};
+
+class UlidMonotonic extends Ulid {
+	static reset() {
+		_previous_time = -1;
+		_previous_id = this.MIN();
+	}
+
+	//Constructors
+
+	static generate({ time } = {}) {
+		time = EpochConverter.toEpoch(EPOCH_ORIGIN_MS, time);
+		let bytes = ByteArray.generateRandomFilled();
+
+		if (time <= _previous_time) {
+			restoreClockSequence(bytes);
+			incrementClockSequence(bytes);
+		} else {
+			setTime(time, bytes)
+			reserveClockSequence(bytes);
+			_previous_time = time;
+		}
+
+		return (_previous_id = new this(bytes));
+	}
+}
+
+UlidMonotonic.reset();
+
+module.exports = { UlidMonotonic };

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/id/ulid.js

@@ -0,0 +1,64 @@
+const ByteArray = require('../common/byte-array');
+const EpochConverter = require('../common/epoch-converter');
+const { BaseId } = require('./base');
+
+const TIME_OFFSET = 0;
+
+const EPOCH_ORIGIN_MS = 0;
+const UINT32_RADIX = Math.pow(2, 32);
+const UINT8_MAX = 0b11111111;
+
+function setTime(time, bytes) {
+	const time_low = time % UINT32_RADIX;
+	const time_high = (time - time_low) / UINT32_RADIX;
+
+	let idx = TIME_OFFSET - 1;
+	bytes[++idx] = (time_high >>> 8) & UINT8_MAX;
+	bytes[++idx] = (time_high >>> 0) & UINT8_MAX;
+	bytes[++idx] = (time_low >>> 24) & UINT8_MAX;
+	bytes[++idx] = (time_low >>> 16) & UINT8_MAX;
+	bytes[++idx] = (time_low >>> 8) & UINT8_MAX;
+	bytes[++idx] = (time_low >>> 0) & UINT8_MAX;
+}
+
+class Ulid extends BaseId {
+
+	//Constructors
+
+	static generate({ time } = {}) {
+		time = EpochConverter.toEpoch(EPOCH_ORIGIN_MS, time);
+
+		let bytes = ByteArray.generateRandomFilled();
+
+		setTime(time, bytes);
+
+		return new this(bytes);
+	}
+
+	static MIN() {
+		return new this(ByteArray.generateZeroFilled());
+	}
+
+	static MAX() {
+		return new this(ByteArray.generateOneFilled());
+	}
+
+	// Accessors
+
+	get time() {
+		let idx = TIME_OFFSET - 1;
+		const time_high = 0
+			| (this.bytes[++idx] << 8)
+			| (this.bytes[++idx] << 0);
+		const time_low = 0
+			| (this.bytes[++idx] << 24)
+			| (this.bytes[++idx] << 16)
+			| (this.bytes[++idx] << 8)
+			| (this.bytes[++idx] << 0);
+		const epoch_ms = (time_high * UINT32_RADIX) + (time_low >>> 0);
+
+		return EpochConverter.fromEpoch(EPOCH_ORIGIN_MS, epoch_ms);
+	};
+}
+
+module.exports = { Ulid, setTime };

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/id/uuid-1.js

@@ -0,0 +1,149 @@
+'use strict';
+
+const ByteArray = require('../common/byte-array');
+const EpochConverter = require('../common/epoch-converter');
+const Machine = require('../common/machine');
+const {
+	Uuid,
+	setVariant,
+	setVersion,
+} = require('./uuid');
+
+const TIME_OFFSET = 0;
+const HIRES_TIME_OFFSET = 2;
+const CLOCK_SEQUENCE_OFFSET = 8;
+const NODE_OFFSET = 10;
+
+const CLOCK_SEQUENCE_RADIX = Math.pow(2, 14);
+const EPOCH_ORIGIN_MS = Date.parse('1582-10-15Z');
+const HIRES_TIME_RADIX = Math.pow(2, 12);
+const TIME_LOW_MS_RADIX = Math.pow(2, 20);
+const UINT8_MAX = 0b11111111;
+
+let _clock_sequence;
+let _hires_time;
+let _previous_time;
+
+function incrementClockSequence() {
+	_clock_sequence = (_clock_sequence + 1) % CLOCK_SEQUENCE_RADIX;
+}
+
+function setClockSequence(time, bytes) {
+	if (_clock_sequence === null) {
+		const random_bytes = ByteArray.generateRandomFilled();
+		_clock_sequence = (
+			0
+			| random_bytes[CLOCK_SEQUENCE_OFFSET + 0] << 8
+			| random_bytes[CLOCK_SEQUENCE_OFFSET + 1] << 0
+		) % CLOCK_SEQUENCE_RADIX;
+	}
+	else if (time < _previous_time) {
+		incrementClockSequence();
+	}
+
+	let idx = CLOCK_SEQUENCE_OFFSET - 1;
+	bytes[++idx] = (_clock_sequence >>> 8) & UINT8_MAX;
+	bytes[++idx] = (_clock_sequence >>> 0) & UINT8_MAX;
+}
+
+function setNode(node, bytes) {
+	for (let idx = 0; idx < 6; ++idx) {
+		bytes[NODE_OFFSET + idx] = node[idx];
+	}
+}
+
+function setTime(time, bytes) {
+	_hires_time = time > _previous_time ? 0 : _hires_time + 1;
+	if (_hires_time === HIRES_TIME_RADIX) {
+		_hires_time = 0;
+		incrementClockSequence();
+	}
+
+	const time_low_ms = time % TIME_LOW_MS_RADIX;
+	const time_low = time_low_ms * HIRES_TIME_RADIX + _hires_time;
+	const time_high = (time - time_low_ms) / TIME_LOW_MS_RADIX;
+
+	let idx = TIME_OFFSET - 1;
+	bytes[++idx] = (time_low >>> 24) & UINT8_MAX;
+	bytes[++idx] = (time_low >>> 16) & UINT8_MAX;
+	bytes[++idx] = (time_low >>> 8) & UINT8_MAX;
+	bytes[++idx] = (time_low >>> 0) & UINT8_MAX;
+	bytes[++idx] = (time_high >>> 8) & UINT8_MAX;
+	bytes[++idx] = (time_high >>> 0) & UINT8_MAX;
+	bytes[++idx] = (time_high >>> 24) & UINT8_MAX;
+	bytes[++idx] = (time_high >>> 16) & UINT8_MAX;
+}
+
+class Uuid1 extends Uuid {
+	static get VARIANT() { return 1 }
+	static get VERSION() { return 1 }
+
+	static reset() {
+		_clock_sequence = null;
+		_hires_time = -1;
+		_previous_time = -1;
+	}
+
+	//Constructors
+
+	static generate({ node, time } = {}) {
+		time = EpochConverter.toEpoch(EPOCH_ORIGIN_MS, time);
+
+		let bytes = ByteArray.generateZeroFilled();
+
+		setTime(time, bytes);
+		setClockSequence(time, bytes);
+		setNode(node || Machine.mac_address, bytes);
+		setVariant(this.VARIANT, bytes);
+		setVersion(this.VERSION, bytes);
+
+		if (time > _previous_time) {
+			_previous_time = time;
+		}
+
+		return new this(bytes);
+	}
+
+	// Accessors
+
+	get clock_sequence() {
+		return (
+			0
+			| this.bytes[CLOCK_SEQUENCE_OFFSET] << 8
+			| this.bytes[CLOCK_SEQUENCE_OFFSET + 1]
+		) & (CLOCK_SEQUENCE_RADIX - 1);
+	}
+
+	get hires_time() {
+		return (
+			0
+			| this.bytes[HIRES_TIME_OFFSET] << 8
+			| this.bytes[HIRES_TIME_OFFSET + 1]
+		) & (HIRES_TIME_RADIX - 1);
+	}
+
+	get node() {
+		return this.bytes.slice(NODE_OFFSET);
+	}
+
+	get time() {
+		let idx = TIME_OFFSET - 1;
+		const time_low_ms = 0
+			| (this.bytes[++idx] << 12)
+			| (this.bytes[++idx] << 4)
+			| (this.bytes[++idx] >>> 4);
+		++idx; // Skip hi-res bits
+		const time_high = 0
+			| (this.bytes[++idx] << 8)
+			| (this.bytes[++idx] << 0)
+			| ((this.bytes[++idx] & 0x0F) << 24)
+			| (this.bytes[++idx] << 16);
+		const epoch_ms = time_high * TIME_LOW_MS_RADIX + time_low_ms;
+
+		return EpochConverter.fromEpoch(EPOCH_ORIGIN_MS, epoch_ms);
+	};
+}
+
+Uuid1.reset();
+
+module.exports = { Uuid1 };

package/dist/layers/baseLayer/nodejs/node_modules/id128/src/id/uuid-4.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const ByteArray = require('../common/byte-array');
+const {
+	Uuid,
+	setVariant,
+	setVersion,
+} = require('./uuid');
+
+class Uuid4 extends Uuid {
+	static get VARIANT() { return 1 }
+	static get VERSION() { return 4 }
+
+	static generate() {
+		let bytes = ByteArray.generateRandomFilled();
+
+		setVariant(this.VARIANT, bytes);
+		setVersion(this.VERSION, bytes);
+
+		return new this(bytes);
+	}
+}
+
+module.exports = { Uuid4 };