@zintrust/core 0.4.27 → 0.4.28

package/app/Controllers/UserQueryBuilderController.js

@@ -0,0 +1,404 @@
+/**
+ * User QueryBuilder Controller
+ * QueryBuilder-backed controller for the users resource.
+ */
+import { Logger, QueryBuilder, Sanitizer, Schema, Validator, getValidatedBody, nowIso, randomBytes, useDatabase, } from '../../src/index.js';
+const isValidationError = (error) => {
+    if (typeof error !== 'object' || error === null)
+        return false;
+    const maybe = error;
+    return maybe.name === 'ValidationError' && typeof maybe.toObject === 'function';
+};
+const isSanitizerError = (error) => {
+    if (typeof error !== 'object' || error === null)
+        return false;
+    const maybe = error;
+    return maybe.name === 'SanitizerError';
+};
+const toJsonRecord = (value) => {
+    if (typeof value !== 'object' || value === null)
+        return {};
+    if (Array.isArray(value))
+        return {};
+    return value;
+};
+const resolveBody = (req) => {
+    return toJsonRecord(getValidatedBody(req) ?? req.body ?? {});
+};
+const getParamCompat = (req, name) => {
+    try {
+        const anyReq = req;
+        if (typeof anyReq.getParam === 'function')
+            return anyReq.getParam(name);
+    }
+    catch {
+        // ignore
+    }
+    const anyReq = req;
+    const params = anyReq.params;
+    if (typeof params === 'object' && params !== null)
+        return params[name];
+    return undefined;
+};
+const requireSelf = (req, res, userId) => {
+    if (typeof userId !== 'string' || userId.length === 0) {
+        res.status(400).json({ error: 'Missing user id' });
+        return false;
+    }
+    const subject = typeof req.user?.sub === 'string' ? req.user.sub : undefined;
+    if (subject === undefined || subject.length === 0) {
+        res.status(401).json({ error: 'Unauthorized' });
+        return false;
+    }
+    if (subject !== userId) {
+        res.status(403).json({ error: 'Forbidden' });
+        return false;
+    }
+    return true;
+};
+const randomInt = (min, max) => {
+    const lo = Math.ceil(min);
+    const hi = Math.floor(max);
+    return Math.floor(lo + Math.random() * (hi - lo + 1)); // NOSONAR is just a test utility
+};
+const randomName = () => {
+    const first = ['Alex', 'Jordan', 'Taylor', 'Sam', 'Casey', 'Riley', 'Morgan'];
+    const last = ['Lee', 'Kim', 'Patel', 'Garcia', 'Brown', 'Nguyen', 'Smith'];
+    return `${first[randomInt(0, first.length - 1)]} ${last[randomInt(0, last.length - 1)]}`;
+};
+const randomEmail = () => {
+    const n = randomInt(10000, 99999);
+    return `user${n}@example.com`;
+};
+const randomPassword = () => {
+    // Not cryptographically perfect UX-wise, but avoids hard-coded credentials.
+    // `base64url` keeps it URL-safe and reasonably short.
+    return randomBytes(12).toString('base64url');
+};
+const pickAllowed = (body, allowed) => {
+    const out = {};
+    for (const [k, v] of Object.entries(body)) {
+        if (allowed.has(k))
+            out[k] = v;
+    }
+    return out;
+};
+const hasUnknownKeys = (body, allowed) => {
+    for (const k of Object.keys(body)) {
+        if (!allowed.has(k))
+            return k;
+    }
+    return null;
+};
+const sanitizeUserUpdateBody = (updateBody) => {
+    const sanitizedUpdateBody = {};
+    if ('name' in updateBody) {
+        sanitizedUpdateBody['name'] = Sanitizer.nameText(updateBody['name']).trim();
+    }
+    if ('email' in updateBody) {
+        sanitizedUpdateBody['email'] = Sanitizer.email(updateBody['email']).trim().toLowerCase();
+    }
+    if ('password' in updateBody) {
+        sanitizedUpdateBody['password'] = Sanitizer.safePasswordChars(updateBody['password']);
+    }
+    return sanitizedUpdateBody;
+};
+const buildUserUpdateSchema = () => {
+    return Schema.create()
+        .custom('name', (v) => v === undefined || typeof v === 'string', 'name must be a string')
+        .minLength('name', 1)
+        .custom('email', (v) => v === undefined || typeof v === 'string', 'email must be a string')
+        .custom('password', (v) => v === undefined || typeof v === 'string', 'password must be a string')
+        .minLength('password', 8);
+};
+const buildUserStoreSchema = () => {
+    return Schema.create()
+        .custom('name', (v) => typeof v === 'string', 'name must be a string')
+        .minLength('name', 1)
+        .custom('email', (v) => typeof v === 'string', 'email must be a string')
+        .email('email')
+        .custom('password', (v) => typeof v === 'string', 'password must be a string')
+        .minLength('password', 8);
+};
+/**
+ * User Controller Methods
+ */
+const userControllerMethods = {
+    /**
+     * List all users
+     * GET /users
+     */
+    async index(req, res) {
+        try {
+            const subject = typeof req.user?.sub === 'string' ? req.user.sub : undefined;
+            if (subject === undefined || subject.length === 0) {
+                res.status(401).json({ error: 'Unauthorized' });
+                return;
+            }
+            const db = useDatabase();
+            const users = await QueryBuilder.create('users', db)
+                .select('id', 'name', 'email', 'created_at', 'updated_at')
+                .where('id', '=', subject)
+                .limit(1)
+                .get();
+            res.json({ data: users });
+        }
+        catch (error) {
+            Logger.error('Error fetching users:', error);
+            res.status(500).json({ error: 'Failed to fetch users' });
+        }
+    },
+    /**
+     * Show a specific user
+     * GET /users/:id
+     */
+    async show(req, res) {
+        try {
+            const db = useDatabase();
+            const rawId = getParamCompat(req, 'id');
+            const id = Sanitizer.digitsOnly(rawId); // Zero trust protection for db id
+            if (typeof id !== 'string' || id.length === 0) {
+                // ✅ Good
+                res.status(400).json({ error: 'Missing user id' });
+                return;
+            }
+            if (!requireSelf(req, res, id))
+                return;
+            const user = await QueryBuilder.create('users', db)
+                .select('id', 'name', 'email', 'created_at', 'updated_at')
+                .where('id', '=', id)
+                .limit(1)
+                .first();
+            if (user === null) {
+                res.status(404).json({ error: 'User not found' });
+                return;
+            }
+            res.json({ data: user });
+        }
+        catch (error) {
+            if (isSanitizerError(error)) {
+                res.status(400).json({ error: error.message });
+                return;
+            }
+            Logger.error('Error fetching user:', error);
+            res.status(500).json({ error: 'Failed to fetch user' });
+        }
+    },
+    /**
+     * Show create form
+     * GET /users/create
+     */
+    async create(_req, res) {
+        res.json({ form: 'Create User Form' });
+    },
+    /**
+     * Store a new user
+     * POST /users
+     */
+    async store(req, res) {
+        try {
+            // Use validated body if available (already sanitized by middleware), otherwise fallback to raw
+            const body = resolveBody(req);
+            const required = ['name', 'email', 'password'];
+            const missing = {};
+            for (const key of required) {
+                const val = body[key];
+                if (typeof val !== 'string' || val.trim() === '') {
+                    missing[key] = ['Required'];
+                }
+            }
+            if (Object.keys(missing).length > 0) {
+                res.status(422).json({ errors: missing });
+                return;
+            }
+            // Trust middleware for sanitization if validation passed.
+            // If we are here, validation ostensibly passed or we are in a context where we must self-validate.
+            // To satisfy defense-in-depth without double-sanitization bottleneck:
+            // We assume body is safe-ish if it came from resolved validated body.
+            // But to be explicit and type-safe, we cast or read fields directly.
+            const db = useDatabase();
+            const ts = nowIso();
+            // Apply bulletproof sanitization for defense-in-depth
+            const name = Sanitizer.nameText(body['name']);
+            const email = Sanitizer.email(body['email']);
+            const password = Sanitizer.safePasswordChars(body['password']);
+            Validator.validate({ name, email, password }, buildUserStoreSchema());
+            await QueryBuilder.create('users', db).insert({
+                name,
+                email,
+                password, // Hashing should be handled by model/service or here if raw
+                created_at: ts,
+                updated_at: ts,
+            });
+            res.status(201).json({ message: 'User created' });
+        }
+        catch (error) {
+            if (isSanitizerError(error)) {
+                res.status(400).json({ error: error.message });
+                return;
+            }
+            if (isValidationError(error)) {
+                res.status(422).json({ errors: error.toObject?.() ?? {} });
+                return;
+            }
+            Logger.error('Error creating user:', error);
+            res.status(500).json({ error: 'Failed to create user' });
+        }
+    },
+    /**
+     * Fill users table with random users
+     * POST /users/fill
+     */
+    async fill(req, res) {
+        try {
+            const body = resolveBody(req);
+            const countVal = body['count'];
+            // Ensure count is a number (middleware validation handles this, but we double check or default)
+            let count = typeof countVal === 'number' ? countVal : 10;
+            if (count < 1)
+                count = 1;
+            if (count > 100)
+                count = 100;
+            const db = useDatabase();
+            const ts = nowIso();
+            // Optimize: Bulk insert instead of N+1 inserts to reduce IO bottleneck and memory overhead
+            const users = Array.from({ length: count }, () => ({
+                name: randomName(),
+                email: randomEmail(),
+                password: randomPassword(),
+                created_at: ts,
+                updated_at: ts,
+            }));
+            await QueryBuilder.create('users', db).insert(users);
+            res.status(201).json({ message: 'Users filled', count });
+        }
+        catch (error) {
+            Logger.error('Error filling users:', error);
+            res.status(500).json({ error: 'Failed to fill users' });
+        }
+    },
+    /**
+     * Show edit form
+     * GET /users/:id/edit
+     */
+    async edit(_req, res) {
+        try {
+            res.json({ form: 'Edit User Form' });
+        }
+        catch (error) {
+            Logger.error('Error loading edit form:', error);
+            res.status(500).json({ error: 'Failed to load edit form' });
+        }
+    },
+    /**
+     * Update a user
+     * PUT /users/:id
+     */
+    async update(req, res) {
+        // NOSONAR bulletproof sanitization requires explicit validation steps
+        try {
+            const db = useDatabase();
+            const rawId = getParamCompat(req, 'id');
+            const id = Sanitizer.digitsOnly(rawId);
+            if (typeof id !== 'string' || id.length === 0) {
+                res.status(400).json({ error: 'Missing user id' });
+                return;
+            }
+            if (!requireSelf(req, res, id))
+                return;
+            const allowed = new Set(['name', 'email', 'password']);
+            const body = resolveBody(req);
+            const unknown = hasUnknownKeys(body, allowed);
+            if (unknown !== null) {
+                res.status(422).json({ errors: { [unknown]: ['Unknown field'] } });
+                return;
+            }
+            const updateBody = pickAllowed(body, allowed);
+            if (Object.keys(updateBody).length === 0) {
+                res.status(422).json({ errors: { body: ['No fields to update'] } });
+                return;
+            }
+            const sanitizedUpdateBody = sanitizeUserUpdateBody(updateBody);
+            Validator.validate(sanitizedUpdateBody, buildUserUpdateSchema());
+            const existing = await QueryBuilder.create('users', db)
+                .select('id')
+                .where('id', '=', id)
+                .limit(1)
+                .first();
+            if (existing === null) {
+                res.status(404).json({ error: 'User not found' });
+                return;
+            }
+            const ts = nowIso();
+            await QueryBuilder.create('users', db)
+                .where('id', '=', id)
+                .update({ ...sanitizedUpdateBody, updated_at: ts });
+            const user = await QueryBuilder.create('users', db)
+                .select('id', 'name', 'email', 'created_at', 'updated_at')
+                .where('id', '=', id)
+                .limit(1)
+                .first();
+            res.json({ message: 'User updated', user });
+        }
+        catch (error) {
+            if (isSanitizerError(error)) {
+                res.status(400).json({ error: error.message });
+                return;
+            }
+            if (isValidationError(error)) {
+                res.status(422).json({ errors: error.toObject?.() ?? {} });
+                return;
+            }
+            Logger.error('Error updating user:', error);
+            res.status(500).json({ error: 'Failed to update user' });
+        }
+    },
+    /**
+     * Delete a user
+     * DELETE /users/:id
+     */
+    async destroy(req, res) {
+        try {
+            const db = useDatabase();
+            const rawId = getParamCompat(req, 'id');
+            const id = Sanitizer.digitsOnly(rawId);
+            if (typeof id !== 'string' || id.length === 0) {
+                res.status(400).json({ error: 'Missing user id' });
+                return;
+            }
+            if (!requireSelf(req, res, id))
+                return;
+            const existing = await QueryBuilder.create('users', db)
+                .select('id')
+                .where('id', '=', id)
+                .limit(1)
+                .first();
+            if (existing === null) {
+                res.status(404).json({ error: 'User not found' });
+                return;
+            }
+            await QueryBuilder.create('users', db).where('id', '=', id).delete();
+            res.json({ message: 'User deleted' });
+        }
+        catch (error) {
+            if (isSanitizerError(error)) {
+                res.status(400).json({ error: error.message });
+                return;
+            }
+            Logger.error('Error deleting user:', error);
+            res.status(500).json({ error: 'Failed to delete user' });
+        }
+    },
+};
+/**
+ * User QueryBuilder Controller Factory
+ */
+export const UserQueryBuilderController = {
+    /**
+     * Create a new user controller instance
+     */
+    create() {
+        return userControllerMethods;
+    },
+};
+export default UserQueryBuilderController;

