@devmoods/express-extras 0.46.0 → 0.47.1

package/dist/{auth → src/auth}/passwordless.d.ts

@@ -3,6 +3,4 @@ export interface PasswordlessAuthProviderOptions<UserModel = AnyUser> {
     getUserByEmail(email: string): Promise<UserModel>;
     onLoginRequest(user: UserModel, temporaryToken: string): Promise<void>;
 }
-export declare function PasswordlessAuthProvider<UserModel extends AnyUser & {
-    email: string;
-}>(options: PasswordlessAuthProviderOptions<UserModel>): AuthProvider<UserModel>;
+export declare function PasswordlessAuthProvider<UserModel extends AnyUser>(options: PasswordlessAuthProviderOptions<UserModel>): AuthProvider<UserModel>;

package/dist/src/config.d.ts

@@ -0,0 +1,38 @@
+export declare const config: {
+    extend: <T extends Record<string, unknown>>(appConfig: T) => {
+        value: {
+            CI: boolean;
+            PORT: number;
+            AUTH_TOKEN_EXPIRES_IN: number;
+            AUTH_TEMP_TOKEN_EXPIRES_IN: number;
+            AUTH_SECRET: string;
+            REDIS_URL: string;
+            POSTGRES_URL: string;
+            SENTRY_DSN: string;
+            LOG_LEVEL: string;
+            LOG_SQL: boolean;
+            NODE_ENV: string;
+            CSRF_SECRET: string;
+            READINESS_PERIOD_MS: number;
+            GRACE_PERIOD_MS: number;
+            SLACK_WEBHOOK_URL: string;
+        } & T;
+    };
+    value: {
+        CI: boolean;
+        PORT: number;
+        AUTH_TOKEN_EXPIRES_IN: number;
+        AUTH_TEMP_TOKEN_EXPIRES_IN: number;
+        AUTH_SECRET: string;
+        REDIS_URL: string;
+        POSTGRES_URL: string;
+        SENTRY_DSN: string;
+        LOG_LEVEL: string;
+        LOG_SQL: boolean;
+        NODE_ENV: string;
+        CSRF_SECRET: string;
+        READINESS_PERIOD_MS: number;
+        GRACE_PERIOD_MS: number;
+        SLACK_WEBHOOK_URL: string;
+    };
+};

package/dist/{config.js → src/config.js}

@@ -9,7 +9,7 @@ function lazy(fn) {
     //   },
     // };
 }
