@appweaver/core 1.0.0

package/prisma/client/models/Seeder.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/prisma/client/models.d.ts

@@ -0,0 +1,7 @@
+export type * from './models/ApiKey';
+export type * from './models/OneTimeToken';
+export type * from './models/Permission';
+export type * from './models/Role';
+export type * from './models/Seeder';
+export type * from './models/File';
+export type * from './commonInputTypes';

package/prisma/client/models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/queue/bull-queue.d.ts

@@ -0,0 +1,37 @@
+import { Job, JobProgress, Worker, WorkerOptions } from 'bullmq';
+import { JobsOptions } from 'bullmq/dist/esm/types';
+import { HealthCheckResult, Queue as CommonQueue, QueueHandlerResponse, QueueProcessor } from '@appweaver/common';
+export declare class BullQueue extends CommonQueue {
+    onDestroy(): Promise<void>;
+    get<Data = any, Response = any>(name: string): BullQueueProcessor<Data, Response>;
+    close(name: string): Promise<boolean>;
+    closeAll(): Promise<void>;
+    checkHealth(): Promise<HealthCheckResult>;
+}
+declare class BullQueueProcessor<Data = any, Response = any> extends QueueProcessor<Data, Response, Job<Data, Response>, JobsOptions, Worker<Data, Response>, WorkerOptions> {
+    readonly name: string;
+    constructor(name: string);
+    sendJob(data: Data, name?: string, options?: JobsOptions): Promise<Job<Data, Response>>;
+    sendBulkJobs(jobs: Array<{
+        data: Data;
+        name?: string;
+        options?: Omit<JobsOptions, 'repeat'>;
+    }>): Promise<Array<Job<Data, Response>>>;
+    addWorker(processor: (job: Job<Data, Response>) => Promise<Response>, options?: Omit<WorkerOptions, 'connection'>): Worker<Data, Response>;
+    removeWorker(id: string): Promise<boolean>;
+    onCompleted(handler: (job: Job<Data, Response>, result: Response, prev: string) => QueueHandlerResponse): string;
+    onFailed(handler: (job: Job<Data, Response> | undefined, error: Error, prev: string) => QueueHandlerResponse): string;
+    onError(handler: (error: Error) => QueueHandlerResponse): string;
+    onProgress(handler: (job: Job<Data, Response>, progress: JobProgress) => QueueHandlerResponse): string;
+    onActive(handler: (job: Job<Data, Response>, prev: string) => QueueHandlerResponse): string;
+    onStalled(handler: (jobId: string, prev: string) => QueueHandlerResponse): string;
+    onDrained(handler: () => QueueHandlerResponse): string;
+    onReady(handler: () => QueueHandlerResponse): string;
+    onPaused(handler: () => QueueHandlerResponse): string;
+    onResumed(handler: () => QueueHandlerResponse): string;
+    onClosing(handler: (msg: string) => QueueHandlerResponse): string;
+    onClosed(handler: () => QueueHandlerResponse): string;
+    removeListener(id: string): boolean;
+    close(): Promise<void>;
+}
+export {};

