@rapidd/core 2.1.2 → 2.1.4

package/src/auth/Auth.ts

@@ -5,7 +5,8 @@ import { authPrisma } from '../core/prisma';
 import { ErrorResponse } from '../core/errors';
 import { createStore, SessionStoreManager } from './stores';
 import { loadDMMF, findUserModel, findIdentifierFields, findPasswordField } from '../core/dmmf';
-import type { RapiddUser, AuthOptions, AuthMethod, ISessionStore } from '../types';
+import { Logger } from '../utils/Logger';
+import type { RapiddUser, AuthOptions, AuthStrategy, ISessionStore } from '../types';
 
 /**
  * Authentication class for user login, logout, and session management
@@ -26,7 +27,7 @@ import type { RapiddUser, AuthOptions, AuthMethod, ISessionStore } from '../type
 export class Auth {
     options: Required<Pick<AuthOptions, 'passwordField' | 'saltRounds'>> & AuthOptions & {
         identifierFields: string[];
-        methods: AuthMethod[];
+        strategies: AuthStrategy[];
         cookieName: string;
         customHeaderName: string;
         session: { ttl: number; store?: string };
@@ -68,8 +69,8 @@ export class Auth {
                 ...options.jwt,
             },
             saltRounds: options.saltRounds || parseInt(process.env.AUTH_SALT_ROUNDS || '10', 10),
-            methods: options.methods
-                || (process.env.AUTH_METHODS?.split(',').map(s => s.trim()) as AuthMethod[])
+            strategies: options.strategies
+                || (process.env.AUTH_STRATEGIES?.split(',').map(s => s.trim()) as AuthStrategy[])
                 || ['bearer'],
             cookieName: options.cookieName || process.env.AUTH_COOKIE_NAME || 'token',
             customHeaderName: options.customHeaderName || process.env.AUTH_CUSTOM_HEADER || 'X-Auth-Token',
@@ -99,7 +100,7 @@ export class Auth {
         try {
             await loadDMMF();
         } catch {
-            console.warn('[Auth] Could not load DMMF, auth auto-detection skipped');
+            Logger.warn('Auth: could not load DMMF, auto-detection skipped');
             return;
         }
 
@@ -109,7 +110,7 @@ export class Auth {
             // Check if a model name was explicitly configured
             if (!this.options.userModel) {
                 this._authDisabled = true;
-                console.log('[Auth] No user table detected in schema, auth disabled');
+                Logger.log('Auth: no user table detected, auth disabled');
                 return;
             }
             // Model name was set but not found in DMMF — warn but don't disable
@@ -142,7 +143,7 @@ export class Auth {
                 throw new Error('[Auth] JWT_SECRET is required in production. Generate one with: node -e "console.log(require(\'crypto\').randomBytes(32).toString(\'hex\'))"');
             }
             this.options.jwt.secret = crypto.randomBytes(32).toString('hex');
-            console.warn('[Auth] No JWT_SECRET set, using auto-generated secret (sessions won\'t persist across restarts)');
+            Logger.warn('Auth: no JWT_SECRET set, using auto-generated secret (sessions won\'t persist across restarts)');
         }
         if (!this.options.jwt.refreshSecret) {
             if (process.env.NODE_ENV === 'production') {
@@ -173,7 +174,7 @@ export class Auth {
                 this._userModel = (authPrisma as any)[match];
                 return this._userModel;
             }
-            console.warn(`[Auth] userModel="${modelName}" not found in Prisma models`);
+            Logger.warn('Auth: userModel not found in Prisma models', { userModel: modelName });
         }
 
         for (const name of ['users', 'user', 'Users', 'User']) {

package/src/auth/stores/RedisStore.ts

@@ -1,5 +1,6 @@
 import Redis from 'ioredis';
 import { ISessionStore } from './ISessionStore';
+import { Logger } from '../../utils/Logger';
 
 /**
  * Redis session store using ioredis.
@@ -36,11 +37,11 @@ export class RedisStore extends ISessionStore {
             connectTimeout: 5000,
         });
 
-        this.client.on('connect', () => console.log('[RedisStore] Connected'));
-        this.client.on('ready', () => console.log('[RedisStore] Ready'));
-        this.client.on('error', (err: Error) => console.error('[RedisStore] Error:', err.message));
-        this.client.on('close', () => console.warn('[RedisStore] Connection closed'));
-        this.client.on('reconnecting', () => console.log('[RedisStore] Reconnecting...'));
+        this.client.on('connect', () => Logger.log('RedisStore connected'));
+        this.client.on('ready', () => Logger.log('RedisStore ready'));
+        this.client.on('error', (err: Error) => Logger.error(err));
+        this.client.on('close', () => Logger.warn('RedisStore connection closed'));
+        this.client.on('reconnecting', () => Logger.log('RedisStore reconnecting'));
 
         this._initialized = true;
         return this.client;

package/src/auth/stores/index.ts

@@ -1,6 +1,7 @@
 import { ISessionStore } from './ISessionStore';
 import { MemoryStore } from './MemoryStore';
 import { RedisStore } from './RedisStore';
+import { Logger } from '../../utils/Logger';
 
 const builtInStores: Record<string, new (options?: any) => ISessionStore> = {
     memory: MemoryStore,
@@ -41,7 +42,7 @@ export class SessionStoreManager extends ISessionStore {
 
         const StoreClass = builtInStores[this.storeName];
         if (!StoreClass) {
-            console.warn(`[SessionStore] Unknown store "${this.storeName}", using memory`);
+            Logger.warn('SessionStore: unknown store, using memory', { store: this.storeName });
             this._primaryStore = this._fallbackStore;
             this._initialized = true;
             return;
@@ -50,7 +51,7 @@ export class SessionStoreManager extends ISessionStore {
         try {
             this._primaryStore = new StoreClass({ ttl: this.ttl });
         } catch (err) {
-            console.warn(`[SessionStore] Failed to create ${this.storeName}: ${(err as Error).message}, using memory`);
+            Logger.warn('SessionStore: failed to create store, using memory', { store: this.storeName, error: (err as Error).message });
             this._primaryStore = this._fallbackStore;
         }
 
@@ -70,15 +71,15 @@ export class SessionStoreManager extends ISessionStore {
         try {
             const isHealthy = await this._primaryStore!.isHealthy();
             if (isHealthy && this._usingFallback) {
-                console.log(`[SessionStore] ${this.storeName} recovered, switching back from memory`);
+                Logger.log('SessionStore: recovered, switching back from memory', { store: this.storeName });
                 this._usingFallback = false;
             } else if (!isHealthy && !this._usingFallback) {
-                console.warn(`[SessionStore] ${this.storeName} unavailable, switching to memory`);
+                Logger.warn('SessionStore: unavailable, switching to memory', { store: this.storeName });
                 this._usingFallback = true;
             }
         } catch {
             if (!this._usingFallback) {
-                console.warn(`[SessionStore] ${this.storeName} health check failed, switching to memory`);
+                Logger.warn('SessionStore: health check failed, switching to memory', { store: this.storeName });
                 this._usingFallback = true;
             }
         }
@@ -98,7 +99,7 @@ export class SessionStoreManager extends ISessionStore {
         try {
             return await (this._primaryStore as any)[operation](...args);
         } catch (err) {
-            console.warn(`[SessionStore] ${this.storeName}.${operation} failed: ${(err as Error).message}, switching to memory`);
+            Logger.warn('SessionStore: operation failed, switching to memory', { store: this.storeName, operation, error: (err as Error).message });
             this._usingFallback = true;
             return (this._fallbackStore as any)[operation](...args);
         }

package/src/core/env.ts

@@ -51,6 +51,10 @@ export interface EnvConfig {
 
     // Proxy
     TRUST_PROXY?: boolean;
+
+    // Logging
+    LOG_LEVEL: 'essential' | 'fine' | 'finest';
+    LOG_DIR: string;
 }
 
 const REQUIRED_VARS = [
@@ -76,7 +80,9 @@ const DEFAULTS: Partial<Record<keyof EnvConfig, string | number | boolean>> = {
     REDIS_PORT: 6379,
     REDIS_DB_RATE_LIMIT: 0,
     REDIS_DB_AUTH: 1,
-    RLS_NAMESPACE: 'app'
+    RLS_NAMESPACE: 'app',
+    LOG_LEVEL: 'essential',
+    LOG_DIR: 'logs',
 };
 
 /**

package/src/core/i18n.ts

@@ -1,5 +1,6 @@
 import { readdirSync } from 'fs';
 import path from 'path';
+import { Logger } from '../utils/Logger';
 
 const ROOT = process.env.ROOT || '';
 const DEFAULT_STRINGS_PATH = ROOT ? path.join(ROOT, 'locales') : './locale';
@@ -40,14 +41,14 @@ export class LanguageDict {
                         this._dictionaries[langCode] = require(dictPath);
                         this._available.push(langCode);
                     } catch (error) {
-                        console.error(`Failed to load dictionary for ${langCode}:`, (error as Error).message);
+                        Logger.error(error as Error, { langCode });
                     }
                 }
             }
 
             this._initialized = true;
         } catch (error) {
-            console.error('Failed to initialize LanguageDict:', (error as Error).message);
+            Logger.error(error as Error);
             this._dictionaries = {};
             this._available = [];
         }

package/src/index.ts

@@ -44,6 +44,7 @@ export { modelMiddleware } from './core/middleware';
 // ── Utilities ────────────────────────────────────────────────────────────────
 export { ApiClient, ApiClientError } from './utils/ApiClient';
 export { Mailer } from './utils/Mailer';
+export { Logger } from './utils/Logger';
 export { env } from './utils';
 
 // ── Environment ──────────────────────────────────────────────────────────────
@@ -73,7 +74,7 @@ export { buildApp } from './app';
 // ── Types ────────────────────────────────────────────────────────────────────
 export type {
     RapiddUser,
-    AuthMethod,
+    AuthStrategy,
     RouteAuthConfig,
     ModelOptions,
     GetManyResult,
@@ -110,3 +111,4 @@ export type {
 } from './plugins/upload';
 
 export type { EnvConfig } from './core/env';
+export type { LogLevel } from './utils/Logger';

package/src/orm/QueryBuilder.ts

@@ -1,5 +1,7 @@
 import { prisma, prismaTransaction, getAcl } from '../core/prisma';
 import { ErrorResponse } from '../core/errors';
+import { LanguageDict } from '../core/i18n';
+import { Logger } from '../utils/Logger';
 import * as dmmf from '../core/dmmf';
 import type {
     RelationConfig,
@@ -2065,13 +2067,13 @@ class QueryBuilder {
      * Handle Prisma errors and convert to standardized error responses
      */
     static errorHandler(error: any, data: Record<string, unknown> = {}): QueryErrorResponse {
-        console.error(error);
+        Logger.error(error);
 
         // Default values
         let statusCode: number = error.status_code || 500;
         let message: string = error instanceof ErrorResponse
             ? error.message
-            : (process.env.NODE_ENV === 'production' ? 'Something went wrong' : (error.message || String(error)));
+            : (process.env.NODE_ENV === 'production' ? LanguageDict.get('internal_server_error') : (error.message || String(error)));
 
         // Handle Prisma error codes
         if (error?.code && PRISMA_ERROR_MAP[error.code]) {
@@ -2082,7 +2084,7 @@ class QueryBuilder {
             if (error.code === 'P2002') {
                 const target = error.meta?.target;
                 const modelName = error.meta?.modelName;
-                message = `Duplicate entry for ${modelName}. Record with ${target}: '${data[target as string]}' already exists`;
+                message = LanguageDict.get('duplicate_entry', { model: modelName, field: target, value: data[target as string] });
             } else {
                 message = errorInfo.message!;
             }

package/src/plugins/auth.ts

@@ -3,7 +3,7 @@ import { FastifyPluginAsync, FastifyRequest } from 'fastify';
 import fp from 'fastify-plugin';
 import { Auth } from '../auth/Auth';
 import { ErrorResponse } from '../core/errors';
-import type { RapiddUser, AuthOptions, AuthMethod, RouteAuthConfig } from '../types';
+import type { RapiddUser, AuthOptions, AuthStrategy, RouteAuthConfig } from '../types';
 
 interface AuthPluginOptions {
     auth?: Auth;
@@ -36,42 +36,42 @@ const authPlugin: FastifyPluginAsync<AuthPluginOptions> = async (fastify, option
         return;
     }
 
-    // Load endpointAuthMethod from config/app.json (prefix → method(s) mapping)
-    let endpointAuthMethod: Record<string, AuthMethod | AuthMethod[] | null> = {};
+    // Load endpointAuthStrategy from config/app.json (prefix → strategy mapping)
+    let endpointAuthStrategy: Record<string, AuthStrategy | AuthStrategy[] | null> = {};
     try {
         const appConfig = require(path.join(process.cwd(), 'config', 'app.json'));
-        if (appConfig.endpointAuthMethod) {
-            endpointAuthMethod = appConfig.endpointAuthMethod;
+        if (appConfig.endpointAuthStrategy) {
+            endpointAuthStrategy = appConfig.endpointAuthStrategy;
         }
     } catch {
-        // No app.json or no endpointAuthMethod — use global default
+        // No app.json or no endpointAuthStrategy — use global default
     }
 
     // Pre-sort prefixes by length (longest first) for correct matching
-    const sortedPrefixes = Object.keys(endpointAuthMethod)
+    const sortedPrefixes = Object.keys(endpointAuthStrategy)
         .sort((a, b) => b.length - a.length);
 
-    // Parse auth on every request using configured methods (checked in order).
-    // Priority: route config > endpointAuthMethod prefix match > global default
+    // Parse auth on every request using configured strategies (checked in order).
+    // Priority: route config > endpointAuthStrategy prefix match > global default
     fastify.addHook('onRequest', async (request) => {
         const routeAuth = (request.routeOptions?.config as any)?.auth as RouteAuthConfig | undefined;
 
-        let methods: AuthMethod[];
-        if (routeAuth?.methods) {
-            methods = routeAuth.methods;
+        let strategies: AuthStrategy[];
+        if (routeAuth?.strategies) {
+            strategies = routeAuth.strategies;
         } else {
             const matchedPrefix = sortedPrefixes.find(p => request.url.startsWith(p));
             if (matchedPrefix) {
-                const value = endpointAuthMethod[matchedPrefix];
+                const value = endpointAuthStrategy[matchedPrefix];
                 if (value === null) {
-                    methods = auth.options.methods;
+                    strategies = auth.options.strategies;
                 } else if (typeof value === 'string') {
-                    methods = [value];
+                    strategies = [value];
                 } else {
-                    methods = value;
+                    strategies = value;
                 }
             } else {
-                methods = auth.options.methods;
+                strategies = auth.options.strategies;
             }
         }
 
@@ -80,10 +80,10 @@ const authPlugin: FastifyPluginAsync<AuthPluginOptions> = async (fastify, option
 
         let user: RapiddUser | null = null;
 
-        for (const method of methods) {
+        for (const strategy of strategies) {
             if (user) break;
 
-            switch (method) {
+            switch (strategy) {
                 case 'bearer': {
                     const h = request.headers.authorization;
                     if (h?.startsWith('Bearer ')) {
@@ -125,7 +125,7 @@ const authPlugin: FastifyPluginAsync<AuthPluginOptions> = async (fastify, option
     fastify.post('/auth/login', async (request, reply) => {
         const result = await auth.login(request.body as { user: string; password: string });
 
-        if (auth.options.methods.includes('cookie')) {
+        if (auth.options.strategies.includes('cookie')) {
             reply.setCookie(auth.options.cookieName, result.accessToken, {
                 path: '/',
                 httpOnly: true,
@@ -141,7 +141,7 @@ const authPlugin: FastifyPluginAsync<AuthPluginOptions> = async (fastify, option
     fastify.post('/auth/logout', async (request, reply) => {
         const result = await auth.logout(request.headers.authorization);
 
-        if (auth.options.methods.includes('cookie')) {
+        if (auth.options.strategies.includes('cookie')) {
             reply.clearCookie(auth.options.cookieName, { path: '/' });
         }
 

package/src/plugins/language.ts

@@ -37,22 +37,22 @@ function resolveLanguage(headerValue: string): string {
             .split(',')
             .map((lang: string) => {
                 const parts = lang.trim().split(';');
-                const code = parts[0].trim();
+                const code = parts[0].trim().replace(/-/g, '_');
                 const quality = parts[1] ? parseFloat(parts[1].replace('q=', '')) : 1.0;
                 return { code, quality };
             })
             .sort((a, b) => b.quality - a.quality);
 
-        // Exact match
+        // Exact match (e.g. "de_DE" header → "de_DE" locale)
         for (const lang of languages) {
             const match = ALLOWED_LANGUAGES.find((a: string) => a.toLowerCase() === lang.code);
             if (match) return match;
         }
 
-        // Language family match (e.g. "en-GB" → "en_US")
+        // Language family match (e.g. "en_GB" header → "en_US" locale)
         for (const lang of languages) {
-            const prefix = lang.code.split('-')[0];
-            const match = ALLOWED_LANGUAGES.find((a: string) => a.toLowerCase().startsWith(prefix + '-'));
+            const prefix = lang.code.split('_')[0];
+            const match = ALLOWED_LANGUAGES.find((a: string) => a.toLowerCase().startsWith(prefix + '_'));
             if (match) return match;
         }
     } catch {

package/src/plugins/response.ts

@@ -2,6 +2,7 @@ import { FastifyPluginAsync, FastifyReply, FastifyRequest } from 'fastify';
 import fp from 'fastify-plugin';
 import { ErrorResponse, ErrorBasicResponse } from '../core/errors';
 import { LanguageDict } from '../core/i18n';
+import { Logger } from '../utils/Logger';
 import type { ListMeta } from '../types';
 
 /**
@@ -37,7 +38,7 @@ const responsePlugin: FastifyPluginAsync = async (fastify) => {
         const request = this.request;
         const language = request?.language || 'en_US';
         const error = new ErrorResponse(statusCode, message, data as Record<string, unknown> | null);
-        console.error(`Error ${statusCode}: ${message}`);
+        Logger.error(message, { statusCode });
         return this.code(statusCode).send(error.toJSON(language));
     });
 
@@ -69,10 +70,10 @@ const responsePlugin: FastifyPluginAsync = async (fastify) => {
         const err = error as Error;
         const message =
             Object.getPrototypeOf(err).constructor === Error && process.env.NODE_ENV === 'production'
-                ? 'Something went wrong'
+                ? LanguageDict.get('internal_server_error', null, language)
                 : err.message || String(error);
 
-        console.error(error);
+        Logger.error(error);
         return reply.code(status).send({ status_code: status, message });
     });
 };

package/src/plugins/upload.ts

@@ -5,6 +5,7 @@ import { pipeline } from 'stream/promises';
 import { Transform } from 'stream';
 import { randomUUID } from 'crypto';
 import path from 'path';
+import { ErrorResponse } from '../core/errors';
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -85,9 +86,9 @@ function getAllowedTypes(option: UploadOptions['allowedTypes']): AllowedType[] {
 function validateFile(
     file: { mimetype: string; filename: string },
     allowedTypes: AllowedType[]
-): { valid: boolean; error?: string } {
+): { valid: boolean; errorKey?: string; errorData?: Record<string, unknown> } {
     if (file.filename.includes('..') || file.filename.includes('/') || file.filename.includes('\\')) {
-        return { valid: false, error: 'Invalid filename' };
+        return { valid: false, errorKey: 'invalid_file_name' };
     }
 
     if (allowedTypes.length === 0) {
@@ -98,11 +99,11 @@ function validateFile(
     const allowedType = allowedTypes.find(t => t.mime === file.mimetype);
 
     if (!allowedType) {
-        return { valid: false, error: `File type '${file.mimetype}' not allowed` };
+        return { valid: false, errorKey: 'file_type_not_allowed', errorData: { mimetype: file.mimetype } };
     }
 
     if (!allowedType.extensions.includes(ext)) {
-        return { valid: false, error: `Extension '${ext}' does not match MIME type '${file.mimetype}'` };
+        return { valid: false, errorKey: 'file_extension_not_allowed', errorData: { extension: ext, mimetype: file.mimetype } };
     }
 
     return { valid: true };
@@ -114,7 +115,7 @@ function createSizeTracker(maxSize: number): { tracker: Transform; getSize: () =
         transform(chunk, encoding, callback) {
             size += chunk.length;
             if (size > maxSize) {
-                callback(new Error(`File size exceeds limit of ${Math.round(maxSize / 1024 / 1024)}MB`));
+                callback(new ErrorResponse(400, 'file_size_exceeds_limit', { limit: Math.round(maxSize / 1024 / 1024) }));
                 return;
             }
             callback(null, chunk);
@@ -229,7 +230,7 @@ async function uploadPluginImpl(
 
             const validation = validateFile(data, allowedTypes);
             if (!validation.valid) {
-                throw new Error(validation.error);
+                throw new ErrorResponse(400, validation.errorKey!, validation.errorData);
             }
 
             const { tempPath, size } = await saveToTemp(data.file, tempDir, data.filename, maxFileSize);
@@ -260,7 +261,7 @@ async function uploadPluginImpl(
 
                 const validation = validateFile(part, allowedTypes);
                 if (!validation.valid) {
-                    throw new Error(validation.error);
+                    throw new ErrorResponse(400, validation.errorKey!, validation.errorData);
                 }
 
                 const { tempPath, size } = await saveToTemp(part.file, tempDir, part.filename, maxFileSize);

package/src/types.ts

@@ -10,10 +10,10 @@ export interface RapiddUser {
     [key: string]: unknown;
 }
 
-export type AuthMethod = 'bearer' | 'basic' | 'cookie' | 'header';
+export type AuthStrategy = 'bearer' | 'basic' | 'cookie' | 'header';
 
 export interface RouteAuthConfig {
-    methods?: AuthMethod[];
+    strategies?: AuthStrategy[];
     cookieName?: string;
     customHeaderName?: string;
 }
@@ -32,7 +32,7 @@ export interface AuthOptions {
         refreshExpiry?: string;
     };
     saltRounds?: number;
-    methods?: AuthMethod[];
+    strategies?: AuthStrategy[];
     cookieName?: string;
     customHeaderName?: string;
 }