@zintrust/core 0.1.41 → 0.1.43

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>;
+/**
+ * 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>;
+export {};
+//# 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;;;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,215 @@
+/**
+ * Example Middleware
+ * Common middleware patterns for ZinTrust
+ */
+import { Logger } from '../../src/config/logger.js';
+import { TokenRevocation } from '../../src/security/TokenRevocation.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;
+        }
+        if (await TokenRevocation.isRevoked(token)) {
+            res.setStatus(401).json({ error: 'Invalid or expired token' });
+            return;
+        }
+        try {
+            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' });
+        }
+    };
+};
+/**
+ * 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"}

package/app/Toolkit/Mail/sendWelcomeEmail.js

@@ -0,0 +1,20 @@
+import { Mail } from '../../../src/tools/mail/index.js';
+export async function sendWelcomeEmail(to, name, attachmentDisk, attachmentPath) {
+    const subject = `Welcome, ${name}`;
+    const text = `Hello ${name}, welcome.`;
+    const attachments = attachmentDisk !== null &&
+        attachmentDisk !== undefined &&
+        attachmentDisk.trim() !== '' &&
+        attachmentPath !== null &&
+        attachmentPath !== undefined &&
+        attachmentPath.trim() !== ''
+        ? [{ disk: attachmentDisk, path: attachmentPath }]
+        : undefined;
+    await Mail.send({
+        to,
+        subject,
+        text,
+        attachments,
+    });
+}
+export default Object.freeze({ sendWelcomeEmail });

package/app/Toolkit/Notification/sendSlackNotification.d.ts

@@ -0,0 +1,8 @@
+export declare function sendSlackNotification(webhookUrl: string, message: {
+    text: string;
+}): Promise<void>;
+declare const _default: Readonly<{
+    sendSlackNotification: typeof sendSlackNotification;
+}>;
+export default _default;
+//# sourceMappingURL=sendSlackNotification.d.ts.map

package/app/Toolkit/Notification/sendSlackNotification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendSlackNotification.d.ts","sourceRoot":"","sources":["../../../../app/Toolkit/Notification/sendSlackNotification.ts"],"names":[],"mappings":"AAEA,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GACxB,OAAO,CAAC,IAAI,CAAC,CAEf;;;;AAED,wBAAwD"}

package/app/Toolkit/Notification/sendSlackNotification.js

@@ -0,0 +1,5 @@
+import { sendSlackWebhook } from '../../../src/tools/notification/drivers/Slack.js';
+export async function sendSlackNotification(webhookUrl, message) {
+    await sendSlackWebhook({ webhookUrl }, message);
+}
+export default Object.freeze({ sendSlackNotification });

package/app/Toolkit/Notification/sendSms.d.ts

@@ -0,0 +1,6 @@
+export declare function sendSmsNotification(accountSid: string, authToken: string, from: string, to: string, body: string): Promise<void>;
+declare const _default: Readonly<{
+    sendSmsNotification: typeof sendSmsNotification;
+}>;
+export default _default;
+//# sourceMappingURL=sendSms.d.ts.map

package/app/Toolkit/Notification/sendSms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendSms.d.ts","sourceRoot":"","sources":["../../../../app/Toolkit/Notification/sendSms.ts"],"names":[],"mappings":"AAEA,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAEf;;;;AAED,wBAAsD"}

package/app/Toolkit/Notification/sendSms.js

@@ -0,0 +1,5 @@
+import { sendSms } from '../../../src/tools/notification/drivers/Twilio.js';
+export async function sendSmsNotification(accountSid, authToken, from, to, body) {
+    await sendSms({ accountSid, authToken, from }, { to, body });
+}
+export default Object.freeze({ sendSmsNotification });

package/app/Types/controller.d.ts

@@ -0,0 +1,42 @@
+import type { IRequest } from '../../src/http/Request';
+import type { IResponse } from '../../src/http/Response';
+export type JsonRecord = Record<string, unknown>;
+export type LoginBody = {
+    email: string;
+    password: string;
+};
+export type RegisterBody = {
+    name: string;
+    email: string;
+    password: string;
+};
+export type UserRow = {
+    id?: unknown;
+    name?: unknown;
+    email?: unknown;
+    password?: unknown;
+};
+export type AuthControllerApi = {
+    login(req: IRequest, res: IResponse): Promise<void>;
+    register(req: IRequest, res: IResponse): Promise<void>;
+    logout(req: IRequest, res: IResponse): Promise<void>;
+    refresh(req: IRequest, res: IResponse): Promise<void>;
+};
+export type ValidationErrorLike = {
+    name?: unknown;
+    toObject?: () => Record<string, string[]>;
+};
+/**
+ * User Controller Interface
+ */
+export interface IUserController {
+    index(req: IRequest, res: IResponse): Promise<void>;
+    show(req: IRequest, res: IResponse): Promise<void>;
+    create(req: IRequest, res: IResponse): Promise<void>;
+    store(req: IRequest, res: IResponse): Promise<void>;
+    fill(req: IRequest, res: IResponse): Promise<void>;
+    edit(req: IRequest, res: IResponse): Promise<void>;
+    update(req: IRequest, res: IResponse): Promise<void>;
+    destroy(req: IRequest, res: IResponse): Promise<void>;
+}
+//# sourceMappingURL=controller.d.ts.map

package/app/Types/controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../app/Types/controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AACF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,QAAQ,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,MAAM,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvD,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAC3C,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,IAAI,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnD,MAAM,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,KAAK,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,IAAI,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnD,IAAI,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnD,MAAM,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvD"}

package/app/Types/controller.js

@@ -0,0 +1 @@
+export {};

package/config/broadcast.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Broadcast Configuration (default override)
+ *
+ * Keep this file declarative:
+ * - Core owns env parsing/default logic.
+ * - Projects can override config by editing values below.
+ */
+declare const _default: {
+    default: string;
+    drivers: {
+        inmemory: {
+            driver: "inmemory";
+        };
+        pusher: {
+            driver: "pusher";
+            appId: string;
+            key: string;
+            secret: string;
+            cluster: string;
+            useTLS: boolean;
+        };
+        redis: {
+            driver: "redis";
+            host: string;
+            port: number;
+            password: string;
+            channelPrefix: string;
+        };
+        redishttps: {
+            driver: "redishttps";
+            endpoint: string;
+            token: string;
+            channelPrefix: string;
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=broadcast.d.ts.map

package/config/broadcast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"broadcast.d.ts","sourceRoot":"","sources":["../../config/broadcast.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,wBA4BqC"}