@devmoods/express-extras 0.64.0 → 0.65.1

package/dist/manage.js

@@ -1,66 +1,71 @@
 import { resolve } from 'node:path';
+import { config } from '@devmoods/config';
+import { generateDatabaseTypes, asCli } from '@devmoods/postgres';
 import { createClient } from '@hey-api/openapi-ts';
-import { program } from 'commander';
+import { Command } from 'commander';
 import {} from 'express';
 import { hashPassword } from './auth.js';
 import { CLI } from './cli.js';
-import { config } from './config.js';
-import { asCli } from './migrate.js';
 import { parseRoutes, toOpenAPISpec } from './routes.js';
-export function registerManagementCommand(register) {
+const defaultProgram = new Command();
+export function registerManagementCommand(register, program = defaultProgram) {
     const cli = new CLI({ printStackTraces: process.argv.includes('--verbose') });
     register(program.command.bind(program), cli);
 }
-export async function runManagementCommands() {
-    program.option('--verbose', 'Verbose mode');
+export async function runManagementCommands(program = defaultProgram) {
+    if (!program.options.some((o) => o.name() === 'verbose')) {
+        program.option('--verbose', 'Verbose mode');
+    }
     await program.parseAsync(process.argv);
 }
-export function registerDefaultCommands(app) {
+export function registerDefaultCommands(app, program = defaultProgram) {
     registerManagementCommand((command, cli) => {
         const migrate = command('migrate');
         asCli(migrate, cli);
-    });
-    registerManagementCommand((command, cli) => command('routes')
-        .option('--openapi', 'Output OpenAPI schema')
-        .option('--json', 'Output JSON')
-        .action(cli.wrap(async (options) => {
-        if (!app) {
-            return;
-        }
-        if (options.openapi) {
-            const routes = toOpenAPISpec(app);
-            console.log(JSON.stringify(routes, null, 2));
-            return;
-        }
-        const routes = parseRoutes(app);
-        if (options.json) {
-            console.log(JSON.stringify(routes, null, 2));
-            return;
-        }
-        for (const route of routes) {
-            cli.writeLine(`${route.method.padEnd(7)} ${route.path}\n`);
-        }
-    })));
+    }, program);
+    registerManagementCommand((command, cli) => {
+        command('routes')
+            .option('--openapi', 'Output OpenAPI schema')
+            .option('--json', 'Output JSON')
+            .action(cli.wrap(async (options) => {
+            if (!app) {
+                return;
+            }
+            if (options.openapi) {
+                const routes = toOpenAPISpec(app);
+                console.log(JSON.stringify(routes, null, 2));
+                return;
+            }
+            const routes = parseRoutes(app);
+            if (options.json) {
+                console.log(JSON.stringify(routes, null, 2));
+                return;
+            }
+            for (const route of routes) {
+                cli.writeLine(`${route.method.padEnd(7)} ${route.path}\n`);
+            }
+        }));
+    }, program);
     registerManagementCommand((command, cli) => {
         command('password-hash').action(cli.wrap(async () => {
             const password = await cli.readInput('Type a password: ');
             const hash = await hashPassword(password);
             cli.writeLine(`${hash}\n`);
         }));
-    });
+    }, program);
     registerManagementCommand((command, cli) => {
         command('show-config')
             .option('--json', 'Output JSON')
             .action(cli.wrap(async (options) => {
             if (options.json) {
-                console.log(JSON.stringify(config.value, null, 2));
+                console.log(JSON.stringify(config, null, 2));
                 return;
             }
-            for (const [key, value] of Object.entries(config.value)) {
+            for (const [key, value] of Object.entries(config)) {
                 cli.writeLine(`${key}=${value}\n`);
             }
         }));
-    });
+    }, program);
     registerManagementCommand((command, cli) => {
         command('generate-api')
             .option('--output <string>', 'Output directory', 'src/types/api-gen')
@@ -90,17 +95,16 @@ export function registerDefaultCommands(app) {
                 ],
             });
         }));