package/queue/bull-queue.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BullQueue = void 0;
+const bullmq_1 = require("bullmq");
+const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+class BullQueue extends common_1.Queue {
+    /** @internal */
+    _queues = new Map();
+    async onDestroy() {
+        await this.closeAll();
+    }
+    get(name) {
+        let processor = this._queues.get(name);
+        if (!processor) {
+            processor = new BullQueueProcessor(name);
+            this._queues.set(name, processor);
+        }
+        return processor;
+    }
+    async close(name) {
+        const processor = this._queues.get(name);
+        if (!processor) {
+            return false;
+        }
+        await processor.close();
+        this._queues.delete(name);
+        return true;
+    }
+    async closeAll() {
+        for (const queueName of this._queues.keys()) {
+            await this.close(queueName);
+        }
+    }
+    async checkHealth() {
+        try {
+            const queue = new BullQueueProcessor('health-check');
+            await queue.close();
+            return { success: true };
+        }
+        catch (e) {
+            return { success: false, message: e.message };
+        }
+    }
+}
+exports.BullQueue = BullQueue;
+class BullQueueProcessor extends common_1.QueueProcessor {
+    name;
+    /** @internal */
+    _connection = (0, context_1.inject)(common_1.Redis).createClient({
+        maxRetriesPerRequest: null
+    });
+    /** @internal */
+    _queue;
+    /** @internal */
+    _workers = [];
+    /** @internal */
+    _listeners = {};
+    constructor(name) {
+        super();
+        this.name = name;
+        this._queue = new bullmq_1.Queue(name, {
+            connection: this._connection,
+            skipVersionCheck: true,
+            defaultJobOptions: {
+                removeOnComplete: {
+                    count: common_1.config.QUEUE_KEEP_COMPLETED_COUNT,
+                    age: common_1.config.QUEUE_KEEP_COMPLETED_SECONDS
+                },
+                removeOnFail: {
+                    count: common_1.config.QUEUE_KEEP_FAILED_COUNT,
+                    age: common_1.config.QUEUE_KEEP_FAILED_SECONDS
+                },
+                attempts: common_1.config.QUEUE_RETRY_ATTEMPTS,
+                backoff: {
+                    delay: common_1.config.QUEUE_RETRY_BACKOFF,
+                    type: common_1.config.QUEUE_RETRY_BACKOFF_TYPE
+                }
+            }
+        });
+    }
+    async sendJob(data, name, options = {}) {
+        return await this._queue.add(name ?? 'defaultJob', data, options);
+    }
+    async sendBulkJobs(jobs) {
+        return await this._queue.addBulk(jobs.map(({ data, name, options }) => ({
+            data,
+            name: name ?? 'defaultJob',
+            ...(options ?? {})
+        })));
+    }
+    addWorker(processor, options = {}) {
+        const worker = new bullmq_1.Worker(this.name, processor, {
+            ...options,
+            connection: this._connection,
+            skipVersionCheck: true,
+            name: `${this.name}_${(0, common_1.uuid)()}`
+        });
+        for (const event of [
+            'completed',
+            'failed',
+            'error',
+            'progress',
+            'active',
+            'stalled',
+            'drained',
+            'ready',
+            'paused',
+            'resumed',
+            'closing',
+            'closed'
+        ]) {
+            worker.on(event, async (...args) => {
+                try {
+                    await this.handleEvent(event, ...args);
+                }
+                catch (error) {
+                    common_1.logger.error(error, `Error occurred while handling event '${event}' for queue '${this.name}'`);
+                }
+            });
+        }
+        this._workers.push(worker);
+        return worker;
+    }
+    async removeWorker(id) {
+        const index = this._workers.findIndex((w) => w.id === id);
+        if (index === -1) {
+            return false;
+        }
+        try {
+            await this._workers[index].close();
+            this._workers.splice(index, 1);
+            return true;
+        }
+        catch (error) {
+            common_1.logger.error(error, `Error occurred while removing worker with ID '${id}' from queue '${this.name}'`);
+            return false;
+        }
+    }
+    onCompleted(handler) {
+        return this.addListener('completed', handler);
+    }
+    onFailed(handler) {
+        return this.addListener('failed', handler);
+    }
+    onError(handler) {
+        return this.addListener('error', handler);
+    }
+    onProgress(handler) {
+        return this.addListener('progress', handler);
+    }
+    onActive(handler) {
+        return this.addListener('active', handler);
+    }
+    onStalled(handler) {
+        return this.addListener('stalled', handler);
+    }
+    onDrained(handler) {
+        return this.addListener('drained', handler);
+    }
+    onReady(handler) {
+        return this.addListener('ready', handler);
+    }
+    onPaused(handler) {
+        return this.addListener('paused', handler);
+    }
+    onResumed(handler) {
+        return this.addListener('resumed', handler);
+    }
+    onClosing(handler) {
+        return this.addListener('closing', handler);
+    }
+    onClosed(handler) {
+        return this.addListener('closed', handler);
+    }
+    removeListener(id) {
+        const listener = this._listeners[id];
+        if (!listener) {
+            return false;
+        }
+        delete this._listeners[id];
+        return true;
+    }
+    async close() {
+        await this._queue.close();
+        for (const worker of this._workers) {
+            await worker.close();
+        }
+    }
+    /** @internal */
+    addListener(event, listener) {
+        const listenerId = (0, common_1.uuid)();
+        this._listeners[listenerId] = { event, listener };
+        return listenerId;
+    }
+    /** @internal */
+    async handleEvent(event, ...args) {
+        const handlerActions = [];
+        for (const value of Object.values(this._listeners)) {
+            if (value.event !== event) {
+                continue;
+            }
+            handlerActions.push(value.listener(...args));
+        }
+        await Promise.allSettled(handlerActions);
+    }
+}

package/queue/memory-queue.d.ts

