@zintrust/core 0.4.26 → 0.4.28

package/app/Jobs/EmailJobService.js

@@ -0,0 +1,113 @@
+import { EmailQueue } from '../Workers/EmailWorker.js';
+import Logger from '../../src/config/logger.js';
+export const EmailJobService = Object.freeze({
+    /**
+     * Send a welcome email using worker queue
+     */
+    async sendWelcome(to, userName, _queueName = 'default') {
+        const payload = {
+            to,
+            subject: 'Welcome to ZinTrust!',
+            template: 'welcome',
+            templateData: {
+                name: userName,
+                action_url: 'https://app.zintrust.com/dashboard',
+                action_text: 'Get Started',
+            },
+        };
+        // Queue job for persistence and monitoring
+        const jobId = await EmailQueue.add(payload, _queueName);
+        // Process immediately for fast delivery
+        Logger.info('Welcome email job queued and waiting to be processed', { jobId, to, userName });
+        return jobId;
+    },
+    /**
+     * Send a password reset email using the worker queue
+     */
+    async sendPasswordReset(to, resetToken) {
+        const payload = {
+            to,
+            subject: 'Reset Your Password',
+            template: 'password-reset',
+            templateData: {
+                name: to.split('@')[0], // Extract username from email
+                reset_link: `https://zintrust.com/reset-password?token=${resetToken}`,
+                action_text: 'Reset Password',
+            },
+        };
+        // Queue job for persistence and monitoring
+        const jobId = await EmailQueue.add(payload);
+        // Process immediately for fast delivery
+        Logger.info('Password reset email job queued and processed', { jobId, to });
+        return jobId;
+    },
+    /**
+     * Send a worker alert email using the worker queue
+     */
+    async sendWorkerAlert(to, workerName, error, jobId) {
+        const payload = {
+            to,
+            subject: `Worker Alert: ${workerName}`,
+            template: 'worker-alert',
+            templateData: {
+                name: to.split('@')[0],
+                alert_level: 'ERROR',
+                alert_message: `Worker ${workerName} encountered an error`,
+                worker_name: workerName,
+                queue_name: 'default',
+                job_id: jobId ?? 'unknown',
+                error_message: error,
+                dashboard_url: 'https://app.zintrust.com/admin/workers',
+            },
+        };
+        const queueJobId = await EmailQueue.add(payload, 'worker-alerts');
+        Logger.info('Worker alert email job queued', { queueJobId, to, workerName });
+        return queueJobId;
+    },
+    /**
+     * Send a general notification email using the worker queue
+     */
+    async sendGeneral(to, subject, message, options = {}) {
+        const payload = {
+            to,
+            subject,
+            template: 'general',
+            templateData: {
+                name: to.split('@')[0],
+                headline: subject,
+                message,
+                primary_color: options.primaryColor ?? '#3b82f6',
+                action_url: options.actionUrl ?? null,
+                action_text: options.actionText ?? 'View Details',
+            },
+        };
+        const jobId = await EmailQueue.add(payload);
+        Logger.info('General email job queued', { jobId, to, subject });
+        return jobId;
+    },
+    /**
+     * Send a custom email with any template
+     */
+    async sendCustom(to, subject, template, templateData) {
+        const payload = {
+            to,
+            subject,
+            template,
+            templateData: {
+                ...templateData,
+                name: Object.hasOwn(templateData, 'name') ? String(templateData['name']) : to.split('@')[0],
+            },
+        };
+        const jobId = await EmailQueue.add(payload);
+        Logger.info('Custom email job queued', { jobId, to, subject, template });
+        return jobId;
+    },
+});
+export default EmailJobService;
+// Test samples pulled from docs/advanced-queue-patterns.md
+// These are small excerpts used by unit tests to ensure docs content is available
+export const testSamples = Object.freeze({
+    advancedQueuePatternsHeadline: 'Advanced Queue Patterns',
+    uniqueIdExample: "await Queue.enqueue('email', { to: 'user@example.com', template: 'welcome' }, { uniqueId: `welcome-email-${userId}` })",
+    releaseAfterExample: "deduplication: { id: 'daily-cleanup', ttl: 86400000, releaseAfter: 3600000 }",
+});

package/app/Middleware/AuthFailureResponder.d.ts

@@ -0,0 +1,3 @@
+import type { MiddlewareFailureResponder } from '../../src/middleware/MiddlewareFailureResponder';
+export declare const authFailureResponder: MiddlewareFailureResponder;
+//# sourceMappingURL=AuthFailureResponder.d.ts.map

