serverless-spy 0.0.61 → 0.0.63

package/node_modules/serialize-error/node_modules/type-fest/source/typed-array.d.ts

@@ -0,0 +1,17 @@
+/**
+Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
+
+@category Array
+*/
+export type TypedArray =
+	| Int8Array
+	| Uint8Array
+	| Uint8ClampedArray
+	| Int16Array
+	| Uint16Array
+	| Int32Array
+	| Uint32Array
+	| Float32Array
+	| Float64Array
+	| BigInt64Array
+	| BigUint64Array;

package/node_modules/serialize-error/node_modules/type-fest/source/union-to-intersection.d.ts

@@ -0,0 +1,60 @@
+/**
+Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void; great(arg: string): void; escape: boolean};
+```
+
+A more applicable example which could make its way into your library code follows.
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+class CommandOne {
+	commands: {
+		a1: () => undefined,
+		b1: () => undefined,
+	}
+}
+
+class CommandTwo {
+	commands: {
+		a2: (argA: string) => undefined,
+		b2: (argB: string) => undefined,
+	}
+}
+
+const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
+type Union = typeof union;
+//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
+
+type Intersection = UnionToIntersection<Union>;
+//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
+```
+
+@category Type
+*/
+export type UnionToIntersection<Union> = (
+	// `extends unknown` is always going to be the case and is used to convert the
+	// `Union` into a [distributive conditional
+	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+	Union extends unknown
+		// The union type is used as the only argument to a function since the union
+		// of function arguments is an intersection.
+		? (distributedUnion: Union) => void
+		// This won't happen.
+		: never
+		// Infer the `Intersection` type since TypeScript represents the positional
+		// arguments of unions of functions as an intersection of the union.
+	) extends ((mergedIntersection: infer Intersection) => void)
+		? Intersection
+		: never;

package/node_modules/serialize-error/node_modules/type-fest/source/value-of.d.ts

@@ -0,0 +1,42 @@
+/**
+Create a union of the given object's values, and optionally specify which keys to get the values from.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+// data.json
+{
+	'foo': 1,
+	'bar': 2,
+	'biz': 3
+}
+
+// main.ts
+import type {ValueOf} from 'type-fest';
+import data = require('./data.json');
+
+export function getData(name: string): ValueOf<typeof data> {
+	return data[name];
+}
+
+export function onlyBar(name: string): ValueOf<typeof data, 'bar'> {
+	return data[name];
+}
+
+// file.ts
+import {getData, onlyBar} from './main';
+
+getData('foo');
+//=> 1
+
+onlyBar('foo');
+//=> TypeError ...
+
+onlyBar('bar');
+//=> 2
+```
+
+@category Object
+*/
+export type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];

package/node_modules/serialize-error/node_modules/type-fest/source/writable.d.ts

@@ -0,0 +1,40 @@
+import type {Except} from './except';
+import type {Simplify} from './simplify';
+
+/**
+Create a type that strips `readonly` from all or some of an object's keys. Inverse of `Readonly<T>`.
+
+This can be used to [store and mutate options within a class](https://github.com/sindresorhus/pageres/blob/4a5d05fca19a5fbd2f53842cbf3eb7b1b63bddd2/source/index.ts#L72), [edit `readonly` objects within tests](https://stackoverflow.com/questions/50703834), [construct a `readonly` object within a function](https://github.com/Microsoft/TypeScript/issues/24509), or to define a single model where the only thing that changes is whether or not some of the keys are writable.
+
+@example
+```
+import type {Writable} from 'type-fest';
+
+type Foo = {
+	readonly a: number;
+	readonly b: readonly string[]; // To show that only the mutability status of the properties, not their values, are affected.
+	readonly c: boolean;
+};
+
+const writableFoo: Writable<Foo> = {a: 1, b: ['2'], c: true};
+writableFoo.a = 3;
+writableFoo.b[0] = 'new value'; // Will still fail as the value of property "b" is still a readonly type.
+writableFoo.b = ['something']; // Will work as the "b" property itself is no longer readonly.
+
+type SomeWritable = Writable<Foo, 'b' | 'c'>;
+// type SomeWritable = {
+// 	readonly a: number;
+// 	b: readonly string[]; // It's now writable. The type of the property remains unaffected.
+// 	c: boolean; // It's now writable.
+// }
+```
+
+@category Object
+*/
+export type Writable<BaseType, Keys extends keyof BaseType = keyof BaseType> =
+	Simplify<
+		// Pick just the keys that are not writable from the base type.
+		Except<BaseType, Keys> &
+		// Pick the keys that should be writable from the base type and make them writable by removing the `readonly` modifier from the key.
+		{-readonly [KeyType in keyof Pick<BaseType, Keys>]: Pick<BaseType, Keys>[KeyType]}
+	>;

