@devmoods/express-extras 0.74.0 → 0.76.0

package/dist/auth/google-client.d.ts

@@ -0,0 +1,12 @@
+export declare function exchangeGoogleAuthorizationCode({ code, clientId, clientSecret, redirectUri, }: {
+    code: string;
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+}): Promise<{
+    id_token?: string | null;
+}>;
+export declare function verifyGoogleIdToken({ token, clientId, }: {
+    token: string;
+    clientId: string;
+}): Promise<import("jose").JWTPayload>;

package/dist/auth/google-client.js

@@ -0,0 +1,27 @@
+import { createFetch } from '@devmoods/fetch';
+import { createRemoteJWKSet, jwtVerify } from 'jose';
+const fetch = createFetch();
+const googleJwks = createRemoteJWKSet(new URL('https://www.googleapis.com/oauth2/v3/certs'));
+export async function exchangeGoogleAuthorizationCode({ code, clientId, clientSecret, redirectUri, }) {
+    const response = await fetch('https://oauth2.googleapis.com/token', {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/x-www-form-urlencoded',
+        },
+        body: new URLSearchParams({
+            code,
+            client_id: clientId,
+            client_secret: clientSecret,
+            redirect_uri: redirectUri,
+            grant_type: 'authorization_code',
+        }),
+    });
+    return response.jsonData;
+}
+export async function verifyGoogleIdToken({ token, clientId, }) {
+    const { payload } = await jwtVerify(token, googleJwks, {
+        audience: clientId,
+        issuer: ['https://accounts.google.com', 'accounts.google.com'],
+    });
+    return payload;
+}

package/dist/auth/google.d.ts

@@ -10,5 +10,5 @@ interface GoogleAuthProviderOptions<UserModel = AnyUser> {
     hostedDomain?: string;
     getOrCreateUserFromUserIdentifier(userIdentifier: string, profile: GoogleProfile): Promise<UserModel>;
 }
-export declare function GoogleAuthProvider<UserModel extends AnyUser>({ clientId, clientSecret, redirectUri, hostedDomain, getOrCreateUserFromUserIdentifier }: GoogleAuthProviderOptions<UserModel>): AuthProvider<UserModel>;
+export declare function GoogleAuthProvider<UserModel extends AnyUser>({ clientId, clientSecret, redirectUri, hostedDomain, getOrCreateUserFromUserIdentifier, }: GoogleAuthProviderOptions<UserModel>): AuthProvider<UserModel>;
 export {};

package/dist/auth/google.js

@@ -1,20 +1,20 @@
 import { config } from '@devmoods/config';
 import { type } from 'arktype';