package/app/Middleware/AuthFailureResponder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthFailureResponder.d.ts","sourceRoot":"","sources":["../../../app/Middleware/AuthFailureResponder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,wCAAwC,CAAC;AAEzF,eAAO,MAAM,oBAAoB,EAAE,0BAOlC,CAAC"}

package/app/Middleware/AuthFailureResponder.js

@@ -0,0 +1,8 @@
+export const authFailureResponder = async (_req, res, context) => {
+    res.setStatus(context.statusCode).json({
+        error: {
+            code: context.reason,
+            message: context.message,
+        },
+    });
+};

package/app/Middleware/ProfilerMiddleware.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Profiler Middleware
+ * Enables request profiling when ENABLE_PROFILER environment variable is set
+ */
+import type { Middleware } from '../../src/middleware/MiddlewareStack';
+/**
+ * ProfilerMiddleware wraps request execution with performance profiling
+ * Enabled via ENABLE_PROFILER=true environment variable
+ * Attaches profiling report to response headers
+ */
+export declare const ProfilerMiddleware: Middleware;
+//# sourceMappingURL=ProfilerMiddleware.d.ts.map

package/app/Middleware/ProfilerMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProfilerMiddleware.d.ts","sourceRoot":"","sources":["../../../app/Middleware/ProfilerMiddleware.ts"],"names":[],"mappings":"AACA;;;GAGG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAG9D;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,UAwChC,CAAC"}

package/app/Middleware/ProfilerMiddleware.js

@@ -0,0 +1,47 @@
+// @ts-nocheck - Example middleware - WIP
+/**
+ * Profiler Middleware
+ * Enables request profiling when ENABLE_PROFILER environment variable is set
+ */
+import { Logger } from '../../src/config/logger.js';
+import { RequestProfiler } from '../../src/profiling/RequestProfiler.js';
+/**
+ * ProfilerMiddleware wraps request execution with performance profiling
+ * Enabled via ENABLE_PROFILER=true environment variable
+ * Attaches profiling report to response headers
+ */
+export const ProfilerMiddleware = async (req, res, next) => {
+    const isEnabled = process.env.ENABLE_PROFILER === 'true';
+    if (!isEnabled) {
+        // Pass through without profiling
+        await next();
+        return;
+    }
+    const profiler = RequestProfiler.create();
+    const queryLogger = profiler.getQueryLogger();
+    // Set up query logging if database is available
+    const db = req.context.db;
+    if (db !== undefined && db !== null && typeof db.onAfterQuery === 'function') {
+        db.onAfterQuery((sql, params, duration) => {
+            queryLogger.logQuery(sql, params, duration, 'middleware-profiling');
+        });
+    }
+    // Capture request execution
+    const profile = await profiler.captureRequest(async () => next());
+    // Attach profile to response
+    res.locals.profile = profile;
+    // Add profiling report to response header
+    try {
+        const report = profiler.generateReport(profile);
+        res.setHeader('X-Profiler-Report', Buffer.from(report).toString('base64'));
+        res.setHeader('X-Profiler-Queries', profile.queriesExecuted.toString());
+        res.setHeader('X-Profiler-Duration', profile.duration.toString());
+        if (profile.n1Patterns.length > 0) {
+            res.setHeader('X-Profiler-N1-Patterns', profile.n1Patterns.length.toString());
+        }
+    }
+    catch (error) {
+        // Silently fail if header encoding fails
+        Logger.error('Failed to encode profiler report header:', error);
+    }
+};

