node-auth-kit 1.0.2

package/dist/src/controllers/registrations.controller.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRegistrationsController = void 0;
+const deviceAuth_1 = require("../deviceAuth");
+const auth_service_factory_1 = require("../factories/auth-service.factory");
+const sanitizeUser = (user) => {
+    const { password: _password, ...safeUser } = user;
+    return safeUser;
+};
+const sanitizeSignupResult = (result) => {
+    return {
+        ...result,
+        user: sanitizeUser(result.user),
+    };
+};
+const defaultRegistrationsController = async (data) => {
+    const authService = (0, auth_service_factory_1.createAuthService)();
+    const result = await authService.signup(data);
+    return sanitizeSignupResult(result);
+};
+const getRegistrationsController = () => {
+    const override = deviceAuth_1.deviceAuth.getControllerOverride('registrations');
+    return override ?? defaultRegistrationsController;
+};
+exports.getRegistrationsController = getRegistrationsController;

package/dist/src/controllers/sessions.controller.d.ts

@@ -0,0 +1,3 @@
+import type { LoginResult } from '../core/auth.service';
+export type SessionsController = (email: string, password: string) => Promise<LoginResult>;
+export declare const getSessionsController: () => SessionsController;

package/dist/src/controllers/sessions.controller.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionsController = void 0;
+const deviceAuth_1 = require("../deviceAuth");
+const auth_service_factory_1 = require("../factories/auth-service.factory");
+const sanitizeUser = (user) => {
+    const { password: _password, ...safeUser } = user;
+    return safeUser;
+};
+const sanitizeLoginResult = (result) => {
+    return {
+        ...result,
+        user: sanitizeUser(result.user),
+    };
+};
+const defaultSessionsController = async (email, password) => {
+    const authService = (0, auth_service_factory_1.createAuthService)();
+    const result = await authService.login(email, password);
+    return sanitizeLoginResult(result);
+};
+const getSessionsController = () => {
+    const override = deviceAuth_1.deviceAuth.getControllerOverride('sessions');
+    return override ?? defaultSessionsController;
+};
+exports.getSessionsController = getSessionsController;

package/dist/src/core/auth.service.d.ts

@@ -0,0 +1,35 @@
+import type { BaseAdapter, AdapterUser } from '../adapters/base.adapter';
+import type { DeviceAuthConfig } from '../config';
+import type { HookName } from '../deviceAuth';
+import type { PasswordService } from './password.service';
+import type { TokenService } from './token.service';
+export interface AuthServiceDeps {
+    adapter: BaseAdapter;
+    config: DeviceAuthConfig;
+    passwordService: PasswordService;
+    tokenService: TokenService;
+    runHooks: (name: HookName, ...args: unknown[]) => Promise<void>;
+}
+export interface SignupResult {
+    user: AdapterUser;
+    accessToken?: string;
+}
+export interface LoginResult {
+    user: AdapterUser;
+    accessToken?: string;
+}
+export declare class AuthService {
+    private readonly adapter;
+    private readonly config;
+    private readonly passwordService;
+    private readonly tokenService;
+    private readonly runHooks;
+    constructor(deps: AuthServiceDeps);
+    signup(data: Record<string, unknown>): Promise<SignupResult>;
+    login(email: string, password: string): Promise<LoginResult>;
+    logout(): Promise<void>;
+    validateUserFromToken(token: string): Promise<AdapterUser | null>;
+    private ensureSignupFields;
+    private ensurePasswordRules;
+    private issueAccessTokenFromUser;
+}