package/app/Jobs/AdvancedEmailJobService.d.ts

@@ -0,0 +1,57 @@
+export declare const AdvancedEmailJobService: Readonly<{
+    sendScheduledLock(to: string, subject: string, template: string, templateData: Record<string, unknown>, delayMs: number, queueName?: string): Promise<string>;
+    /**
+     * Send an advanced email with deduplication support
+     */
+    sendWithDeduplication(to: string, subject: string, template: string, templateData: Record<string, unknown>, deduplicationId: string, queueName?: string): Promise<string>;
+    /**
+     * Send an email with unique lock to prevent duplicates
+     */
+    sendWithUniqueLock(to: string, subject: string, template: string, templateData: Record<string, unknown>, uniqueVia: string, queueName?: string): Promise<string>;
+    /**
+     * Send a high-priority email with custom options
+     */
+    sendHighPriority(to: string, subject: string, template: string, templateData: Record<string, unknown>, options?: {
+        priority?: number;
+        delay?: number;
+        attempts?: number;
+    }, queueName?: string): Promise<string>;
+    /**
+     * Send a bulk email with batch processing support
+     */
+    sendBulk(recipients: string[], subject: string, template: string, templateData: Record<string, unknown>, batchId?: string, queueName?: string): Promise<string[]>;
+    /**
+     * Send an email with custom envelope metadata
+     */
+    sendWithMetadata(to: string, subject: string, template: string, templateData: Record<string, unknown>, metadata: {
+        campaign?: string;
+        source?: string;
+        priority?: string;
+        tags?: string[];
+    }, queueName?: string): Promise<string>;
+    /**
+     * Send a scheduled email with delay
+     */
+    sendScheduled(to: string, subject: string, template: string, templateData: Record<string, unknown>, delayMs: number, queueName?: string): Promise<string>;
+    /**
+     * Process a single advanced email job
+     */
+    processOne(queueName?: string): Promise<boolean>;
+    /**
+     * Process all advanced email jobs in queue
+     */
+    processAll(queueName?: string): Promise<number>;
+    /**
+     * Start the advanced email worker
+     */
+    start(queueName?: string): Promise<void>;
+}>;
+export default AdvancedEmailJobService;
+export declare const testSamples: Readonly<{
+    advancedQueuePatternsHeadline: "Advanced Queue Patterns";
+    uniqueIdExample: "await AdvancedEmailJobService.sendWithDeduplication('user@example.com', 'Welcome', 'welcome', { name: 'User' }, 'welcome-user-123')";
+    uniqueViaExample: "await AdvancedEmailJobService.sendWithUniqueLock('user@example.com', 'Reset Password', 'password-reset', { token: 'abc123' }, 'user-email')";
+    bulkExample: "await AdvancedEmailJobService.sendBulk(['user1@example.com', 'user2@example.com'], 'Newsletter', 'newsletter', { issue: 'Q1-2024' })";
+    scheduledExample: "await AdvancedEmailJobService.sendScheduled('user@example.com', 'Reminder', 'reminder', { event: 'meeting' }, 3600000)";
+}>;
+//# sourceMappingURL=AdvancedEmailJobService.d.ts.map