package/node_modules/serialize-error/package.json

@@ -0,0 +1,46 @@
+{
+	"name": "serialize-error",
+	"version": "11.0.0",
+	"description": "Serialize/deserialize an error into a plain object",
+	"license": "MIT",
+	"repository": "sindresorhus/serialize-error",
+	"funding": "https://github.com/sponsors/sindresorhus",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "https://sindresorhus.com"
+	},
+	"type": "module",
+	"exports": "./index.js",
+	"engines": {
+		"node": ">=14.16"
+	},
+	"scripts": {
+		"test": "xo && ava && tsd"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts",
+		"error-constructors.js",
+		"error-constructors.d.ts"
+	],
+	"keywords": [
+		"error",
+		"serialize",
+		"stringify",
+		"object",
+		"convert",
+		"process",
+		"send",
+		"cause",
+		"deserialize"
+	],
+	"dependencies": {
+		"type-fest": "^2.12.2"
+	},
+	"devDependencies": {
+		"ava": "^4.2.0",
+		"tsd": "^0.20.0",
+		"xo": "^0.48.0"
+	}
+}

package/node_modules/serialize-error/readme.md

@@ -0,0 +1,198 @@
+# serialize-error
+
+> Serialize/deserialize an error into a plain object
+
+Useful if you for example need to `JSON.stringify()` or `process.send()` the error.
+
+## Install
+
+```sh
+npm install serialize-error
+```
+
+## Usage
+
+```js
+import {serializeError, deserializeError} from 'serialize-error';
+
+const error = new Error('🦄');
+
+console.log(error);
+//=> [Error: 🦄]
+
+const serialized = serializeError(error);
+
+console.log(serialized);
+//=> {name: 'Error', message: '🦄', stack: 'Error: 🦄\n    at Object.<anonymous> …'}
+
+const deserialized = deserializeError(serialized);
+
+console.log(deserialized);
+//=> [Error: 🦄]
+```
+
+### Error constructors
+
+When a serialized error with a known `name` is encountered, it will be deserialized using the corresponding error constructor, while unknown error names will be deserialized as regular errors:
+
+```js
+import {deserializeError} from 'serialize-error';
+
+const known = deserializeError({
+	name: 'TypeError',
+	message: '🦄'
+});
+
+console.log(known);
+//=> [TypeError: 🦄] <-- Still a TypeError
+
+const unknown = deserializeError({
+	name: 'TooManyCooksError',
+	message: '🦄'
+});
+
+console.log(unknown);
+//=> [Error: 🦄] <-- Just a regular Error
+```
+
+The [list of known errors](./error-constructors.js) can be extended globally. This also works if `serialize-error` is a sub-dependency that's not used directly.
+
+```js
+import {errorConstructors} from 'serialize-error';
+import {MyCustomError} from './errors.js'
+
+errorConstructors.set('MyCustomError', MyCustomError)
+```
+
+**Warning:** Only simple and standard error constructors are supported, like `new MyCustomError(message)`. If your error constructor **requires** a second parameter or does not accept a string as first parameter, adding it to this map **will** break the deserialization.
+
+## API
+
+### serializeError(value, options?)
+
+Serialize an `Error` object into a plain object.
+
+- Non-error values are passed through.
+- Custom properties are preserved.
+- Non-enumerable properties are kept non-enumerable (name, message, stack).
+- Enumerable properties are kept enumerable (all properties besides the non-enumerable ones).
+- Buffer properties are replaced with `[object Buffer]`.
+- Circular references are handled.
+- If the input object has a `.toJSON()` method, then it's called instead of serializing the object's properties.
+- It's up to `.toJSON()` implementation to handle circular references and enumerability of the properties.
+
+### value
+
+Type: `Error | unknown`
+
+### toJSON implementation examples
+
+```js
+import {serializeError} from 'serialize-error';
+
+class ErrorWithDate extends Error {
+	constructor() {
+		super();
+		this.date = new Date();
+	}
+}
+
+const error = new ErrorWithDate();
+
+serializeError(error);
+// => {date: '1970-01-01T00:00:00.000Z', name, message, stack}
+```
+
+```js
+import {serializeError} from 'serialize-error';
+
+const error = new Error('Unicorn');
+
+error.horn = {
+	toJSON() {
+		return 'x';
+	}
+};
+
+serializeError(error);
+// => {horn: 'x', name, message, stack}
+```
+
+### deserializeError(value, options?)
+
+Deserialize a plain object or any value into an `Error` object.
+
+- `Error` objects are passed through.
+- Objects that have at least a `message` property are interpreted as errors.
+- All other values are wrapped in a `NonError` error.
+- Custom properties are preserved.
+- Non-enumerable properties are kept non-enumerable (name, message, stack, cause).
+- Enumerable properties are kept enumerable (all properties besides the non-enumerable ones).
+- Circular references are handled.
+- [Native error constructors](./error-constructors.js) are preserved (TypeError, DOMException, etc) and [more can be added.](#error-constructors)
+
+### value
+
+Type: `{message: string} | unknown`
+
+### options
+
+Type: `object`
+
+#### maxDepth
+
+Type: `number`\
+Default: `Number.POSITIVE_INFINITY`
+
+The maximum depth of properties to preserve when serializing/deserializing.
+
+```js
+import {serializeError} from 'serialize-error';
+
+const error = new Error('🦄');
+error.one = {two: {three: {}}};
+
+console.log(serializeError(error, {maxDepth: 1}));
+//=> {name: 'Error', message: '🦄', one: {}}
+
+console.log(serializeError(error, {maxDepth: 2}));
+//=> {name: 'Error', message: '🦄', one: { two: {}}}
+```
+
+#### useToJSON
+
+Type: `boolean`\
+Default: `true`
+
+Indicate whether to use a `.toJSON()` method if encountered in the object. This is useful when a custom error implements [its own serialization logic via `.toJSON()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#tojson_behavior) but you prefer to not use it.
+
+### isErrorLike(value)
+
+Predicate to determine whether a value looks like an error, even if it's not an instance of `Error`. It must have at least the `name`, `message`, and `stack` properties.
+
+```js
+import {isErrorLike} from 'serialize-error';
+
+const error = new Error('🦄');
+error.one = {two: {three: {}}};
+
+isErrorLike({
+	name: 'DOMException',
+	message: 'It happened',
+	stack: 'at foo (index.js:2:9)',
+});
+//=> true
+
+isErrorLike(new Error('🦄'));
+//=> true
+
+isErrorLike(serializeError(new Error('🦄'));
+//=> true
+
+isErrorLike({
+	name: 'Bluberricious pancakes',
+	stack: 12,
+	ingredients: 'Blueberry',
+});
+//=> false
+```

package/package.json

@@ -103,12 +103,13 @@
     "@aws-sdk/util-dynamodb": "^3.180.0",
     "aws-lambda": "^1.0.7",
     "aws4": "^1.11.0",
-    "ws": "^8.9.0",
     "bootstrap": "^5.2.1",
     "bootstrap-icons": "^1.9.1",
     "caporal": "^1.4.0",
     "json-format-highlight": "^1.0.4",
-    "open": "^8.4.0"
+    "open": "^8.4.0",
+    "serialize-error": "^11.0.0",
+    "ws": "^8.9.0"
   },
   "keywords": [
     "cdk",
@@ -133,7 +134,7 @@
     "require": "./lib/index.js"
   },
   "license": "MPL-2.0",
-  "version": "0.0.61",
+  "version": "0.0.63",
   "types": "lib/index.d.ts",
   "stability": "stable",
   "jsii": {
@@ -167,7 +168,8 @@
     "bootstrap-icons",
     "caporal",
     "json-format-highlight",
-    "open"
+    "open",
+    "serialize-error"
   ],
   "jest": {
     "testMatch": [