package/dist/src/core/auth.service.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+class AuthService {
+    constructor(deps) {
+        this.adapter = deps.adapter;
+        this.config = deps.config;
+        this.passwordService = deps.passwordService;
+        this.tokenService = deps.tokenService;
+        this.runHooks = deps.runHooks;
+    }
+    async signup(data) {
+        this.ensureSignupFields(data);
+        const password = data['password'];
+        if (typeof password !== 'string') {
+            throw new Error('Password is required and must be a string');
+        }
+        this.ensurePasswordRules(password);
+        const hashedPassword = await this.passwordService.hashPassword(password);
+        const createData = {
+            ...data,
+            password: hashedPassword,
+        };
+        if (createData['role'] == null) {
+            createData['role'] = this.config.defaultRole;
+        }
+        await this.runHooks('beforeRegister', createData);
+        const user = await this.adapter.createUser(createData);
+        await this.runHooks('afterRegister', user);
+        if (this.config.authType === 'jwt') {
+            const accessToken = this.issueAccessTokenFromUser(user);
+            return { user, accessToken };
+        }
+        return { user };
+    }
+    async login(email, password) {
+        const user = await this.adapter.findUserByEmail(email);
+        if (!user) {
+            throw new Error('Invalid credentials');
+        }
+        const storedPassword = user['password'];
+        if (typeof storedPassword !== 'string') {
+            throw new Error('Invalid user password configuration');
+        }
+        await this.runHooks('beforeLogin', user);
+        const isValid = await this.passwordService.comparePassword(password, storedPassword);
+        if (!isValid) {
+            throw new Error('Invalid credentials');
+        }
+        await this.runHooks('afterLogin', user);
+        if (this.config.authType === 'jwt') {
+            const accessToken = this.issueAccessTokenFromUser(user);
+            return { user, accessToken };
+        }
+        return { user };
+    }
+    async logout() {
+        return;
+    }
+    async validateUserFromToken(token) {
+        if (this.config.authType !== 'jwt') {
+            throw new Error('Token-based validation is only available for jwt authType');
+        }
+        const payload = this.tokenService.verifyToken(token);
+        const userId = payload.sub;
+        if (userId == null) {
+            throw new Error('Token payload missing subject');
+        }
+        const user = await this.adapter.findUserById(userId);
+        if (user) {
+            const mutableUser = user;
+            if (mutableUser['id'] == null) {
+                mutableUser['id'] = userId;
+            }
+            if (Object.prototype.hasOwnProperty.call(payload, 'role')) {
+                mutableUser['role'] = payload['role'];
+            }
+        }
+        return user;
+    }
+    ensureSignupFields(data) {
+        for (const field of this.config.signupFields) {
+            if (data[field] == null) {
+                throw new Error(`Missing required signup field: ${field}`);
+            }
+        }
+    }
+    ensurePasswordRules(password) {
+        const rules = this.config.password;
+        if (password.length < rules.minLength) {
+            throw new Error('Password does not meet minimum length requirement');
+        }
+        if (rules.requireNumbers && !/[0-9]/.test(password)) {
+            throw new Error('Password must contain at least one number');
+        }
+        if (rules.requireSpecialChars && !/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
+            throw new Error('Password must contain at least one special character');
+        }
+    }
+    issueAccessTokenFromUser(user) {
+        const userId = user['id'];
+        if (userId == null) {
+            throw new Error('User record does not contain an id field');
+        }
+        const role = user['role'] ?? null;
+        const payload = {
+            sub: userId,
+            role,
+        };
+        return this.tokenService.generateAccessToken(payload);
+    }
+}
+exports.AuthService = AuthService;

package/dist/src/core/password.service.d.ts

@@ -0,0 +1,9 @@
+export interface PasswordServiceOptions {
+    saltRounds: number;
+}
+export declare class PasswordService {
+    private readonly saltRounds;
+    constructor(options: PasswordServiceOptions);
+    hashPassword(plainPassword: string): Promise<string>;
+    comparePassword(plainPassword: string, hashedPassword: string): Promise<boolean>;
+}

package/dist/src/core/password.service.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasswordService = void 0;
+const bcrypt_1 = __importDefault(require("bcrypt"));
+class PasswordService {
+    constructor(options) {
+        this.saltRounds = options.saltRounds;
+    }
+    async hashPassword(plainPassword) {
+        return bcrypt_1.default.hash(plainPassword, this.saltRounds);
+    }
+    async comparePassword(plainPassword, hashedPassword) {
+        return bcrypt_1.default.compare(plainPassword, hashedPassword);
+    }
+}
+exports.PasswordService = PasswordService;