package/app/Jobs/AdvancedEmailJobService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdvancedEmailJobService.d.ts","sourceRoot":"","sources":["../../../app/Jobs/AdvancedEmailJobService.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,uBAAuB;0BAE5B,MAAM,WACD,MAAM,YACL,MAAM,gBACF,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WAC5B,MAAM,uBAEd,OAAO,CAAC,MAAM,CAAC;IAmBlB;;OAEG;8BAGG,MAAM,WACD,MAAM,YACL,MAAM,gBACF,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,mBACpB,MAAM,uBAEtB,OAAO,CAAC,MAAM,CAAC;IAwBlB;;OAEG;2BAEG,MAAM,WACD,MAAM,YACL,MAAM,gBACF,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,aAC1B,MAAM,uBAEhB,OAAO,CAAC,MAAM,CAAC;IAelB;;OAEG;yBAEG,MAAM,WACD,MAAM,YACL,MAAM,gBACF,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAC5B;QACP,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,uBAEA,OAAO,CAAC,MAAM,CAAC;IAyBlB;;OAEG;yBAEW,MAAM,EAAE,WACX,MAAM,YACL,MAAM,gBACF,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAC3B,MAAM,uBAEf,OAAO,CAAC,MAAM,EAAE,CAAC;IAkCpB;;OAEG;yBAEG,MAAM,WACD,MAAM,YACL,MAAM,gBACF,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAC3B;QACR,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;KACjB,uBAEA,OAAO,CAAC,MAAM,CAAC;IAoBlB;;OAEG;sBAEG,MAAM,WACD,MAAM,YACL,MAAM,gBACF,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WAC5B,MAAM,uBAEd,OAAO,CAAC,MAAM,CAAC;IAmBlB;;OAEG;oCACmD,OAAO,CAAC,OAAO,CAAC;IAItE;;OAEG;oCACmD,OAAO,CAAC,MAAM,CAAC;IAIrE;;OAEG;+BAC8C,OAAO,CAAC,IAAI,CAAC;EAG9D,CAAC;AAEH,eAAe,uBAAuB,CAAC;AAGvC,eAAO,MAAM,WAAW;;;;;;EAUtB,CAAC"}

