@cepseudo/adonis-audit-log 1.0.0

package/build/src/models/audit_log.d.ts

@@ -0,0 +1,10 @@
+import { BaseModel } from '@adonisjs/lucid/orm';
+import { DateTime } from 'luxon';
+export default class AuditLog extends BaseModel {
+    static table: string;
+    id: number;
+    actionType: string;
+    metadata: Record<string, unknown>;
+    userId: number | null;
+    createdAt: DateTime;
+}

package/build/src/models/audit_log.js

@@ -0,0 +1,37 @@
+/*
+|--------------------------------------------------------------------------
+| Audit Log Model
+|--------------------------------------------------------------------------
+|
+| Lucid model for the audit_logs table. Stores custom application logs
+| for tracking user actions and business events.
+|
+*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseModel, column } from '@adonisjs/lucid/orm';
+export default class AuditLog extends BaseModel {
+    static table = 'audit_logs';
+}
+__decorate([
+    column({ isPrimary: true })
+], AuditLog.prototype, "id", void 0);
+__decorate([
+    column()
+], AuditLog.prototype, "actionType", void 0);
+__decorate([
+    column({
+        prepare: (value) => JSON.stringify(value),
+        consume: (value) => (typeof value === 'string' ? JSON.parse(value) : value),
+    })
+], AuditLog.prototype, "metadata", void 0);
+__decorate([
+    column()
+], AuditLog.prototype, "userId", void 0);
+__decorate([
+    column.dateTime({ autoCreate: true })
+], AuditLog.prototype, "createdAt", void 0);

package/build/src/models/error_log.d.ts

@@ -0,0 +1,15 @@
+import { BaseModel } from '@adonisjs/lucid/orm';
+import { DateTime } from 'luxon';
+export default class ErrorLog extends BaseModel {
+    static table: string;
+    id: number;
+    errorType: string;
+    message: string;
+    stack: string | null;
+    url: string | null;
+    method: string | null;
+    statusCode: number | null;
+    userId: number | null;
+    context: Record<string, unknown> | null;
+    createdAt: DateTime;
+}

package/build/src/models/error_log.js

@@ -0,0 +1,52 @@
+/*
+|--------------------------------------------------------------------------
+| Error Log Model
+|--------------------------------------------------------------------------
+|
+| Lucid model for the error_logs table. Stores application error tracking
+| data.
+|
+*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseModel, column } from '@adonisjs/lucid/orm';
+export default class ErrorLog extends BaseModel {
+    static table = 'error_logs';
+}
+__decorate([
+    column({ isPrimary: true })
+], ErrorLog.prototype, "id", void 0);
+__decorate([
+    column()
+], ErrorLog.prototype, "errorType", void 0);
+__decorate([
+    column()
+], ErrorLog.prototype, "message", void 0);
+__decorate([
+    column()
+], ErrorLog.prototype, "stack", void 0);
+__decorate([
+    column()
+], ErrorLog.prototype, "url", void 0);
+__decorate([
+    column()
+], ErrorLog.prototype, "method", void 0);
+__decorate([
+    column()
+], ErrorLog.prototype, "statusCode", void 0);
+__decorate([
+    column()
+], ErrorLog.prototype, "userId", void 0);
+__decorate([
+    column({
+        prepare: (value) => (value ? JSON.stringify(value) : null),
+        consume: (value) => value ? (typeof value === 'string' ? JSON.parse(value) : value) : null,
+    })
+], ErrorLog.prototype, "context", void 0);
+__decorate([
+    column.dateTime({ autoCreate: true })
+], ErrorLog.prototype, "createdAt", void 0);

package/build/src/models/request_log.d.ts

@@ -0,0 +1,17 @@
+import { BaseModel } from '@adonisjs/lucid/orm';
+import { DateTime } from 'luxon';
+export default class RequestLog extends BaseModel {
+    static table: string;
+    id: number;
+    method: string;
+    url: string;
+    routeName: string | null;
+    statusCode: number;
+    responseTimeMs: number;
+    ip: string | null;
+    userAgent: string | null;
+    userId: number | null;
+    requestBody: Record<string, unknown> | null;
+    requestQuery: Record<string, unknown> | null;
+    createdAt: DateTime;
+}

package/build/src/models/request_log.js

@@ -0,0 +1,61 @@
+/*
+|--------------------------------------------------------------------------
+| Request Log Model
+|--------------------------------------------------------------------------
+|
+| Lucid model for the request_logs table. Stores automatic HTTP request
+| logging data.
+|
+*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseModel, column } from '@adonisjs/lucid/orm';
+export default class RequestLog extends BaseModel {
+    static table = 'request_logs';
+}
+__decorate([
+    column({ isPrimary: true })
+], RequestLog.prototype, "id", void 0);
+__decorate([
+    column()
+], RequestLog.prototype, "method", void 0);
+__decorate([
+    column()
+], RequestLog.prototype, "url", void 0);
+__decorate([
+    column()
+], RequestLog.prototype, "routeName", void 0);
+__decorate([
+    column()
+], RequestLog.prototype, "statusCode", void 0);
+__decorate([
+    column()
+], RequestLog.prototype, "responseTimeMs", void 0);
+__decorate([
+    column()
+], RequestLog.prototype, "ip", void 0);
+__decorate([
+    column()
+], RequestLog.prototype, "userAgent", void 0);
+__decorate([
+    column()
+], RequestLog.prototype, "userId", void 0);
+__decorate([
+    column({
+        prepare: (value) => (value ? JSON.stringify(value) : null),
+        consume: (value) => value ? (typeof value === 'string' ? JSON.parse(value) : value) : null,
+    })
+], RequestLog.prototype, "requestBody", void 0);
+__decorate([
+    column({
+        prepare: (value) => (value ? JSON.stringify(value) : null),
+        consume: (value) => value ? (typeof value === 'string' ? JSON.parse(value) : value) : null,
+    })
+], RequestLog.prototype, "requestQuery", void 0);
+__decorate([
+    column.dateTime({ autoCreate: true })
+], RequestLog.prototype, "createdAt", void 0);

package/build/src/request_logger.d.ts

@@ -0,0 +1,24 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { AuditConfig } from './types.js';
+import RequestLog from './models/request_log.js';
+export declare class RequestLogger {
+    #private;
+    protected config: AuditConfig;
+    constructor(config: AuditConfig);
+    /**
+     * Check if the request should be logged
+     */
+    shouldLog(ctx: HttpContext): boolean;
+    /**
+     * Sanitize sensitive fields from an object
+     */
+    sanitize(data: Record<string, unknown> | null): Record<string, unknown> | null;
+    /**
+     * Log the request (fire-and-forget, non-blocking)
+     */
+    logAsync(ctx: HttpContext, responseTimeMs: number): void;
+    /**
+     * Log the request (blocking, returns the created log)
+     */
+    log(ctx: HttpContext, responseTimeMs: number): Promise<RequestLog | null>;
+}