package/app/Middleware/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Example Middleware
+ * Common middleware patterns for ZinTrust
+ */
+import type { IRequest } from '../../src/http/Request';
+import type { IResponse } from '../../src/http/Response';
+import type { CsrfTokenManagerType, ICsrfTokenManager } from '../../src/security/CsrfTokenManager';
+import type { IJwtManager, JwtAlgorithm, JwtManagerType } from '../../src/security/JwtManager';
+import type { SchemaType } from '../../src/validation/Validator';
+type JwtManagerInput = IJwtManager | JwtManagerType;
+type CsrfManagerInput = ICsrfTokenManager | CsrfTokenManagerType;
+/**
+ * Authentication Middleware
+ * Verify user is authenticated
+ */
+export declare const authMiddleware: (req: IRequest, res: IResponse, next: () => Promise<void>) => Promise<void>;
+/**
+ * CORS Middleware
+ * Handle CORS headers
+ */
+export declare const corsMiddleware: (req: IRequest, res: IResponse, next: () => Promise<void>) => Promise<void>;
+/**
+ * JSON Request Middleware
+ * Parse JSON request bodies
+ */
+export declare const jsonMiddleware: (req: IRequest, res: IResponse, next: () => Promise<void>) => Promise<void>;
+/**
+ * Logging Middleware
+ * Log all requests
+ */
+export declare const loggingMiddleware: (req: IRequest, res: IResponse, next: () => Promise<void>) => Promise<void>;
+export declare const rateLimitMiddleware: (req: IRequest, res: IResponse, next: () => Promise<void>) => Promise<void>;
+/**
+ * Trailing Slash Middleware
+ * Redirect URLs with trailing slashes
+ */
+export declare const trailingSlashMiddleware: (req: IRequest, res: IResponse, next: () => Promise<void>) => Promise<void>;
+/**
+ * JWT Authentication Middleware
+ * Verify JWT token and extract claims
+ */
+export declare const jwtMiddleware: (jwtManager: JwtManagerInput, algorithm?: JwtAlgorithm) => (req: IRequest, res: IResponse, next: () => Promise<void>) => Promise<void>;
+export { authFailureResponder } from '../Middleware/AuthFailureResponder';
+/**
+ * CSRF Protection Middleware
+ * Validate CSRF tokens for state-changing requests
+ */
+export declare const csrfMiddleware: (csrfManager: CsrfManagerInput) => (req: IRequest, res: IResponse, next: () => Promise<void>) => Promise<void>;
+/**
+ * Input Validation Middleware
+ * Validate request body against schema
+ */
+export declare const validationMiddleware: (schema: SchemaType) => (req: IRequest, res: IResponse, next: () => Promise<void>) => Promise<void>;
+/**
+ * XSS Protection Middleware
+ * Sanitize and escape user input
+ */
+export declare const xssProtectionMiddleware: (req: IRequest, res: IResponse, next: () => Promise<void>) => Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/app/Middleware/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../app/Middleware/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC1F,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGtF,OAAO,KAAK,EAAW,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAGjE,KAAK,eAAe,GAAG,WAAW,GAAG,cAAc,CAAC;AACpD,KAAK,gBAAgB,GAAG,iBAAiB,GAAG,oBAAoB,CAAC;AAajE;;;GAGG;AACH,eAAO,MAAM,cAAc,GACzB,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,KACxB,OAAO,CAAC,IAAI,CASd,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,GACzB,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,KACxB,OAAO,CAAC,IAAI,CAWd,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,GACzB,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,KACxB,OAAO,CAAC,IAAI,CAYd,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAC5B,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,KACxB,OAAO,CAAC,IAAI,CAYd,CAAC;AAQF,eAAO,MAAM,mBAAmB,GAC9B,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,KACxB,OAAO,CAAC,IAAI,CAsBd,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAClC,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,KACxB,OAAO,CAAC,IAAI,CAUd,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAI,YAAY,eAAe,EAAE,YAAW,YAAsB,MAC5E,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,KAAG,OAAO,CAAC,IAAI,CAgCtF,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAE5E;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,aAAa,gBAAgB,MAC5C,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,KAAG,OAAO,CAAC,IAAI,CAmCtF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,UAAU,MACvC,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,KAAG,OAAO,CAAC,IAAI,CAwBtF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAClC,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,KACxB,OAAO,CAAC,IAAI,CAiBd,CAAC"}

package/app/Middleware/index.js