@@ -0,0 +1,54 @@
+import { HealthCheckResult, Queue as CommonQueue, QueueHandlerResponse, QueueJob, QueueProcessor } from '@appweaver/common';
+type MemoryQueueJob<Data = any, Response = any> = QueueJob<Data, Response> & {
+    status: 'waiting' | 'active' | 'completed' | 'failed';
+    error?: Error;
+    attempts: number;
+    maxAttempts: number;
+    createdAt: number;
+    processedAt?: number;
+    finishedAt?: number;
+};
+type MemoryJobOptions = {
+    attempts?: number;
+    delay?: number;
+    priority?: number;
+};
+type MemoryWorker<Data = any, Response = any> = {
+    id: string;
+    processor: (job: MemoryQueueJob<Data, Response>) => Promise<Response>;
+    active: boolean;
+};
+export declare class MemoryQueue extends CommonQueue {
+    onDestroy(): Promise<void>;
+    get<Data = any, Response = any>(name: string): MemoryQueueProcessor<Data, Response>;
+    close(name: string): Promise<boolean>;
+    closeAll(): Promise<void>;
+    checkHealth(): Promise<HealthCheckResult>;
+}
+declare class MemoryQueueProcessor<Data = any, Response = any> extends QueueProcessor<Data, Response, MemoryQueueJob<Data, Response>, MemoryJobOptions, MemoryWorker<Data, Response>, undefined> {
+    readonly name: string;
+    constructor(name: string);
+    sendJob(data: Data, name?: string, options?: MemoryJobOptions): Promise<MemoryQueueJob<Data, Response>>;
+    sendBulkJobs(jobs: Array<{
+        data: Data;
+        name?: string;
+        options?: MemoryJobOptions;
+    }>): Promise<Array<MemoryQueueJob<Data, Response>>>;
+    addWorker(processor: (job: MemoryQueueJob<Data, Response>) => Promise<Response>, _options?: undefined): MemoryWorker<Data, Response>;
+    removeWorker(id: string): Promise<boolean>;
+    onCompleted(handler: (job: MemoryQueueJob<Data, Response>, result: Response, prev: string) => QueueHandlerResponse): string;
+    onFailed(handler: (job: MemoryQueueJob<Data, Response> | undefined, error: Error, prev: string) => QueueHandlerResponse): string;
+    onError(handler: (error: Error) => QueueHandlerResponse): string;
+    onProgress(handler: (job: MemoryQueueJob<Data, Response>, progress: string | boolean | number | object) => QueueHandlerResponse): string;
+    onActive(handler: (job: MemoryQueueJob<Data, Response>, prev: string) => QueueHandlerResponse): string;
+    onStalled(handler: (jobId: string, prev: string) => QueueHandlerResponse): string;
+    onDrained(handler: () => QueueHandlerResponse): string;
+    onReady(handler: () => QueueHandlerResponse): string;
+    onPaused(handler: () => QueueHandlerResponse): string;
+    onResumed(handler: () => QueueHandlerResponse): string;
+    onClosing(handler: (msg: string) => QueueHandlerResponse): string;
+    onClosed(handler: () => QueueHandlerResponse): string;
+    removeListener(id: string): boolean;
+    close(): Promise<void>;
+}
+export {};