-    });
+    }, program);
     registerManagementCommand((command, cli) => {
         command('generate-db')
             .option('--output <string>', 'Output file path', 'src/types/db.gen.ts')
             .option('--connection <string>', 'Database connection string')
             .action(cli.wrap(async (options) => {
-            const { generateDatabaseTypes } = await import('./postgres-ts-generator.js');
             try {
                 await generateDatabaseTypes({
                     outputPath: options.output,
-                    connectionString: options.connection || config.value.POSTGRES_URL,
+                    connectionString: options.connection || config.POSTGRES_URL,
                 });
                 cli.writeLine(`✅ Database types generated successfully at: ${options.output}\n`);
             }
@@ -108,5 +112,5 @@ export function registerDefaultCommands(app) {
                 cli.writeLine(`❌ Failed to generate database types: ${error}\n`);
             }
         }));
-    });
+    }, program);
 }

package/dist/middleware.d.ts

@@ -77,3 +77,6 @@ type ResponseWrapper<TResponseBody extends AnyResponseBody> = TResponseBody | TR
  * Alias of `route()`
  */
 export declare function asyncMiddleware<RequestBody, RequestQuery extends Record<string, any> = Record<string, any>, ResponseBody extends AnyResponseBody = Record<string, any>, ParamKeys extends string = string>(fn: (req: Request<Record<ParamKeys, string>, ResponseBody, RequestBody, RequestQuery, Record<string, any>>, res: Response<ResponseBody, object>, next: NextFunction) => ResponseWrapper<ResponseBody> | Promise<ResponseWrapper<ResponseBody>>): RequestHandler<Record<ParamKeys, string>, ResponseBody, RequestBody, RequestQuery>;
+export declare function withTransaction(wrapper: {
+    transaction: (fn: () => Promise<void>) => Promise<void>;
+}): RequestHandler;

package/dist/middleware.js

@@ -1,23 +1,23 @@
 import * as crypto from 'node:crypto';
 import {} from 'node:http';
+import { config } from '@devmoods/config';
+import { startTimer } from '@devmoods/observability';
 import { compose } from 'compose-middleware';
 import cookieParser from 'cookie-parser';
 import { json as jsonParser, urlencoded as urlencodedParser, } from 'express';
 import helmet from 'helmet';
 import {} from './auth.js';
-import { config } from './config.js';
-import { ANONYMOUS_SESSION_KEY, setContext, useContext, withRequestContext, } from './context.js';
+import { ANONYMOUS_SESSION_KEY, setRequestContext, useRequestContext, withRequestContext, } from './context.js';
 import { csrf, doubleCsrfProtection, } from './csrf.js';
 import { NotFound } from './errors.js';
 import { getLogger } from './logger.js';
-import { startTimer } from './utils.js';
 export { urlencodedParser, jsonParser };
 const logger = getLogger('http');
 export { asyncMiddleware as route };
 export { compose as composeMiddleware };
 const CSP_NONCE_KEY = 'csp-nonce';
 export function useCspNonce() {
-    return useContext(CSP_NONCE_KEY) ?? '__CSP_NOT_SET__';
+    return useRequestContext(CSP_NONCE_KEY) ?? '__CSP_NOT_SET__';
 }
 /**
  * Register middleware that must come before the app routes.
@@ -131,7 +131,7 @@ export function notFound() {
  */
 function setCspNonce() {
     return function setCspNonceMiddleware(req, res, next) {
-        setContext(CSP_NONCE_KEY, crypto.randomBytes(16).toString('base64'));
+        setRequestContext(CSP_NONCE_KEY, crypto.randomBytes(16).toString('base64'));
         next();
     };
 }
@@ -150,11 +150,11 @@ export function setAnonymousCookie() {
                 maxAge: 365 * 24 * 60 * 60 * 1000,
                 httpOnly: true,
                 secure: process.env.NODE_ENV === 'production',
-                sameSite: config.value.AUTH_COOKIE_SAME_SITE,
+                sameSite: config.AUTH_COOKIE_SAME_SITE,
             });
         }
         // Store sessionId in request context