@@ -0,0 +1,216 @@
+/**
+ * Example Middleware
+ * Common middleware patterns for ZinTrust
+ */
+import { Logger } from '../../src/config/logger.js';
+import { JwtSessions } from '../../src/security/JwtSessions.js';
+import { XssProtection } from '../../src/security/XssProtection.js';
+import { Validator } from '../../src/validation/Validator.js';
+const resolveJwtManager = (jwtManager) => 'verify' in jwtManager ? jwtManager : jwtManager.create();
+const resolveCsrfManager = (csrfManager) => 'validateToken' in csrfManager ? csrfManager : csrfManager.create();
+const resolveSchema = (schema) => 'getRules' in schema ? schema : schema.create();
+/**
+ * Authentication Middleware
+ * Verify user is authenticated
+ */
+export const authMiddleware = async (req, res, next) => {
+    const token = req.getHeader('authorization');
+    if (token === undefined || token === '') {
+        res.setStatus(401).json({ error: 'Unauthorized' });
+        return;
+    }
+    await next();
+};
+/**
+ * CORS Middleware
+ * Handle CORS headers
+ */
+export const corsMiddleware = async (req, res, next) => {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+    if (req.getMethod() === 'OPTIONS') {
+        res.setStatus(200).send('');
+        return;
+    }
+    await next();
+};
+/**
+ * JSON Request Middleware
+ * Parse JSON request bodies
+ */
+export const jsonMiddleware = async (req, res, next) => {
+    if (req.getMethod() === 'GET' || req.getMethod() === 'DELETE') {
+        await next();
+        return;
+    }
+    if (req.isJson() === false) {
+        res.setStatus(415).json({ error: 'Content-Type must be application/json' });
+        return;
+    }
+    await next();
+};
+/**
+ * Logging Middleware
+ * Log all requests
+ */
+export const loggingMiddleware = async (req, res, next) => {
+    const startTime = Date.now();
+    const method = req.getMethod();
+    const path = req.getPath();
+    Logger.info(`→ ${method} ${path}`);
+    await next();
+    const duration = Date.now() - startTime;
+    const status = res.getStatus();
+    Logger.info(`← ${status} ${method} ${path} (${duration}ms)`);
+};
+/**
+ * Rate Limiting Middleware
+ * Simple in-memory rate limiting
+ */
+const requestCounts = new Map();
+export const rateLimitMiddleware = async (req, res, next) => {
+    const ip = req.getRaw().socket.remoteAddress ?? 'unknown';
+    const now = Date.now();
+    const windowMs = 60 * 1000; // 1 minute
+    const maxRequests = 100;
+    if (requestCounts.has(ip) === false) {
+        requestCounts.set(ip, []);
+    }
+    const requests = requestCounts.get(ip) ?? [];
+    const recentRequests = requests.filter((time) => now - time < windowMs);
+    if (recentRequests.length >= maxRequests) {
+        res.setStatus(429).json({ error: 'Too many requests' });
+        return;
+    }
+    recentRequests.push(now);
+    requestCounts.set(ip, recentRequests);
+    await next();
+};
+/**
+ * Trailing Slash Middleware
+ * Redirect URLs with trailing slashes
+ */
+export const trailingSlashMiddleware = async (req, res, next) => {
+    const path = req.getPath();
+    if (path.length > 1 && path.endsWith('/') === true) {
+        const withoutSlash = path.slice(0, -1);
+        res.redirect(withoutSlash, 301);
+        return;
+    }
+    await next();
+};
+/**
+ * JWT Authentication Middleware
+ * Verify JWT token and extract claims
+ */
+export const jwtMiddleware = (jwtManager, algorithm = 'HS256') => {
+    return async (req, res, next) => {
+        const authHeader = req.getHeader('authorization');
+        if (authHeader === undefined || authHeader === '') {
+            res.setStatus(401).json({ error: 'Missing authorization header' });
+            return;
+        }
+        const authHeaderStr = (Array.isArray(authHeader) ? authHeader[0] : authHeader).trim();
+        const [scheme, ...rest] = authHeaderStr.split(/\s+/);
+        const token = rest.join(' ').trim();
+        if (scheme.toLowerCase() !== 'bearer' || token === '') {
+            res.setStatus(401).json({ error: 'Invalid authorization header format' });
+            return;
+        }
+        try {
+            if (!(await JwtSessions.isActive(token))) {
+                res.setStatus(401).json({ error: 'Invalid or expired token' });
+                return;
+            }
+            const payload = resolveJwtManager(jwtManager).verify(token, algorithm);
+            // Store in request context (TypeScript allows dynamic properties)
+            req.user = payload;
+            await next();
+        }
+        catch (error) {
+            Logger.error('JWT verification failed:', error);
+            res.setStatus(401).json({ error: 'Invalid or expired token' });
+        }
+    };
+};
+export { authFailureResponder } from '../Middleware/AuthFailureResponder.js';
+/**
+ * CSRF Protection Middleware
+ * Validate CSRF tokens for state-changing requests
+ */
+export const csrfMiddleware = (csrfManager) => {
+    return async (req, res, next) => {
+        const method = req.getMethod();
+        // Only validate on state-changing requests
+        if (['POST', 'PUT', 'PATCH', 'DELETE'].includes(method) === false) {
+            await next();
+            return;
+        }
+        const sessionId = req.sessionId ?? req.getHeader('x-session-id');
+        if (sessionId === undefined || sessionId === '') {
+            res.setStatus(400).json({ error: 'Missing session ID' });
+            return;
+        }
+        const csrfToken = req.getHeader('x-csrf-token');
+        if (csrfToken === undefined || csrfToken === '') {
+            res.setStatus(403).json({ error: 'Missing CSRF token' });
+            return;
+        }
+        const isValid = await resolveCsrfManager(csrfManager).validateToken(String(sessionId), String(csrfToken));
+        if (isValid === false) {
+            res.setStatus(403).json({ error: 'Invalid or expired CSRF token' });
+            return;
+        }
+        await next();
+    };
+};
+/**
+ * Input Validation Middleware
+ * Validate request body against schema
+ */
+export const validationMiddleware = (schema) => {
+    return async (req, res, next) => {
+        if (req.getMethod() === 'GET' || req.getMethod() === 'DELETE') {
+            await next();
+            return;
+        }
+        try {
+            const body = req.body ?? {};
+            Validator.validate(body, resolveSchema(schema));
+            await next();
+        }
+        catch (error) {
+            Logger.error('Validation error:', error);
+            const newError = error;
+            if (error !== undefined &&
+                'toObject' in newError &&
+                typeof newError.toObject === 'function') {
+                res.setStatus(422).json({ errors: newError.toObject() });
+            }
+            else {
+                res.setStatus(400).json({ error: 'Invalid request body' });
+            }
+        }
+    };
+};
+/**
+ * XSS Protection Middleware
+ * Sanitize and escape user input
+ */
+export const xssProtectionMiddleware = async (req, res, next) => {
+    // Add XSS protection headers
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+    res.setHeader('X-Frame-Options', 'DENY');
+    res.setHeader('X-XSS-Protection', '1; mode=block');
+    // Sanitize request body if present
+    const body = req.body;
+    if (body !== undefined && body !== null && typeof body === 'object') {
+        for (const [key, value] of Object.entries(body)) {
+            if (typeof value === 'string') {
+                body[key] = XssProtection.escape(value);
+            }
+        }
+    }
+    await next();
+};

