aws-sdk-vitest-mock 0.1.0

package/README.md

@@ -0,0 +1,265 @@
+<p align="center">
+  <img src="logo.png" alt="aws-sdk-vitest-mock logo" width="180" />
+</p>
+
+<h1 align="center">AWS SDK Vitest Mock</h1>
+
+<p align="center">
+  A powerful, type-safe mocking library for AWS SDK v3 with Vitest
+</p>
+
+---
+
+## ✨ Features
+
+- 🎯 **Type-Safe Mocking** - Full TypeScript support with strict type checking
+- 📦 **Zero Dependencies** - No extra dependencies
+- 🔄 **Dual Module Support** - Works with both ESM and CommonJS
+- 🎭 **Flexible Mocking** - Support for partial matching, strict matching, and custom handlers
+- 🧩 **Chainable API** - Fluent interface for configuring multiple mock behaviors
+- 🔍 **Custom Matchers** - Vitest matchers for asserting AWS SDK command calls
+
+## 📦 Installation
+
+```bash
+bun add -D aws-sdk-vitest-mock
+```
+
+Or with other package managers:
+
+```bash
+npm install --save-dev aws-sdk-vitest-mock
+```
+
+```bash
+yarn add -D aws-sdk-vitest-mock
+```
+
+```bash
+pnpm add -D aws-sdk-vitest-mock
+```
+
+## 🚀 Quick Start
+
+### Basic Usage
+
+```typescript
+import { mockClient } from "aws-sdk-vitest-mock";
+import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3";
+
+// Mock the S3 client
+const s3Mock = mockClient(S3Client);
+
+// Configure mock responses
+s3Mock.on(GetObjectCommand).resolves({
+  Body: "mock data",
+  ContentType: "text/plain",
+});
+
+// Use in your tests
+const client = new S3Client({});
+const result = await client.send(
+  new GetObjectCommand({
+    Bucket: "my-bucket",
+    Key: "my-key",
+  }),
+);
+
+console.log(result.Body); // 'mock data'
+
+// Clean up
+s3Mock.restore();
+```
+
+### Request Matching
+
+```typescript
+// Partial matching (default)
+s3Mock.on(GetObjectCommand, { Bucket: "bucket1" }).resolves({ Body: "data1" });
+
+s3Mock.on(GetObjectCommand, { Bucket: "bucket2" }).resolves({ Body: "data2" });
+
+// Strict matching
+s3Mock
+  .on(GetObjectCommand, { Bucket: "b", Key: "k" }, { strict: true })
+  .resolves({ Body: "exact match" });
+```
+
+### Sequential Responses
+
+```typescript
+s3Mock
+  .on(GetObjectCommand)
+  .resolvesOnce({ Body: "first call" })
+  .resolvesOnce({ Body: "second call" })
+  .resolves({ Body: "subsequent calls" });
+
+// First call returns 'first call'
+// Second call returns 'second call'
+// All other calls return 'subsequent calls'
+```
+
+### Error Handling
+
+```typescript
+s3Mock.on(GetObjectCommand).rejects(new Error("Not found"));
+
+// Or with rejectsOnce
+s3Mock
+  .on(GetObjectCommand)
+  .rejectsOnce(new Error("Temporary failure"))
+  .resolves({ Body: "success" });
+```
+
+### Custom Handlers
+
+```typescript
+s3Mock.on(GetObjectCommand).callsFake(async (input, getClient) => {
+  const client = getClient();
+  console.log("Bucket:", input.Bucket);
+  return { Body: `Dynamic response for ${input.Key}` };
+});
+```
+
+### Mocking Existing Instances
+
+```typescript
+const existingClient = new S3Client({ region: "us-east-1" });
+const mock = mockClientInstance(existingClient);
+
+mock.on(GetObjectCommand).resolves({ Body: "mocked" });
+
+// The existing instance is now mocked
+const result = await existingClient.send(
+  new GetObjectCommand({
+    Bucket: "b",
+    Key: "k",
+  }),
+);
+```
+
+## 🧪 Custom Matchers
+
+Import the custom matchers in your test setup:
+
+```typescript
+// vitest.setup.ts
+import "aws-sdk-vitest-mock/vitest-setup";
+```
+
+Then use them in your tests:
+
+```typescript
+import { expect, test } from "vitest";
+import { mockClient } from "aws-sdk-vitest-mock";
+import { DynamoDBClient, GetItemCommand } from "@aws-sdk/client-dynamodb";
+
+test("should call DynamoDB", async () => {
+  const ddbMock = mockClient(DynamoDBClient);
+  ddbMock.on(GetItemCommand).resolves({ Item: { id: { S: "123" } } });
+
+  const client = new DynamoDBClient({});
+  await client.send(
+    new GetItemCommand({
+      TableName: "users",
+      Key: { id: { S: "123" } },
+    }),
+  );
+
+  // Assert the command was called
+  expect(ddbMock).toHaveReceivedCommand(GetItemCommand);
+
+  // Assert it was called a specific number of times
+  expect(ddbMock).toHaveReceivedCommandTimes(GetItemCommand, 1);
+
+  // Assert it was called with specific input
+  expect(ddbMock).toHaveReceivedCommandWith(GetItemCommand, {
+    TableName: "users",
+    Key: { id: { S: "123" } },
+  });
+
+  // Assert the nth call had specific input
+  expect(ddbMock).toHaveReceivedNthCommandWith(1, GetItemCommand, {
+    TableName: "users",
+  });
+});
+```
+
+## 📚 API Reference
+
+### `mockClient<TClient>(ClientConstructor)`
+
+Creates a mock for an AWS SDK client constructor.
+
+**Returns:** `AwsClientStub<TClient>`
+
+### `mockClientInstance<TClient>(clientInstance)`
+
+Mocks an existing AWS SDK client instance.
+
+**Returns:** `AwsClientStub<TClient>`
+
+### `AwsClientStub` Methods
+
+- `on(Command, matcher?, options?)` - Configure mock for a command
+- `reset()` - Clear all mocks and call history
+- `restore()` - Restore original client behavior
+- `calls()` - Get call history
+
+### `AwsCommandStub` Methods (Chainable)
+
+- `resolves(output)` - Return successful response
+- `resolvesOnce(output)` - Return successful response once
+- `rejects(error)` - Return error
+- `rejectsOnce(error)` - Return error once
+- `callsFake(handler)` - Custom response handler
+- `callsFakeOnce(handler)` - Custom response handler (once)
+
+## 🤝 Contributing
+
+We welcome contributions! 🎉 Please read our [Contributing Guidelines](./CONTRIBUTING.md) for details on:
+
+- 🐛 Reporting bugs
+- 💡 Suggesting features
+- 🔧 Development setup
+- ✅ Code standards
+- 📝 Commit guidelines
+- 🚀 Pull request process
+
+### Quick Start for Contributors
+
+```bash
+# Fork and clone the repo
+git clone https://github.com/YOUR-USERNAME/aws-sdk-vitest-mock.git
+cd aws-sdk-vitest-mock
+
+# Install dependencies
+bun install
+
+# Run tests
+bun nx test
+
+# Run linting
+bun nx lint
+
+# Build the library
+bun nx build
+
+# Make your changes and submit a PR!
+```
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for the complete guide.
+
+## 📝 License
+
+MIT
+
+## 🔗 Links
+
+- [GitHub Repository](https://github.com/sudokar/aws-sdk-vitest-mock)
+- [Issue Tracker](https://github.com/sudokar/aws-sdk-vitest-mock/issues)
+- [Changelog](https://github.com/sudokar/aws-sdk-vitest-mock/releases)
+
+---
+
+**Made with ❤️ by [sudokar](https://github.com/sudokar)**

package/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("vitest"),h=require("./matchers-D1XEjFLq.cjs");function m(r,t){return Object.keys(t).every(c=>{const o=t[c],n=r[c];return o&&typeof o=="object"&&!Array.isArray(o)?typeof n!="object"||n===null?!1:m(n,o):n===o})}function y(r,t){if(r===t)return!0;if(typeof r!="object"||r===null||typeof t!="object"||t===null)return r===t;const c=Object.keys(r),o=Object.keys(t);return c.length!==o.length?!1:o.every(n=>{if(!Object.prototype.hasOwnProperty.call(r,n))return!1;const s=r[n],e=t[n];return typeof s=="object"&&s!==null&&typeof e=="object"&&e!==null?y(s,e):s===e})}function k(r){return async function(t){const c=this,o=()=>c,n=r.map.get(t.constructor);if(n){const s=n.findIndex(e=>e.strict?e.matcher&&y(t.input,e.matcher):!e.matcher||m(t.input,e.matcher));if(s!==-1){const e=n[s];return e.once&&n.splice(s,1),e.handler(t.input,o)}}throw new Error(`No mock configured for command: ${t.constructor.name}`)}}function b(r,t,c,o={}){const n=(e,a)=>{const p={matcher:c,handler:e,once:a,strict:!!o.strict},i=r.map.get(t)??[];if(a){const l=i.findIndex(u=>!u.once);l===-1?i.push(p):i.splice(l,0,p),r.map.set(t,i)}else{const l=i.filter(u=>u.once||JSON.stringify(u.matcher)!==JSON.stringify(c));l.push(p),r.map.set(t,l)}},s={resolves(e){return n(()=>Promise.resolve(e),!1),s},rejects(e){return n(()=>{const a=typeof e=="string"?new Error(e):e;return Promise.reject(a)},!1),s},callsFake(e){return n(e,!1),s},resolvesOnce(e){return n(()=>Promise.resolve(e),!0),s},rejectsOnce(e){return n(()=>{const a=typeof e=="string"?new Error(e):e;return Promise.reject(a)},!0),s},callsFakeOnce(e){return n(e,!0),s}};return s}const j=r=>{const t={map:new WeakMap},c=("prototype"in r,r.prototype),o=f.vi.spyOn(c,"send").mockImplementation(k(t));return{client:void 0,on:(s,e,a)=>b(t,s,e,a),reset:()=>{o.mockClear(),t.map=new WeakMap},restore:()=>{o.mockRestore(),t.map=new WeakMap},calls:()=>o.mock.calls}},d=r=>{const t={map:new WeakMap},c=f.vi.spyOn(r,"send").mockImplementation(k(t));return{client:r,on:(n,s,e)=>b(t,n,s,e),reset:()=>{c.mockClear(),t.map=new WeakMap},restore:()=>{c.mockRestore(),t.map=new WeakMap},calls:()=>c.mock.calls}};exports.matchers=h.matchers;exports.mockClient=j;exports.mockClientInstance=d;

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/mock-client.js';
+export { matchers } from './lib/matchers.js';

package/index.js

@@ -0,0 +1,113 @@
+import { vi as f } from "vitest";
+import { m as w } from "./matchers-DclpcT4f.js";
+function m(r, t) {
+  return Object.keys(t).every((c) => {
+    const o = t[c], n = r[c];
+    return o && typeof o == "object" && !Array.isArray(o) ? typeof n != "object" || n === null ? !1 : m(n, o) : n === o;
+  });
+}
+function y(r, t) {
+  if (r === t) return !0;
+  if (typeof r != "object" || r === null || typeof t != "object" || t === null)
+    return r === t;
+  const c = Object.keys(r), o = Object.keys(t);
+  return c.length !== o.length ? !1 : o.every((n) => {
+    if (!Object.prototype.hasOwnProperty.call(r, n)) return !1;
+    const s = r[n], e = t[n];
+    return typeof s == "object" && s !== null && typeof e == "object" && e !== null ? y(s, e) : s === e;
+  });
+}
+function k(r) {
+  return async function(t) {
+    const c = this, o = () => c, n = r.map.get(t.constructor);
+    if (n) {
+      const s = n.findIndex((e) => e.strict ? e.matcher && y(t.input, e.matcher) : !e.matcher || m(t.input, e.matcher));
+      if (s !== -1) {
+        const e = n[s];
+        return e.once && n.splice(s, 1), e.handler(t.input, o);
+      }
+    }
+    throw new Error(`No mock configured for command: ${t.constructor.name}`);
+  };
+}
+function b(r, t, c, o = {}) {
+  const n = (e, a) => {
+    const p = {
+      matcher: c,
+      handler: e,
+      once: a,
+      strict: !!o.strict
+    }, i = r.map.get(t) ?? [];
+    if (a) {
+      const l = i.findIndex((u) => !u.once);
+      l === -1 ? i.push(p) : i.splice(l, 0, p), r.map.set(t, i);
+    } else {
+      const l = i.filter(
+        (u) => u.once || JSON.stringify(u.matcher) !== JSON.stringify(c)
+      );
+      l.push(p), r.map.set(t, l);
+    }
+  }, s = {
+    resolves(e) {
+      return n(() => Promise.resolve(e), !1), s;
+    },
+    rejects(e) {
+      return n(() => {
+        const a = typeof e == "string" ? new Error(e) : e;
+        return Promise.reject(a);
+      }, !1), s;
+    },
+    callsFake(e) {
+      return n(e, !1), s;
+    },
+    resolvesOnce(e) {
+      return n(() => Promise.resolve(e), !0), s;
+    },
+    rejectsOnce(e) {
+      return n(() => {
+        const a = typeof e == "string" ? new Error(e) : e;
+        return Promise.reject(a);
+      }, !0), s;
+    },
+    callsFakeOnce(e) {
+      return n(e, !0), s;
+    }
+  };
+  return s;
+}
+const j = (r) => {
+  const t = {
+    map: /* @__PURE__ */ new WeakMap()
+  }, c = ("prototype" in r, r.prototype), o = f.spyOn(c, "send").mockImplementation(k(t));
+  return {
+    client: void 0,
+    on: (s, e, a) => b(t, s, e, a),
+    reset: () => {
+      o.mockClear(), t.map = /* @__PURE__ */ new WeakMap();
+    },
+    restore: () => {
+      o.mockRestore(), t.map = /* @__PURE__ */ new WeakMap();
+    },
+    calls: () => o.mock.calls
+  };
+}, d = (r) => {
+  const t = {
+    map: /* @__PURE__ */ new WeakMap()
+  }, c = f.spyOn(r, "send").mockImplementation(k(t));
+  return {
+    client: r,
+    on: (n, s, e) => b(t, n, s, e),
+    reset: () => {
+      c.mockClear(), t.map = /* @__PURE__ */ new WeakMap();
+    },
+    restore: () => {
+      c.mockRestore(), t.map = /* @__PURE__ */ new WeakMap();
+    },
+    calls: () => c.mock.calls
+  };
+};
+export {
+  w as matchers,
+  j as mockClient,
+  d as mockClientInstance
+};

package/lib/matchers.d.ts

@@ -0,0 +1,29 @@
+import { AwsClientStub } from './mock-client.js';
+type CommandConstructor = new (...args: unknown[]) => unknown;
+interface MatcherResult {
+    pass: boolean;
+    message: () => string;
+}
+export declare const matchers: {
+    toHaveReceivedCommand(received: AwsClientStub, command: CommandConstructor): MatcherResult;
+    toHaveReceivedCommandTimes(received: AwsClientStub, command: CommandConstructor, times: number): MatcherResult;
+    toHaveReceivedCommandWith(this: {
+        equals: (a: unknown, b: unknown) => boolean;
+    }, received: AwsClientStub, command: CommandConstructor, input: Record<string, unknown>): MatcherResult;
+    toHaveReceivedNthCommandWith(this: {
+        equals: (a: unknown, b: unknown) => boolean;
+    }, received: AwsClientStub, n: number, command: CommandConstructor, input: Record<string, unknown>): MatcherResult;
+};
+export interface AwsSdkMatchers<R = unknown> {
+    toHaveReceivedCommand(command: CommandConstructor): R;
+    toHaveReceivedCommandTimes(command: CommandConstructor, times: number): R;
+    toHaveReceivedCommandWith(command: CommandConstructor, input: Record<string, unknown>): R;
+    toHaveReceivedNthCommandWith(n: number, command: CommandConstructor, input: Record<string, unknown>): R;
+}
+declare module 'vitest' {
+    interface Assertion extends AwsSdkMatchers {
+    }
+    interface AsymmetricMatchersContaining extends AwsSdkMatchers {
+    }
+}
+export {};

package/lib/mock-client.d.ts

@@ -0,0 +1,48 @@
+import { SmithyResolvedConfiguration } from '@smithy/smithy-client';
+import { MiddlewareStack, Handler } from '@smithy/types';
+import { Mock } from 'vitest';
+export interface MetadataBearer {
+    $metadata?: unknown;
+}
+export interface StructuralCommand<TInput extends object, TOutput extends MetadataBearer> {
+    readonly input: TInput;
+    middlewareStack: MiddlewareStack<TInput, TOutput>;
+    resolveMiddleware(stack: MiddlewareStack<TInput, TOutput>, configuration: unknown, options: unknown): Handler<TInput, TOutput>;
+}
+export type CommandConstructor<TInput extends object, TOutput extends MetadataBearer> = new (input: TInput) => StructuralCommand<TInput, TOutput>;
+export type AnyClient = {
+    send(command: AnyCommand): Promise<MetadataBearer>;
+    config: SmithyResolvedConfiguration<unknown>;
+};
+export type AnyCommand = StructuralCommand<object, MetadataBearer>;
+export type ClientConstructor<TClient extends AnyClient> = (abstract new (config: unknown) => TClient) | {
+    prototype: TClient;
+};
+type CommandHandler<TInput extends object = object, TOutput extends MetadataBearer = MetadataBearer, TClient extends AnyClient = AnyClient> = (input: TInput, getClient: () => TClient | undefined) => Promise<TOutput>;
+interface MockOptions {
+    strict?: boolean;
+}
+export interface AwsClientStub<TClient extends AnyClient = AnyClient> {
+    readonly client: TClient | undefined;
+    on: <TInput extends object, TOutput extends MetadataBearer>(command: CommandConstructor<TInput, TOutput>, request?: Partial<TInput>, options?: MockOptions) => AwsCommandStub<TInput, TOutput, TClient>;
+    reset: () => void;
+    restore: () => void;
+    calls: () => ReturnType<Mock['mock']['calls']['slice']>;
+}
+export interface AwsCommandStub<TInput extends object, TOutput extends MetadataBearer, TClient extends AnyClient = AnyClient> {
+    /** Set a permanent mock response (used after all once handlers are consumed) */
+    resolves: (output: Partial<TOutput>) => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Set a permanent mock rejection (used after all once handlers are consumed) */
+    rejects: (error: Error | string) => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Set a permanent custom handler (used after all once handlers are consumed) */
+    callsFake: (fn: CommandHandler<TInput, TOutput, TClient>) => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Add a one-time mock response (consumed in order) */
+    resolvesOnce: (output: Partial<TOutput>) => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Add a one-time mock rejection (consumed in order) */
+    rejectsOnce: (error: Error | string) => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Add a one-time custom handler (consumed in order) */
+    callsFakeOnce: (fn: CommandHandler<TInput, TOutput, TClient>) => AwsCommandStub<TInput, TOutput, TClient>;
+}
+export declare const mockClient: <TClient extends AnyClient>(clientConstructor: ClientConstructor<TClient>) => AwsClientStub<TClient>;
+export declare const mockClientInstance: <TClient extends AnyClient>(clientInstance: TClient) => AwsClientStub<AnyClient>;
+export {};

package/lib/vitest-setup.d.ts

@@ -0,0 +1 @@
+export {};

package/matchers-D1XEjFLq.cjs

@@ -0,0 +1 @@
+"use strict";const d={toHaveReceivedCommand(n,e){const t=n.calls().some(a=>a[0]instanceof e),s=e.name;return{pass:t,message:()=>t?`Expected AWS SDK mock not to have received command ${s}`:`Expected AWS SDK mock to have received command ${s}`}},toHaveReceivedCommandTimes(n,e,c){const t=n.calls().filter(o=>o[0]instanceof e),s=t.length===c,a=e.name;return{pass:s,message:()=>s?`Expected AWS SDK mock not to have received command ${a} ${c} times`:`Expected AWS SDK mock to have received command ${a} ${c} times, but received ${t.length} times`}},toHaveReceivedCommandWith(n,e,c){const s=n.calls().filter(o=>o[0]instanceof e).some(o=>this.equals(o[0].input,c)),a=e.name;return{pass:s,message:()=>s?`Expected AWS SDK mock not to have received command ${a} with ${JSON.stringify(c)}`:`Expected AWS SDK mock to have received command ${a} with ${JSON.stringify(c)}`}},toHaveReceivedNthCommandWith(n,e,c,t){const a=n.calls().filter(i=>i[0]instanceof c)[e-1],o=!!(a&&this.equals(a[0].input,t)),m=c.name;return{pass:o,message:()=>o?`Expected AWS SDK mock not to have received nth (${e}) command ${m} with ${JSON.stringify(t)}`:`Expected AWS SDK mock to have received nth (${e}) command ${m} with ${JSON.stringify(t)}`}}};exports.matchers=d;

package/matchers-DclpcT4f.js

@@ -0,0 +1,33 @@
+const d = {
+  toHaveReceivedCommand(n, e) {
+    const t = n.calls().some((a) => a[0] instanceof e), o = e.name;
+    return {
+      pass: t,
+      message: () => t ? `Expected AWS SDK mock not to have received command ${o}` : `Expected AWS SDK mock to have received command ${o}`
+    };
+  },
+  toHaveReceivedCommandTimes(n, e, c) {
+    const t = n.calls().filter((s) => s[0] instanceof e), o = t.length === c, a = e.name;
+    return {
+      pass: o,
+      message: () => o ? `Expected AWS SDK mock not to have received command ${a} ${c} times` : `Expected AWS SDK mock to have received command ${a} ${c} times, but received ${t.length} times`
+    };
+  },
+  toHaveReceivedCommandWith(n, e, c) {
+    const o = n.calls().filter((s) => s[0] instanceof e).some((s) => this.equals(s[0].input, c)), a = e.name;
+    return {
+      pass: o,
+      message: () => o ? `Expected AWS SDK mock not to have received command ${a} with ${JSON.stringify(c)}` : `Expected AWS SDK mock to have received command ${a} with ${JSON.stringify(c)}`
+    };
+  },
+  toHaveReceivedNthCommandWith(n, e, c, t) {
+    const a = n.calls().filter((i) => i[0] instanceof c)[e - 1], s = !!(a && this.equals(a[0].input, t)), m = c.name;
+    return {
+      pass: s,
+      message: () => s ? `Expected AWS SDK mock not to have received nth (${e}) command ${m} with ${JSON.stringify(t)}` : `Expected AWS SDK mock to have received nth (${e}) command ${m} with ${JSON.stringify(t)}`
+    };
+  }
+};
+export {
+  d as m
+};

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "aws-sdk-vitest-mock",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "require": {
+        "types": "./index.d.ts",
+        "default": "./index.cjs"
+      }
+    },
+    "./vitest-setup": {
+      "import": "./vitest-setup.js",
+      "require": "./vitest-setup.cjs"
+    }
+  },
+  "license": "MIT",
+  "author": "sudokar",
+  "scripts": {
+    "prepare": "husky",
+    "prepublishOnly": "HUSKY=0"
+  },
+  "nx": {
+    "includedScripts": []
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@aws-sdk/client-dynamodb": "3.948.0",
+    "@aws-sdk/client-s3": "3.948.0",
+    "@aws-sdk/lib-dynamodb": "3.948.0",
+    "@aws-sdk/types": "3.936.0",
+    "@eslint/js": "9.39.1",
+    "@nx/eslint": "22.2.2",
+    "@nx/eslint-plugin": "22.2.2",
+    "@nx/js": "22.2.2",
+    "@nx/vite": "22.2.2",
+    "@nx/vitest": "22.2.2",
+    "@nx/workspace": "22.2.2",
+    "@smithy/types": "4.9.0",
+    "@swc-node/register": "1.11.1",
+    "@swc/core": "1.15.3",
+    "@swc/helpers": "0.5.17",
+    "@types/node": "24.10.3",
+    "@typescript-eslint/parser": "8.49.0",
+    "@vitest/coverage-v8": "4.0.15",
+    "@vitest/eslint-plugin": "1.5.2",
+    "eslint": "9.39.1",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-import": "2.32.0",
+    "eslint-plugin-security": "3.0.1",
+    "eslint-plugin-sonarjs": "3.0.5",
+    "eslint-plugin-unicorn": "62.0.0",
+    "husky": "9.1.7",
+    "lint-staged": "16.2.7",
+    "nx": "22.2.2",
+    "prettier": "3.7.4",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.49.0",
+    "vite": "7.2.7",
+    "vite-plugin-dts": "4.5.4",
+    "vitest": "4.0.15"
+  },
+  "peerDependencies": {
+    "@aws-sdk/core": "^3",
+    "vitest": "^4"
+  }
+}

package/vitest-setup.cjs

@@ -0,0 +1 @@
+"use strict";const e=require("vitest"),t=require("./matchers-D1XEjFLq.cjs");e.expect.extend(t.matchers);

package/vitest-setup.js

@@ -0,0 +1,3 @@
+import { expect as m } from "vitest";
+import { m as e } from "./matchers-DclpcT4f.js";
+m.extend(e);