package/app/Jobs/AdvancedEmailJobService.js

@@ -0,0 +1,185 @@
+import { AdvancEmailQueue } from '../Workers/AdvancEmailWorker.js';
+import { generateUuid, Logger } from '../../src/index.js';
+export const AdvancedEmailJobService = Object.freeze({
+    async sendScheduledLock(to, subject, template, templateData, delayMs, queueName = 'advanced-test-redis2') {
+        const payload = {
+            to,
+            subject,
+            template,
+            templateData,
+            uniqueId: `scheduled-${Date.now()}-${generateUuid()}`,
+        };
+        const queueOptions = {
+            delay: delayMs, // ✅ This passes delay to BullMQ
+        };
+        const jobId = await AdvancEmailQueue.add(payload, queueName, queueOptions);
+        const scheduledTime = new Date(Date.now() + delayMs).toISOString();
+        Logger.info('Scheduled advanced email queued', { jobId, to, subject, scheduledTime });
+        return jobId;
+    },
+    /**
+     * Send an advanced email with deduplication support
+     */
+    async sendWithDeduplication(to, subject, template, templateData, deduplicationId, queueName = 'advanced-test-redis2') {
+        const payload = {
+            to,
+            subject,
+            template,
+            templateData,
+            uniqueId: deduplicationId,
+            deduplication: {
+                id: deduplicationId,
+                ttl: 86400000, // 24 hours
+                releaseAfter: 3600000, // 1 hour
+            },
+        };
+        const jobId = await AdvancEmailQueue.add(payload, queueName);
+        Logger.info('Advanced email with deduplication queued', {
+            jobId,
+            to,
+            subject,
+            deduplicationId,
+        });
+        return jobId;
+    },
+    /**
+     * Send an email with unique lock to prevent duplicates
+     */
+    async sendWithUniqueLock(to, subject, template, templateData, uniqueVia, queueName = 'advanced-test-redis2') {
+        const payload = {
+            to,
+            subject,
+            template,
+            templateData,
+            uniqueId: `unique-${Date.now()}-${generateUuid()}`,
+            uniqueVia,
+        };
+        const jobId = await AdvancEmailQueue.add(payload, queueName);
+        Logger.info('Advanced email with unique lock queued', { jobId, to, subject, uniqueVia });
+        return jobId;
+    },
+    /**
+     * Send a high-priority email with custom options
+     */
+    async sendHighPriority(to, subject, template, templateData, options = {}, queueName = 'advanced-test-redis2') {
+        const payload = {
+            to,
+            subject,
+            template,
+            templateData,
+            timestamp: Date.now(),
+            attempts: options.attempts ?? 3,
+        };
+        const queueOptions = {
+            priority: options.priority ?? 10,
+            delay: options.delay ?? 0,
+        };
+        const jobId = await AdvancEmailQueue.add(payload, queueName, queueOptions);
+        Logger.info('High priority advanced email queued', {
+            jobId,
+            to,
+            subject,
+            priority: queueOptions.priority,
+        });
+        return jobId;
+    },
+    /**
+     * Send a bulk email with batch processing support
+     */
+    async sendBulk(recipients, subject, template, templateData, batchId, queueName = 'advanced-test-redis2') {
+        const batchIdentifier = batchId ?? `batch-${Date.now()}-${generateUuid()}`;
+        const jobPromises = recipients.map(async (to, index) => {
+            const payload = {
+                to,
+                subject,
+                template,
+                templateData: {
+                    ...templateData,
+                    batch_id: batchIdentifier,
+                    recipient_index: index + 1,
+                    total_recipients: recipients.length,
+                },
+                uniqueId: `${batchIdentifier}-${to}`,
+                deduplication: {
+                    id: `${batchIdentifier}-${to}`,
+                    ttl: 86400000, // 24 hours
+                },
+            };
+            return AdvancEmailQueue.add(payload, queueName);
+        });
+        const jobIds = await Promise.all(jobPromises);
+        Logger.info('Bulk advanced emails queued', {
+            batchId: batchIdentifier,
+            recipientCount: recipients.length,
+            jobIds: jobIds.length,
+        });
+        return jobIds;
+    },
+    /**
+     * Send an email with custom envelope metadata
+     */
+    async sendWithMetadata(to, subject, template, templateData, metadata, queueName = 'advanced-test-redis2') {
+        const payload = {
+            to,
+            subject,
+            template,
+            templateData: {
+                ...templateData,
+                campaign: metadata.campaign,
+                source: metadata.source,
+                priority: metadata.priority,
+                tags: metadata.tags,
+            },
+            uniqueId: `meta-${Date.now()}-${generateUuid()}`,
+        };
+        const jobId = await AdvancEmailQueue.add(payload, queueName);
+        Logger.info('Advanced email with metadata queued', { jobId, to, subject, metadata });
+        return jobId;
+    },
+    /**
+     * Send a scheduled email with delay
+     */
+    async sendScheduled(to, subject, template, templateData, delayMs, queueName = 'advanced-test-redis2') {
+        const payload = {
+            to,
+            subject,
+            template,
+            templateData,
+            uniqueId: `scheduled-${Date.now()}-${generateUuid()}`,
+        };
+        const queueOptions = {
+            delay: delayMs,
+        };
+        const jobId = await AdvancEmailQueue.add(payload, queueName, queueOptions);
+        const scheduledTime = new Date(Date.now() + delayMs).toISOString();
+        Logger.info('Scheduled advanced email queued', { jobId, to, subject, scheduledTime });
+        return jobId;
+    },
+    /**
+     * Process a single advanced email job
+     */
+    async processOne(queueName = 'advanced-test-redis2') {
+        return AdvancEmailQueue.processOne(queueName);
+    },
+    /**
+     * Process all advanced email jobs in queue
+     */
+    async processAll(queueName = 'advanced-test-redis2') {
+        return AdvancEmailQueue.processAll(queueName);
+    },
+    /**
+     * Start the advanced email worker
+     */
+    async start(queueName = 'advanced-test-redis2') {
+        return AdvancEmailQueue.start(queueName);
+    },
+});
+export default AdvancedEmailJobService;
+// Test samples for advanced queue patterns
+export const testSamples = Object.freeze({
+    advancedQueuePatternsHeadline: 'Advanced Queue Patterns',
+    uniqueIdExample: "await AdvancedEmailJobService.sendWithDeduplication('user@example.com', 'Welcome', 'welcome', { name: 'User' }, 'welcome-user-123')",
+    uniqueViaExample: "await AdvancedEmailJobService.sendWithUniqueLock('user@example.com', 'Reset Password', 'password-reset', { token: 'abc123' }, 'user-email')",
+    bulkExample: "await AdvancedEmailJobService.sendBulk(['user1@example.com', 'user2@example.com'], 'Newsletter', 'newsletter', { issue: 'Q1-2024' })",
+    scheduledExample: "await AdvancedEmailJobService.sendScheduled('user@example.com', 'Reminder', 'reminder', { event: 'meeting' }, 3600000)",
+});