package/app/Models/Post.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Example Post Model
+ */
+import type { IRelationship } from '../../src/orm/Relationships';
+import type { ModelConfig } from '../../src/orm/Model';
+export declare const PostConfig: ModelConfig;
+/**
+ * Post Model
+ * Refactored to Functional Object pattern
+ */
+export declare const Post: import("../../src/orm/Model").DefinedModel<{
+    readonly author: () => IRelationship;
+}>;
+//# sourceMappingURL=Post.d.ts.map

package/app/Models/Post.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Post.d.ts","sourceRoot":"","sources":["../../../app/Models/Post.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAU,WAAW,EAAE,MAAM,YAAY,CAAC;AAGtD,eAAO,MAAM,UAAU,EAAE,WASxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,IAAI;;EAOf,CAAC"}

package/app/Models/Post.js

@@ -0,0 +1,27 @@
+/**
+ * Example Post Model
+ */
+import { User } from '../Models/User.js';
+import { Model } from '../../src/orm/Model.js';
+export const PostConfig = {
+    table: 'posts',
+    fillable: ['title', 'content', 'user_id'],
+    hidden: [],
+    timestamps: true,
+    casts: {
+        published_at: 'datetime',
+        is_published: 'boolean',
+    },
+};
+/**
+ * Post Model
+ * Refactored to Functional Object pattern
+ */
+export const Post = Model.define(PostConfig, {
+    /**
+     * Get post's author
+     */
+    author(model) {
+        return model.belongsTo(User);
+    },
+});

package/app/Models/User.d.ts

@@ -0,0 +1,14 @@
+/**
+ * User Model
+ */
+/**
+ * User Model Definition
+ */
+export declare const User: import("../../src/orm/Model").DefinedModel<{
+    readonly profile: () => undefined;
+    readonly posts: () => import("../../src").IRelationship;
+    readonly isAdmin: () => boolean;
+    readonly getFullName: () => string;
+}>;
+export default User;
+//# sourceMappingURL=User.d.ts.map