package/build/src/request_logger.js

@@ -0,0 +1,130 @@
+/*
+|--------------------------------------------------------------------------
+| Request Logger
+|--------------------------------------------------------------------------
+|
+| Logic for logging HTTP requests. Used by the request logger middleware.
+|
+*/
+import { getUserIdFromContext } from './types.js';
+import RequestLog from './models/request_log.js';
+export class RequestLogger {
+    config;
+    #excludedMethods;
+    #excludedRoutes;
+    #sanitizeFields;
+    constructor(config) {
+        this.config = config;
+        // Pre-compute sets for O(1) lookups
+        this.#excludedMethods = new Set(config.requestLog.excludeMethods);
+        this.#excludedRoutes = config.requestLog.excludeRoutes;
+        this.#sanitizeFields = new Set(config.requestLog.sanitizeFields);
+    }
+    /**
+     * Check if the request should be logged
+     */
+    shouldLog(ctx) {
+        if (!this.config.enabled || !this.config.requestLog.enabled) {
+            return false;
+        }
+        const { request } = ctx;
+        const method = request.method();
+        const url = request.url();
+        // O(1) lookup instead of O(n)
+        if (this.#excludedMethods.has(method)) {
+            return false;
+        }
+        // Check excluded routes
+        for (const excludedRoute of this.#excludedRoutes) {
+            if (url.startsWith(excludedRoute)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Check if object needs sanitization
+     */
+    #needsSanitization(data) {
+        for (const key of Object.keys(data)) {
+            if (this.#sanitizeFields.has(key)) {
+                return true;
+            }
+            const value = data[key];
+            if (typeof value === 'object' &&
+                value !== null &&
+                this.#needsSanitization(value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Sanitize sensitive fields from an object
+     */
+    sanitize(data) {
+        if (!data || this.#sanitizeFields.size === 0) {
+            return data;
+        }
+        // Skip copy if no sanitization needed
+        if (!this.#needsSanitization(data)) {
+            return data;
+        }
+        const sanitized = {};
+        for (const [key, value] of Object.entries(data)) {
+            if (this.#sanitizeFields.has(key)) {
+                sanitized[key] = '[REDACTED]';
+            }
+            else if (typeof value === 'object' && value !== null) {
+                sanitized[key] = this.sanitize(value);
+            }
+            else {
+                sanitized[key] = value;
+            }
+        }
+        return sanitized;
+    }
+    /**
+     * Log the request (fire-and-forget, non-blocking)
+     */
+    logAsync(ctx, responseTimeMs) {
+        if (!this.shouldLog(ctx)) {
+            return;
+        }
+        // Fire-and-forget to not block the response
+        setImmediate(() => {
+            this.#createLog(ctx, responseTimeMs).catch((error) => {
+                console.error('[RequestLogger] Failed to log request:', error);
+            });
+        });
+    }
+    /**
+     * Log the request (blocking, returns the created log)
+     */
+    async log(ctx, responseTimeMs) {
+        if (!this.shouldLog(ctx)) {
+            return null;
+        }
+        return this.#createLog(ctx, responseTimeMs);
+    }
+    async #createLog(ctx, responseTimeMs) {
+        const { request, response, route } = ctx;
+        const entry = {
+            method: request.method(),
+            url: request.url(true),
+            routeName: route?.name ?? null,
+            statusCode: response.getStatus(),
+            responseTimeMs,
+            ip: request.ip(),
+            userAgent: request.header('user-agent')?.substring(0, 512) ?? null,
+            userId: getUserIdFromContext(ctx),
+            requestBody: this.config.requestLog.logBody
+                ? this.sanitize(request.body())
+                : null,
+            requestQuery: this.config.requestLog.logQuery
+                ? this.sanitize(request.qs())
+                : null,
+        };
+        return RequestLog.create(entry);
+    }
+}

package/build/src/types.d.ts

@@ -0,0 +1,94 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Interface for authenticated user with minimal required properties
+ */
+export interface AuthUser {
+    id: number;
+}
+/**
+ * Interface for auth object when @adonisjs/auth is installed
+ */
+export interface AuthContract {
+    user?: AuthUser | null;
+}
+/**
+ * Extended HttpContext that may include auth from @adonisjs/auth package
+ */
+export interface HttpContextWithAuth extends HttpContext {
+    auth?: AuthContract;
+}
+/**
+ * Type guard to check if context has auth
+ */
+export declare function hasAuth(ctx: HttpContext): ctx is HttpContextWithAuth;
+/**
+ * Helper to safely get user ID from context
+ */
+export declare function getUserIdFromContext(ctx: HttpContext): number | null;
+/**
+ * Interface for HTTP errors with status code
+ */
+export interface HttpError extends Error {
+    status?: number;
+    code?: string;
+}
+/**
+ * Type guard to check if error is an HttpError
+ */
+export declare function isHttpError(error: unknown): error is HttpError;
+/**
+ * Helper to get status code from error
+ */
+export declare function getErrorStatusCode(error: unknown): number | undefined;
+export interface AuditConfig {
+    enabled: boolean;
+    requestLog: {
+        enabled: boolean;
+        excludeRoutes: string[];
+        excludeMethods: string[];
+        logBody: boolean;
+        logQuery: boolean;
+        sanitizeFields: string[];
+    };
+    errorLog: {
+        enabled: boolean;
+        excludeStatusCodes: number[];
+        includeStack: boolean;
+    };
+    auditLog: {
+        enabled: boolean;
+    };
+    retention: {
+        requestLogs: number;
+        errorLogs: number;
+        auditLogs: number;
+    };
+}
+export interface AuditLogEntry {
+    actionType: string;
+    metadata: Record<string, unknown>;
+    userId?: number | null;
+}
+export interface RequestLogEntry {
+    method: string;
+    url: string;
+    routeName: string | null;
+    statusCode: number;
+    responseTimeMs: number;
+    ip: string | null;
+    userAgent: string | null;
+    userId: number | null;
+    requestBody: Record<string, unknown> | null;
+    requestQuery: Record<string, unknown> | null;
+}
+export interface ErrorLogEntry {
+    errorType: string;
+    message: string;
+    stack: string | null;
+    url: string | null;
+    method: string | null;
+    statusCode: number | null;
+    userId: number | null;
+    context: Record<string, unknown> | null;
+}
+export declare function defineConfig(config: Partial<AuditConfig>): AuditConfig;

package/build/src/types.js

@@ -0,0 +1,64 @@
+/*
+|--------------------------------------------------------------------------
+| Types
+|--------------------------------------------------------------------------
+|
+| TypeScript interfaces and types for the audit log package.
+|
+*/
+/**
+ * Type guard to check if context has auth
+ */
+export function hasAuth(ctx) {
+    return 'auth' in ctx && ctx.auth !== undefined;
+}
+/**
+ * Helper to safely get user ID from context
+ */
+export function getUserIdFromContext(ctx) {
+    if (hasAuth(ctx)) {
+        return ctx.auth?.user?.id ?? null;
+    }
+    return null;
+}
+/**
+ * Type guard to check if error is an HttpError
+ */
+export function isHttpError(error) {
+    return error instanceof Error;
+}
+/**
+ * Helper to get status code from error
+ */
+export function getErrorStatusCode(error) {
+    if (isHttpError(error)) {
+        return error.status;
+    }
+    return undefined;
+}
+export function defineConfig(config) {
+    return {
+        enabled: config.enabled ?? true,
+        requestLog: {
+            enabled: config.requestLog?.enabled ?? true,
+            excludeRoutes: config.requestLog?.excludeRoutes ?? ['/health', '/metrics'],
+            excludeMethods: config.requestLog?.excludeMethods ?? ['OPTIONS'],
+            logBody: config.requestLog?.logBody ?? false,
+            logQuery: config.requestLog?.logQuery ?? true,
+            sanitizeFields: config.requestLog?.sanitizeFields ?? ['password', 'token', 'secret'],
+        },
+        errorLog: {
+            enabled: config.errorLog?.enabled ?? true,
+            excludeStatusCodes: config.errorLog?.excludeStatusCodes ?? [404],
+            includeStack: config.errorLog?.includeStack ?? true,
+        },
+        auditLog: {
+            enabled: config.auditLog?.enabled ?? true,
+        },
+        retention: {
+            requestLogs: config.retention?.requestLogs ?? 30,
+            errorLogs: config.retention?.errorLogs ?? 90,
+            auditLogs: config.retention?.auditLogs ?? 365,
+        },
+    };
+}

package/build/stubs/config.stub

@@ -0,0 +1,40 @@
+{{{
+  exports({
+    to: app.configPath('audit.ts')
+  })
+}}}
+import { defineConfig } from '@cepseudo/adonis-audit-log'
+
+export default defineConfig({
+  // Enable/disable all logging
+  enabled: true,
+
+  // Request logging options
+  requestLog: {
+    enabled: true,
+    excludeRoutes: ['/health', '/metrics'],
+    excludeMethods: ['OPTIONS'],
+    logBody: false,
+    logQuery: true,
+    sanitizeFields: ['password', 'token', 'secret'],
+  },
+
+  // Error logging options
+  errorLog: {
+    enabled: true,
+    excludeStatusCodes: [404],
+    includeStack: true,
+  },
+
+  // Audit log options
+  auditLog: {
+    enabled: true,
+  },
+
+  // Retention (days) - for cleanup job
+  retention: {
+    requestLogs: 30,
+    errorLogs: 90,
+    auditLogs: 365,
+  },
+})

package/build/stubs/main.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Path to the root directory where the stubs are stored. We use
+ * this path within commands and the configure hook
+ */
+export declare const stubsRoot: string;

package/build/stubs/main.js

@@ -0,0 +1,7 @@
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Path to the root directory where the stubs are stored. We use
+ * this path within commands and the configure hook
+ */
+export const stubsRoot = dirname(fileURLToPath(import.meta.url));

package/build/stubs/migrations/create_audit_logs_table.stub

@@ -0,0 +1,24 @@
+{{#var tableName = 'audit_logs'}}
+{{#var migrationName = 'create_' + tableName + '_table'}}
+import { BaseSchema } from '@adonisjs/lucid/schema'
+
+export default class extends BaseSchema {
+  protected tableName = '{{ tableName }}'
+
+  async up() {
+    this.schema.createTable(this.tableName, (table) => {
+      table.increments('id')
+      table.string('action_type').notNullable().index()
+      table.jsonb('metadata').notNullable().defaultTo('{}')
+      table.integer('user_id').unsigned().nullable().references('id').inTable('users').onDelete('SET NULL')
+      table.timestamp('created_at').notNullable().defaultTo(this.now())
+
+      table.index(['created_at'])
+      table.index(['user_id'])
+    })
+  }
+
+  async down() {
+    this.schema.dropTable(this.tableName)
+  }
+}

package/build/stubs/migrations/create_error_logs_table.stub

@@ -0,0 +1,31 @@
+{{#var tableName = 'error_logs'}}
+{{#var migrationName = 'create_' + tableName + '_table'}}
+import { BaseSchema } from '@adonisjs/lucid/schema'
+
+export default class extends BaseSchema {
+  protected tableName = '{{ tableName }}'
+
+  async up() {
+    this.schema.createTable(this.tableName, (table) => {
+      table.increments('id')
+      table.string('error_type').notNullable()
+      table.text('message').notNullable()
+      table.text('stack').nullable()
+      table.string('url', 2048).nullable()
+      table.string('method', 10).nullable()
+      table.integer('status_code').nullable()
+      table.integer('user_id').unsigned().nullable().references('id').inTable('users').onDelete('SET NULL')
+      table.jsonb('context').nullable()
+      table.timestamp('created_at').notNullable().defaultTo(this.now())
+
+      table.index(['created_at'])
+      table.index(['user_id'])
+      table.index(['error_type'])
+      table.index(['status_code'])
+    })
+  }
+
+  async down() {
+    this.schema.dropTable(this.tableName)
+  }
+}

package/build/stubs/migrations/create_request_logs_table.stub

@@ -0,0 +1,33 @@
+{{#var tableName = 'request_logs'}}
+{{#var migrationName = 'create_' + tableName + '_table'}}
+import { BaseSchema } from '@adonisjs/lucid/schema'
+
+export default class extends BaseSchema {
+  protected tableName = '{{ tableName }}'
+
+  async up() {
+    this.schema.createTable(this.tableName, (table) => {
+      table.increments('id')
+      table.string('method', 10).notNullable()
+      table.string('url', 2048).notNullable()
+      table.string('route_name').nullable()
+      table.integer('status_code').notNullable()
+      table.integer('response_time_ms').notNullable()
+      table.string('ip', 45).nullable()
+      table.string('user_agent', 512).nullable()
+      table.integer('user_id').unsigned().nullable().references('id').inTable('users').onDelete('SET NULL')
+      table.jsonb('request_body').nullable()
+      table.jsonb('request_query').nullable()
+      table.timestamp('created_at').notNullable().defaultTo(this.now())
+
+      table.index(['created_at'])
+      table.index(['user_id'])
+      table.index(['status_code'])
+      table.index(['method'])
+    })
+  }
+
+  async down() {
+    this.schema.dropTable(this.tableName)
+  }
+}