package/queue/memory-queue.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryQueue = void 0;
+const common_1 = require("@appweaver/common");
+class MemoryQueue extends common_1.Queue {
+    /** @internal */
+    _queues = new Map();
+    async onDestroy() {
+        await this.closeAll();
+    }
+    get(name) {
+        let processor = this._queues.get(name);
+        if (!processor) {
+            processor = new MemoryQueueProcessor(name);
+            this._queues.set(name, processor);
+        }
+        return processor;
+    }
+    async close(name) {
+        const processor = this._queues.get(name);
+        if (!processor) {
+            return false;
+        }
+        await processor.close();
+        this._queues.delete(name);
+        return true;
+    }
+    async closeAll() {
+        for (const queueName of this._queues.keys()) {
+            await this.close(queueName);
+        }
+    }
+    async checkHealth() {
+        try {
+            const queue = new MemoryQueueProcessor('health-check');
+            await queue.close();
+            return { success: true };
+        }
+        catch (e) {
+            return { success: false, message: e.message };
+        }
+    }
+}
+exports.MemoryQueue = MemoryQueue;
+class MemoryQueueProcessor extends common_1.QueueProcessor {
+    name;
+    /** @internal */
+    _jobs = new Map();
+    /** @internal */
+    _workers = [];
+    /** @internal */
+    _listeners = {};
+    /** @internal */
+    _processing = false;
+    /** @internal */
+    _paused = false;
+    /** @internal */
+    _closed = false;
+    /** @internal */
+    _processingTimeout;
+    constructor(name) {
+        super();
+        this.name = name;
+        this.emitEvent('ready').catch((error) => {
+            common_1.logger.error(error, `Memory queue processing error`);
+        });
+    }
+    async sendJob(data, name, options = {}) {
+        if (this._closed) {
+            throw new Error(`Queue ${this.name} is closed`);
+        }
+        const jobId = (0, common_1.uuid)();
+        const job = {
+            id: jobId,
+            name: name ?? 'defaultJob',
+            data,
+            returnvalue: undefined,
+            status: 'waiting',
+            attempts: 0,
+            maxAttempts: options.attempts ?? 3,
+            createdAt: Date.now()
+        };
+        if (options.delay) {
+            setTimeout(() => {
+                this._jobs.set(jobId, job);
+                this.processJobs();
+            }, options.delay);
+        }
+        else {
+            this._jobs.set(jobId, job);
+            this.processJobs();
+        }
+        return job;
+    }
+    async sendBulkJobs(jobs) {
+        const createdJobs = [];
+        for (const jobSpec of jobs) {
+            const job = await this.sendJob(jobSpec.data, jobSpec.name, jobSpec.options);
+            createdJobs.push(job);
+        }
+        return createdJobs;
+    }
+    addWorker(processor, _options) {
+        const worker = {
+            id: (0, common_1.uuid)(),
+            processor,
+            active: true
+        };
+        this._workers.push(worker);
+        this.processJobs();
+        return worker;
+    }
+    async removeWorker(id) {
+        const index = this._workers.findIndex((w) => w.id === id);
+        if (index === -1) {
+            return false;
+        }
+        this._workers[index].active = false;
+        this._workers.splice(index, 1);
+        return true;
+    }
+    onCompleted(handler) {
+        return this.addListener('completed', handler);
+    }
+    onFailed(handler) {
+        return this.addListener('failed', handler);
+    }
+    onError(handler) {
+        return this.addListener('error', handler);
+    }
+    onProgress(handler) {
+        return this.addListener('progress', handler);
+    }
+    onActive(handler) {
+        return this.addListener('active', handler);
+    }
+    onStalled(handler) {
+        return this.addListener('stalled', handler);
+    }
+    onDrained(handler) {
+        return this.addListener('drained', handler);
+    }
+    onReady(handler) {
+        return this.addListener('ready', handler);
+    }
+    onPaused(handler) {
+        return this.addListener('paused', handler);
+    }
+    onResumed(handler) {
+        return this.addListener('resumed', handler);
+    }
+    onClosing(handler) {
+        return this.addListener('closing', handler);
+    }
+    onClosed(handler) {
+        return this.addListener('closed', handler);
+    }
+    removeListener(id) {
+        const listener = this._listeners[id];
+        if (!listener) {
+            return false;
+        }
+        delete this._listeners[id];
+        return true;
+    }
+    async close() {
+        this._closed = true;
+        await this.emitEvent('closing', 'Queue is closing');
+        if (this._processingTimeout) {
+            clearTimeout(this._processingTimeout);
+        }
+        // Wait for active jobs to complete
+        const activeJobs = Array.from(this._jobs.values()).filter((job) => job.status === 'active');
+        if (activeJobs.length > 0) {
+            await new Promise((resolve) => {
+                const checkInterval = setInterval(() => {
+                    const stillActive = Array.from(this._jobs.values()).some((job) => job.status === 'active');
+                    if (!stillActive) {
+                        clearInterval(checkInterval);
+                        resolve();
+                    }
+                }, 100);
+            });
+        }
+        await this.emitEvent('closed');
+    }
+    /** @internal */
+    addListener(event, listener) {
+        const listenerId = (0, common_1.uuid)();
+        this._listeners[listenerId] = { event, listener };
+        return listenerId;
+    }
+    /** @internal */
+    async emitEvent(event, ...args) {
+        const handlerActions = [];
+        for (const value of Object.values(this._listeners)) {
+            if (value.event !== event) {
+                continue;
+            }
+            try {
+                handlerActions.push(value.listener(...args));
+            }
+            catch (error) {
+                common_1.logger.error(error, `Error occurred while handling event '${event}' for queue '${this.name}'`);
+            }
+        }
+        await Promise.allSettled(handlerActions);
+    }
+    /** @internal */
+    processJobs() {
+        if (this._processing || this._paused || this._closed) {
+            return;
+        }
+        this._processing = true;
+        this._processingTimeout = setTimeout(async () => {
+            try {
+                const waitingJobs = Array.from(this._jobs.values())
+                    .filter((job) => job.status === 'waiting')
+                    .sort((a, b) => a.createdAt - b.createdAt);
+                const availableWorkers = this._workers.filter((w) => w.active);
+                if (waitingJobs.length === 0 || availableWorkers.length === 0) {
+                    this._processing = false;
+                    if (waitingJobs.length === 0 && this._jobs.size > 0) {
+                        const hasActiveJobs = Array.from(this._jobs.values()).some((job) => job.status === 'active');
+                        if (!hasActiveJobs) {
+                            await this.emitEvent('drained');
+                        }
+                    }
+                    return;
+                }
+                // Process jobs with available workers
+                const jobsToProcess = waitingJobs.slice(0, availableWorkers.length);
+                for (let i = 0; i < jobsToProcess.length; i++) {
+                    const job = jobsToProcess[i];
+                    const worker = availableWorkers[i];
+                    await this.processJob(job, worker);
+                }
+            }
+            finally {
+                this._processing = false;
+                // Continue processing if there are more jobs
+                if (!this._paused && !this._closed) {
+                    this.processJobs();
+                }
+            }
+        }, 0);
+    }
+    /** @internal */
+    async processJob(job, worker) {
+        job.status = 'active';
+        job.processedAt = Date.now();
+        job.attempts++;
+        await this.emitEvent('active', job, job.status);
+        try {
+            const result = await worker.processor(job);
+            job.returnvalue = result;
+            job.status = 'completed';
+            job.finishedAt = Date.now();
+            await this.emitEvent('completed', job, result, 'active');
+            // Clean up completed job after a short delay
+            setTimeout(() => {
+                this._jobs.delete(job.id);
+            }, 1000);
+        }
+        catch (error) {
+            job.error = error;
+            if (job.attempts >= job.maxAttempts) {
+                job.status = 'failed';
+                job.finishedAt = Date.now();
+                await this.emitEvent('failed', job, error, 'active');
+                // Clean up failed job after a short delay
+                setTimeout(() => {
+                    this._jobs.delete(job.id);
+                }, 1000);
+            }
+            else {
+                // Retry the job
+                job.status = 'waiting';
+                await this.emitEvent('error', error);
+            }
+        }
+    }
+}