package/app/Models/User.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"User.d.ts","sourceRoot":"","sources":["../../../app/Models/User.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH;;GAEG;AACH,eAAO,MAAM,IAAI;;;;;EAwChB,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/app/Models/User.js

@@ -0,0 +1,44 @@
+/**
+ * User Model
+ */
+import { Post } from '../Models/Post.js';
+import { Model } from '../../src/orm/Model.js';
+/**
+ * User Model Definition
+ */
+export const User = Model.define({
+    table: 'users',
+    fillable: ['name', 'email', 'password'],
+    hidden: ['password'],
+    timestamps: true,
+    casts: {
+        email_verified_at: 'datetime',
+    },
+}, {
+    /**
+     * Get user's profile
+     */
+    profile(_model) {
+        return undefined; // Placeholder
+    },
+    /**
+     * Get user's posts
+     */
+    posts(model) {
+        return model.hasMany(Post);
+    },
+    /**
+     * Check if user is admin
+     */
+    isAdmin(model) {
+        return model.getAttribute('is_admin') === 1;
+    },
+    /**
+     * Get user's full name
+     */
+    getFullName(model) {
+        const name = model.getAttribute('name');
+        return typeof name === 'string' ? name : '';
+    },
+});
+export default User;

package/app/Schedules/JobTracking.d.ts

@@ -0,0 +1,3 @@
+declare const JobTrackingCleanupSchedule: import("../../src/scheduler").ISchedule;
+export default JobTrackingCleanupSchedule;
+//# sourceMappingURL=JobTracking.d.ts.map

package/app/Schedules/JobTracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JobTracking.d.ts","sourceRoot":"","sources":["../../../app/Schedules/JobTracking.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,0BAA0B,yCAMtB,CAAC;AAEX,eAAe,0BAA0B,CAAC"}

package/app/Schedules/JobTracking.js

@@ -0,0 +1,13 @@
+import { Env } from '../../src/config/env.js';
+import Schedule from '../../src/scheduler/Schedule.js';
+import { cleanupJobTrackingOnce } from '../../src/schedules/job-tracking-cleanup.js';
+const enabled = Env.getBool('JOB_TRACKING_CLEANUP_ENABLED', false);
+const intervalMs = Env.getInt('JOB_TRACKING_CLEANUP_INTERVAL_MS', 6 * 60 * 60 * 1000);
+const JobTrackingCleanupSchedule = Schedule.define('jobTracking.cleanup', async () => {
+    await cleanupJobTrackingOnce();
+})
+    .intervalMs(intervalMs)
+    .withoutOverlapping({ provider: Env.get('JOB_TRACKING_CLEANUP_LOCK_PROVIDER', 'redis') })
+    .enabledWhen(enabled)
+    .build();
+export default JobTrackingCleanupSchedule;

package/app/Schedules/index.d.ts

@@ -0,0 +1,2 @@
+export { default as jobTrackingCleanup } from '../Schedules/JobTracking';
+//# sourceMappingURL=index.d.ts.map

package/app/Schedules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../app/Schedules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,4BAA4B,CAAC"}

package/app/Schedules/index.js

@@ -0,0 +1 @@
+export { default as jobTrackingCleanup } from '../Schedules/JobTracking.js';

package/app/Toolkit/Broadcast/sendBroadcast.d.ts

@@ -0,0 +1,6 @@
+export declare function sendBroadcast(channel: string, event: string, data: unknown): Promise<void>;
+declare const _default: Readonly<{
+    sendBroadcast: typeof sendBroadcast;
+}>;
+export default _default;
+//# sourceMappingURL=sendBroadcast.d.ts.map

package/app/Toolkit/Broadcast/sendBroadcast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendBroadcast.d.ts","sourceRoot":"","sources":["../../../../app/Toolkit/Broadcast/sendBroadcast.ts"],"names":[],"mappings":"AAEA,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhG;;;;AAED,wBAAgD"}

package/app/Toolkit/Broadcast/sendBroadcast.js

@@ -0,0 +1,5 @@
+import { Broadcast } from '../../../src/tools/broadcast/Broadcast.js';
+export async function sendBroadcast(channel, event, data) {
+    await Broadcast.send(channel, event, data);
+}
+export default Object.freeze({ sendBroadcast });

package/app/Toolkit/Mail/sendWelcomeEmail.d.ts

@@ -0,0 +1,6 @@
+export declare function sendWelcomeEmail(to: string, name: string, attachmentDisk?: string, attachmentPath?: string): Promise<void>;
+declare const _default: Readonly<{
+    sendWelcomeEmail: typeof sendWelcomeEmail;
+}>;
+export default _default;
+//# sourceMappingURL=sendWelcomeEmail.d.ts.map

package/app/Toolkit/Mail/sendWelcomeEmail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendWelcomeEmail.d.ts","sourceRoot":"","sources":["../../../../app/Toolkit/Mail/sendWelcomeEmail.ts"],"names":[],"mappings":"AAEA,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,cAAc,CAAC,EAAE,MAAM,EACvB,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC,CAoBf;;;;AAED,wBAAmD"}