package/dist/src/core/token.service.d.ts

@@ -0,0 +1,15 @@
+export interface TokenServiceOptions {
+    secret: string;
+    expiresIn: string;
+}
+export interface AccessTokenPayload {
+    sub: string | number;
+    [key: string]: unknown;
+}
+export declare class TokenService {
+    private readonly secret;
+    private readonly expiresIn;
+    constructor(options: TokenServiceOptions);
+    generateAccessToken(payload: AccessTokenPayload): string;
+    verifyToken(token: string): AccessTokenPayload;
+}

package/dist/src/core/token.service.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenService = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+class TokenService {
+    constructor(options) {
+        this.secret = options.secret;
+        this.expiresIn = options.expiresIn;
+    }
+    generateAccessToken(payload) {
+        // Casts are used here to avoid tight coupling to jsonwebtoken's type overloads,
+        // while preserving correct runtime behavior.
+        return jsonwebtoken_1.default.sign(payload, this.secret, { expiresIn: this.expiresIn });
+    }
+    verifyToken(token) {
+        const decoded = jsonwebtoken_1.default.verify(token, this.secret);
+        if (typeof decoded === 'string') {
+            throw new Error('Invalid token payload type');
+        }
+        return decoded;
+    }
+}
+exports.TokenService = TokenService;

package/dist/src/deviceAuth.d.ts

@@ -0,0 +1,32 @@
+import type { DeviceAuthConfig } from './config';
+import type { BaseAdapter } from './adapters/base.adapter';
+export type HookName = 'beforeRegister' | 'afterRegister' | 'beforeLogin' | 'afterLogin';
+export type HookFn = (...args: unknown[]) => unknown | Promise<unknown>;
+export interface ControllerOverrides {
+    [controllerName: string]: any;
+}
+declare class DeviceAuthCore {
+    private _config;
+    private _adapter;
+    private _hooks;
+    private _controllerOverrides;
+    constructor();
+    /** Initialize global configuration (Devise-style initializer). */
+    init(config?: Partial<DeviceAuthConfig>): this;
+    /** Register the database adapter (Prisma, Mongoose, etc.). */
+    useAdapter(adapter: BaseAdapter): this;
+    /** Register a hook callback for a given lifecycle event. */
+    registerHook(name: HookName, fn: HookFn): this;
+    /** Internal: execute all hooks for an event, without breaking core flow. */
+    runHooks(name: HookName, ...args: unknown[]): Promise<void>;
+    /** Register or override controllers (full or partial). */
+    override(controllerName: string, implementation: unknown): this;
+    /** Get an overridden controller implementation, if any. */
+    getControllerOverride<T = unknown>(controllerName: string): T | undefined;
+    /** Expose current config (read-only by convention). */
+    get config(): DeviceAuthConfig;
+    /** Expose current adapter. Will throw if not configured. */
+    get adapter(): BaseAdapter;
+}
+export declare const deviceAuth: DeviceAuthCore;
+export type { DeviceAuthConfig };

