@devmoods/express-extras 0.64.0 → 0.65.0

package/dist/config.js

@@ -1,39 +1,38 @@
-import { readEnv } from './utils.js';
-function lazy(fn) {
-    return { value: fn() };
-}
-const baseConfig = {
-    CI: readEnv.boolean('CI', false),
-    PORT: readEnv.number('PORT', 0),
-    PUBLIC_URL: readEnv('PUBLIC_URL', ''),
-    AUTH_TOKEN_EXPIRES_IN: readEnv.number('AUTH_TOKEN_EXPIRES', 3600 * 24 * 30), // 30 days
-    AUTH_TEMP_TOKEN_EXPIRES_IN: readEnv.number('AUTH_TEMP_TOKEN_EXPIRES', 3600),
-    AUTH_OTP_EXPIRES_IN: readEnv.number('AUTH_OTP_EXPIRES', 5 * 60),
-    AUTH_SECRET: readEnv('AUTH_JWT_SECRET', ''),
-    AUTH_COOKIE_SAME_SITE: readEnv('AUTH_COOKIE_SAME_SITE', 'strict'),
-    REDIS_URL: readEnv('REDIS_URL', ''),
-    REDIS_KEY_PREFIX: readEnv('REDIS_KEY_PREFIX', ''),
-    POSTGRES_URL: readEnv('POSTGRES_URL', ''),
-    SENTRY_DSN: readEnv('SENTRY_DSN', ''),
-    LOG_LEVEL: readEnv('LOG_LEVEL', 'INFO'),
-    LOG_SQL: readEnv.boolean('LOG_SQL', false),
-    NODE_ENV: readEnv('NODE_ENV', 'development'),
-    CSRF_SECRET: readEnv('CSRF_SECRET', ''),
-    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', ''),
-    VITE_USE_DEV_SERVER: readEnv.boolean('VITE_USE_DEV_SERVER', false),
+import { define, merge, t } from '@devmoods/config';
+import { postgresConfig } from '@devmoods/postgres';
+const app = define({
+    CI: t.boolean(false),
+    PORT: t.number(0),
+    PUBLIC_URL: t.string(),
+    AUTH_TOKEN_EXPIRES: t.number(3600 * 24 * 30),
+    AUTH_TEMP_TOKEN_EXPIRES: t.number(3600),
+    AUTH_OTP_EXPIRES: t.number(5 * 60),
+    AUTH_JWT_SECRET: t.string(),
+    AUTH_COOKIE_SAME_SITE: t.enum(['strict', 'lax', 'none'], 'strict'),
+    REDIS_URL: t.string(),
+    REDIS_KEY_PREFIX: t.string(),
+    SENTRY_DSN: t.string(),
+    LOG_LEVEL: t.string(),
+    LOG_SQL: t.boolean(),
+    NODE_ENV: t.string(),
+    CSRF_SECRET: t.string(),
+    READINESS_PERIOD_MS: t.number(0),
+    GRACE_PERIOD_MS: t.number(20_000),
+    SLACK_WEBHOOK_URL: t.string(),
+    VITE_USE_DEV_SERVER: t.boolean(false),
     /**
      * Email configuration
      */
-    EMAIL_HOST: readEnv('EMAIL_HOST', ''),
-    EMAIL_PORT: readEnv('EMAIL_PORT', '587'),
-    EMAIL_USER: readEnv('EMAIL_USER', ''),
-    EMAIL_PASS: readEnv('EMAIL_PASS', ''),
-    EMAIL_SENDER_NAME: readEnv('EMAIL_SENDER_NAME', ''),
-    EMAIL_SENDER_ADDRESS: readEnv('EMAIL_SENDER_ADDRESS', ''),
-};
-export const config = lazy(() => baseConfig);
-export function extendConfig(appConfig) {
-    return lazy(() => Object.assign(baseConfig, appConfig));
-}
+    EMAIL_HOST: t.string(),
+    EMAIL_PORT: t.number(587),
+    EMAIL_USER: t.string(),
+    EMAIL_PASS: t.string(),
+    EMAIL_SENDER_NAME: t.string(),
+    EMAIL_SENDER_ADDRESS: t.string(),
+    /**
+     * Google configuration
+     */
+    GOOGLE_AUTH_CLIENT_ID: t.string(),
+    GOOGLE_AUTH_CLIENT_SECRET: t.string(),
+});
+export const config = merge(app, postgresConfig);

package/dist/context.d.ts

@@ -1,6 +1,8 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { type Request, type RequestHandler } from 'express';
 export declare const requestContext: AsyncLocalStorage<Map<string, any>>;