-import { OAuth2Client } from 'google-auth-library';
+import { exchangeGoogleAuthorizationCode, verifyGoogleIdToken, } from './google-client.js';
 import { createTokenResponse } from './token.js';
 import {} from './types.js';
 import { BadRequest, Unauthorized } from '../errors.js';
 import { getLogger } from '../logger.js';
 const logger = getLogger('auth');
 export function GoogleAuthProvider({ clientId = config.GOOGLE_AUTH_CLIENT_ID, clientSecret = config.GOOGLE_AUTH_CLIENT_SECRET, redirectUri = `${config.PUBLIC_URL}/api/v1/auth/google/callback`, hostedDomain, getOrCreateUserFromUserIdentifier, }) {
-    const client = new OAuth2Client({
-        clientId,
-        clientSecret,
-        redirectUri,
-    });
     const verifyAuthorizationCode = async (inputCode) => {
         try {
-            const { tokens } = await client.getToken(inputCode);
+            const tokens = await exchangeGoogleAuthorizationCode({
+                code: inputCode,
+                clientId,
+                clientSecret,
+                redirectUri,
+            });
             return { idToken: tokens.id_token };
         }
         catch (e) {
@@ -23,15 +23,18 @@ export function GoogleAuthProvider({ clientId = config.GOOGLE_AUTH_CLIENT_ID, cl
         }
     };
     const verifyIdToken = async (token) => {
-        const ticket = await client.verifyIdToken({
-            idToken: token,
-            audience: clientId,
-        });
-        const payload = ticket.getPayload();
-        if (!payload) {
-            throw Unauthorized('Token from Google contains invalid payload');
+        try {
+            return await verifyGoogleIdToken({
+                token,
+                clientId,
+            });
+        }
+        catch (e) {
+            logger.error(e);
+            throw Unauthorized('Token from Google contains invalid payload', {
+                cause: e,
+            });
         }
-        return payload;
     };
     const requiredScopes = ['openid', 'email', 'profile'];
     return {
@@ -79,18 +82,20 @@ export function GoogleAuthProvider({ clientId = config.GOOGLE_AUTH_CLIENT_ID, cl
                     throw Unauthorized('Invalid id token');
                 }
                 const payload = await verifyIdToken(idToken);
-                if (!payload.sub) {
+                if (typeof payload.sub !== 'string' || payload.sub.length === 0) {
                     throw Unauthorized('Token from Google is missing subject');
                 }
-                if (!payload.email || payload.email_verified !== true) {
+                if (typeof payload.email !== 'string' ||
+                    payload.email_verified !== true) {
                     throw Unauthorized('Token from Google contains unverified email');
                 }
-                if (hostedDomain && payload.hd !== hostedDomain) {
+                if (hostedDomain &&
+                    (typeof payload.hd !== 'string' || payload.hd !== hostedDomain)) {
                     throw Unauthorized('Token from Google contains invalid hosted domain');
                 }
                 const user = await getOrCreateUserFromUserIdentifier(payload.sub, {
                     email: payload.email,
-                    fullName: payload.name ?? '',
+                    fullName: typeof payload.name === 'string' ? payload.name : '',
                 });
                 const accessToken = await context.login(req, res, user);
                 logger.info('google-login', { email: user.email });

package/dist/auth/token.d.ts

@@ -4,7 +4,7 @@ export declare const tokenSchema: ValidationSchema;
 export declare function createTokenResponse(accessToken: AccessToken): readonly [201, {
     readonly token: string;
 }, {
-    readonly 'Cache-Control': 'no-store';
+    readonly 'Cache-Control': "no-store";
 }];
 export type AccessToken = Awaited<ReturnType<typeof createAccessToken>>;
 /**
@@ -12,7 +12,7 @@ export type AccessToken = Awaited<ReturnType<typeof createAccessToken>>;
  */
 export declare function createAccessToken(payload: any, version?: string, secret?: string): Promise<{
     token: string;
-    tokenType: 'Bearer';
+    tokenType: "Bearer";
     expiresIn: number;
 }>;
 /**

package/dist/auth/token.js

@@ -2,7 +2,6 @@ import { randomUUID } from 'node:crypto';
 import { config } from '@devmoods/config';
 import {} from 'express';
 import { SignJWT, jwtVerify } from 'jose';
-import { v4 } from 'uuid';
 import { InvalidToken } from './errors.js';
 import {} from '../validate.js';
 const ACCESS_TOKEN_COOKIE_NAME = 'access_token';
@@ -101,7 +100,7 @@ export function extractAccessTokenFromRequest(req) {
 export function setAccessTokenCookie(res, token) {
     const sameSite = config.AUTH_COOKIE_SAME_SITE;
     if (token == null) {
-        res.cookie(ACCESS_TOKEN_COOKIE_NAME, v4(), {
+        res.cookie(ACCESS_TOKEN_COOKIE_NAME, randomUUID(), {
             expires: new Date(1970, 0, 1),
             sameSite,
             secure: process.env.NODE_ENV === 'production',

package/dist/auth.d.ts

@@ -20,4 +20,4 @@ export interface CreateAuth<UserModel extends AnyUser> {
     logout: (req: Request, res: Response) => Promise<void>;
     setSessionTokenVersion: (version: string) => void;
 }
-export declare function createAuth<UserModel extends AnyUser>({ getUserById, filterUser, tokenStorage, providers, loginUrl, onUserLoggedIn, sessionTokenVersion: initialSessionTokenVersion }: AuthOptions<UserModel>): CreateAuth<UserModel>;
+export declare function createAuth<UserModel extends AnyUser>({ getUserById, filterUser, tokenStorage, providers, loginUrl, onUserLoggedIn, sessionTokenVersion: initialSessionTokenVersion, }: AuthOptions<UserModel>): CreateAuth<UserModel>;

package/dist/cache.d.ts

@@ -17,7 +17,7 @@ export interface MemoryCacheAdapterOptions {
 export declare class RedisCacheAdapter extends CacheAdapter {
     redis: RedisClient;
     keyPrefix: string;
-    constructor(redis: RedisClient, { keyPrefix }?: RedisCacheAdapterOptions);
+    constructor(redis: RedisClient, { keyPrefix, }?: RedisCacheAdapterOptions);
     get(key: string): Promise<any>;
     set(key: string, value: unknown, expires?: number | null): Promise<void>;
     clear(key?: string): Promise<void>;
@@ -42,7 +42,7 @@ export declare function createCache(adapter: CacheAdapter): {
     wrap: <T>(key: string, options: CacheOptions | number | null, fn: () => Promise<T>) => Promise<T>;
     decorate: <T, Arguments extends any[]>(options: CacheOptions | number | null, fn: (...args: Arguments) => T | Promise<T>) => {
         (...args: Arguments): Promise<T>;
-        clear: (...args: Arguments) => Promise<void>;
+        clear(...args: Arguments): Promise<void>;
     };
     hashKey: typeof hashKey;
 };

package/dist/config.d.ts

@@ -2,7 +2,7 @@ declare module '@devmoods/config' {
     interface Config extends ConfigFromDefs<typeof app> {
     }
 }
-declare const app: Defs<{
+declare const app: import("@devmoods/config").Defs<{
     CI: boolean;
     PORT: number;
     PUBLIC_URL: string;

package/dist/context.d.ts

@@ -9,7 +9,7 @@ export interface RequestContextOptions {
 /**
  * Middleware for setting a `requestId` on the request context.
  */
-export declare function withRequestContext({ getRequestId }?: RequestContextOptions): RequestHandler;
+export declare function withRequestContext({ getRequestId, }?: RequestContextOptions): RequestHandler;
 /**
  * Return a value from the request context
  */

package/dist/context.js

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomUUID } from 'node:crypto';
 import {} from 'express';
-import { v4 as uuid } from 'uuid';
 export const requestContext = new AsyncLocalStorage();
 export const REQUEST_ID_CONTEXT_KEY = 'requestId';
 export const JOB_ID_CONTEXT_KEY = 'jobId';
@@ -9,7 +9,7 @@ export const JOB_ID_CONTEXT_KEY = 'jobId';
  */
 export function withRequestContext({ getRequestId = (req) => req.headers['X-Request-ID'], } = {}) {
     return (req, res, next) => {
-        const requestId = getRequestId(req) || uuid();
+        const requestId = getRequestId(req) || randomUUID();
         requestContext.run(new Map(), () => {
             setRequestContext(REQUEST_ID_CONTEXT_KEY, requestId);
             next();

package/dist/cookie-consent.d.ts

@@ -1,3 +1,3 @@
-export declare function cookieConsent({ onConsent }: {
+export declare function cookieConsent({ onConsent, }: {
     onConsent: (consents: string[]) => Promise<void> | void;
 }): import("express-serve-static-core").Router;

package/dist/csrf.d.ts

@@ -10,7 +10,7 @@ interface CsrfOptions {
     cookieName: string;
     sessionIdentifier: string;
 }
-export declare function csrf({ exempt, sessionIdentifier, cookieName }?: CsrfMiddlewareOptions): RequestHandler;
+export declare function csrf({ exempt, sessionIdentifier, cookieName, }?: CsrfMiddlewareOptions): RequestHandler;
 export declare function setCsrfOptions(options: CsrfOptions): void;
 export declare function useCsrfOptions(): CsrfOptions;
 interface TokenOptions {

package/dist/csrf.js

@@ -115,8 +115,8 @@ const validateRequest = (req) => {
     }
 };
 export function doubleCsrfProtection(req) {
-    // oxlint-disable-next-line eslint-plugin-react-hooks/rules-of-hooks
     return async () => {
+        // oxlint-disable-next-line eslint-plugin-react-hooks/rules-of-hooks
         const { exempt } = useCsrfOptions();
         if (exempt) {
             return;

package/dist/email.d.ts

@@ -11,7 +11,7 @@ export interface EmailOptions {
 export interface SendEmailOptions extends nodemailer.SendMailOptions {
     message: string;
 }
-export declare function createEmail({ host, port, user, pass, senderName, senderAddress, onEmailSent }?: EmailOptions): {
+export declare function createEmail({ host, port, user, pass, senderName, senderAddress, onEmailSent, }?: EmailOptions): {
     send: ({ to, subject, message, ...rest }: SendEmailOptions) => Promise<void>;
     transporter: nodemailer.Transporter<import("nodemailer/lib/smtp-transport/index.js").SentMessageInfo, import("nodemailer/lib/smtp-transport/index.js").Options>;
 };

package/dist/faktory.d.ts

@@ -29,7 +29,7 @@ export interface FaktoryWorkerOptions<GlobalContext> {
     jobContext?: GlobalContext;
 }
 export { createFaktoryWorker as createJobWorker };
-export declare function createFaktoryWorker<GlobalContext>({ queues, jobs, faktory: createFactory, jobContext }: FaktoryWorkerOptions<GlobalContext>): Promise<{
+export declare function createFaktoryWorker<GlobalContext>({ queues, jobs, faktory: createFactory, jobContext, }: FaktoryWorkerOptions<GlobalContext>): Promise<{
     start(workerOptions?: WorkerOptions): Promise<void>;
     stop(): Promise<void>;
 }>;

package/dist/logger.d.ts

@@ -30,7 +30,7 @@ export declare function clearGlobalLoggerContext(): void;
 export type Logger = ReturnType<typeof createLogger>;
 export declare function addDefaultLoggerOutput(output: LoggerAdapter): void;
 export declare function clearDefaultLoggerOutputs(): void;
-export declare function createLogger({ name, getContext, level, outputs }: LoggerOptions): {
+export declare function createLogger({ name, getContext, level, outputs, }: LoggerOptions): {
     debug(message: string, context?: LoggerContext): void;
     info(message: string, context?: LoggerContext): void;
     warn(message: string, context?: LoggerContext): void;

package/dist/middleware.d.ts

@@ -55,7 +55,7 @@ export interface BeforeMiddleware extends RequestHandler {
 /**
  * Register middleware that must come before the app routes.
  */
-export declare function before({ cookies, helmet: useHelmet, json: useJson, csrf: useCsrf, urlencoded: useUrlencoded, allowUnsafeInlineScripts, cspDirectives, auth }?: BeforeMiddlewareOptions): BeforeMiddleware;
+export declare function before({ cookies, helmet: useHelmet, json: useJson, csrf: useCsrf, urlencoded: useUrlencoded, allowUnsafeInlineScripts, cspDirectives, auth, }?: BeforeMiddlewareOptions): BeforeMiddleware;
 /**
  * Middleware that sends a 404
  *

package/dist/middleware.js

@@ -1,13 +1,13 @@
 import * as crypto from 'node:crypto';
 import {} from 'node:http';
 import { config } from '@devmoods/config';
-import { startTimer } from '@devmoods/observability';
+import { metrics, startTimer } from '@devmoods/observability';
 import cookieParser from 'cookie-parser';
 import { json as jsonParser, urlencoded as urlencodedParser, static as staticMiddleware, } from 'express';
 import helmet from 'helmet';
 import {} from './auth.js';
 import { compose } from './composeMiddleware.js';
-import { ANONYMOUS_SESSION_KEY, setRequestContext, useRequestContext, withRequestContext, } from './context.js';
+import { ANONYMOUS_SESSION_KEY, requestContext, setRequestContext, useRequestContext, withRequestContext, } from './context.js';
 import { csrf, doubleCsrfProtection, } from './csrf.js';
 import { NotFound } from './errors.js';
 import { getLogger } from './logger.js';
@@ -26,6 +26,7 @@ export function useCspNonce() {
 export function before({ cookies = true, helmet: useHelmet = true, json: useJson = true, csrf: useCsrf = false, urlencoded: useUrlencoded = false, allowUnsafeInlineScripts = false, cspDirectives = (x) => x, auth, } = {}) {
     const middleware = compose([
         withRequestContext(),
+        startRequestTimer(),
         (cookies || useCsrf) && cookieParser(),
         cookies && setAnonymousCookie(),
         typeof useCsrf === 'object' && useCsrf != null
@@ -76,21 +77,52 @@ export function before({ cookies = true, helmet: useHelmet = true, json: useJson
     });
     return middleware;
 }
+const REQUEST_TIMER_KEY = 'request-timer';
+const LOG_REQUEST_FILTERED_PATHS = [
+    '/src',
+    '/node_modules',
+    '/@fs',
+    '/@vite',
+    '/@react-refresh',
+    '/@id',
+    '/analytics.js',
+];
+function isLogFilteredPath(req) {
+    return LOG_REQUEST_FILTERED_PATHS.some((p) => req.path.startsWith(p));
+}
+/**
+ * Derive a low-cardinality route label (e.g. `/users/:id`) for metrics.
+ * Falls back to `unknown` when no route matched (e.g. 404).
+ */
+function getRouteLabel(req) {
+    const routePath = req.route?.path;
+    if (!routePath) {
+        return 'unknown';
+    }
+    /* c8 ignore next 1 */
+    const pattern = Array.isArray(routePath) ? routePath.join('|') : routePath;
+    return `${req.baseUrl}${pattern}`;
+}
+/**
+ * Start a timer as early as possible in the middleware chain so the
+ * duration reported by `logRequestDuration` includes time spent in
+ * upstream middlewares (cookie parsing, CSRF, auth, etc.).
+ */
+function startRequestTimer() {
+    return function startRequestTimerMiddleware(req, res, next) {
+        if (isLogFilteredPath(req)) {
+            return next();
+        }
+        setRequestContext(REQUEST_TIMER_KEY, startTimer());
+        next();
+    };
+}
 function logRequestDuration() {
-    const FILTERED_PATHS = [
-        '/src',
-        '/node_modules',
-        '/@fs',
-        '/@vite',
-        '/@react-refresh',
-        '/@id',
-        '/analytics.js',
-    ];
     return function logRequestDurationMiddleware(req, res, next) {
-        if (FILTERED_PATHS.some((p) => req.path.startsWith(p))) {
+        const timer = requestContext.getStore()?.get(REQUEST_TIMER_KEY);
+        if (!timer) {
             return next();
         }
-        const timer = startTimer();
         logger.info('http request', {
             method: req.method,
             url: req.originalUrl,
@@ -107,13 +139,20 @@ function logRequestDuration() {
         });
         res.on('finish', () => {
             const duration = timer.getDuration();
+            const route = getRouteLabel(req);
             logger.info('http response', {
                 method: req.method,
                 url: req.originalUrl,
                 path: req.path,
+                route,
                 duration,
                 status: res.statusCode,
             });
+            metrics.distribution('http_request_duration_seconds', duration, {
+                method: req.method,
+                route,
+                status: res.statusCode >= 400 ? 'error' : 'success',
+            });
         });
         next();
     };

package/dist/rate-limit.d.ts

@@ -30,4 +30,4 @@ export interface RateLimitOptions {
 /**
  * Returns a middleware for rate limiting requests.
  */
-export declare function rateLimit(redis: RedisClient, { max, windowSizeInSeconds, getKey }?: RateLimitOptions): RateLimitMiddleware;
+export declare function rateLimit(redis: RedisClient, { max, windowSizeInSeconds, getKey, }?: RateLimitOptions): RateLimitMiddleware;

package/dist/redis.d.ts

@@ -1,7 +1,6 @@
-import { createClient } from 'redis';
 export interface RedisOptions {
     url?: string;
     onError?: (error: Error) => void;
 }
-export type RedisClient = ReturnType<typeof createClient>;
-export declare function createRedis({ url, onError }?: RedisOptions): RedisClient;
+export type RedisClient = ReturnType<typeof createRedis>;
+export declare function createRedis({ url, onError, }?: RedisOptions): import("redis").RedisClientType<{}, {}, {}, 3, {}>;

package/dist/routes.d.ts

@@ -2,9 +2,9 @@ import { type Application } from 'express';
 export declare function createDocsRouter(app: Application, extras?: Record<string, any>): import("express").RequestHandler<Record<string, string>, {
     openapi: string;
     info: {
+        description?: string | undefined;
         title: string;
         version: string;
-        description?: string | undefined;
     };
     tags: {
         name: string;
@@ -42,9 +42,9 @@ export declare function toOpenAPISpec(app: Application, info?: {
 }): {
     openapi: string;
     info: {
+        description?: string | undefined;
         title: string;
         version: string;
-        description?: string | undefined;
     };
     tags: {
         name: string;

package/dist/slack.d.ts

@@ -17,7 +17,7 @@ type Blocks = unknown[];
  *
  * See https://api.slack.com/messaging/webhooks
  */
-export declare function createSlack({ webhookUrl, dryRun }?: SlackOptions): {
+export declare function createSlack({ webhookUrl, dryRun, }?: SlackOptions): {
     postMessage: (message: Message, blocks?: Blocks) => Promise<unknown>;
 };
 export {};

package/dist/utils.d.ts

@@ -4,8 +4,6 @@ export declare function readEnv(key: string): string | undefined;
 export declare function readEnv(key: string, defaultValue: string): string;
 export declare namespace readEnv {
     var number: typeof readEnvNumber;
-}
-export declare namespace readEnv {
     var boolean: typeof readEnvBoolean;
 }
 declare function readEnvNumber(key: string, defaultValue: number): number;

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

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

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

@@ -2,7 +2,6 @@ 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 });
@@ -10,6 +9,6 @@ export async function render(req, options) {
     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,
+        context: undefined,
     };
 }

package/dist/vite/defineViteConfig.d.ts

@@ -1,5 +1,5 @@
 import { type UserConfig } from 'vite';
-export declare function defineViteConfig({ base, ssr, analyze }: {
+export declare function defineViteConfig({ base, ssr, analyze, }: {
     base?: string;
     reactCompiler?: boolean;
     ssr?: boolean;

package/dist/vite/ssr.d.ts

@@ -22,5 +22,5 @@ export interface SsrMiddleware extends RequestHandler {
  *
  * See more: https://vite.dev/guide/ssr
  */
-export declare function createSsrMiddleware<InitialData = unknown>({ root, getInitialData, useDevServer }?: SsrMiddlewareOptions<InitialData>): Promise<SsrMiddleware>;
+export declare function createSsrMiddleware<InitialData = unknown>({ root, getInitialData, useDevServer, }?: SsrMiddlewareOptions<InitialData>): Promise<SsrMiddleware>;
 export declare function replaceSsrPlaceholders(template: string, values: Record<string, unknown>): string;

package/dist/vitest/testClient.d.ts

@@ -7,23 +7,23 @@ export declare function createTestClient(server: Server | Application, options?:
     duplicate(): Promise</*elided*/ any>;
     cookieJar: tough.CookieJar;
     fetch: {
-        <TResponseData, TRequestData = any, TTransformedResponseData = TResponseData, TTransformedRequestData = TRequestData, TSchema extends import("@standard-schema/spec").StandardSchemaV1<TTransformedResponseData, any> = import("@standard-schema/spec").StandardSchemaV1<TTransformedResponseData, TTransformedResponseData>>(url: string, options?: import("@devmoods/fetch").RequestOptions<TRequestData, TTransformedRequestData, TResponseData, TTransformedResponseData, TSchema>): Promise<import("@devmoods/fetch").HttpResponse<import("@standard-schema/spec").StandardSchemaV1.InferOutput<TSchema>>>;
+        <TResponseData, TRequestData = any, TTransformedResponseData = TResponseData, TTransformedRequestData = TRequestData, TSchema extends import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, any> = import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, TTransformedResponseData>>(url: string, options?: import("@devmoods/fetch").RequestOptions<TRequestData, TTransformedRequestData, TResponseData, TTransformedResponseData, TSchema>): Promise<import("@devmoods/fetch").HttpResponse<import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1.InferOutput<TSchema>>>;
         intercept(interceptor: import("@devmoods/fetch").FetchInterceptor): () => void;
     };
     post: {
-        <TResponseData, TRequestData = any, TTransformedResponseData = TResponseData, TTransformedRequestData = TRequestData, TSchema extends import("@standard-schema/spec").StandardSchemaV1<TTransformedResponseData, any> = import("@standard-schema/spec").StandardSchemaV1<TTransformedResponseData, TTransformedResponseData>>(url: string, options?: import("@devmoods/fetch").RequestOptions<TRequestData, TTransformedRequestData, TResponseData, TTransformedResponseData, TSchema>): Promise<import("@devmoods/fetch").HttpResponse<import("@standard-schema/spec").StandardSchemaV1.InferOutput<TSchema>>>;
+        <TResponseData, TRequestData = any, TTransformedResponseData = TResponseData, TTransformedRequestData = TRequestData, TSchema extends import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, any> = import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, TTransformedResponseData>>(url: string, options?: import("@devmoods/fetch").RequestOptions<TRequestData, TTransformedRequestData, TResponseData, TTransformedResponseData, TSchema>): Promise<import("@devmoods/fetch").HttpResponse<import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1.InferOutput<TSchema>>>;
         intercept(interceptor: import("@devmoods/fetch").FetchInterceptor): () => void;
     };
     get: {
-        <TResponseData, TRequestData = any, TTransformedResponseData = TResponseData, TTransformedRequestData = TRequestData, TSchema extends import("@standard-schema/spec").StandardSchemaV1<TTransformedResponseData, any> = import("@standard-schema/spec").StandardSchemaV1<TTransformedResponseData, TTransformedResponseData>>(url: string, options?: import("@devmoods/fetch").RequestOptions<TRequestData, TTransformedRequestData, TResponseData, TTransformedResponseData, TSchema>): Promise<import("@devmoods/fetch").HttpResponse<import("@standard-schema/spec").StandardSchemaV1.InferOutput<TSchema>>>;
+        <TResponseData, TRequestData = any, TTransformedResponseData = TResponseData, TTransformedRequestData = TRequestData, TSchema extends import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, any> = import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, TTransformedResponseData>>(url: string, options?: import("@devmoods/fetch").RequestOptions<TRequestData, TTransformedRequestData, TResponseData, TTransformedResponseData, TSchema>): Promise<import("@devmoods/fetch").HttpResponse<import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1.InferOutput<TSchema>>>;
         intercept(interceptor: import("@devmoods/fetch").FetchInterceptor): () => void;
     };
     put: {
-        <TResponseData, TRequestData = any, TTransformedResponseData = TResponseData, TTransformedRequestData = TRequestData, TSchema extends import("@standard-schema/spec").StandardSchemaV1<TTransformedResponseData, any> = import("@standard-schema/spec").StandardSchemaV1<TTransformedResponseData, TTransformedResponseData>>(url: string, options?: import("@devmoods/fetch").RequestOptions<TRequestData, TTransformedRequestData, TResponseData, TTransformedResponseData, TSchema>): Promise<import("@devmoods/fetch").HttpResponse<import("@standard-schema/spec").StandardSchemaV1.InferOutput<TSchema>>>;
+        <TResponseData, TRequestData = any, TTransformedResponseData = TResponseData, TTransformedRequestData = TRequestData, TSchema extends import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, any> = import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, TTransformedResponseData>>(url: string, options?: import("@devmoods/fetch").RequestOptions<TRequestData, TTransformedRequestData, TResponseData, TTransformedResponseData, TSchema>): Promise<import("@devmoods/fetch").HttpResponse<import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1.InferOutput<TSchema>>>;
         intercept(interceptor: import("@devmoods/fetch").FetchInterceptor): () => void;
     };
     delete: {
-        <TResponseData, TRequestData = any, TTransformedResponseData = TResponseData, TTransformedRequestData = TRequestData, TSchema extends import("@standard-schema/spec").StandardSchemaV1<TTransformedResponseData, any> = import("@standard-schema/spec").StandardSchemaV1<TTransformedResponseData, TTransformedResponseData>>(url: string, options?: import("@devmoods/fetch").RequestOptions<TRequestData, TTransformedRequestData, TResponseData, TTransformedResponseData, TSchema>): Promise<import("@devmoods/fetch").HttpResponse<import("@standard-schema/spec").StandardSchemaV1.InferOutput<TSchema>>>;
+        <TResponseData, TRequestData = any, TTransformedResponseData = TResponseData, TTransformedRequestData = TRequestData, TSchema extends import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, any> = import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, TTransformedResponseData>>(url: string, options?: import("@devmoods/fetch").RequestOptions<TRequestData, TTransformedRequestData, TResponseData, TTransformedResponseData, TSchema>): Promise<import("@devmoods/fetch").HttpResponse<import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1.InferOutput<TSchema>>>;
         intercept(interceptor: import("@devmoods/fetch").FetchInterceptor): () => void;
     };
     close: () => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.74.0",
+  "version": "0.76.0",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
     "format": "oxfmt .",
     "test": "NODE_ENV=test DOTENV_CONFIG_PATH=.env.test vitest",
     "test:coverage": "pnpm run test --coverage",
-    "build": "pnpm run clean && tsgo",
+    "build": "pnpm run clean && tsc",
     "prepublishOnly": "pnpm run clean && pnpm run build"
   },
   "repository": {
@@ -61,44 +61,42 @@
   ],
   "license": "ISC",
   "devDependencies": {
-    "@vitejs/plugin-react": "^6.0.1",
-    "arktype": "^2.2.0",
+    "@vitejs/plugin-react": "^6.0.3",
+    "arktype": "^2.2.2",
     "faktory-worker": "^4.7.1",
-    "react": "^19.2.5",
-    "react-dom": "^19.2.5",
-    "vite": "^8.0.8"
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "vite": "^8.1.3"
   },
   "dependencies": {
-    "@devmoods/config": "0.2.4",
-    "@devmoods/fetch": "^4.3.0",
-    "@devmoods/observability": "0.3.0",
-    "@devmoods/postgres": "0.6.0",
-    "@hey-api/openapi-ts": "^0.96.0",
+    "@devmoods/config": "0.3.0",
+    "@devmoods/fetch": "^4.3.1",
+    "@devmoods/observability": "0.4.0",
+    "@devmoods/postgres": "0.8.0",
+    "@hey-api/openapi-ts": "^0.99.0",
     "@rolldown/plugin-babel": "^0.2.3",
     "@standard-schema/spec": "^1.1.0",
     "@types/bcrypt": "^6.0.0",
     "@types/cookie-parser": "^1.4.10",
     "@types/express": "^5.0.6",
     "@types/koa-compose": "^3.2.9",
-    "@types/nodemailer": "^8.0.0",
-    "@types/qs": "^6.15.0",
-    "ajv": "^8.18.0",
+    "@types/nodemailer": "^8.0.1",
+    "@types/qs": "^6.15.1",
+    "ajv": "^8.20.0",
     "argon2": "^0.44.0",
     "babel-plugin-react-compiler": "^1.0.0",
     "bcrypt": "^6.0.0",
     "chalk": "^5.6.2",
-    "commander": "^14.0.3",
+    "commander": "^15.0.0",
     "cookie-parser": "^1.4.7",
     "dotenv": "^17.4.2",
     "express": "^4.21.2",
-    "google-auth-library": "^10.6.2",
-    "helmet": "^8.1.0",
-    "jose": "^6.2.2",
-    "nodemailer": "^8.0.5",
-    "redis": "^5.12.1",
-    "sonda": "^0.11.1",
+    "helmet": "^8.2.0",
+    "jose": "^6.2.3",
+    "nodemailer": "^9.0.3",
+    "redis": "^6.1.0",
+    "sonda": "^0.13.1",
     "tough-cookie": "^6.0.1",
-    "uuid": "^13.0.0",
     "vitest-fail-on-console": "^0.10.1"
   },
   "peerDependencies": {
@@ -111,5 +109,5 @@
   "engines": {
     "node": ">=20 <26"
   },
-  "gitHead": "2c4100d80823bcf16bd962b4b8a26bd078522dfc"
+  "gitHead": "52519bed307a1eedf13ab334f11c1ad9c7c8db91"
 }