package/dist/src/deviceAuth.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deviceAuth = void 0;
+const config_1 = require("./config");
+class DeviceAuthCore {
+    constructor() {
+        this._adapter = null;
+        this._hooks = {};
+        this._controllerOverrides = {};
+        this._config = (0, config_1.mergeConfig)();
+    }
+    /** Initialize global configuration (Devise-style initializer). */
+    init(config) {
+        this._config = (0, config_1.mergeConfig)(config);
+        return this;
+    }
+    /** Register the database adapter (Prisma, Mongoose, etc.). */
+    useAdapter(adapter) {
+        this._adapter = adapter;
+        return this;
+    }
+    /** Register a hook callback for a given lifecycle event. */
+    registerHook(name, fn) {
+        if (!this._hooks[name]) {
+            this._hooks[name] = [];
+        }
+        this._hooks[name].push(fn);
+        return this;
+    }
+    /** Internal: execute all hooks for an event, without breaking core flow. */
+    async runHooks(name, ...args) {
+        const fns = this._hooks[name];
+        if (!fns || fns.length === 0)
+            return;
+        for (const fn of fns) {
+            try {
+                // eslint-disable-next-line @typescript-eslint/await-thenable
+                await fn(...args);
+            }
+            catch (err) {
+                // Intentionally swallow errors to avoid breaking core flow
+                // In future we can add optional logging hooks
+            }
+        }
+    }
+    /** Register or override controllers (full or partial). */
+    override(controllerName, implementation) {
+        this._controllerOverrides[controllerName] = implementation;
+        return this;
+    }
+    /** Get an overridden controller implementation, if any. */
+    getControllerOverride(controllerName) {
+        return this._controllerOverrides[controllerName];
+    }
+    /** Expose current config (read-only by convention). */
+    get config() {
+        return this._config;
+    }
+    /** Expose current adapter. Will throw if not configured. */
+    get adapter() {
+        if (!this._adapter) {
+            throw new Error('device_auth adapter is not configured. Call deviceAuth.useAdapter().');
+        }
+        return this._adapter;
+    }
+}
+exports.deviceAuth = new DeviceAuthCore();

package/dist/src/factories/auth-service.factory.d.ts

@@ -0,0 +1,2 @@
+import { AuthService } from '../core/auth.service';
+export declare const createAuthService: () => AuthService;

package/dist/src/factories/auth-service.factory.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthService = void 0;
+const deviceAuth_1 = require("../deviceAuth");
+const auth_service_1 = require("../core/auth.service");
+const password_service_1 = require("../core/password.service");
+const token_service_1 = require("../core/token.service");
+const createAuthService = () => {
+    const config = deviceAuth_1.deviceAuth.config;
+    const adapter = deviceAuth_1.deviceAuth.adapter;
+    const passwordService = new password_service_1.PasswordService({
+        saltRounds: config.password.saltRounds,
+    });
+    const secret = process.env.DEVICE_AUTH_JWT_SECRET;
+    if (!secret) {
+        throw new Error('DEVICE_AUTH_JWT_SECRET environment variable is required for JWT authentication. Set DEVICE_AUTH_JWT_SECRET to a strong, random secret in your environment configuration.');
+    }
+    const tokenService = new token_service_1.TokenService({
+        secret,
+        expiresIn: config.token.accessTokenTtl,
+    });
+    return new auth_service_1.AuthService({
+        adapter,
+        config,
+        passwordService,
+        tokenService,
+        runHooks: deviceAuth_1.deviceAuth.runHooks.bind(deviceAuth_1.deviceAuth),
+    });
+};
+exports.createAuthService = createAuthService;

package/dist/src/hooks/index.d.ts

@@ -0,0 +1,5 @@
+import { type HookFn } from '../deviceAuth';
+export declare const beforeRegister: (fn: HookFn) => void;
+export declare const afterRegister: (fn: HookFn) => void;
+export declare const beforeLogin: (fn: HookFn) => void;
+export declare const afterLogin: (fn: HookFn) => void;

package/dist/src/hooks/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.afterLogin = exports.beforeLogin = exports.afterRegister = exports.beforeRegister = void 0;
+const deviceAuth_1 = require("../deviceAuth");
+const beforeRegister = (fn) => {
+    deviceAuth_1.deviceAuth.registerHook('beforeRegister', fn);
+};
+exports.beforeRegister = beforeRegister;
+const afterRegister = (fn) => {
+    deviceAuth_1.deviceAuth.registerHook('afterRegister', fn);
+};
+exports.afterRegister = afterRegister;
+const beforeLogin = (fn) => {
+    deviceAuth_1.deviceAuth.registerHook('beforeLogin', fn);
+};
+exports.beforeLogin = beforeLogin;
+const afterLogin = (fn) => {
+    deviceAuth_1.deviceAuth.registerHook('afterLogin', fn);
+};
+exports.afterLogin = afterLogin;