+export declare const REQUEST_ID_CONTEXT_KEY = "requestId";
+export declare const JOB_ID_CONTEXT_KEY = "jobId";
 export interface RequestContextOptions {
     getRequestId?: (req: Request) => string | undefined;
 }
@@ -11,14 +13,15 @@ export declare function withRequestContext({ getRequestId, }?: RequestContextOpt
 /**
  * Return a value from the request context
  */
-export declare function useContext<T>(key: string): T | undefined;
+export declare function useRequestContext<T>(key: string): T | undefined;
 /**
  * Set a value on the request context
  */
-export declare function setContext<T>(key: string, value: T): void;
+export declare function setRequestContext<T>(key: string, value: T): void;
 /**
  * Obtain the requestId from the current async request context.
  */
 export declare function useRequestId(): string | undefined;
+export declare function useJobId(): string | undefined;
 export declare const ANONYMOUS_SESSION_KEY = "anonymous-session";
 export declare function useAnonymousSession(): string | undefined;

package/dist/context.js

@@ -2,7 +2,8 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import {} from 'express';
 import { v4 as uuid } from 'uuid';
 export const requestContext = new AsyncLocalStorage();
-const REQUEST_ID = 'requestId';
+export const REQUEST_ID_CONTEXT_KEY = 'requestId';
+export const JOB_ID_CONTEXT_KEY = 'jobId';
 /**
  * Middleware for setting a `requestId` on the request context.
  */
@@ -10,10 +11,7 @@ export function withRequestContext({ getRequestId = (req) => req.headers['X-Requ
     return (req, res, next) => {
         const requestId = getRequestId(req) || uuid();
         requestContext.run(new Map(), () => {
-            const store = requestContext.getStore();
-            if (store) {
-                store.set(REQUEST_ID, requestId);
-            }
+            setRequestContext(REQUEST_ID_CONTEXT_KEY, requestId);
             next();
         });
     };
@@ -21,7 +19,7 @@ export function withRequestContext({ getRequestId = (req) => req.headers['X-Requ
 /**
  * Return a value from the request context
  */
-export function useContext(key) {
+export function useRequestContext(key) {
     const store = requestContext.getStore();
     if (store) {
         return store.get(key);
@@ -30,7 +28,7 @@ export function useContext(key) {
 /**
  * Set a value on the request context
  */
-export function setContext(key, value) {
+export function setRequestContext(key, value) {
     const store = requestContext.getStore();
     if (store) {
         store.set(key, value);
@@ -40,9 +38,12 @@ export function setContext(key, value) {
  * Obtain the requestId from the current async request context.
  */
 export function useRequestId() {
-    return useContext(REQUEST_ID);
+    return useRequestContext(REQUEST_ID_CONTEXT_KEY);
+}
+export function useJobId() {
+    return useRequestContext(JOB_ID_CONTEXT_KEY);
 }
 export const ANONYMOUS_SESSION_KEY = 'anonymous-session';
 export function useAnonymousSession() {
-    return useContext(ANONYMOUS_SESSION_KEY);
+    return useRequestContext(ANONYMOUS_SESSION_KEY);
 }

package/dist/csrf.js

@@ -1,16 +1,16 @@
 import { createHash, randomBytes } from 'node:crypto';
+import { config } from '@devmoods/config';
 import {} from 'express';
-import { config } from './config.js';
-import { setContext, useContext } from './context.js';
+import { setRequestContext, useRequestContext } from './context.js';
 import { Forbidden } from './errors.js';
 const ignoredMethods = new Set(['GET', 'HEAD', 'OPTIONS']);
 const defaultCookieName = () => {
-    return config.value.NODE_ENV === 'production' && !config.value.CI
+    return config.NODE_ENV === 'production' && !config.CI
         ? '__Host-devmoods.x-csrf-token'
         : 'devmoods.x-csrf-token';
 };
 export const getCsrfSecret = () => {
-    const secret = config.value.CSRF_SECRET;
+    const secret = config.CSRF_SECRET;
     if (!secret) {
         throw new Error('CSRF_SECRET is not set');
     }
@@ -31,10 +31,10 @@ export function csrf({ exempt = false, sessionIdentifier, cookieName, } = {}) {
 }
 const CSRF_CONTEXT_KEY = '@csrfConfig';
 export function setCsrfOptions(options) {
-    setContext(CSRF_CONTEXT_KEY, options);
+    setRequestContext(CSRF_CONTEXT_KEY, options);
 }
 function useCsrfOptions() {
-    return (useContext(CSRF_CONTEXT_KEY) || {
+    return (useRequestContext(CSRF_CONTEXT_KEY) || {
         exempt: true,
         cookieName: defaultCookieName(),
         sessionIdentifier: '',

package/dist/email.d.ts

@@ -1,7 +1,7 @@
 import * as nodemailer from 'nodemailer';
 export interface EmailOptions {
     host?: string;
-    port?: string;
+    port?: number;
     user?: string;
     pass?: string;
     senderName?: string;

package/dist/email.js

@@ -1,11 +1,11 @@
+import { config } from '@devmoods/config';
 import * as nodemailer from 'nodemailer';
-import { config } from './config.js';
 import { getLogger } from './logger.js';
 const logger = getLogger('email');
-export function createEmail({ host = config.value.EMAIL_HOST, port = config.value.EMAIL_PORT, user = config.value.EMAIL_USER, pass = config.value.EMAIL_PASS, senderName = config.value.EMAIL_SENDER_NAME, senderAddress = config.value.EMAIL_SENDER_ADDRESS, onEmailSent, } = {}) {
+export function createEmail({ host = config.EMAIL_HOST, port = config.EMAIL_PORT, user = config.EMAIL_USER, pass = config.EMAIL_PASS, senderName = config.EMAIL_SENDER_NAME, senderAddress = config.EMAIL_SENDER_ADDRESS, onEmailSent, } = {}) {
     const transporter = nodemailer.createTransport({
         host,
-        port: parseInt(port || '587', 10),
+        port,
         secure: false,
         auth: user && pass ? { user, pass } : undefined,
     });

package/dist/errors.js

@@ -1,10 +1,10 @@
 import { STATUS_CODES } from 'node:http';
+import { DoesNotExistError, IntegrityError } from '@devmoods/postgres';
 import * as Sentry from '@sentry/node';
 import { errors } from 'compose-middleware';
 import {} from 'express';
 import { InvalidToken } from './auth/errors.js';
 import { getLogger } from './logger.js';
-import { DoesNotExistError, IntegrityError } from './postgres.js';
 export class ApiError extends Error {
     status;
     payload;

package/dist/faktory.d.ts

@@ -26,7 +26,7 @@ export interface FaktoryWorkerOptions<GlobalContext> {
     faktory?: typeof create;
     jobContext?: GlobalContext;
 }
-export declare function useJobId(): string | undefined;
+export { createFaktoryWorker as createJobWorker };
 export declare function createFaktoryWorker<GlobalContext>({ queueName, jobs, faktory: createFactory, jobContext, }: FaktoryWorkerOptions<GlobalContext>): Promise<{
     start(workerOptions?: WorkerOptions): Promise<void>;
     stop(): Promise<void>;

package/dist/faktory.js

@@ -1,10 +1,9 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
 import { randomUUID } from 'node:crypto';
+import { startTimer } from '@devmoods/observability';
 import { create } from 'faktory-worker';
+import { JOB_ID_CONTEXT_KEY, requestContext, setRequestContext, } from './context.js';
 import { getLogger } from './logger.js';
-import { startTimer } from './utils.js';
 const logger = getLogger('faktory');
-const JOB_ID = 'jobId';
 export function createJobs({ queueName, faktory: createFactory = create, }) {
     const faktory = createFactory();
     function job(optionsOrFn, fnOrUndefined) {
@@ -56,13 +55,7 @@ export function createJobs({ queueName, faktory: createFactory = create, }) {
     }
     return { job, queueName };
 }
-const context = new AsyncLocalStorage();
-export function useJobId() {
-    const store = context.getStore();
-    if (store) {
-        return store.get(JOB_ID);
-    }
-}
+export { createFaktoryWorker as createJobWorker };
 export async function createFaktoryWorker({ queueName, jobs, faktory: createFactory = create, jobContext, }) {
     const faktory = createFactory();
     const filter = (j) => !!Object.prototype.hasOwnProperty.call(j, '$job');
@@ -86,11 +79,8 @@ export async function createFaktoryWorker({ queueName, jobs, faktory: createFact
                         jobName: ctx.job.jobtype,
                         jobId,
                     });
-                    await context.run(new Map(), async () => {
-                        const store = context.getStore();
-                        if (store) {
-                            store.set(JOB_ID, jobId);
-                        }
+                    await requestContext.run(new Map(), async () => {
+                        setRequestContext(JOB_ID_CONTEXT_KEY, jobId);
                         await next();
                     });
                     const duration = timer.getDuration();

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+export * from '@devmoods/observability';
+export * from '@devmoods/postgres';
 export * from './auth.js';
 export * from './cache.js';
 export * from './cookie-consent.js';
@@ -13,14 +15,12 @@ export * from './listen.js';
 export * from './logger.js';
 export * from './manage.js';
 export * from './middleware.js';
-export * from './postgres.js';
 export * from './rate-limit.js';
 export * from './redis.js';
 export * from './router.js';
 export * from './routes.js';
 export * from './sentry.js';
 export * from './slack.js';
-export * from './sql.js';
 export * from './utils.js';
 export * from './validate.js';
 export * from './webapi.js';

package/dist/index.js

@@ -1,4 +1,6 @@
-/* c8 ignore next 100 */
+/* c8 ignore start */
+export * from '@devmoods/observability';
+export * from '@devmoods/postgres';
 export * from './auth.js';
 export * from './cache.js';
 export * from './cookie-consent.js';
@@ -14,14 +16,13 @@ export * from './listen.js';
 export * from './logger.js';
 export * from './manage.js';
 export * from './middleware.js';
-export * from './postgres.js';
 export * from './rate-limit.js';
 export * from './redis.js';
 export * from './router.js';
 export * from './routes.js';
 export * from './sentry.js';
 export * from './slack.js';
-export * from './sql.js';
 export * from './utils.js';
 export * from './validate.js';
 export * from './webapi.js';
+/* c8 ignore stop */

package/dist/listen.d.ts

@@ -10,10 +10,10 @@ interface ExpressServerOptions {
     beforeShutdown?(): Promise<void> | void;
     healthCheck?(type?: 'live' | 'ready'): Promise<unknown>;
 }
-export declare function createExpressServer(app: Application, options?: ExpressServerOptions): {
+interface ExpressServer extends StoppableServer {
     start(): Promise<void>;
-    stop(): Promise<boolean>;
+    port: number;
     terminate(): Promise<void>;
-    readonly port: number;
-};
+}
+export declare function createExpressServer(app: Application, options?: ExpressServerOptions): ExpressServer;
 export {};

package/dist/listen.js

@@ -1,18 +1,16 @@
 import * as http from 'node:http';
 import {} from 'node:http';
 import {} from 'node:net';
+import { config } from '@devmoods/config';
 import { delay } from '@devmoods/fetch';
+import { startTimer } from '@devmoods/observability';
 import {} from 'express';
-import { config } from './config.js';
 import { BadRequest } from './errors.js';
 import { getLogger } from './logger.js';
 import { route } from './middleware.js';
-import { envPort, startTimer } from './utils.js';
-import { validateQuery } from './validate.js';
+import { envPort } from './utils.js';
 const logger = getLogger('http');
 const appTimer = startTimer();
-const READINESS_PERIOD = config.value.READINESS_PERIOD_MS;
-const GRACE_PERIOD = config.value.GRACE_PERIOD_MS;
 export function stoppable(server, grace = Infinity) {
     let stopped = false;
     let gracefully = true;
@@ -76,7 +74,7 @@ export function stoppable(server, grace = Infinity) {
     return server;
 }
 export function createExpressServer(app, options = {}) {
-    const server = stoppable(http.createServer(app), GRACE_PERIOD);
+    const server = stoppable(http.createServer(app), config.GRACE_PERIOD_MS);
     let stopping = false;
     async function onSignal(signal) {
         if (stopping) {
@@ -86,7 +84,7 @@ export function createExpressServer(app, options = {}) {
         const timer = startTimer();
         try {
             logger.info(`app shutting down due to ${signal}`);
-            await delay(READINESS_PERIOD + 1000);
+            await delay(config.READINESS_PERIOD_MS + 1000);
             await options.beforeShutdown?.();
             const gracefully = await server.stop();
             await options.onShutdown?.();
@@ -108,23 +106,18 @@ export function createExpressServer(app, options = {}) {
     }
     const healthTypes = ['live', 'ready'];
     if (!app.get('__healthAttached')) {
-        app.get('/health/:type?', validateQuery({
-            type: 'object',
-            properties: {
-                type: { type: 'string', enum: ['live', 'ready'] },
-            },
-        }), route(async (req) => {
+        app.get('/health/:type?', route(async (req) => {
             const timestamp = new Date().toISOString();
+            const validateType = (type) => {
+                return healthTypes.includes(type);
+            };
+            const type = req.params.type || req.query.type || 'ready';
+            if (!validateType(type)) {
+                throw BadRequest('Invalid health type');
+            }
             try {
                 if (stopping) {
-                    throw new Error();
-                }
-                const validateType = (type) => {
-                    return healthTypes.includes(type);
-                };
-                const type = req.params.type || req.query.type || 'ready';
-                if (!validateType(type)) {
-                    throw BadRequest('Invalid health type');
+                    throw new Error('The server is shutting down');
                 }
                 const meta = await options.healthCheck?.(type);
                 return { status: 'ok', type, meta, timestamp };
@@ -136,31 +129,36 @@ export function createExpressServer(app, options = {}) {
         }));
         app.set('__healthAttached', true);
     }
-    return {
-        start() {
-            const port = app.get('port') ?? envPort(0);
-            return new Promise((resolve) => {
-                server.listen(port, () => {
-                    logger.info('app listening', {
-                        port: this.port,
-                        duration: appTimer.getDuration(),
-                    });
-                    resolve();
-                });
-            });
-        },
-        stop() {
-            return server.stop();
-        },
-        terminate() {
-            return onSignal('SIGTERM');
-        },
-        get port() {
-            const address = server.address();
-            if (address == null || typeof address === 'string') {
+    const expressServer = server;
+    Object.defineProperty(expressServer, 'port', {
+        get() {
+            const address = this.address();
+            if (address == null) {
+                throw new Error('address is null, server not listening?');
+            }
+            /* c8 ignore next 3 */
+            if (typeof address === 'string') {
                 throw new Error('address was a string, should not happen');
             }
             return address.port;
         },
+        enumerable: true,
+        configurable: true,
+    });
+    expressServer.start = function start() {
+        const port = app.get('port') ?? envPort(0);
+        return new Promise((resolve) => {
+            server.listen(port, () => {
+                logger.info('app listening', {
+                    port: expressServer.port,
+                    duration: appTimer.getDuration(),
+                });
+                resolve();
+            });
+        });
+    };
+    expressServer.terminate = function terminate() {
+        return onSignal('SIGTERM');
     };
+    return expressServer;
 }

package/dist/logger.d.ts

@@ -15,6 +15,7 @@ export interface LoggerOptions {
     output?: LoggerOutputWriter;
 }
 export declare function setGlobalLoggerContext(getContext: () => LoggerContext): void;
+export declare function clearGlobalLoggerContext(): void;
 export type Logger = ReturnType<typeof createLogger>;
 export declare function createLogger({ name, getContext, level, output, }: LoggerOptions): {
     debug(message: string, context?: LoggerContext): void;

package/dist/logger.js

@@ -1,6 +1,6 @@
 import * as os from 'node:os';
+import { config } from '@devmoods/config';
 import * as Sentry from '@sentry/node';
-import { config } from './config.js';
 import { useAnonymousSession, useRequestId } from './context.js';
 const LEVELS = {
     TRACE: 10,
@@ -12,20 +12,26 @@ const LEVELS = {
 };
 const LEVELS_TO_NAME = Object.fromEntries(Object.entries(LEVELS).map(([name, level]) => [level, name.toLowerCase()]));
 const _loggers = new Map();
-let _globalGetContext;
+const _getGlobalContextFns = [];
 export function setGlobalLoggerContext(getContext) {
-    _globalGetContext = getContext;
+    _getGlobalContextFns.push(getContext);
+}
+export function clearGlobalLoggerContext() {
+    _getGlobalContextFns.length = 0;
 }
 function defaultGetContext() {
     const nameArgIndex = process.argv.indexOf('--name');
+    const globalContext = _getGlobalContextFns.reduce((acc, fn) => {
+        return Object.assign(acc, fn());
+    }, {});
     return {
         app: nameArgIndex > -1 ? process.argv.at(nameArgIndex + 1) : undefined,
         requestId: useRequestId(),
         sessionId: useAnonymousSession(),
-        ..._globalGetContext?.(),
+        ...globalContext,
     };
 }
-export function createLogger({ name, getContext, level = config.value.LOG_LEVEL, output = process.stdout, }) {
+export function createLogger({ name, getContext, level = config.LOG_LEVEL, output = process.stdout, }) {
     if (_loggers.has(name)) {
         throw new Error(`A logger named ${name} already exists`);
     }

package/dist/manage.d.ts

@@ -1,8 +1,6 @@
-import { program } from 'commander';
+import { Command } from 'commander';
 import { type Express } from 'express';
 import { CLI } from './cli.js';
-type Command = typeof program.command;
-export declare function registerManagementCommand(register: (command: Command, cli: CLI) => void): void;
-export declare function runManagementCommands(): Promise<void>;
-export declare function registerDefaultCommands(app: Express | null): void;
-export {};
+export declare function registerManagementCommand(register: (command: Command['command'], cli: CLI) => void, program?: Command): void;
+export declare function runManagementCommands(program?: Command): Promise<void>;
+export declare function registerDefaultCommands(app: Express | null, program?: Command): void;