-        setContext(ANONYMOUS_SESSION_KEY, sessionId);
+        setRequestContext(ANONYMOUS_SESSION_KEY, sessionId);
         next();
     };
 }
@@ -212,3 +212,20 @@ export function asyncMiddleware(fn) {
     Object.defineProperty(handler, 'name', { value: fn.name });
     return handler;
 }
+export function withTransaction(wrapper) {
+    return async function withTransactionMiddleware(req, res, next) {
+        try {
+            await wrapper.transaction(async () => {
+                await new Promise((resolve, reject) => {
+                    res.on('finish', resolve);
+                    res.on('error', reject);
+                    next();
+                });
+            });
+        }
+        catch (error) {
+            /* c8 ignore next 2 */
+            next(error);
+        }
+    };
+}

package/dist/rate-limit.d.ts

@@ -19,4 +19,5 @@ export interface RateLimitOptions {
 }
 export declare function rateLimit(redis: RedisClient, { max, windowSizeInSeconds, getKey, }?: RateLimitOptions): RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>> & {
     clear: (key: string) => Promise<void>;
+    clearAll: () => Promise<number>;
 };

package/dist/rate-limit.js

@@ -1,11 +1,12 @@
+import { config } from '@devmoods/config';
 import {} from 'express';
-import { config } from './config.js';
 import { makeError } from './errors.js';
 import {} from './redis.js';
 export function rateLimit(redis, { max = 100, windowSizeInSeconds = 60, getKey = (req) => req.ip || 'unknown', } = {}) {
+    const keyPrefix = `${config.REDIS_KEY_PREFIX}rate-limit:`;
     const handler = async (req, res, next) => {
         try {
-            const key = `${config.value.REDIS_KEY_PREFIX}rate-limit:${getKey(req)}`;
+            const key = `${keyPrefix}${getKey(req)}`;
             // Use Redis to track requests
             const currentCount = await redis.get(key);
             const count = currentCount ? parseInt(currentCount, 10) : 0;
@@ -28,8 +29,29 @@ export function rateLimit(redis, { max = 100, windowSizeInSeconds = 60, getKey =
         }
     };
     const clear = async (key) => {
-        await redis.del(`rate-limit:${key}`);
+        await redis.del(`${keyPrefix}${key}`);
+    };
+    const clearAll = async () => {
+        let cursor = '0';
+        let deletedCount = 0;
+        const pattern = `${config.REDIS_KEY_PREFIX}rate-limit:*`;
+        do {
+            // Use SCAN instead of KEYS - non-blocking iteration
+            const result = await redis.scan(cursor, {
+                MATCH: pattern,
+                COUNT: 100, // Process in batches of 100
+            });
+            cursor = result.cursor;
+            const keys = result.keys;
+            if (keys.length > 0) {
+                // Use UNLINK instead of DEL - asynchronous deletion
+                await redis.unlink(keys);
+                deletedCount += keys.length;
+            }
+        } while (cursor !== '0');
+        return deletedCount;
     };
     handler.clear = clear;
+    handler.clearAll = clearAll;
     return handler;
 }

package/dist/redis.d.ts

@@ -7,4 +7,4 @@ export type RedisClient = ReturnType<typeof createClient>;
 export declare function createRedis({ url, onError, }?: RedisOptions): RedisClient;
 export declare function connectRedis(redis: RedisClient, shouldContinue?: boolean): Promise<void>;
 export declare function stopRedis(redis: RedisClient, timeout?: number): Promise<void>;
-export declare function pingRedis(redis: RedisClient): Promise<string>;
+export declare function pingRedis(redis: RedisClient, timeout?: number): Promise<string>;

package/dist/redis.js

@@ -1,7 +1,7 @@
+import { config } from '@devmoods/config';
 import { createClient } from 'redis';
-import { config } from './config.js';
 import { withTimeout } from './utils.js';
-export function createRedis({ url = config.value.REDIS_URL, onError, } = {}) {
+export function createRedis({ url = config.REDIS_URL, onError, } = {}) {
     const client = createClient({ url });
     // Always attach a listener even if
     // onError is not provided.
@@ -29,6 +29,6 @@ export async function stopRedis(redis, timeout = 10000) {
         return redis.destroy();
     }
 }
-export function pingRedis(redis) {
-    return withTimeout(redis.ping(), 1000);
+export function pingRedis(redis, timeout = 1000) {
+    return withTimeout(redis.ping(), timeout);
 }

package/dist/sentry.js

@@ -1,11 +1,17 @@
+import { config } from '@devmoods/config';
+import { eventLoopBlockIntegration } from '@sentry/node-native';
 import { nodeProfilingIntegration } from '@sentry/profiling-node';
-import { config } from './config.js';
 export function sentryOptions(options = {}) {
     return {
-        dsn: config.value.SENTRY_DSN,
-        tracesSampleRate: 1.0,
-        profilesSampleRate: 1.0,
-        integrations: [nodeProfilingIntegration()],
+        dsn: config.SENTRY_DSN,
+        tracesSampleRate: config.SENTRY_TRACES_SAMPLE_RATE,
+        profilesSampleRate: config.SENTRY_PROFILES_SAMPLE_RATE,
+        integrations: [
+            nodeProfilingIntegration(),
+            eventLoopBlockIntegration({
+                threshold: config.SENTRY_EVENT_LOOP_THRESHOLD,
+            }),
+        ],
         enableLogs: true,
         ...options,
     };

package/dist/setupTests.global.d.ts

@@ -0,0 +1,2 @@
+export declare function setup(): Promise<void>;
+export declare function teardown(): Promise<void>;

package/dist/setupTests.global.js

@@ -0,0 +1,4 @@
+/* c8 ignore start */
+export async function setup() { }
+export async function teardown() { }
+/* c8 ignore stop */

package/dist/setupTests.js

@@ -1,6 +1,9 @@
 import 'dotenv/config';
 import EventEmitter from 'node:events';
+import { loadConfig } from '@devmoods/config';
+import { config } from './config.js';
 import { extendMatchers, failOnConsole } from './vitest/index.js';
 EventEmitter.setMaxListeners(20);
 failOnConsole();
 extendMatchers(expect);
+loadConfig(config);

package/dist/slack.js

@@ -1,5 +1,5 @@
+import { config } from '@devmoods/config';
 import { createFetch } from '@devmoods/fetch';
-import { config } from './config.js';
 import { getLogger } from './logger.js';
 const logger = getLogger('slack');
 /**
@@ -15,7 +15,7 @@ const logger = getLogger('slack');
  *
  * See https://api.slack.com/messaging/webhooks
  */
-export function createSlack({ webhookUrl = config.value.SLACK_WEBHOOK_URL, dryRun = process.env.NODE_ENV !== 'production', } = {}) {
+export function createSlack({ webhookUrl = config.SLACK_WEBHOOK_URL, dryRun = process.env.NODE_ENV !== 'production', } = {}) {
     const fetch = createFetch();
     /**
      * Post a message to Slack

package/dist/utils.d.ts

@@ -1,19 +1,6 @@
 import { type EventEmitter } from 'node:events';
 import { withTimeout, TimeoutError, delay } from '@devmoods/fetch';
 export { withTimeout, TimeoutError, delay };
-/**
- * Start a high resolution timer
- */
-export declare function startTimer(): {
-    /**
-     * Reset the timer
-     */
-    reset(): void;
-    /**
-     * Get duration in seconds
-     */
-    getDuration(): number;
-};
 export declare function readEnv(key: string): string | undefined;
 export declare function readEnv(key: string, defaultValue: string): string;
 export declare namespace readEnv {

package/dist/utils.js

@@ -1,27 +1,6 @@
 import {} from 'node:events';
 import { withTimeout, TimeoutError, delay } from '@devmoods/fetch';
 export { withTimeout, TimeoutError, delay };
-/**
- * Start a high resolution timer
- */
-export function startTimer() {
-    let start = process.hrtime();
-    return {
-        /**
-         * Reset the timer
-         */
-        reset() {
-            start = process.hrtime();
-        },
-        /**
-         * Get duration in seconds
-         */
-        getDuration() {
-            const elapsed = process.hrtime(start);
-            return (elapsed[0] * 1e9 + elapsed[1]) / 1e9;
-        },
-    };
-}
 export function readEnv(key, defaultValue) {
     const value = process.env[key];
     return value ?? defaultValue;

package/dist/validate.js

@@ -28,10 +28,11 @@ export async function validateSchema(data, schema) {
         return {
             isValid: false,
             errors: (error instanceof ValidationError
-                ? error.issues.map((issue) => [
-                    String(issue.path ?? '/'),
-                    issue.message,
-                ])
+                ? /* c8 ignore next 5*/
+                    error.issues.map((issue) => [
+                        String(issue.path ?? '/'),
+                        issue.message,
+                    ])
                 : []).reduce((result, item) => {
                 const [key, value] = item;
                 if (Array.isArray(result[key])) {
@@ -61,6 +62,7 @@ export function validateStandardSchema(schemas) {
                 }
             }
             next();
+            /* c8 ignore next 3 */
         }
         catch (error) {
             next(error);
@@ -89,6 +91,7 @@ function toJsonSchema(standardSchema) {
     if ('toJsonSchema' in standardSchema &&
         typeof standardSchema.toJsonSchema === 'function') {
         return standardSchema.toJsonSchema();
+        /* c8 ignore next 3 */
     }
     return {};
 }

package/dist/vite/__tests__/fixtures/src/entry-server.d.ts

@@ -0,0 +1,5 @@
+import { type SsrRenderOptions } from '../../../types.js';
+export declare function render(req: Request, options: SsrRenderOptions): Promise<{
+    html: string;
+    context: any;
+}>;

package/dist/vite/__tests__/fixtures/src/entry-server.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { renderToString } from 'react-dom/server';
+import {} from '../../../types.js';
+export async function render(req, options) {
+    const helmetContext = {};
+    const initialData = await options.getInitialData(req);
+    if (initialData.shouldRedirect) {
+        throw new Response('redirect', { status: 302 });
+    }
+    const html = renderToString(_jsxs("html", { lang: "en", children: [_jsxs("head", { children: [options.useDevServer && (_jsx("script", { type: "module", nonce: options.nonce, children: options.preamble })), _jsx("meta", { charSet: "utf-8" }), _jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1, shrink-to-fit=no" }), _jsx("meta", { name: "theme-color", content: "#FFFFFF" }), _jsx("meta", { name: "apple-mobile-web-app-capable", content: "yes" }), _jsx("meta", { name: "apple-mobile-web-app-title", content: "express-extras" }), _jsx("link", { rel: "apple-touch-icon", href: "/apple-touch-icon.png" }), options.placeholders, _jsx("meta", { name: "csrf-token", content: options.csrfToken })] }), _jsxs("body", { children: [_jsx("div", { id: "root", children: _jsx("h1", { children: "Hello World!" }) }), options.useDevServer && (_jsx("script", { type: "module", src: "/src/entry-client.tsx" })), _jsx("script", { defer: true, "data-domain": options.publicUrl.hostname, src: "/analytics.js" }), _jsx("script", { nonce: options.nonce, children: `window.store = ${JSON.stringify(initialData)};` })] })] }));
+    return {
+        html,
+        context: helmetContext.helmet,
+    };
+}

package/dist/vite/defineViteConfig.js

@@ -1,4 +1,5 @@
 /// <reference types="vitest" />
+import { existsSync } from 'node:fs';
 import * as path from 'node:path';
 import react from '@vitejs/plugin-react';
 import Sonda from 'sonda/vite';
@@ -12,6 +13,14 @@ export function defineViteConfig({ base = '', reactCompiler = false, ssr = false
         `${process.cwd().split('/').pop()}.local`,
         `${process.cwd().split('/').pop()}.test`,
     ];
+    /* c8 ignore next 4 */
+    const globalSetup = existsSync(path.resolve('./src/setupTests.global.ts'))
+        ? [path.resolve('./src/setupTests.global.ts')]
+        : undefined;
+    /* c8 ignore next 4 */
+    const setupFiles = existsSync(path.resolve('./src/setupTests.ts'))
+        ? [path.resolve('./src/setupTests.ts')]
+        : undefined;
     const port = readEnv.number('VITE_PORT', 5173);
     return defineConfig({
         plugins: [
@@ -69,7 +78,8 @@ export function defineViteConfig({ base = '', reactCompiler = false, ssr = false
             }
             : undefined,
         test: {
-            setupFiles: ['./src/setupTests'],
+            setupFiles,
+            globalSetup,
             include: ['src/**/*.{test,spec}.?(c|m)[jt]s?(x)'],
             globals: true,
         },

package/dist/vite/index.d.ts

@@ -0,0 +1 @@
+export { defineViteConfig } from './defineViteConfig.js';

package/dist/vite/index.js

@@ -0,0 +1,3 @@
+/* c8 ignore start */
+export { defineViteConfig } from './defineViteConfig.js';
+/* c8 ignore stop */

package/dist/vite/ssr.d.ts

@@ -4,3 +4,4 @@ export interface SsrMiddlewareOptions<InitialData = unknown> {
     useDevServer?: boolean;
 }
 export declare function createSsrMiddleware<InitialData = unknown>({ root, getInitialData, useDevServer, }?: SsrMiddlewareOptions<InitialData>): Promise<import("compose-middleware").RequestHandler<any, any, void>>;
+export declare function replaceSsrPlaceholders(template: string, values: Record<string, unknown>): string;

package/dist/vite/ssr.js

@@ -1,14 +1,14 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { config } from '@devmoods/config';
 import {} from 'compose-middleware';
 import express, {} from 'express';
 import { createServer as createViteServer } from 'vite';
 import {} from './types.js';
-import { config } from '../config.js';
 import { generateCsrfToken } from '../csrf.js';
 import { composeMiddleware, route, useCspNonce } from '../middleware.js';
 import { createFetchRequest } from '../webapi.js';
-export async function createSsrMiddleware({ root = process.cwd(), getInitialData, useDevServer = config.value.VITE_USE_DEV_SERVER, } = {}) {
+export async function createSsrMiddleware({ root = process.cwd(), getInitialData, useDevServer = config.VITE_USE_DEV_SERVER, } = {}) {
     const resolve = (p) => path.resolve(root, p);
     let vite;
     const middlewares = [];
@@ -53,7 +53,7 @@ export async function createSsrMiddleware({ root = process.cwd(), getInitialData
             window.$RefreshSig$ = () => (type) => type
             window.__vite_plugin_react_preamble_installed__ = true
           `,
-                publicUrl: new URL(config.value.PUBLIC_URL),
+                publicUrl: new URL(config.PUBLIC_URL),
                 csrfToken: generateCsrfToken(req, res),
             });
             const readManifest = async () => {
@@ -84,6 +84,7 @@ export async function createSsrMiddleware({ root = process.cwd(), getInitialData
                 error.status >= 300 &&
                 error.status <= 399) {
                 return res.redirect(error.status, error.headers.get('Location') || '');
+                /* c8 ignore next 9 */
             }
             if (useDevServer) {
                 vite.ssrFixStacktrace(error);
@@ -93,7 +94,7 @@ export async function createSsrMiddleware({ root = process.cwd(), getInitialData
     }));
     return composeMiddleware(middlewares);
 }
-function replaceSsrPlaceholders(template, values) {
+export function replaceSsrPlaceholders(template, values) {
     return template.replace(/\{\{\s*([\w-]+)\s*\}\}/g, (match, variableName) => {
         if (Object.prototype.hasOwnProperty.call(values, variableName)) {
             const value = values[variableName];
@@ -107,20 +108,24 @@ function replaceSsrPlaceholders(template, values) {
 }
 async function getAssetLinks(manifestPath, input, publicPath = '/') {
     const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf-8'));
+    /* c8 ignore next 3 */
     if (!manifest[input]) {
         throw Error('Entry not found in the manifest.json file');
     }
     const chunk = manifest[input];
+    /* c8 ignore next 3 */
     const cssHtml = (chunk.css || [])
         .map((href) => `<link rel="stylesheet" href="${publicPath}${href}" />`)
         .join(' ');
     // Generate HTML for preload links
     const preloadList = [input];
+    /* c8 ignore next 3 */
     if (Array.isArray(chunk.imports)) {
         preloadList.push(...chunk.imports);
     }
     const preloadHtml = preloadList
         .map((pre) => {
+        /* c8 ignore next 3 */
         if (!manifest[pre]?.file) {
             return '';
         }

package/dist/vitest/index.d.ts

@@ -1 +1,6 @@
+import { type TestFunction } from 'vitest';
 export * from './matchers.js';
+export * from './testClient.js';
+export declare function createTransactionWrapper(wrapped: {
+    transaction: <T>(fn: () => Promise<T> | T) => Promise<T> | T;
+}): <T>(run: TestFunction<T>) => TestFunction<T>;

package/dist/vitest/index.js

@@ -1 +1,25 @@
+import {} from 'vitest';
 export * from './matchers.js';
+export * from './testClient.js';
+class RollbackError extends Error {
+}
+export function createTransactionWrapper(wrapped) {
+    const wrapTransaction = (run) => {
+        return async (context) => {
+            try {
+                await wrapped.transaction(async () => {
+                    await run(context);
+                    throw new RollbackError();
+                    /* c8 ignore next 1 */
+                });
+            }
+            catch (error) {
+                if (error instanceof RollbackError) {
+                    return;
+                }
+                throw error;
+            }
+        };
+    };
+    return wrapTransaction;
+}

package/dist/vitest/matchers.d.ts

@@ -1,7 +1,7 @@
 import { type ExpectStatic } from 'vitest';
 import failOnConsole from 'vitest-fail-on-console';
 interface CustomMatchers<R = unknown> {
-    toMatchResponse: (statusCode: number, body: unknown) => R;
+    toMatchResponse: (statusCode: number, body?: unknown) => R;
 }
 declare module 'vitest' {
     interface Matchers<T = any> extends CustomMatchers<T> {

package/dist/vitest/matchers.js

@@ -1,6 +1,7 @@
 import {} from 'vitest';
 import failOnConsole from 'vitest-fail-on-console';
 export { failOnConsole };
+/* c8 ignore start */
 export function extendMatchers(expect) {
     expect.extend({
         toMatchResponse(received, expectedStatusCode, expectedBody) {
@@ -8,13 +9,15 @@ export function extendMatchers(expect) {
             // Check if received is a proper response object
             if (!received ||
                 typeof received !== 'object' ||
-                !('status' in received)) {
+                !('status' in received || 'response' in received)) {
                 return {
                     pass: false,
                     message: () => `Expected response object with status property, but received: ${this.utils.printReceived(received)}`,
                 };
             }
-            const { status, body } = received;
+            const response = 'response' in received ? received.response : received;
+            const status = response.status;
+            const body = 'jsonData' in response ? response.jsonData : response.body;
             // Check status code
             const statusMatches = status === expectedStatusCode;
             // Check body (if provided)
@@ -59,3 +62,4 @@ export function extendMatchers(expect) {
         },
     });
 }
+/* c8 ignore stop */