package/dist/src/middlewares/authenticate.middleware.d.ts

@@ -0,0 +1,15 @@
+import type { AdapterUser } from '../adapters/base.adapter';
+interface RequestLike {
+    headers?: Record<string, unknown>;
+    session?: any;
+}
+interface ResponseLike {
+    status(code: number): this;
+    json(body: any): this;
+}
+type NextFunction = () => void;
+export interface AuthenticatedRequest extends RequestLike {
+    user?: AdapterUser | null;
+}
+export declare const authenticate: (req: AuthenticatedRequest, res: ResponseLike, next: NextFunction) => Promise<void>;
+export {};

package/dist/src/middlewares/authenticate.middleware.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authenticate = void 0;
+const deviceAuth_1 = require("../deviceAuth");
+const auth_service_factory_1 = require("../factories/auth-service.factory");
+const sendUnauthorized = (res) => {
+    res.status(401).json({ error: 'Unauthorized' });
+};
+const authenticate = async (req, res, next) => {
+    const config = deviceAuth_1.deviceAuth.config;
+    try {
+        if (config.authType === 'jwt') {
+            const authHeader = req.headers?.['authorization'];
+            if (!authHeader || typeof authHeader !== 'string') {
+                sendUnauthorized(res);
+                return;
+            }
+            const [scheme, token] = authHeader.split(' ');
+            if (scheme !== 'Bearer' || !token) {
+                sendUnauthorized(res);
+                return;
+            }
+            const authService = (0, auth_service_factory_1.createAuthService)();
+            const user = await authService.validateUserFromToken(token);
+            if (!user) {
+                sendUnauthorized(res);
+                return;
+            }
+            req.user = user;
+            next();
+            return;
+        }
+        // Basic session-based auth support: expect req.session.user to be populated by the host app.
+        const sessionUser = req.session?.user;
+        if (!sessionUser) {
+            sendUnauthorized(res);
+            return;
+        }
+        req.user = sessionUser;
+        next();
+    }
+    catch (err) {
+        sendUnauthorized(res);
+    }
+};
+exports.authenticate = authenticate;

package/dist/src/middlewares/authorize.middleware.d.ts

@@ -0,0 +1,8 @@
+import type { AuthenticatedRequest } from './authenticate.middleware';
+interface ResponseLike {
+    status(code: number): this;
+    json(body: any): this;
+}
+type NextFunction = () => void;
+export declare const authorize: (...roles: string[]) => (req: AuthenticatedRequest, res: ResponseLike, next: NextFunction) => void;
+export {};

package/dist/src/middlewares/authorize.middleware.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authorize = void 0;
+const getUserRole = (user) => {
+    const role = user['role'];
+    if (role == null)
+        return null;
+    if (typeof role === 'string')
+        return role;
+    return String(role);
+};
+const sendUnauthorized = (res) => {
+    res.status(401).json({ error: 'Unauthorized' });
+};
+const authorize = (...roles) => {
+    return (req, res, next) => {
+        const fromReq = req.user;
+        const fromSession = req.session?.user;
+        const user = fromReq ?? fromSession ?? null;
+        if (!user) {
+            sendUnauthorized(res);
+            return;
+        }
+        const userRole = getUserRole(user);
+        if (roles.length === 0) {
+            next();
+            return;
+        }
+        if (userRole != null && roles.includes(userRole)) {
+            next();
+            return;
+        }
+        res.status(403).json({ error: 'Forbidden' });
+    };
+};
+exports.authorize = authorize;

package/dist/src/overrides/index.d.ts

@@ -0,0 +1,7 @@
+import type { RegistrationsController } from '../controllers/registrations.controller';
+import type { SessionsController } from '../controllers/sessions.controller';
+export interface ControllerOverrideConfig {
+    registrations?: RegistrationsController;
+    sessions?: SessionsController;
+}
+export declare const applyControllerOverrides: (config: ControllerOverrideConfig) => void;

