@devmoods/express-extras 0.23.0 → 0.25.0

package/README.md

@@ -44,12 +44,7 @@ FORCE_EXIT_TIMEOUT=
 
 APP_JWT_SECRET=123456
 
-PGHOST=localhost
-PGUSER=my_database
-PGPASSWORD=
-PGDATABASE=my_database_dev
-PGPORT=5432
-
+POSTGRES_URL=postgresql://user:pass@localhost:5432/my_database
 REDIS_URL=
 
 SLACK_WEBHOOK_URL=

package/dist/auth.d.ts

@@ -1,27 +1,54 @@
 import { type Request, type RequestHandler, type Response, Router } from 'express';
 import type { RedisClient } from './redis.js';
+/**
+ * Returns a signed JWT token.
+ */
 export declare function createAuthToken(payload: any, secret?: string): string;
-export interface AuthLoginMethods<User = any> {
-    emailAndPassword?: (email: string, verifyPassword: (realPassword: string) => Promise<boolean>) => Promise<User>;
+/**
+ * Decode the given JWT token.
+ */
+export declare function decodeAuthToken(token: string): {
+    [x: string]: any;
+    iss?: string | undefined;
+    sub?: string | undefined;
+    aud?: string | string[] | undefined;
+    exp?: number | undefined;
+    nbf?: number | undefined;
+    iat?: number | undefined;
+    jti?: string | undefined;
+};
+export interface EmailAndPasswordOptions<UserModel = AnyUser> {
+    login: (email: string, verifyPassword: (realPassword: string) => Promise<boolean>) => Promise<UserModel>;
+    onPasswordResetRequest?(user: UserModel, temporaryToken: string): void | Promise<void>;
+    onPasswordChanged?(user: UserModel, newPassword: string): Promise<void>;
+    onEmailVerificationRequest?(user: UserModel, temporaryToken: string): Promise<void>;
+    onEmailVerified?(user: UserModel): Promise<void>;
+}
+export declare function EmailAndPasswordAuthProvider<UserModel extends AnyUser>(options: EmailAndPasswordOptions<UserModel>): AuthProvider<UserModel>;
+export interface AuthProviderContext<UserModel extends AnyUser> {
+    filterUser: AuthOptions<UserModel>['filterUser'];
+    redis: AuthOptions<UserModel>['redis'];
+    setCurrentUser: (user: UserModel) => void;
+    createTemporaryToken(user: UserModel): Promise<string>;
+    middleware: (authorize?: boolean) => RequestHandler;
+}
+export type AnyUser = Record<string, any>;
+export interface AuthProvider<UserModel extends AnyUser> {
+    setupRoutes(router: Router, context: AuthProviderContext<UserModel>): void;
 }
-export interface AuthOptions<UserModel extends Record<string, any>> {
+export interface AuthOptions<UserModel extends AnyUser> {
     getUserByToken(token: Record<string, any>): Promise<UserModel>;
-    methods: AuthLoginMethods<UserModel>;
+    providers: AuthProvider<UserModel>[];
     redis: RedisClient;
     filterUser(user: UserModel): Partial<UserModel>;
-    tokenExpiry?: number;
-    onPasswordResetRequest?(user: UserModel, temporaryToken: string): void | Promise<void>;
-    onPasswordChanged?(user: UserModel, newPassword: string): Promise<void>;
-    onEmailVerificationRequest?(user: UserModel, verificationToken: string): Promise<void>;
-    onEmailVerified?(user: UserModel): Promise<void>;
 }
-export interface CreateAuth<UserModel extends Record<string, any>> {
+export interface CreateAuth<UserModel extends AnyUser> {
     createRouter: () => Router;
     useCurrentUser: () => UserModel | undefined;
     middleware: (authorize?: boolean) => RequestHandler;
-    createVerificationToken(user: UserModel): Promise<string>;
+    createTemporaryToken(user: UserModel): Promise<string>;
 }
-export declare function createAuth<UserModel extends Record<string, any>>({ getUserByToken, methods: { emailAndPassword }, filterUser, redis, tokenExpiry, onPasswordResetRequest, onPasswordChanged, onEmailVerified, onEmailVerificationRequest, }: AuthOptions<UserModel>): CreateAuth<UserModel>;
+export declare function createAuth<UserModel extends AnyUser>({ getUserByToken, filterUser, redis, providers, }: AuthOptions<UserModel>): CreateAuth<UserModel>;
 /**
  * Extract a Bearer token from the HTTP Authorization header
  * of `req`.
@@ -35,6 +62,17 @@ export declare function parseAuthorizationHeader(req: Request): string | null;
  *   2. Cookie named `access_token`
  */
 export declare function extractAccessTokenFromRequest(req: Request): string | null;
+/**
+ * Set or expire the access token cookie.
+ *
+ * If the provided token is `null` the cookie will be cleared.
+ */
 export declare function setAccessTokenCookie(res: Response, token: string | null): void;
+/**
+ * Compare two password hashes using bcrypt.
+ */
 export declare function checkIfPasswordsMatch(realPassword: string, attemptedPassword: string): Promise<boolean>;
+/**
+ * Returns a hash of a password suitable for storage.
+ */
 export declare function hashPassword(password: string): Promise<string>;

package/dist/auth.js

@@ -8,23 +8,43 @@ import { BadRequest, NotFound, Unauthorized } from './errors.js';
 import { getLogger } from './logger.js';
 import { route } from './middleware.js';
 import { validateBody, validateParams, } from './validate.js';
+import { readEnv } from './utils.js';
 const logger = getLogger('auth');
-const TOKEN_EXPIRES_IN = 3600 * 48;
-const TEMP_TOKEN_EXIRES_IN = 3600;
-export function createAuthToken(payload, secret = process.env.APP_JWT_SECRET) {
+const TOKEN_EXPIRES_IN = readEnv.number('AUTH_TOKEN_EXPIRES', 3600 * 48);
+const TEMP_TOKEN_EXIRES_IN = readEnv.number('AUTH_TEMP_TOKEN_EXPIRES', 3600);
+const AUTH_SECRET = readEnv('AUTH_JWT_SECRET', '');
+const tokenSchema = {
+    type: 'string',
+    minLength: 50,
+    maxLength: 256,
+};
+const passwordSchema = { type: 'string', minLength: 8 };
+const emailSchema = { type: 'string', minLength: 4 };
+/**
+ * Returns a signed JWT token.
+ */
+export function createAuthToken(payload, secret = AUTH_SECRET) {
     return jwt.sign(payload, secret, { expiresIn: TOKEN_EXPIRES_IN });
 }
-export function createAuth({ getUserByToken, methods: { emailAndPassword }, filterUser = (x) => x, redis, tokenExpiry = TOKEN_EXPIRES_IN, onPasswordResetRequest, onPasswordChanged, onEmailVerified, onEmailVerificationRequest, }) {
-    const useCurrentUser = () => useContext('currentUser');
-    const setCurrentUser = (user) => setContext('currentUser', user);
+/**
+ * Decode the given JWT token.
+ */
+export function decodeAuthToken(token) {
+    try {
+        const decoded = jwt.verify(token.trim(), AUTH_SECRET);
+        if (typeof decoded === 'string') {
+            throw new Error('decoded value not an object');
+        }
+        return { ...decoded };
+    }
+    catch (error) {
+        throw new Error(`Failed to decode auth token: ${error.message}`);
+    }
+}
+export function EmailAndPasswordAuthProvider(options) {
     const skipPasswordCheck = async () => true;
-    const createRouter = () => {
-        const router = Router();
-        router.get('/me', middleware(), route(() => {
-            const user = useCurrentUser();
-            return filterUser(user);
-        }));
-        if (emailAndPassword) {
+    return {
+        setupRoutes(router, context) {
             router.post('/login', validateBody({
                 type: 'object',
                 properties: {
@@ -34,11 +54,11 @@ export function createAuth({ getUserByToken, methods: { emailAndPassword }, filt
                 required: ['email', 'password'],
             }), route(async ({ body: { email, password } }, res) => {
                 try {
-                    const user = await emailAndPassword(email, (realPassword) => checkIfPasswordsMatch(realPassword, password));
-                    const token = createAuthToken(filterUser(user));
-                    await redis.set(token, '1', { EX: tokenExpiry });
+                    const user = await options.login(email, (realPassword) => checkIfPasswordsMatch(realPassword, password));
+                    const token = createAuthToken(context.filterUser(user));
+                    await context.redis.set(token, '1', { EX: TOKEN_EXPIRES_IN });
                     setAccessTokenCookie(res, token);
-                    setCurrentUser(user);
+                    context.setCurrentUser(user);
                     logger.info('access token created');
                     return [201, { token }];
                 }
@@ -47,38 +67,21 @@ export function createAuth({ getUserByToken, methods: { emailAndPassword }, filt
                     throw Unauthorized(error.message);
                 }
             }));
-        }
-        router.get('/logout', route(async (req, res) => {
-            const token = extractAccessTokenFromRequest(req);
-            if (token) {
-                await redis.del(token);
-            }
-            setAccessTokenCookie(res, null);
-            res.redirect('/');
-        }));
-        const tokenSchema = {
-            type: 'string',
-            minLength: 50,
-            maxLength: 256,
-        };
-        const passwordSchema = { type: 'string', minLength: 8 };
-        const emailSchema = { type: 'string', minLength: 4 };
-        if (emailAndPassword) {
             router.post('/change-password', validateBody({
                 type: 'object',
                 properties: { token: tokenSchema, password: passwordSchema },
                 required: ['token', 'password'],
             }), route(async (req) => {
                 const { password, token } = req.body;
-                const email = await redis.get(token);
+                const email = await context.redis.get(token);
                 if (!email) {
                     logger.info('invalid reset token', { token });
                     throw BadRequest('invalid reset token');
                 }
-                const user = await emailAndPassword(email, skipPasswordCheck);
-                setCurrentUser(user);
-                await onPasswordChanged?.(user, await hashPassword(password));
-                await redis.del(token);
+                const user = await options.login(email, skipPasswordCheck);
+                context.setCurrentUser(user);
+                await options.onPasswordChanged?.(user, await hashPassword(password));
+                await context.redis.del(token);
                 logger.info('user changed password');
                 return 200;
             }));
@@ -88,15 +91,9 @@ export function createAuth({ getUserByToken, methods: { emailAndPassword }, filt
                 required: ['email'],
             }), route(async (req) => {
                 const { email } = req.body;
-                if (!emailAndPassword) {
-                    throw new Error('Not applicable for login method');
-                }
-                const user = await emailAndPassword(email, skipPasswordCheck);
-                const verificationToken = crypto.randomBytes(32).toString('hex');
-                await redis.set(verificationToken, user.email, {
-                    EX: TEMP_TOKEN_EXIRES_IN,
-                });
-                await onEmailVerificationRequest?.(user, verificationToken);
+                const user = await options.login(email, skipPasswordCheck);
+                const temporaryToken = await context.createTemporaryToken(user);
+                await options.onEmailVerificationRequest?.(user, temporaryToken);
                 return 202;
             }));
             router.post('/verify-email', validateBody({
@@ -105,7 +102,7 @@ export function createAuth({ getUserByToken, methods: { emailAndPassword }, filt
                 required: ['token', 'email'],
             }), route(async (req) => {
                 const { token, email } = req.body;
-                const storedEmail = await redis.get(token);
+                const storedEmail = await context.redis.get(token);
                 if (!storedEmail) {
                     logger.info('invalid verification token', { token });
                     throw BadRequest('invalid verification token');
@@ -117,14 +114,57 @@ export function createAuth({ getUserByToken, methods: { emailAndPassword }, filt
                     });
                     throw BadRequest('invalid verification token');
                 }
-                const user = await emailAndPassword(storedEmail, skipPasswordCheck);
-                setCurrentUser(user);
-                await onEmailVerified?.(user);
-                await redis.del(token);
+                const user = await options.login(storedEmail, skipPasswordCheck);
+                context.setCurrentUser(user);
+                await options.onEmailVerified?.(user);
+                await context.redis.del(token);
                 logger.info('user verified');
                 return 200;
             }));
-        }
+            router.post('/reset', context.middleware(false), validateBody({
+                type: 'object',
+                properties: { email: emailSchema },
+                required: ['email'],
+            }), route(async (req) => {
+                const { email } = req.body;
+                try {
+                    const user = await options.login(email, skipPasswordCheck);
+                    const temporaryToken = await context.createTemporaryToken(user);
+                    await options.onPasswordResetRequest?.(user, temporaryToken);
+                    logger.info('password reset request', { email });
+                }
+                catch (error) {
+                    logger.error(error, 'auth reset failed');
+                }
+                return 202;
+            }));
+        },
+    };
+}
+export function createAuth({ getUserByToken, filterUser = (x) => x, redis, providers, }) {
+    const useCurrentUser = () => useContext('currentUser');
+    const setCurrentUser = (user) => setContext('currentUser', user);
+    const providerContext = {
+        filterUser,
+        redis,
+        setCurrentUser,
+        createTemporaryToken,
+        middleware,
+    };
+    const createRouter = () => {
+        const router = Router();
+        router.get('/me', middleware(), route(() => {
+            const user = useCurrentUser();
+            return filterUser(user);
+        }));
+        router.get('/logout', route(async (req, res) => {
+            const token = extractAccessTokenFromRequest(req);
+            if (token) {
+                await redis.del(token);
+            }
+            setAccessTokenCookie(res, null);
+            res.redirect('/');
+        }));
         /**
          * Check that a reset token is valid.
          */
@@ -141,32 +181,6 @@ export function createAuth({ getUserByToken, methods: { emailAndPassword }, filt
             }
             return 200;
         }));
-        /**
-         * Request password reset
-         */
-        router.post('/reset', middleware(false), validateBody({
-            type: 'object',
-            properties: { email: emailSchema },
-            required: ['email'],
-        }), route(async (req) => {
-            const { email } = req.body;
-            if (!emailAndPassword) {
-                throw new Error('Not applicable for login method');
-            }
-            try {
-                const user = await emailAndPassword(email, skipPasswordCheck);
-                const temporaryToken = crypto.randomBytes(32).toString('hex');
-                await redis.set(temporaryToken, user.email, {
-                    EX: TEMP_TOKEN_EXIRES_IN,
-                });
-                await onPasswordResetRequest?.(user, temporaryToken);
-                logger.info('password reset request', { email });
-            }
-            catch (error) {
-                logger.error(error, 'auth reset failed');
-            }
-            return 202;
-        }));
         router.get('/token/refresh', middleware(false), route(async (req, res) => {
             const user = useCurrentUser();
             if (!user) {
@@ -174,11 +188,14 @@ export function createAuth({ getUserByToken, methods: { emailAndPassword }, filt
             }
             const { exp, iat, ...rest } = user;
             const token = createAuthToken(rest);
-            await redis.set(token, '1', { EX: tokenExpiry });
+            await redis.set(token, '1', { EX: TOKEN_EXPIRES_IN });
             setAccessTokenCookie(res, token);
             logger.info('refreshed token', { user });
             return { token };
         }));
+        for (const provider of providers) {
+            provider.setupRoutes(router, providerContext);
+        }
         return router;
     };
     function middleware(authorize = true) {
@@ -199,11 +216,8 @@ export function createAuth({ getUserByToken, methods: { emailAndPassword }, filt
                     }
                     throw new InvalidToken('token expired');
                 }
-                const decoded = jwt.verify(token.trim(), process.env.APP_JWT_SECRET);
-                if (typeof decoded === 'string') {
-                    throw new Error('Failed to decode token');
-                }
-                const user = await getUserByToken({ ...decoded });
+                const decoded = decodeAuthToken(token);
+                const user = await getUserByToken(decoded);
                 setCurrentUser(user);
                 next();
             }
@@ -214,7 +228,11 @@ export function createAuth({ getUserByToken, methods: { emailAndPassword }, filt
             }
         };
     }
-    async function createVerificationToken(user) {
+    /**
+     * Create a short-lived token tied to a user that can be
+     * used for different kinds of verification.
+     */
+    async function createTemporaryToken(user) {
         try {
             const temporaryToken = crypto.randomBytes(32).toString('hex');
             await redis.set(temporaryToken, user.email, {
@@ -231,7 +249,7 @@ export function createAuth({ getUserByToken, methods: { emailAndPassword }, filt
         createRouter,
         useCurrentUser,
         middleware,
-        createVerificationToken,
+        createTemporaryToken,
     };
 }
 /**
@@ -274,6 +292,11 @@ export function extractAccessTokenFromRequest(req) {
     }
     return null;
 }
+/**
+ * Set or expire the access token cookie.
+ *
+ * If the provided token is `null` the cookie will be cleared.
+ */
 export function setAccessTokenCookie(res, token) {
     if (token == null) {
         res.cookie('access_token', v4(), {
@@ -294,6 +317,9 @@ class InvalidToken extends Error {
         this.name = 'Invalid Token';
     }
 }
+/**
+ * Compare two password hashes using bcrypt.
+ */
 export async function checkIfPasswordsMatch(realPassword, attemptedPassword) {
     if (!realPassword) {
         throw new Error('User has no defined password');
@@ -304,6 +330,9 @@ export async function checkIfPasswordsMatch(realPassword, attemptedPassword) {
     }
     return true;
 }
+/**
+ * Returns a hash of a password suitable for storage.
+ */
 export function hashPassword(password) {
     return bcrypt.hash(password, 10);
 }

package/dist/errors.js

@@ -1,7 +1,7 @@
 import { STATUS_CODES } from 'node:http';
 import * as Sentry from '@sentry/node';
 import { errors } from 'compose-middleware';
-import { IntegrityError } from './postgres.js';
+import { DoesNotExistError, IntegrityError } from './postgres.js';
 export class ApiError extends Error {
 }
 export const BadRequest = (reason) => makeError(400, 'Invalid Params', { reason });
@@ -41,6 +41,9 @@ function convertToAPIError(error) {
     if (error instanceof IntegrityError) {
         return Conflict(error.message);
     }
+    if (error instanceof DoesNotExistError) {
+        return NotFound(error.message);
+    }
     return error;
 }
 function _errorHandler({ onError }) {

package/dist/faktory.d.ts

@@ -11,7 +11,7 @@ export declare function createJobs({ queueName }: JobsOptions): {
     };
     queueName: string;
 };
-export type Task = ReturnType<ReturnType<typeof createJobs>['job']>;
+export type Job = ReturnType<ReturnType<typeof createJobs>['job']>;
 export interface FaktoryWorkerOptions {
     jobs: unknown[];
     queueName: string;

package/dist/index.d.ts

@@ -11,5 +11,5 @@ export * from './redis.js';
 export * from './routes.js';
 export * from './sentry.js';
 export * from './slack.js';
+export * from './utils.js';
 export * from './validate.js';
-export declare const envPort: (defaultPort?: number) => number;

package/dist/index.js

@@ -11,5 +11,5 @@ export * from './redis.js';
 export * from './routes.js';
 export * from './sentry.js';
 export * from './slack.js';
+export * from './utils.js';
 export * from './validate.js';
-export const envPort = (defaultPort = 3000) => parseInt(process.env.PORT, 10) || defaultPort;

package/dist/listen.js

@@ -1,8 +1,9 @@
 import { createTerminus } from '@godaddy/terminus';
 import { getLogger } from './logger.js';
+import { readEnv } from './utils.js';
 const logger = getLogger('http');
-const READINESS_PERIOD_MS = parseInt(process.env.READINESS_PERIOD_MS || '', 10) || 0;
-const FORCE_EXIT_TIMEOUT = parseInt(process.env.FORCE_EXIT_TIMEOUT || '', 10) || 1000;
+const READINESS_PERIOD_MS = readEnv.number('READINESS_PERIOD_MS', 0);
+const FORCE_EXIT_TIMEOUT = readEnv.number('FORCE_EXIT_TIMEOUT', 5000);
 /**
  * Listen on the given port and setup proper signal
  * handlers for terminating the process properly.

package/dist/middleware.d.ts

@@ -29,4 +29,4 @@ export declare function after(): RequestHandler;
 /**
  * Alias of `route()`
  */
-export declare function asyncMiddleware<RequestBody, RequestQuery = void>(fn: RequestHandler<Record<string, string>, any, RequestBody, RequestQuery>): RequestHandler<Record<string, string>, any, RequestBody, RequestQuery>;
+export declare function asyncMiddleware<RequestBody, RequestQuery = object>(fn: RequestHandler<Record<string, string>, any, RequestBody, RequestQuery>): RequestHandler<Record<string, string>, any, RequestBody, RequestQuery>;

package/dist/postgres.d.ts

@@ -2,6 +2,7 @@ import pg, { type PoolClient, type QueryResult, type QueryResultRow } from 'pg';
 import { SQL, type SQLStatement } from 'sql-template-strings';
 export interface PostgresOptions extends pg.PoolConfig {
     onError?: (error: Error, client: any) => void;
+    url?: pg.PoolConfig['connectionString'];
 }
 export declare class DoesNotExistError extends Error {
     constructor(message: string);
@@ -31,7 +32,7 @@ export declare class Transaction extends Connection {
  *
  * @param config
  */
-export declare function createPostgres({ onError, ...config }?: PostgresOptions): {
+export declare function createPostgres({ onError, url, ...config }?: PostgresOptions): {
     insert: <T extends pg.QueryResultRow>(text: string | SQLStatement, values?: Value[] | undefined) => Promise<pg.QueryResult<T>>;
     query: <T_1 extends pg.QueryResultRow>(text: string | SQLStatement, values?: Value[] | undefined) => Promise<pg.QueryResult<T_1>>;
     first: <T_2>(text: string | SQLStatement, values?: Value[] | undefined) => Promise<T_2 | null>;

package/dist/postgres.js

@@ -1,5 +1,6 @@
 import pg from 'pg';
 import { SQL } from 'sql-template-strings';
+import { readEnv } from './utils.js';
 export class DoesNotExistError extends Error {
     constructor(message) {
         super(message);
@@ -67,8 +68,8 @@ export class Transaction extends Connection {
  *
  * @param config
  */
-export function createPostgres({ onError = () => { }, ...config } = {}) {
-    const pool = new pg.Pool(config);
+export function createPostgres({ onError = () => { }, url = readEnv('POSTGRES_URL'), ...config } = {}) {
+    const pool = new pg.Pool({ connectionString: url, ...config });
     pool.on('error', onError);
     async function withConnection(callback) {
         const client = await pool.connect();

package/dist/redis.js

@@ -1,5 +1,6 @@
 import { createClient } from 'redis';
-export function createRedis({ url = process.env.REDIS_URL, onError, }) {
+import { readEnv } from './utils.js';
+export function createRedis({ url = readEnv('REDIS_URL', ''), onError, }) {
     const client = createClient({ url });
     client.on('error', onError);
     return client;

package/dist/sentry.js

@@ -1,11 +1,15 @@
 import * as Sentry from '@sentry/node';
+import { attachSentryClientToLoggers } from './logger.js';
+import { readEnv } from './utils.js';
 /**
  * Create a pre-configured Sentry client
  */
 export function createSentry(options = {}) {
+    const client = Sentry;
     return {
-        client: Sentry,
+        client,
         init(app, getOptions = (defaultOptions) => defaultOptions) {
+            attachSentryClientToLoggers(client);
             Sentry.init(getOptions(createSentryOptions(app, options)));
         },
     };
@@ -15,7 +19,7 @@ export function createSentry(options = {}) {
  */
 export function createSentryOptions(app, options = {}) {
     return {
-        dsn: process.env.SENTRY_DSN,
+        dsn: readEnv('SENTRY_DSN'),
         integrations: [
             new Sentry.Integrations.Http({ tracing: true }),
             app && new Sentry.Integrations.Express({ app }),

package/dist/setupTests.d.ts

@@ -0,0 +1 @@
+import 'dotenv/config';

package/dist/setupTests.js

@@ -0,0 +1,9 @@
+import 'dotenv/config';
+import * as crypto from 'node:crypto';
+// @ts-ignore
+import createFetchMock from 'vitest-fetch-mock';
+import { vi } from 'vitest';
+const fetchMocker = createFetchMock(vi);
+fetchMocker.enableMocks();
+// @ts-ignore
+globalThis.crypto = crypto;

package/dist/slack.js

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

package/dist/utils.d.ts

@@ -5,3 +5,13 @@
 export declare function startTimer(): {
     getDuration(): number;
 };
+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;
+    var boolean: typeof readEnvBoolean;
+}
+declare function readEnvNumber(key: string, defaultValue: number): number;
+declare function readEnvBoolean(key: string, defaultValue: boolean): boolean;
+export declare const envPort: (defaultPort?: number) => number;
+export {};

package/dist/utils.js

@@ -11,3 +11,17 @@ export function startTimer() {
         },
     };
 }
+export function readEnv(key, defaultValue) {
+    const value = process.env[key];
+    return value ?? defaultValue;
+}
+readEnv.number = readEnvNumber;
+readEnv.boolean = readEnvBoolean;
+function readEnvNumber(key, defaultValue) {
+    const str = readEnv(key, `${defaultValue}`);
+    return parseFloat(str);
+}
+function readEnvBoolean(key, defaultValue) {
+    return ['true', '1', 't'].includes(readEnv(key, `${defaultValue}`).toLowerCase());
+}
+export const envPort = (defaultPort = 3000) => readEnv.number('PORT', defaultPort);

package/dist/validate.d.ts

@@ -44,7 +44,7 @@ export declare function compileValidateSchema(schema: ValidationSchema, options?
     errors: null;
 } | {
     isValid: boolean;
-    errors: never[] | {
+    errors: {
         [key: string]: any[];
     };
 };

package/dist/validate.js

@@ -45,7 +45,7 @@ export function compileValidateSchema(schema, options = {}) {
                 errors: null,
             };
         }
-        const errors = transformAjvErrors(validate.errors) || {};
+        const errors = transformAjvErrors(validate.errors);
         validate.errors = null;
         return {
             isValid: false,
@@ -65,7 +65,7 @@ export function validateSchema(data, schema, options = {}) {
             errors: null,
         };
     }
-    const errors = transformAjvErrors(ajv.errors) || {};
+    const errors = transformAjvErrors(ajv.errors);
     ajv.errors = null;
     return {
         isValid: false,
@@ -73,8 +73,9 @@ export function validateSchema(data, schema, options = {}) {
     };
 }
 function transformAjvErrors(errors) {
+    /* c8 ignore next 3 */
     if (errors == null) {
-        return [];
+        return {};
     }
     return errors
         .map((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",
@@ -24,15 +24,16 @@
   "license": "ISC",
   "devDependencies": {
     "@devmoods/eslint-config": "^1.2.0",
-    "@sentry/types": "^7.61.1",
+    "@sentry/types": "^7.63.0",
     "@types/express-serve-static-core": "^4.17.35",
-    "@types/node": "20.4.7",
+    "@types/node": "20.4.10",
     "@types/supertest": "^2.0.12",
-    "@typescript-eslint/eslint-plugin": "^6.2.1",
-    "@typescript-eslint/parser": "^6.2.1",
+    "@typescript-eslint/eslint-plugin": "^6.3.0",
+    "@typescript-eslint/parser": "^6.3.0",
+    "@vitest/coverage-v8": "^0.34.1",
     "@vitest/expect": "^0.34.1",
     "chalk": "^5.3.0",
-    "eslint": "^8.46.0",
+    "eslint": "^8.47.0",
     "eslint-plugin-jsx-a11y": "^6.7.1",
     "eslint-plugin-prettier": "^5.0.0",
     "eslint-plugin-react": "^7.33.1",
@@ -44,12 +45,13 @@
     "supertest": "6.3.3",
     "ts-node": "10.9.1",
     "typescript": "5.1.6",
-    "vitest": "^0.34.1"
+    "vitest": "^0.34.1",
+    "vitest-fetch-mock": "^0.2.2"
   },
   "dependencies": {
     "@devmoods/fetch": "^3.3.0",
     "@godaddy/terminus": "^4.12.1",
-    "@sentry/node": "^7.61.1",
+    "@sentry/node": "^7.63.0",
     "@types/bcrypt": "^5.0.0",
     "@types/body-parser": "^1.19.2",
     "@types/cookie-parser": "^1.4.3",
@@ -101,7 +103,7 @@
     "start:worker": "ts-node --esm example/worker.ts",
     "clean": "rm -rf dist",
     "lint": "eslint src",
-    "test": "NODE_ENV=test vitest",
+    "test": "NODE_ENV=test DOTENV_CONFIG_PATH=.env.test vitest",
     "build": "pnpm run clean && tsc --project tsconfig.build.json",
     "prettier": "prettier --write '**/*.{js,css,md,ts,tsx}'",
     "import-sort": "import-sort --write '**/*.{js,jsx,ts,tsx}'",