-export const config = lazy(() => ({
+const baseConfig = () => ({
     CI: readEnv.boolean('CI', false),
     PORT: readEnv.number('PORT', 0),
     AUTH_TOKEN_EXPIRES_IN: readEnv.number('AUTH_TOKEN_EXPIRES', 3600 * 24 * 30), // 30 days
@@ -25,4 +25,11 @@ export const config = lazy(() => ({
     READINESS_PERIOD_MS: readEnv.number('READINESS_PERIOD_MS', 0),
     GRACE_PERIOD_MS: readEnv.number('GRACE_PERIOD_MS', 20000),
     SLACK_WEBHOOK_URL: readEnv('SLACK_WEBHOOK_URL', ''),
-}));
+});
+export const config = {
+    ...lazy(baseConfig),
+    extend: (appConfig) => {
+        const base = config.value;
+        return lazy(() => ({ ...base, ...appConfig }));
+    },
+};

package/dist/{index.d.ts → src/index.d.ts}

@@ -1,6 +1,7 @@
 export * from './auth.js';
 export * from './cache.js';
 export * from './cli.js';
+export * from './config.js';
 export * from './context.js';
 export * from './csrf.js';
 export * from './email.js';
@@ -17,3 +18,4 @@ export * from './sentry.js';
 export * from './slack.js';
 export * from './utils.js';
 export * from './validate.js';
+export * from './webapi.js';

package/dist/{index.js → src/index.js}

@@ -2,6 +2,7 @@
 export * from './auth.js';
 export * from './cache.js';
 export * from './cli.js';
+export * from './config.js';
 export * from './context.js';
 export * from './csrf.js';
 export * from './email.js';
@@ -18,3 +19,4 @@ export * from './sentry.js';
 export * from './slack.js';
 export * from './utils.js';
 export * from './validate.js';
+export * from './webapi.js';

package/dist/{middleware.d.ts → src/middleware.d.ts}

@@ -1,5 +1,6 @@
 import { type ServerResponse, type IncomingMessage } from 'node:http';
 import bodyParser from 'body-parser';
+import { compose } from 'compose-middleware';
 import { type NextFunction, type RequestHandler, type Request, type Response } from 'express';
 import { type CsrfMiddlewareOptions } from './csrf.js';
 type UrlencodedParser = typeof bodyParser.urlencoded;
@@ -7,6 +8,7 @@ type JsonParser = typeof bodyParser.json;
 export declare const urlencodedParser: UrlencodedParser;
 export declare const jsonParser: JsonParser;
 export { asyncMiddleware as route };
+export { compose as composeMiddleware };
 type ContentSecurityPolicyDirectiveValue = string | ((req: IncomingMessage, res: ServerResponse) => string);
 export interface BeforeMiddlewareCSPDirectives {
     'script-src': ContentSecurityPolicyDirectiveValue[];

package/dist/{middleware.js → src/middleware.js}

@@ -14,6 +14,7 @@ export const urlencodedParser = bodyParser.urlencoded;
 export const jsonParser = bodyParser.json;
 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) ?? 'fuck';

package/dist/src/vite/defineViteConfig.d.ts

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

package/dist/src/vite/defineViteConfig.js

@@ -0,0 +1,53 @@
+/// <reference types="vitest" />
+import * as path from 'node:path';
+import react from '@vitejs/plugin-react';
+import { defineConfig } from 'vite';
+import { readEnv } from '../utils.js';
+export function defineViteConfig({ base = '', reactCompiler = false, ssr = false, }) {
+    const port = readEnv.number('VITE_PORT', 5173);
+    return defineConfig({
+        plugins: [
+            react({
+                ...(reactCompiler
+                    ? {
+                        babel: {
+                            plugins: ['babel-plugin-react-compiler'],
+                        },
+                    }
+                    : {}),
+            }),
+        ],
+        base,
+        build: {
+            chunkSizeWarningLimit: 750,
+            manifest: true,
+            rollupOptions: {
+                input: {
+                    index: path.resolve(process.cwd(), 'src/entry-client.tsx'),
+                },
+            },
+        },
+        server: !ssr
+            ? {
+                host: readEnv('VITE_HOST', '0.0.0.0'),
+                port,
+                strictPort: true,
+                origin: readEnv('VITE_ORIGIN', `http://localhost:${port}`),
+            }
+            : undefined,
+        ssr: {
+            noExternal: ['react-helmet-async'],
+        },
+        test: {
+            setupFiles: ['./src/setupTests'],
+            include: ['src/**/*.{test,spec}.?(c|m)[jt]s?(x)'],
+        },
+        css: {
+            preprocessorOptions: {
+                scss: {
+                    api: 'modern-compiler',
+                },
+            },
+        },
+    });
+}

package/dist/src/vite/ssr.d.ts

@@ -0,0 +1,7 @@
+import express from 'express';
+export interface SsrMiddleWareOptions {
+    root?: string;
+    getInitialData?: (req: string) => Promise<unknown>;
+    useDevServer?: boolean;
+}
+export declare function createSsrMiddleware({ root, getInitialData, useDevServer, }?: SsrMiddleWareOptions): Promise<express.RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>[]>;

package/dist/src/vite/ssr.js

@@ -0,0 +1,120 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import express, {} from 'express';
+import { createServer as createViteServer } from 'vite';
+import {} from './types.js';
+import { route, useCspNonce } from '../middleware.js';
+import { readEnv } from '../utils.js';
+export async function createSsrMiddleware({ root = process.cwd(), getInitialData = async () => ({}), useDevServer = readEnv.boolean('VITE_USE_DEV_SERVER', false), } = {}) {
+    const resolve = (p) => path.resolve(root, p);
+    let vite;
+    const middlewares = [];
+    if (useDevServer) {
+        vite = await createViteServer({
+            root,
+            server: { middlewareMode: true },
+            appType: 'custom',
+        });
+        middlewares.push(vite.middlewares);
+    }
+    else {
+        middlewares.push(express.static(resolve('dist/client'), { index: false }));
+    }
+    middlewares.push(route(async (req, res) => {
+        try {
+            let render;
+            if (useDevServer) {
+                render = (await vite.ssrLoadModule('/src/entry-server.tsx')).render;
+            }
+            else {
+                // @ts-expect-error foo foo fo
+                const result = await import('../../dist/server/entry-server.js');
+                render = result.render;
+            }
+            const rendered = await render(req, res, {
+                useDevServer,
+                getInitialData,
+                placeholders: `
+            {{ ssr-title }}
+            {{ ssr-meta }}
+            {{ ssr-preload }}
+            {{ ssr-js }}
+            {{ ssr-css }}
+          `,
+                nonce: useCspNonce(),
+                preamble: `
+            import RefreshRuntime from "/@react-refresh"
+            RefreshRuntime.injectIntoGlobalHook(window)
+            window.$RefreshReg$ = () => {}
+            window.$RefreshSig$ = () => (type) => type
+            window.__vite_plugin_react_preamble_installed__ = true
+          `,
+            });
+            const readManifest = async () => {
+                if (useDevServer) {
+                    return { preload: '', css: '', js: '' };
+                }
+                const manifestPath = path.resolve(root, 'dist/client/.vite/manifest.json');
+                return getAssetLinks(manifestPath, 'src/entry-client.tsx');
+            };
+            let html = rendered.html;
+            const context = Object.assign({}, rendered.context, await readManifest());
+            const ssrPlaceholders = Object.fromEntries(Object.entries(context).map(([k, v]) => [`ssr-${k}`, v.toString()]));
+            html = replaceSsrPlaceholders(html, ssrPlaceholders);
+            html = `<!DOCTYPE html>\n${html}`;
+            return [200, html, { 'Content-type': 'text/html' }];
+        }
+        catch (error) {
+            if (error instanceof Response &&
+                error.status >= 300 &&
+                error.status <= 399) {
+                return res.redirect(error.status, error.headers.get('Location') || '');
+            }
+            if (useDevServer) {
+                vite.ssrFixStacktrace(error);
+            }
+            throw error;
+        }
+    }));
+    return middlewares;
+}
+function replaceSsrPlaceholders(template, values) {
+    return template.replace(/\{\{\s*([\w-]+)\s*\}\}/g, (match, variableName) => {
+        if (Object.prototype.hasOwnProperty.call(values, variableName)) {
+            const value = values[variableName];
+            if (value == null) {
+                return '';
+            }
+            return String(value);
+        }
+        return match;
+    });
+}
+async function getAssetLinks(manifestPath, input, publicPath = '/') {
+    const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf-8'));
+    if (!manifest[input]) {
+        throw Error('Entry not found in the manifest.json file');
+    }
+    const chunk = manifest[input];
+    const cssHtml = (chunk.css || [])
+        .map((href) => `<link rel="stylesheet" href="${publicPath}${href}" />`)
+        .join(' ');
+    // Generate HTML for preload links
+    const preloadList = [input];
+    if (Array.isArray(chunk.imports)) {
+        preloadList.push(...chunk.imports);
+    }
+    const preloadHtml = preloadList
+        .map((pre) => {
+        if (!manifest[pre]?.file) {
+            return '';
+        }
+        return `<link rel="modulepreload" href="${publicPath}${manifest[pre].file}" />`;
+    })
+        .join(' ');
+    return {
+        preload: preloadHtml,
+        css: cssHtml,
+        js: `<script type="module" src="${publicPath}${chunk.file}"></script>`,
+    };
+}

package/dist/src/vite/types.d.ts

@@ -0,0 +1,12 @@
+import { type Request, type Response } from 'express';
+export interface SsrRenderOptions {
+    useDevServer: boolean;
+    placeholders: string;
+    nonce: string;
+    preamble: string;
+    getInitialData: (req: string) => Promise<unknown>;
+}
+export type EntryRenderFn = (req: Request, res: Response, options: SsrRenderOptions) => Promise<{
+    html: string;
+    context: any;
+}>;

package/dist/src/vite/types.js

@@ -0,0 +1 @@
+import {} from 'express';

package/dist/src/vite.d.ts

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

package/dist/src/vite.js

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

package/dist/src/webapi.d.ts

@@ -0,0 +1,3 @@
+import { type Request as ExpressRequest } from 'express';
+export declare function createFetchHeaders(requestHeaders: ExpressRequest['headers']): Headers;
+export declare function createFetchRequest(req: ExpressRequest): Request;

package/dist/src/webapi.js

@@ -0,0 +1,44 @@
+import {} from 'express';
+import { BadRequest } from './errors.js';
+export function createFetchHeaders(requestHeaders) {
+    const headers = new Headers();
+    for (const [key, values] of Object.entries(requestHeaders)) {
+        if (values) {
+            if (Array.isArray(values)) {
+                for (const value of values) {
+                    headers.append(key, value);
+                }
+            }
+            else {
+                headers.set(key, values);
+            }
+        }
+    }
+    return headers;
+}
+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
+        const url = new URL(req.originalUrl || req.url, origin);
+        const controller = new AbortController();
+        req.on('close', () => {
+            controller.abort();
+        });
+        const init = {
+            method: req.method,
+            headers: createFetchHeaders(req.headers),
+            signal: controller.signal,
+        };
+        if (req.method !== 'GET' && req.method !== 'HEAD') {
+            init.body = req.body;
+        }
+        return new Request(url.href, init);
+    }
+    catch (error) {
+        if (error instanceof TypeError) {
+            throw BadRequest('Invalid request');
+        }
+        throw error;
+    }
+}

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.46.0",
+  "version": "0.47.1",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
-  "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./vite": "./dist/vite.js",
+    "./vite/ssr": "./dist/vite/ssr.js",
+    "./vite/types": "./dist/vite/types.js"
+  },
   "author": {
     "name": "hanse",
     "email": "hanse@koren.im"
@@ -22,6 +27,7 @@
     "@types/koa-compose": "^3.2.8",
     "@types/node": "22.10.2",
     "@types/supertest": "^6.0.2",
+    "@vitejs/plugin-react": "^4.3.4",
     "@vitest/coverage-v8": "^2.1.8",
     "cookiejar": "^2.1.4",
     "eslint": "^9.17.0",
@@ -31,6 +37,7 @@
     "ts-node": "10.9.2",
     "tsx": "^4.19.2",
     "typescript": "5.7.2",
+    "vite": "^6.0.5",
     "vitest": "^2.1.8",
     "vitest-fail-on-console": "^0.7.1"
   },
@@ -68,7 +75,9 @@
     "singleQuote": true
   },
   "peerDependencies": {
-    "faktory-worker": "^4.5.1"
+    "@vitejs/plugin-react": ">=4.3.4",
+    "faktory-worker": ">=4.5.1",
+    "vite": ">=6.0.5"
   },
   "engines": {
     "node": ">=20.3.0 <23"

package/dist/config.d.ts

@@ -1,19 +0,0 @@
-export declare const config: {
-    value: {
-        CI: boolean;
-        PORT: number;
-        AUTH_TOKEN_EXPIRES_IN: number;
-        AUTH_TEMP_TOKEN_EXPIRES_IN: number;
-        AUTH_SECRET: string;
-        REDIS_URL: string;
-        POSTGRES_URL: string;
-        SENTRY_DSN: string;
-        LOG_LEVEL: string;
-        LOG_SQL: boolean;
-        NODE_ENV: string;
-        CSRF_SECRET: string;
-        READINESS_PERIOD_MS: number;
-        GRACE_PERIOD_MS: number;
-        SLACK_WEBHOOK_URL: string;
-    };
-};