package/app/Jobs/EmailJobService.d.ts

@@ -0,0 +1,33 @@
+export declare const EmailJobService: Readonly<{
+    /**
+     * Send a welcome email using worker queue
+     */
+    sendWelcome(to: string, userName: string, _queueName?: string): Promise<string>;
+    /**
+     * Send a password reset email using the worker queue
+     */
+    sendPasswordReset(to: string, resetToken: string): Promise<string>;
+    /**
+     * Send a worker alert email using the worker queue
+     */
+    sendWorkerAlert(to: string, workerName: string, error: string, jobId?: string): Promise<string>;
+    /**
+     * Send a general notification email using the worker queue
+     */
+    sendGeneral(to: string, subject: string, message: string, options?: {
+        actionUrl?: string;
+        actionText?: string;
+        primaryColor?: string;
+    }): Promise<string>;
+    /**
+     * Send a custom email with any template
+     */
+    sendCustom(to: string, subject: string, template: string, templateData: Record<string, unknown>): Promise<string>;
+}>;
+export default EmailJobService;
+export declare const testSamples: Readonly<{
+    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 }";
+}>;
+//# sourceMappingURL=EmailJobService.d.ts.map

package/app/Jobs/EmailJobService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmailJobService.d.ts","sourceRoot":"","sources":["../../../app/Jobs/EmailJobService.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe;IAC1B;;OAEG;oBACmB,MAAM,YAAY,MAAM,eAAc,MAAM,GAAe,OAAO,CAAC,MAAM,CAAC;IAoBhG;;OAEG;0BACyB,MAAM,cAAc,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAqBxE;;OAEG;wBAEG,MAAM,cACE,MAAM,SACX,MAAM,UACL,MAAM,GACb,OAAO,CAAC,MAAM,CAAC;IAsBlB;;OAEG;oBAEG,MAAM,WACD,MAAM,WACN,MAAM,YACN;QACP,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,GACA,OAAO,CAAC,MAAM,CAAC;IAoBlB;;OAEG;mBAEG,MAAM,WACD,MAAM,YACL,MAAM,gBACF,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACpC,OAAO,CAAC,MAAM,CAAC;EAelB,CAAC;AAEH,eAAe,eAAe,CAAC;AAI/B,eAAO,MAAM,WAAW;;;;EAMtB,CAAC"}