package/dist/src/overrides/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyControllerOverrides = void 0;
+const deviceAuth_1 = require("../deviceAuth");
+const applyControllerOverrides = (config) => {
+    if (config.registrations) {
+        deviceAuth_1.deviceAuth.override('registrations', config.registrations);
+    }
+    if (config.sessions) {
+        deviceAuth_1.deviceAuth.override('sessions', config.sessions);
+    }
+};
+exports.applyControllerOverrides = applyControllerOverrides;

package/dist/src/routes/auth.routes.d.ts

@@ -0,0 +1,2 @@
+import { Router } from 'express';
+export declare const createAuthRouter: () => Router;

package/dist/src/routes/auth.routes.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthRouter = void 0;
+const express_1 = require("express");
+const registrations_controller_1 = require("../controllers/registrations.controller");
+const sessions_controller_1 = require("../controllers/sessions.controller");
+const createAuthRouter = () => {
+    const router = (0, express_1.Router)();
+    const registrationsController = (0, registrations_controller_1.getRegistrationsController)();
+    const sessionsController = (0, sessions_controller_1.getSessionsController)();
+    router.post('/signup', async (req, res, next) => {
+        try {
+            const data = req.body ?? {};
+            if (!data || typeof data !== 'object' || Array.isArray(data)) {
+                return res.status(400).json({ error: 'Invalid signup payload' });
+            }
+            const result = await registrationsController(data);
+            res.json(result);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'An unexpected error occurred';
+            res.status(400).json({ error: message });
+        }
+    });
+    router.post('/login', async (req, res, next) => {
+        try {
+            const { email, password } = req.body ?? {};
+            if (typeof email !== 'string' || typeof password !== 'string') {
+                return res.status(400).json({ error: 'Invalid login payload' });
+            }
+            const result = await sessionsController(email, password);
+            res.json(result);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'An unexpected error occurred';
+            res.status(400).json({ error: message });
+        }
+    });
+    return router;
+};
+exports.createAuthRouter = createAuthRouter;

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

@@ -0,0 +1,11 @@
+import type { BaseAdapter } from '../adapters/base.adapter';
+import type { DeviceAuthConfig } from '../config';
+export type Role = string;
+export interface User extends Record<string, unknown> {
+    id?: string | number;
+    email?: string;
+    password?: string;
+    role?: Role;
+}
+export type Adapter = BaseAdapter;
+export type Config = DeviceAuthConfig;

package/dist/src/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { pick } from './pick';
+export type { ResponseLike } from './response';
+export { sendJson, sendError, badRequest, unauthorized, forbidden, internalError, } from './response';

package/dist/src/utils/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.internalError = exports.forbidden = exports.unauthorized = exports.badRequest = exports.sendError = exports.sendJson = exports.pick = void 0;
+var pick_1 = require("./pick");
+Object.defineProperty(exports, "pick", { enumerable: true, get: function () { return pick_1.pick; } });
+var response_1 = require("./response");
+Object.defineProperty(exports, "sendJson", { enumerable: true, get: function () { return response_1.sendJson; } });
+Object.defineProperty(exports, "sendError", { enumerable: true, get: function () { return response_1.sendError; } });
+Object.defineProperty(exports, "badRequest", { enumerable: true, get: function () { return response_1.badRequest; } });
+Object.defineProperty(exports, "unauthorized", { enumerable: true, get: function () { return response_1.unauthorized; } });
+Object.defineProperty(exports, "forbidden", { enumerable: true, get: function () { return response_1.forbidden; } });
+Object.defineProperty(exports, "internalError", { enumerable: true, get: function () { return response_1.internalError; } });

package/dist/src/utils/pick.d.ts

@@ -0,0 +1 @@
+export declare const pick: <T extends object, const K extends readonly (keyof T)[]>(source: T, keys: K) => Pick<T, K[number]>;