@devmoods/express-extras 0.63.1 → 0.65.0

package/dist/vitest/index.js

@@ -0,0 +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

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

package/dist/vitest/matchers.js

@@ -0,0 +1,65 @@
+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) {
+            const { isNot } = this;
+            // Check if received is a proper response object
+            if (!received ||
+                typeof received !== 'object' ||
+                !('status' in received || 'response' in received)) {
+                return {
+                    pass: false,
+                    message: () => `Expected response object with status property, but received: ${this.utils.printReceived(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)
+            let bodyMatches = true;
+            let bodyMessage = '';
+            if (expectedBody !== undefined) {
+                if (typeof expectedBody === 'object' && expectedBody !== null) {
+                    // For objects, do a deep equality check
+                    bodyMatches = this.equals(body, expectedBody);
+                    if (!bodyMatches) {
+                        bodyMessage = `\n\nExpected body:\n${this.utils.printExpected(expectedBody)}\nReceived body:\n${this.utils.printReceived(body)}`;
+                    }
+                }
+                else {
+                    // For primitives, do a simple equality check
+                    bodyMatches = body === expectedBody;
+                    if (!bodyMatches) {
+                        bodyMessage = `\n\nExpected body: ${this.utils.printExpected(expectedBody)}\nReceived body: ${this.utils.printReceived(body)}`;
+                    }
+                }
+            }
+            const pass = statusMatches && bodyMatches;
+            let message = '';
+            if (!statusMatches) {
+                message += `Expected status: ${this.utils.printExpected(expectedStatusCode)}\nReceived status: ${this.utils.printReceived(status)}`;
+            }
+            if (!bodyMatches) {
+                message += bodyMessage;
+            }
+            return {
+                pass,
+                message: () => {
+                    if (pass && isNot) {
+                        return `Expected response not to match status ${expectedStatusCode}${expectedBody !== undefined ? ` with body ${this.utils.printExpected(expectedBody)}` : ''}`;
+                    }
+                    if (!pass && !isNot) {
+                        return `Expected response to match status ${expectedStatusCode}${expectedBody !== undefined ? ` with body ${this.utils.printExpected(expectedBody)}` : ''}\n\n${message}`;
+                    }
+                    return message;
+                },
+            };
+        },
+    });
+}
+/* c8 ignore stop */

package/dist/vitest/testClient.d.ts

@@ -0,0 +1,30 @@
+import { type Server } from 'node:http';
+import { type FetchClientOptions } from '@devmoods/fetch';
+import { type Application } from 'express';
+import * as tough from 'tough-cookie';
+export declare function createTestClient(server: Server | Application, options?: FetchClientOptions): Promise<{
+    duplicate(): Promise</*elided*/ any>;
+    cookieJar: tough.CookieJar;
+    fetch: {
+        <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", { 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", { 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", { 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", { 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>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+}>;

package/dist/vitest/testClient.js

@@ -0,0 +1,98 @@
+import { createServer } from 'node:http';
+import {} from 'node:net';
+import { createFetch, HttpError, } from '@devmoods/fetch';
+import {} from 'express';
+import * as tough from 'tough-cookie';
+export async function createTestClient(server, options) {
+    // Express app
+    if ('route' in server) {
+        server = createServer(server);
+    }
+    let address = server.address();
+    /* c8 ignore next 5 */
+    if (typeof address === 'string') {
+        throw new Error(`Can't use a server listening on a UNIX domain socket: ${address}`);
+    }
+    let started = false;
+    if (address == null) {
+        await new Promise((resolve) => {
+            server.once('listening', resolve);
+            server.listen(0);
+        });
+        started = true;
+        address = server.address();
+    }
+    const cookieJar = new tough.CookieJar();
+    const fetch = createFetch({
+        getRootUrl: () => `http://localhost:${address.port}`,
+        redirect: 'manual',
+        ...options,
+    });
+    fetch.intercept({
+        request: async (req) => {
+            req.headers.set('cookie', await cookieJar.getCookieString(req.url));
+        },
+        response: async (response) => {
+            const cookies = response.headers.getSetCookie();
+            await Promise.all(cookies.map(async (cookie) => await cookieJar.setCookie(cookie, response.url, {
+                ignoreError: false,
+            })));
+        },
+    });
+    const post = async (url, opt) => {
+        return fetch(url, { method: 'POST', ...opt }).catch((e) => {
+            if (e instanceof HttpError) {
+                return e.response;
+            }
+            throw e;
+        });
+    };
+    post.intercept = fetch.intercept;
+    const get = async (url, opt) => {
+        return fetch(url, { method: 'GET', ...opt }).catch((e) => {
+            if (e instanceof HttpError) {
+                return e.response;
+            }
+            throw e;
+        });
+    };
+    get.intercept = fetch.intercept;
+    const put = async (url, opt) => {
+        return fetch(url, { method: 'PUT', ...opt }).catch((e) => {
+            if (e instanceof HttpError) {
+                return e.response;
+            }
+            throw e;
+        });
+    };
+    put.intercept = fetch.intercept;
+    const delete_ = async (url, opt) => {
+        return fetch(url, { method: 'DELETE', ...opt }).catch((e) => {
+            if (e instanceof HttpError) {
+                return e.response;
+            }
+            throw e;
+        });
+    };
+    delete_.intercept = fetch.intercept;
+    const close = async () => {
+        if (started) {
+            server.close();
+        }
+    };
+    return {
+        duplicate() {
+            return createTestClient(server, options);
+        },
+        cookieJar,
+        fetch,
+        post,
+        get,
+        put,
+        delete: delete_,
+        close,
+        [Symbol.asyncDispose]: async () => {
+            await close();
+        },
+    };
+}

package/dist/webapi.js

@@ -4,6 +4,7 @@ export function createFetchHeaders(requestHeaders) {
     const headers = new Headers();
     for (const [key, values] of Object.entries(requestHeaders)) {
         if (values) {
+            /* c8 ignore next 4 */
             if (Array.isArray(values)) {
                 for (const value of values) {
                     headers.append(key, value);
@@ -20,8 +21,10 @@ export function createFetchRequest(req) {
     try {
         const origin = `${req.protocol}://${req.get('host')}`;
         // Note: This had to take originalUrl into account for presumably vite's proxying
+        /* c8 ignore next 1 */
         const url = new URL(req.originalUrl || req.url, origin);
         const controller = new AbortController();
+        /* c8 ignore next 3 */
         req.on('close', () => {
             controller.abort();
         });
@@ -34,6 +37,7 @@ export function createFetchRequest(req) {
             init.body = req.body;
         }
         return new Request(url.href, init);
+        /* c8 ignore next 7 */
     }
     catch (error) {
         if (error instanceof TypeError) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.63.1",
+  "version": "0.65.0",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",
@@ -12,10 +12,16 @@
         "default": "./dist/index.js"
       }
     },
+    "./config": {
+      "import": {
+        "types": "./dist/config.d.ts",
+        "default": "./dist/config.js"
+      }
+    },
     "./vite": {
       "import": {
         "types": "./dist/vite/vite.d.ts",
-        "default": "./dist/vite.js"
+        "default": "./dist/vite/index.js"
       }
     },
     "./vite/ssr": {
@@ -29,11 +35,21 @@
         "types": "./dist/vite/types.d.ts",
         "default": "./dist/vite/types.js"
       }
+    },
+    "./vitest": {
+      "import": {
+        "types": "./dist/vitest/index.d.ts",
+        "default": "./dist/vitest/index.js"
+      }
     }
   },
-  "author": {
-    "name": "hanse",
-    "email": "hanse@koren.im"
+  "scripts": {
+    "clean": "rm -rf dist",
+    "lint": "eslint",
+    "test": "NODE_ENV=test DOTENV_CONFIG_PATH=.env.test vitest",
+    "test:coverage": "pnpm run test --coverage",
+    "build": "pnpm run clean && tsc",
+    "prepublishOnly": "pnpm run clean && pnpm run build"
   },
   "repository": {
     "type": "git",
@@ -44,45 +60,36 @@
   ],
   "license": "ISC",
   "devDependencies": {
-    "@devmoods/eslint-config": "^2.12.0",
     "@types/koa-compose": "^3.2.8",
-    "@types/node": "24.3.1",
-    "@types/supertest": "^6.0.3",
-    "@vitejs/plugin-react": "^5.0.2",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@vitejs/plugin-react": "^5.0.3",
     "arktype": "^2.1.22",
-    "cookiejar": "^2.1.4",
-    "eslint": "^9.35.0",
     "faktory-worker": "^4.7.1",
-    "prettier": "3.6.2",
-    "supertest": "7.1.4",
-    "ts-node": "10.9.2",
-    "tsx": "^4.20.5",
-    "typescript": "5.9.2",
-    "vite": "^7.1.5",
-    "vitest": "^3.2.4",
-    "vitest-fail-on-console": "^0.10.1"
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "vite": "^7.1.7"
   },
   "dependencies": {
+    "@devmoods/config": "0.1.1",
     "@devmoods/fetch": "^4.2.0",
-    "@hey-api/openapi-ts": "^0.82.5",
-    "@sentry/node": "^10.10.0",
-    "@sentry/profiling-node": "^10.10.0",
+    "@devmoods/observability": "0.1.1",
+    "@devmoods/postgres": "0.1.1",
+    "@hey-api/openapi-ts": "^0.84.3",
+    "@sentry/node": "^10.15.0",
+    "@sentry/node-native": "^10.15.0",
+    "@sentry/profiling-node": "^10.15.0",
     "@standard-schema/spec": "^1.0.0",
     "@types/bcrypt": "^6.0.0",
     "@types/cookie-parser": "^1.4.9",
     "@types/express": "^5.0.3",
     "@types/jsonwebtoken": "^9.0.10",
     "@types/nodemailer": "^7.0.1",
-    "@types/pg": "^8.15.5",
     "@types/qs": "^6.14.0",
     "@types/superagent": "^8.1.9",
-    "@types/uuid": "^10.0.0",
     "ajv": "^8.17.1",
     "argon2": "^0.44.0",
     "bcrypt": "^6.0.0",
     "chalk": "^5.6.2",
-    "commander": "^14.0.0",
+    "commander": "^14.0.1",
     "compose-middleware": "^5.0.1",
     "cookie-parser": "^1.4.7",
     "dotenv": "^17.2.2",
@@ -91,15 +98,11 @@
     "helmet": "^8.1.0",
     "jsonwebtoken": "^9.0.2",
     "nodemailer": "^7.0.6",
-    "pg": "^8.16.3",
-    "pg-structure": "^7.15.3",
     "redis": "^5.8.2",
     "sonda": "^0.9.0",
-    "sql-formatter": "^15.6.8",
-    "uuid": "^12.0.0"
-  },
-  "prettier": {
-    "singleQuote": true
+    "tough-cookie": "^6.0.0",
+    "uuid": "^13.0.0",
+    "vitest-fail-on-console": "^0.10.1"
   },
   "peerDependencies": {
     "@vitejs/plugin-react": ">=4.3.4",
@@ -111,13 +114,5 @@
   "engines": {
     "node": ">=20 <25"
   },
-  "scripts": {
-    "start": "pushd example; pnpm run start --watch; popd example;",
-    "start:worker": "pushd example; pnpm run start:worker; popd example;",
-    "clean": "rm -rf dist",
-    "lint": "eslint",
-    "test": "./test.sh",
-    "build": "pnpm run clean && tsc --project tsconfig.build.json",
-    "format": "prettier --write '**/*.{js,css,md,ts,tsx}'"
-  }
-}
+  "gitHead": "600a2c41cd71ae45a5fc01058b84eeeb48be63b1"
+}

package/dist/__tests__/__migrations__/1_a.d.ts

@@ -1,3 +0,0 @@
-import { type Connection } from '../../postgres.js';
-export declare function up(query: Connection['query']): Promise<void>;
-export declare function down(query: Connection['query']): Promise<void>;

package/dist/__tests__/__migrations__/1_a.js

@@ -1,9 +0,0 @@
-import {} from '../../postgres.js';
-export async function up(query) {
-    await query('CREATE TABLE baz (id serial primary key)');
-    await query('CREATE TABLE foo (id serial primary key)');
-}
-export async function down(query) {
-    await query('DROP TABLE foo');
-    await query('DROP TABLE baz');
-}

package/dist/migrate.d.ts

@@ -1,47 +0,0 @@
-import { type Command } from 'commander';
-import { type CLI } from './cli.js';
-import { createPostgres } from './postgres.js';
-interface Migration {
-    name: string;
-    filename: string;
-    version: number;
-}
-interface MigrationFileAPI {
-    useTransaction?: boolean;
-    up(fn: any): Promise<void> | Promise<void> | string | undefined;
-    down(fn: any): Promise<string> | Promise<void> | string | undefined;
-}
-export declare const asCli: (command: Command, cli: CLI) => void;
-export interface MigratorOptions {
-    postgres?: ReturnType<typeof createPostgres>;
-    migrationTableName?: string;
-    verbose?: boolean;
-    pathToMigrations?: string;
-}
-export declare class Migrator {
-    private postgres;
-    private migrationTableName;
-    private pathToMigrations;
-    private filenameRegExp;
-    private verbose;
-    constructor({ postgres, pathToMigrations, migrationTableName, verbose, }?: MigratorOptions);
-    end(): Promise<void>;
-    init(): Promise<boolean>;
-    isInstalled(): Promise<boolean>;
-    create(name: string | null | undefined, format?: 'ts' | 'sql'): Promise<string>;
-    runMigrations(direction: 'up' | 'down'): Promise<number>;
-    log(...args: any[]): void;
-    executeMigration(migrations: Migration[], currentVersion: number, direction: 'up' | 'down'): Promise<number>;
-    readMigrationFile(filename: string): Promise<MigrationFileAPI>;
-    migrate(migrator: MigrationFileAPI, direction: 'up' | 'down'): Promise<void>;
-    updateCurrentVersion(version: number): Promise<import("pg").QueryResult<import("pg").QueryResultRow>>;
-    getCurrentVersion(): Promise<number>;
-    getMigrations(): Promise<{
-        filename: string;
-        version: number;
-        name: string;
-    }[]>;
-    getPreviousMigrations(migrations: Migration[], currentVersion: number): Migration[];
-    getPendingMigrations(migrations: Migration[], currentVersion: number): Migration[];
-}
-export {};