package/resource/index.d.ts

@@ -0,0 +1,4 @@
+export * from './resource-loader';
+export * from './resource-routes';
+export * from './resource-schema';
+export * from './resource-service';

package/resource/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./resource-loader"), exports);
+__exportStar(require("./resource-routes"), exports);
+__exportStar(require("./resource-schema"), exports);
+__exportStar(require("./resource-service"), exports);

package/resource/resource-loader.d.ts

@@ -0,0 +1,26 @@
+import { ResourceContext } from '../types';
+export type LoadResourcePaths = {
+    /** Path pattern used for finding files that export resource models (default: `./src/resources/"*"/*model.ts`) */
+    modelPattern?: string;
+    /** Path pattern used for finding files that export resource models (default: `./src/resources/"*"/*service.ts`) */
+    servicePattern?: string;
+    /** Path pattern used for finding files that export resource models (default: `./src/resources/"*"/*policy.ts`) */
+    policyPattern?: string;
+    /** Path pattern used for finding files that export resource models (default: `./src/resources/"*"/*route.ts)` */
+    routePattern?: string;
+};
+/**
+ * Loads application resources including models, services, policies, and routes.
+ *
+ * @param {string} [baseDir] - Optional base directory path from which to load the resources.
+ *                              If not provided, defaults to the application's root directory.
+ * @param {LoadResourcePaths} [paths={}] Path patterns for loading resources: models, services, policies, and routes.
+ * @return {Promise<ResourceContext>} A promise that resolves to an object containing
+ * the loaded resources:
+ *
+ *         - `models`: The application models.
+ *         - `services`: The application services.
+ *         - `policies`: The access policies.
+ *         - `routes`: The application routes.
+ */
+export declare function loadResources(baseDir?: string, paths?: LoadResourcePaths): Promise<ResourceContext>;