@beeblock/svelar 0.4.0

package/dist/queue/JobMonitor.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Queue Job Monitor
+ *
+ * Driver-agnostic utilities for querying queue job state.
+ * Used by the admin dashboard to display job metrics and manage jobs.
+ */
+export interface JobInfo {
+    id: string;
+    jobClass: string;
+    queue: string;
+    status: 'waiting' | 'active' | 'completed' | 'failed' | 'delayed';
+    attempts: number;
+    maxAttempts: number;
+    payload: string;
+    error?: string;
+    createdAt: number;
+    processedAt?: number;
+    failedAt?: number;
+    delayedUntil?: number;
+}
+export interface JobCounts {
+    waiting: number;
+    active: number;
+    completed: number;
+    failed: number;
+    delayed: number;
+    total: number;
+}
+export interface JobFilter {
+    status?: JobInfo['status'];
+    queue?: string;
+    jobClass?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface QueueHealth {
+    driver: string;
+    queues: Record<string, JobCounts>;
+    oldestWaitingJob?: number;
+    failureRate: number;
+    throughput: number;
+}
+declare class JobMonitorService {
+    private _config;
+    private _bullmq;
+    private _metrics;
+    configure(config: {
+        driver: string;
+        default: string;
+        connections: Record<string, any>;
+    }): void;
+    /** Record a processed job (called internally by queue system) */
+    recordProcessed(): void;
+    /** Record a failed job (called internally by queue system) */
+    recordFailed(): void;
+    /**
+     * Get job counts for a queue (or all queues)
+     */
+    getCounts(queueName?: string): Promise<JobCounts>;
+    /**
+     * List jobs with filtering and pagination
+     */
+    listJobs(filter?: JobFilter): Promise<JobInfo[]>;
+    /**
+     * Get details for a single job
+     */
+    getJob(jobId: string): Promise<JobInfo | null>;
+    /**
+     * Retry a failed job
+     */
+    retryJob(jobId: string): Promise<boolean>;
+    /**
+     * Delete a job from the queue
+     */
+    deleteJob(jobId: string): Promise<boolean>;
+    /**
+     * Get overall queue health metrics
+     */
+    getHealth(): Promise<QueueHealth>;
+    /**
+     * Flush all completed jobs (cleanup)
+     */
+    flushCompleted(queueName?: string): Promise<number>;
+    /**
+     * Flush all failed jobs
+     */
+    flushFailed(queueName?: string): Promise<number>;
+    private getBullMQ;
+    private getRedisConnection;
+    private getRedisQueue;
+    private _getRedisJobCounts;
+    private _listRedisJobs;
+    private _getRedisJob;
+    private _retryRedisJob;
+    private _deleteRedisJob;
+    private _flushRedisCompleted;
+    private _flushRedisFailed;
+    private _bullmqJobToInfo;
+    private getDbConnection;
+    private getDbTable;
+    private _getDatabaseJobCounts;
+    private _listDatabaseJobs;
+    private _getDatabaseJob;
+    private _retryDatabaseJob;
+    private _deleteDatabaseJob;
+    private _flushDatabaseFailed;
+}
+export declare const JobMonitor: JobMonitorService;
+export {};

package/dist/queue/JobMonitor.js

@@ -0,0 +1,5 @@
+var C=Object.defineProperty;var p=(d,t)=>()=>(d&&(t=d(d=0)),t);var _=(d,t)=>{for(var e in t)C(d,e,{get:t[e],enumerable:!0})};function u(d,t){let e=Symbol.for(d),n=globalThis;return n[e]||(n[e]=t()),n[e]}var f=p(()=>{"use strict"});var w={};_(w,{Connection:()=>D});var b,D,y=p(()=>{"use strict";f();b=class{connections=new Map;config=null;defaultName="default";configure(t){this.config=t,this.defaultName=t.default}async connection(t){let e=t??this.defaultName;if(this.connections.has(e))return this.connections.get(e).drizzle;if(!this.config)throw new Error("Database not configured. Call Connection.configure() first, or register DatabaseServiceProvider.");let n=this.config.connections[e];if(!n)throw new Error(`Database connection "${e}" is not defined in configuration.`);let s=await this.createConnection(n);return this.connections.set(e,s),s.drizzle}async rawClient(t){let e=t??this.defaultName;return await this.connection(e),this.connections.get(e).rawClient}async raw(t,e=[],n){let s=await this.connection(n),a=this.getConfig(n);switch(a.driver){case"sqlite":{let i=await this.rawClient(n),r=e.map(o=>typeof o=="boolean"?o?1:0:o instanceof Date?o.toISOString():o),c=i.prepare(t),l=t.trimStart().toUpperCase();return l.startsWith("SELECT")||l.startsWith("PRAGMA")||l.startsWith("WITH")?c.all(...r):c.run(...r)}case"postgres":return(await this.rawClient(n))(t,...e);case"mysql":{let i=await this.rawClient(n),[r]=await i.execute(t,e);return r}default:throw new Error(`Unsupported driver: ${a.driver}`)}}getDriver(t){return this.getConfig(t).driver}getConfig(t){let e=t??this.defaultName;if(!this.config)throw new Error("Database not configured.");let n=this.config.connections[e];if(!n)throw new Error(`Database connection "${e}" is not defined.`);return n}async disconnect(t){if(t){let e=this.connections.get(t);e&&(await this.closeConnection(e),this.connections.delete(t))}else{for(let[e,n]of this.connections)await this.closeConnection(n);this.connections.clear()}}isConnected(t){return this.connections.has(t??this.defaultName)}async transaction(t,e){let n=this.getConfig(e),s=await this.rawClient(e);switch(n.driver){case"sqlite":{s.exec("BEGIN");try{let a=await t();return s.exec("COMMIT"),a}catch(a){throw s.exec("ROLLBACK"),a}}case"postgres":{await s`BEGIN`;try{let a=await t();return await s`COMMIT`,a}catch(a){throw await s`ROLLBACK`,a}}case"mysql":{let a=await s.getConnection();await a.beginTransaction();try{let i=await t();return await a.commit(),a.release(),i}catch(i){throw await a.rollback(),a.release(),i}}default:throw new Error(`Unsupported driver: ${n.driver}`)}}async createConnection(t){switch(t.driver){case"sqlite":return this.createSQLiteConnection(t);case"postgres":return this.createPostgresConnection(t);case"mysql":return this.createMySQLConnection(t);default:throw new Error(`Unsupported database driver: ${t.driver}`)}}async createSQLiteConnection(t){let e=t.filename??t.database??":memory:";try{let n=(await import("better-sqlite3")).default,{drizzle:s}=await import("drizzle-orm/better-sqlite3"),a=new n(e);return a.pragma("journal_mode = WAL"),a.pragma("foreign_keys = ON"),{drizzle:s(a),config:t,rawClient:a}}catch(n){let s;try{s=(await new Function("mod","return import(mod)")("node:sqlite")).DatabaseSync}catch{throw new Error(`No SQLite driver available. Install better-sqlite3 (npm install better-sqlite3) or use Node.js v22+ which includes built-in SQLite support. Original error: ${n instanceof Error?n.message:String(n)}`)}let a=new s(e);a.exec("PRAGMA journal_mode = WAL"),a.exec("PRAGMA foreign_keys = ON");let i={prepare(c){let l=a.prepare(c);return{all(...o){return l.all(...o)},run(...o){return l.run(...o)},get(...o){return l.get(...o)}}},exec(c){a.exec(c)},pragma(c){return a.prepare(`PRAGMA ${c}`).all()},close(){a.close()}},r;try{let{drizzle:c}=await import("drizzle-orm/better-sqlite3");r=c(i)}catch{r=i}return{drizzle:r,config:t,rawClient:i}}}async createPostgresConnection(t){let e=(await import("postgres")).default,{drizzle:n}=await import("drizzle-orm/postgres-js"),s=t.url??`postgres://${t.user}:${t.password}@${t.host??"localhost"}:${t.port??5432}/${t.database}`,a=e(s);return{drizzle:n(a),config:t,rawClient:a}}async createMySQLConnection(t){let e=await import("mysql2/promise"),{drizzle:n}=await import("drizzle-orm/mysql2"),s=e.createPool({host:t.host??"localhost",port:t.port??3306,database:t.database,user:t.user,password:t.password,uri:t.url});return{drizzle:n(s),config:t,rawClient:s}}async closeConnection(t){try{switch(t.config.driver){case"sqlite":t.rawClient.close();break;case"postgres":await t.rawClient.end();break;case"mysql":await t.rawClient.end();break}}catch{}}},D=u("svelar.connection",()=>new b)});f();var g=class{_config=null;_bullmq=null;_metrics={processed:[],failed:[]};configure(t){this._config=t}recordProcessed(){this._metrics.processed.push(Date.now());let t=Date.now()-36e5;this._metrics.processed=this._metrics.processed.filter(e=>e>t)}recordFailed(){this._metrics.failed.push(Date.now());let t=Date.now()-36e5;this._metrics.failed=this._metrics.failed.filter(e=>e>t)}async getCounts(t="default"){let e=this._config?.connections[this._config.default]?.driver;return e==="redis"?this._getRedisJobCounts(t):e==="database"?this._getDatabaseJobCounts(t):{waiting:0,active:0,completed:0,failed:0,delayed:0,total:0}}async listJobs(t={}){let e=this._config?.connections[this._config.default]?.driver;return e==="redis"?this._listRedisJobs(t):e==="database"?this._listDatabaseJobs(t):[]}async getJob(t){let e=this._config?.connections[this._config.default]?.driver;return e==="redis"?this._getRedisJob(t):e==="database"?this._getDatabaseJob(t):null}async retryJob(t){let e=this._config?.connections[this._config.default]?.driver;return e==="redis"?this._retryRedisJob(t):e==="database"?this._retryDatabaseJob(t):!1}async deleteJob(t){let e=this._config?.connections[this._config.default]?.driver;return e==="redis"?this._deleteRedisJob(t):e==="database"?this._deleteDatabaseJob(t):!1}async getHealth(){let t=this._config?.connections[this._config.default]?.driver??"sync",e=await this.getCounts("default"),n=Date.now()-36e5,s=this._metrics.processed.filter(r=>r>n).length,a=this._metrics.failed.filter(r=>r>n).length,i=s+a;return{driver:t,queues:{default:e},failureRate:i>0?a/i*100:0,throughput:s}}async flushCompleted(t="default"){return this._config?.connections[this._config.default]?.driver==="redis"?this._flushRedisCompleted(t):0}async flushFailed(t="default"){let e=this._config?.connections[this._config.default]?.driver;return e==="redis"?this._flushRedisFailed(t):e==="database"?this._flushDatabaseFailed(t):0}async getBullMQ(){if(this._bullmq)return this._bullmq;try{return this._bullmq=await Function('return import("bullmq")')(),this._bullmq}catch{throw new Error("bullmq is required for the Redis queue monitor.")}}getRedisConnection(){let t=this._config?.connections[this._config.default]??{};if(t.url){let e=new URL(t.url);return{host:e.hostname||"localhost",port:parseInt(e.port)||6379,password:e.password||t.password||void 0,db:parseInt(e.pathname?.slice(1)||"0")||t.db||0}}return{host:t.host??"localhost",port:t.port??6379,password:t.password,db:t.db??0}}async getRedisQueue(t){let e=await this.getBullMQ(),n=this.getRedisConnection(),s=this._config?.connections[this._config.default]??{};return new e.Queue(t,{connection:n,prefix:s.prefix??"svelar"})}async _getRedisJobCounts(t){let e=await this.getRedisQueue(t);try{let n=await e.getJobCounts("waiting","active","completed","failed","delayed");return{waiting:n.waiting??0,active:n.active??0,completed:n.completed??0,failed:n.failed??0,delayed:n.delayed??0,total:(n.waiting??0)+(n.active??0)+(n.completed??0)+(n.failed??0)+(n.delayed??0)}}finally{await e.close()}}async _listRedisJobs(t){let e=await this.getRedisQueue(t.queue??"default"),n=t.limit??50,s=t.offset??0;try{let a;return t.status?a=await e.getJobs([t.status],s,s+n-1):a=await e.getJobs(["waiting","active","completed","failed","delayed"],s,s+n-1),a.filter(i=>i!=null).filter(i=>!t.jobClass||i.name===t.jobClass).map(i=>this._bullmqJobToInfo(i))}finally{await e.close()}}async _getRedisJob(t){let e=await this.getRedisQueue("default");try{let n=await e.getJob(t);return n?this._bullmqJobToInfo(n):null}finally{await e.close()}}async _retryRedisJob(t){let e=await this.getRedisQueue("default");try{let n=await e.getJob(t);return n?(await n.retry(),!0):!1}catch{return!1}finally{await e.close()}}async _deleteRedisJob(t){let e=await this.getRedisQueue("default");try{let n=await e.getJob(t);return n?(await n.remove(),!0):!1}catch{return!1}finally{await e.close()}}async _flushRedisCompleted(t){let e=await this.getRedisQueue(t);try{let n=await e.getJobs(["completed"]),s=0;for(let a of n)a&&(await a.remove(),s++);return s}finally{await e.close()}}async _flushRedisFailed(t){let e=await this.getRedisQueue(t);try{let n=await e.getJobs(["failed"]),s=0;for(let a of n)a&&(await a.remove(),s++);return s}finally{await e.close()}}_bullmqJobToInfo(t){let e=t.finishedOn?t.failedReason?"failed":"completed":t.delay&&t.delay>0&&!t.processedOn?"delayed":t.processedOn?"active":"waiting";return{id:t.id,jobClass:t.name??t.data?.jobClass??"Unknown",queue:t.queueName??"default",status:e,attempts:t.attemptsMade??0,maxAttempts:t.opts?.attempts??3,payload:JSON.stringify(t.data??{}),error:t.failedReason??void 0,createdAt:t.timestamp??Date.now(),processedAt:t.processedOn??void 0,failedAt:t.failedReason?t.finishedOn:void 0,delayedUntil:t.delay?t.timestamp+t.delay:void 0}}async getDbConnection(){let{Connection:t}=await Promise.resolve().then(()=>(y(),w));return t}getDbTable(){return this._config?.connections[this._config.default]?.table??"svelar_jobs"}async _getDatabaseJobCounts(t){let e=await this.getDbConnection(),n=this.getDbTable(),s=Math.floor(Date.now()/1e3),i=(await e.raw(`SELECT
+         SUM(CASE WHEN reserved_at IS NULL AND available_at <= ? THEN 1 ELSE 0 END) as waiting,
+         SUM(CASE WHEN reserved_at IS NOT NULL THEN 1 ELSE 0 END) as active,
+         SUM(CASE WHEN reserved_at IS NULL AND available_at > ? THEN 1 ELSE 0 END) as delayed
+       FROM ${n} WHERE queue = ?`,[s,s,t]))?.[0]??{},r=Number(i.waiting)||0,c=Number(i.active)||0,l=Number(i.delayed)||0;return{waiting:r,active:c,completed:0,failed:0,delayed:l,total:r+c+l}}async _listDatabaseJobs(t){let e=await this.getDbConnection(),n=this.getDbTable(),s=t.limit??50,a=t.offset??0,i=Math.floor(Date.now()/1e3),r="WHERE 1=1",c=[];return t.queue&&(r+=" AND queue = ?",c.push(t.queue)),t.status==="waiting"?(r+=" AND reserved_at IS NULL AND available_at <= ?",c.push(i)):t.status==="active"?r+=" AND reserved_at IS NOT NULL":t.status==="delayed"&&(r+=" AND reserved_at IS NULL AND available_at > ?",c.push(i)),c.push(s,a),(await e.raw(`SELECT * FROM ${n} ${r} ORDER BY created_at DESC LIMIT ? OFFSET ?`,c)??[]).map(o=>{let v=JSON.parse(o.payload??"{}"),h=o.reserved_at!=null,m=!h&&o.available_at>i;return{id:o.id,jobClass:v.jobClass??"Unknown",queue:o.queue,status:h?"active":m?"delayed":"waiting",attempts:o.attempts??0,maxAttempts:o.max_attempts??3,payload:o.payload,createdAt:(o.created_at??0)*1e3,delayedUntil:m?o.available_at*1e3:void 0}})}async _getDatabaseJob(t){let e=await this.getDbConnection(),n=this.getDbTable(),s=await e.raw(`SELECT * FROM ${n} WHERE id = ?`,[t]);if(!s||s.length===0)return null;let a=s[0],i=JSON.parse(a.payload??"{}"),r=Math.floor(Date.now()/1e3);return{id:a.id,jobClass:i.jobClass??"Unknown",queue:a.queue,status:a.reserved_at?"active":a.available_at>r?"delayed":"waiting",attempts:a.attempts??0,maxAttempts:a.max_attempts??3,payload:a.payload,createdAt:(a.created_at??0)*1e3}}async _retryDatabaseJob(t){let e=await this.getDbConnection(),n=this.getDbTable(),s=Math.floor(Date.now()/1e3);try{return await e.raw(`UPDATE ${n} SET reserved_at = NULL, available_at = ?, attempts = 0 WHERE id = ?`,[s,t]),!0}catch{return!1}}async _deleteDatabaseJob(t){let e=await this.getDbConnection(),n=this.getDbTable();try{return await e.raw(`DELETE FROM ${n} WHERE id = ?`,[t]),!0}catch{return!1}}async _flushDatabaseFailed(t){let e=await this.getDbConnection(),n=this.getDbTable();return 0}},A=u("svelar.jobMonitor",()=>new g);export{A as JobMonitor};

package/dist/queue/index.d.ts

@@ -0,0 +1,279 @@
+/**
+ * Svelar Queue / Jobs
+ *
+ * Background job processing with sync, in-memory, and database-backed queues.
+ * Dispatch jobs from anywhere — controllers, services, model hooks, middleware,
+ * other jobs, or CLI commands.
+ *
+ * @example
+ * ```ts
+ * import { Queue, Job } from 'svelar/queue';
+ *
+ * class SendWelcomeEmail extends Job {
+ *   constructor(private userId: number) { super(); }
+ *
+ *   async handle(): Promise<void> {
+ *     const user = await User.findOrFail(this.userId);
+ *     await Mailer.send({ to: user.email, template: 'welcome' });
+ *   }
+ *
+ *   failed(error: Error): void {
+ *     console.error('Failed to send welcome email:', error);
+ *   }
+ * }
+ *
+ * // Register the job class (required for database driver deserialization)
+ * Queue.register(SendWelcomeEmail);
+ *
+ * // Dispatch to queue (async — processed by a worker)
+ * await Queue.dispatch(new SendWelcomeEmail(user.id));
+ *
+ * // Dispatch with delay (seconds)
+ * await Queue.dispatch(new SendWelcomeEmail(user.id), { delay: 60 });
+ *
+ * // Run synchronously regardless of configured driver
+ * await Queue.dispatchSync(new SendWelcomeEmail(user.id));
+ *
+ * // Chain jobs — run in sequence, stop on failure
+ * await Queue.chain([
+ *   new ProcessPayment(orderId),
+ *   new SendReceipt(orderId),
+ *   new UpdateInventory(orderId),
+ * ]);
+ *
+ * // Process jobs (in a worker)
+ * await Queue.work();
+ * ```
+ */
+export type QueueDriver = 'sync' | 'memory' | 'database' | 'redis';
+export interface QueueConfig {
+    default: string;
+    connections: Record<string, QueueConnectionConfig>;
+}
+export interface QueueConnectionConfig {
+    driver: QueueDriver;
+    /** Queue name (default: 'default') */
+    queue?: string;
+    /** Max retry attempts */
+    maxAttempts?: number;
+    /** Retry delay in seconds */
+    retryDelay?: number;
+    /** Database table for database driver */
+    table?: string;
+    /** Redis connection URL for redis driver (default: redis://localhost:6379) */
+    url?: string;
+    /** Redis host (alternative to url) */
+    host?: string;
+    /** Redis port (default: 6379) */
+    port?: number;
+    /** Redis password */
+    password?: string;
+    /** Redis database index (default: 0) */
+    db?: number;
+    /** BullMQ queue prefix (default: 'svelar') */
+    prefix?: string;
+    /** Default job options for BullMQ */
+    defaultJobOptions?: {
+        removeOnComplete?: boolean | number;
+        removeOnFail?: boolean | number;
+    };
+}
+export interface DispatchOptions {
+    /** Queue name */
+    queue?: string;
+    /** Delay in seconds before processing */
+    delay?: number;
+    /** Max retry attempts */
+    maxAttempts?: number;
+}
+export declare abstract class Job {
+    /** Number of times this job has been attempted */
+    attempts: number;
+    /** Maximum attempts before failing permanently */
+    maxAttempts: number;
+    /** Delay before retry (in seconds) */
+    retryDelay: number;
+    /** Queue to dispatch to */
+    queue: string;
+    /**
+     * Handle the job — implement your logic here
+     */
+    abstract handle(): Promise<void>;
+    /**
+     * Called when the job has failed after all retries
+     */
+    failed(error: Error): void;
+    /**
+     * Called before each retry
+     */
+    retrying(attempt: number): void;
+    /**
+     * Serialize the job for storage.
+     * Override this if your job needs custom serialization.
+     */
+    serialize(): string;
+    /**
+     * Restore job properties from deserialized data.
+     * Called when reconstructing a job from the database.
+     * Override this if your job needs custom deserialization.
+     */
+    restore(data: Record<string, any>): void;
+}
+export interface FailedJobRecord {
+    id: string;
+    queue: string;
+    jobClass: string;
+    payload: string;
+    exception: string;
+    failedAt: number;
+}
+declare class QueueManager {
+    private config;
+    private drivers;
+    private processing;
+    private jobRegistry;
+    private failedStore;
+    private _activeWorker;
+    configure(config: QueueConfig): void;
+    /**
+     * Register a job class for database driver deserialization.
+     *
+     * @example
+     * Queue.register(SendWelcomeEmail);
+     * Queue.register(ProcessPayment);
+     */
+    register(JobClass: new (...args: any[]) => Job): void;
+    /**
+     * Register multiple job classes at once.
+     *
+     * @example
+     * Queue.registerAll([SendWelcomeEmail, ProcessPayment, GenerateReport]);
+     */
+    registerAll(classes: Array<new (...args: any[]) => Job>): void;
+    /**
+     * Dispatch a job to the configured queue driver.
+     * The job will be processed asynchronously by a worker (unless using the sync driver).
+     *
+     * @example
+     * // Basic dispatch
+     * await Queue.dispatch(new SendWelcomeEmail(user.id));
+     *
+     * // Dispatch with options
+     * await Queue.dispatch(new SendWelcomeEmail(user.id), {
+     *   queue: 'emails',
+     *   delay: 60,         // Wait 60 seconds before processing
+     *   maxAttempts: 5,
+     * });
+     */
+    dispatch(job: Job, options?: DispatchOptions): Promise<void>;
+    /**
+     * Dispatch a job synchronously, bypassing the configured queue driver.
+     * The job runs immediately in the current process and the promise
+     * resolves when the job completes (or rejects if it fails all retries).
+     *
+     * Use this when you need the result right away, in tests, or for
+     * jobs that must complete before the response is sent.
+     *
+     * @example
+     * // Run immediately regardless of configured driver
+     * await Queue.dispatchSync(new SendWelcomeEmail(user.id));
+     *
+     * // Useful in tests
+     * await Queue.dispatchSync(new ProcessPayment(orderId));
+     */
+    dispatchSync(job: Job): Promise<void>;
+    /**
+     * Chain multiple jobs to run in sequence.
+     * Each job runs after the previous one completes successfully.
+     * If any job fails (after all retries), the chain stops.
+     *
+     * @example
+     * await Queue.chain([
+     *   new ProcessPayment(orderId),
+     *   new SendReceipt(orderId),
+     *   new UpdateInventory(orderId),
+     * ]);
+     *
+     * // Chain with options
+     * await Queue.chain([
+     *   new ProcessPayment(orderId),
+     *   new SendReceipt(orderId),
+     * ], { queue: 'orders' });
+     */
+    chain(jobs: Job[], options?: DispatchOptions): Promise<void>;
+    /**
+     * Process jobs from the queue (worker loop).
+     *
+     * For sync/memory/database drivers this runs a poll loop.
+     * For the redis driver this starts a BullMQ Worker that processes
+     * jobs natively — no polling required.
+     *
+     * @returns Number of processed jobs (poll drivers) or 0 (redis — the
+     *          worker runs indefinitely until stop() is called).
+     */
+    work(options?: {
+        queue?: string;
+        maxJobs?: number;
+        sleep?: number;
+        /** BullMQ concurrency (redis driver only, default: 1) */
+        concurrency?: number;
+    }): Promise<number>;
+    /**
+     * Stop the worker loop (poll drivers) or close the BullMQ Worker (redis).
+     */
+    stop(): Promise<void>;
+    /**
+     * Get the size of a queue
+     */
+    size(queue?: string): Promise<number>;
+    /**
+     * Clear all jobs from a queue
+     */
+    clear(queue?: string): Promise<void>;
+    /**
+     * List all failed jobs.
+     *
+     * @example
+     * const failures = await Queue.failed();
+     * for (const f of failures) {
+     *   console.log(f.jobClass, f.exception);
+     * }
+     */
+    failed(): Promise<FailedJobRecord[]>;
+    /**
+     * Retry a failed job by its ID.
+     * The job is re-dispatched to the queue and removed from the failed_jobs table.
+     *
+     * @example
+     * await Queue.retry('some-uuid');
+     */
+    retry(failedJobId: string): Promise<boolean>;
+    /**
+     * Retry all failed jobs.
+     *
+     * @example
+     * const count = await Queue.retryAll();
+     * console.log(`Retried ${count} jobs`);
+     */
+    retryAll(): Promise<number>;
+    /**
+     * Remove a single failed job record.
+     *
+     * @example
+     * await Queue.forgetFailed('some-uuid');
+     */
+    forgetFailed(failedJobId: string): Promise<boolean>;
+    /**
+     * Remove all failed job records.
+     *
+     * @example
+     * const count = await Queue.flushFailed();
+     */
+    flushFailed(): Promise<number>;
+    private resolveDriver;
+}
+/**
+ * Global Queue singleton
+ */
+export declare const Queue: QueueManager;
+export {};

package/dist/queue/index.js

@@ -0,0 +1,5 @@
+var R=Object.defineProperty;var P=(l,e)=>()=>(l&&(e=l(l=0)),e);var Q=(l,e)=>{for(var t in e)R(l,t,{get:e[t],enumerable:!0})};function p(l,e){let t=Symbol.for(l),r=globalThis;return r[t]||(r[t]=e()),r[t]}var g=P(()=>{"use strict"});var b={};Q(b,{Connection:()=>j});var w,j,y=P(()=>{"use strict";g();w=class{connections=new Map;config=null;defaultName="default";configure(e){this.config=e,this.defaultName=e.default}async connection(e){let t=e??this.defaultName;if(this.connections.has(t))return this.connections.get(t).drizzle;if(!this.config)throw new Error("Database not configured. Call Connection.configure() first, or register DatabaseServiceProvider.");let r=this.config.connections[t];if(!r)throw new Error(`Database connection "${t}" is not defined in configuration.`);let a=await this.createConnection(r);return this.connections.set(t,a),a.drizzle}async rawClient(e){let t=e??this.defaultName;return await this.connection(t),this.connections.get(t).rawClient}async raw(e,t=[],r){let a=await this.connection(r),s=this.getConfig(r);switch(s.driver){case"sqlite":{let i=await this.rawClient(r),u=t.map(c=>typeof c=="boolean"?c?1:0:c instanceof Date?c.toISOString():c),n=i.prepare(e),o=e.trimStart().toUpperCase();return o.startsWith("SELECT")||o.startsWith("PRAGMA")||o.startsWith("WITH")?n.all(...u):n.run(...u)}case"postgres":return(await this.rawClient(r))(e,...t);case"mysql":{let i=await this.rawClient(r),[u]=await i.execute(e,t);return u}default:throw new Error(`Unsupported driver: ${s.driver}`)}}getDriver(e){return this.getConfig(e).driver}getConfig(e){let t=e??this.defaultName;if(!this.config)throw new Error("Database not configured.");let r=this.config.connections[t];if(!r)throw new Error(`Database connection "${t}" is not defined.`);return r}async disconnect(e){if(e){let t=this.connections.get(e);t&&(await this.closeConnection(t),this.connections.delete(e))}else{for(let[t,r]of this.connections)await this.closeConnection(r);this.connections.clear()}}isConnected(e){return this.connections.has(e??this.defaultName)}async transaction(e,t){let r=this.getConfig(t),a=await this.rawClient(t);switch(r.driver){case"sqlite":{a.exec("BEGIN");try{let s=await e();return a.exec("COMMIT"),s}catch(s){throw a.exec("ROLLBACK"),s}}case"postgres":{await a`BEGIN`;try{let s=await e();return await a`COMMIT`,s}catch(s){throw await a`ROLLBACK`,s}}case"mysql":{let s=await a.getConnection();await s.beginTransaction();try{let i=await e();return await s.commit(),s.release(),i}catch(i){throw await s.rollback(),s.release(),i}}default:throw new Error(`Unsupported driver: ${r.driver}`)}}async createConnection(e){switch(e.driver){case"sqlite":return this.createSQLiteConnection(e);case"postgres":return this.createPostgresConnection(e);case"mysql":return this.createMySQLConnection(e);default:throw new Error(`Unsupported database driver: ${e.driver}`)}}async createSQLiteConnection(e){let t=e.filename??e.database??":memory:";try{let r=(await import("better-sqlite3")).default,{drizzle:a}=await import("drizzle-orm/better-sqlite3"),s=new r(t);return s.pragma("journal_mode = WAL"),s.pragma("foreign_keys = ON"),{drizzle:a(s),config:e,rawClient:s}}catch(r){let a;try{a=(await new Function("mod","return import(mod)")("node:sqlite")).DatabaseSync}catch{throw new Error(`No SQLite driver available. Install better-sqlite3 (npm install better-sqlite3) or use Node.js v22+ which includes built-in SQLite support. Original error: ${r instanceof Error?r.message:String(r)}`)}let s=new a(t);s.exec("PRAGMA journal_mode = WAL"),s.exec("PRAGMA foreign_keys = ON");let i={prepare(n){let o=s.prepare(n);return{all(...c){return o.all(...c)},run(...c){return o.run(...c)},get(...c){return o.get(...c)}}},exec(n){s.exec(n)},pragma(n){return s.prepare(`PRAGMA ${n}`).all()},close(){s.close()}},u;try{let{drizzle:n}=await import("drizzle-orm/better-sqlite3");u=n(i)}catch{u=i}return{drizzle:u,config:e,rawClient:i}}}async createPostgresConnection(e){let t=(await import("postgres")).default,{drizzle:r}=await import("drizzle-orm/postgres-js"),a=e.url??`postgres://${e.user}:${e.password}@${e.host??"localhost"}:${e.port??5432}/${e.database}`,s=t(a);return{drizzle:r(s),config:e,rawClient:s}}async createMySQLConnection(e){let t=await import("mysql2/promise"),{drizzle:r}=await import("drizzle-orm/mysql2"),a=t.createPool({host:e.host??"localhost",port:e.port??3306,database:e.database,user:e.user,password:e.password,uri:e.url});return{drizzle:r(a),config:e,rawClient:a}}async closeConnection(e){try{switch(e.config.driver){case"sqlite":e.rawClient.close();break;case"postgres":await e.rawClient.end();break;case"mysql":await e.rawClient.end();break}}catch{}}},j=p("svelar.connection",()=>new w)});g();var v=class{attempts=0;maxAttempts=3;retryDelay=60;queue="default";failed(e){console.error(`[Queue] Job ${this.constructor.name} permanently failed:`,e.message)}retrying(e){}serialize(){let e={};for(let[t,r]of Object.entries(this))typeof r!="function"&&(e[t]=r);return JSON.stringify(e)}restore(e){for(let[t,r]of Object.entries(e))t!=="attempts"&&t!=="maxAttempts"&&t!=="retryDelay"&&t!=="queue"&&(this[t]=r)}},h=class{async push(e){try{e.job.attempts=1,await e.job.handle()}catch(t){if(e.attempts+1<e.maxAttempts)return e.attempts++,e.job.attempts=e.attempts+1,e.job.retrying(e.job.attempts),this.push(e);e.job.failed(t)}}async pop(){return null}async size(){return 0}async clear(){}},C=class{queues=new Map;async push(e){let t=e.queue;this.queues.has(t)||this.queues.set(t,[]),this.queues.get(t).push(e)}async pop(e="default"){let t=this.queues.get(e)??[],r=Date.now(),a=t.findIndex(s=>s.availableAt<=r);return a===-1?null:t.splice(a,1)[0]}async size(e="default"){return this.queues.get(e)?.length??0}async clear(e){e?this.queues.delete(e):this.queues.clear()}},m=class{constructor(e,t){this.table=e;this.registry=t}async getConnection(){let{Connection:e}=await Promise.resolve().then(()=>(y(),b));return e}async push(e){await(await this.getConnection()).raw(`INSERT INTO ${this.table} (id, queue, payload, attempts, max_attempts, available_at, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,[e.id,e.queue,JSON.stringify({jobClass:e.jobClass,payload:e.payload}),e.attempts,e.maxAttempts,Math.floor(e.availableAt/1e3),Math.floor(e.createdAt/1e3)])}async pop(e="default"){let t=await this.getConnection(),r=Math.floor(Date.now()/1e3),a=await t.raw(`SELECT * FROM ${this.table}
+       WHERE queue = ? AND available_at <= ? AND reserved_at IS NULL
+       ORDER BY created_at ASC LIMIT 1`,[e,r]);if(!a||a.length===0)return null;let s=a[0];await t.raw(`UPDATE ${this.table} SET reserved_at = ?, attempts = attempts + 1 WHERE id = ?`,[r,s.id]);let i=JSON.parse(s.payload),u=this.registry.resolve(i.jobClass,i.payload);return{id:s.id,jobClass:i.jobClass,payload:i.payload,queue:s.queue,attempts:s.attempts+1,maxAttempts:s.max_attempts,availableAt:s.available_at*1e3,createdAt:s.created_at*1e3,job:u}}async size(e="default"){return(await(await this.getConnection()).raw(`SELECT COUNT(*) as count FROM ${this.table} WHERE queue = ? AND reserved_at IS NULL`,[e]))?.[0]?.count??0}async clear(e){let t=await this.getConnection();e?await t.raw(`DELETE FROM ${this.table} WHERE queue = ?`,[e]):await t.raw(`DELETE FROM ${this.table}`,[])}async delete(e){await(await this.getConnection()).raw(`DELETE FROM ${this.table} WHERE id = ?`,[e])}async release(e,t=0){let r=await this.getConnection(),a=Math.floor(Date.now()/1e3)+t;await r.raw(`UPDATE ${this.table} SET reserved_at = NULL, available_at = ? WHERE id = ?`,[a,e])}},f=class{queues=new Map;config;registry;_bullmq=null;constructor(e,t){this.config=e,this.registry=t}async getBullMQ(){if(this._bullmq)return this._bullmq;try{return this._bullmq=await Function('return import("bullmq")')(),this._bullmq}catch{throw new Error("bullmq is required for the Redis queue driver. Install it with: npm install bullmq")}}getRedisConnection(){if(this.config.url){let e=new URL(this.config.url);return{host:e.hostname||"localhost",port:parseInt(e.port)||6379,password:e.password||this.config.password||void 0,db:parseInt(e.pathname?.slice(1)||"0")||this.config.db||0}}return{host:this.config.host??"localhost",port:this.config.port??6379,password:this.config.password,db:this.config.db??0}}async getQueue(e){if(this.queues.has(e))return this.queues.get(e);let t=await this.getBullMQ(),r=this.getRedisConnection(),a=this.config.prefix??"svelar",s=new t.Queue(e,{connection:r,prefix:a,defaultJobOptions:{removeOnComplete:this.config.defaultJobOptions?.removeOnComplete??100,removeOnFail:this.config.defaultJobOptions?.removeOnFail??500}});return this.queues.set(e,s),s}async push(e){let t=await this.getQueue(e.queue),r=Math.max(0,e.availableAt-Date.now());await t.add(e.jobClass,{jobClass:e.jobClass,payload:e.payload},{jobId:e.id,delay:r>0?r:void 0,attempts:e.maxAttempts,backoff:{type:"fixed",delay:(e.job.retryDelay??60)*1e3}})}async pop(e){return null}async size(e="default"){let r=await(await this.getQueue(e)).getJobCounts("waiting","delayed","active");return r.waiting+r.delayed+r.active}async clear(e){if(e)await(await this.getQueue(e)).obliterate({force:!0});else for(let t of this.queues.values())await t.obliterate({force:!0})}async createWorker(e,t,r,a){let s=await this.getBullMQ(),i=this.getRedisConnection(),u=this.config.prefix??"svelar",n=new s.Worker(e,async o=>{let c=o.data,d=t.resolve(c.jobClass,c.payload);d.attempts=o.attemptsMade+1,await d.handle()},{connection:i,prefix:u,concurrency:a?.concurrency??1});return n.on("failed",async(o,c)=>{let d=o?.data;if(d)try{let x=t.resolve(d.jobClass,d.payload);o.attemptsMade>=(o.opts?.attempts??3)&&(x.failed(c),await r.store({id:o.id,jobClass:d.jobClass,payload:d.payload,queue:e,attempts:o.attemptsMade,maxAttempts:o.opts?.attempts??3,availableAt:Date.now(),createdAt:o.timestamp??Date.now(),job:x},c))}catch{console.error("[Queue] Failed to resolve job for failure handler:",c.message)}}),n}},D=class{table="svelar_failed_jobs";async getConnection(){let{Connection:e}=await Promise.resolve().then(()=>(y(),b));return e}async store(e,t){try{await(await this.getConnection()).raw(`INSERT INTO ${this.table} (id, queue, job_class, payload, exception, failed_at)
+         VALUES (?, ?, ?, ?, ?, ?)`,[crypto.randomUUID(),e.queue,e.jobClass,e.payload,t.stack??t.message,Math.floor(Date.now()/1e3)])}catch{console.error("[Queue] Could not persist failed job (run migration to create svelar_failed_jobs table)")}}async all(){return(await(await this.getConnection()).raw(`SELECT * FROM ${this.table} ORDER BY failed_at DESC`,[])??[]).map(r=>({id:r.id,queue:r.queue,jobClass:r.job_class,payload:r.payload,exception:r.exception,failedAt:r.failed_at}))}async find(e){let r=await(await this.getConnection()).raw(`SELECT * FROM ${this.table} WHERE id = ? LIMIT 1`,[e]);if(!r||r.length===0)return null;let a=r[0];return{id:a.id,queue:a.queue,jobClass:a.job_class,payload:a.payload,exception:a.exception,failedAt:a.failed_at}}async forget(e){return await(await this.getConnection()).raw(`DELETE FROM ${this.table} WHERE id = ?`,[e]),!0}async flush(){let e=await this.getConnection(),r=(await e.raw(`SELECT COUNT(*) as count FROM ${this.table}`,[]))?.[0]?.count??0;return await e.raw(`DELETE FROM ${this.table}`,[]),r}},q=class{jobs=new Map;register(e){this.jobs.set(e.name,e)}registerAll(e){for(let t of e)this.register(t)}resolve(e,t){let r=this.jobs.get(e);if(!r)throw new Error(`Job class "${e}" is not registered. Call Queue.register(${e}) in your app bootstrap. Registered jobs: [${[...this.jobs.keys()].join(", ")}]`);let a=Object.create(r.prototype);a.attempts=0,a.maxAttempts=3,a.retryDelay=60,a.queue="default";try{let s=JSON.parse(t);a.restore(s)}catch{}return a}has(e){return this.jobs.has(e)}},E=class{config={default:"sync",connections:{sync:{driver:"sync"}}};drivers=new Map;processing=!1;jobRegistry=new q;failedStore=new D;_activeWorker=null;configure(e){this.config=e,this.drivers.clear()}register(e){this.jobRegistry.register(e)}registerAll(e){this.jobRegistry.registerAll(e)}async dispatch(e,t){let r=this.config.default,a=this.config.connections[r],s=this.resolveDriver(r);t?.queue&&(e.queue=t.queue),t?.maxAttempts!==void 0&&(e.maxAttempts=t.maxAttempts);let i={id:crypto.randomUUID(),jobClass:e.constructor.name,payload:e.serialize(),queue:e.queue??a?.queue??"default",attempts:0,maxAttempts:e.maxAttempts,availableAt:Date.now()+(t?.delay??0)*1e3,createdAt:Date.now(),job:e};await s.push(i)}async dispatchSync(e){let t=new h,r={id:crypto.randomUUID(),jobClass:e.constructor.name,payload:e.serialize(),queue:e.queue,attempts:0,maxAttempts:e.maxAttempts,availableAt:Date.now(),createdAt:Date.now(),job:e};await t.push(r)}async chain(e,t){if(e.length===0)return;let r=new A(e);t?.queue&&(r.queue=t.queue),t?.maxAttempts!==void 0&&(r.maxAttempts=t.maxAttempts),await this.dispatch(r,t)}async work(e){let t=this.config.default,r=this.resolveDriver(t),a=e?.queue??"default";if(r instanceof f){let n=await r.createWorker(a,this.jobRegistry,this.failedStore,{concurrency:e?.concurrency??1});return this.processing=!0,this._activeWorker=n,await new Promise(o=>{let c=()=>{this.processing?setTimeout(c,500):n.close().then(o).catch(o)};c()}),0}let s=e?.maxJobs??1/0,i=(e?.sleep??1)*1e3,u=0;for(this.processing=!0;this.processing&&u<s;){let n=await r.pop(a);if(!n){if(s===1/0){await new Promise(o=>setTimeout(o,i));continue}break}n.attempts++,n.job.attempts=n.attempts;try{await n.job.handle(),u++,r instanceof m&&await r.delete(n.id)}catch(o){if(n.attempts<n.maxAttempts){n.job.retrying(n.attempts);let c=n.job.retryDelay??60;r instanceof m?await r.release(n.id,c):(n.availableAt=Date.now()+c*1e3,await r.push(n))}else n.job.failed(o),await this.failedStore.store(n,o),r instanceof m&&await r.delete(n.id)}}return u}async stop(){this.processing=!1,this._activeWorker&&(await this._activeWorker.close(),this._activeWorker=null)}async size(e){return this.resolveDriver(this.config.default).size(e)}async clear(e){return this.resolveDriver(this.config.default).clear(e)}async failed(){return this.failedStore.all()}async retry(e){let t=await this.failedStore.find(e);if(!t)return!1;let r=this.jobRegistry.resolve(t.jobClass,t.payload);return r.queue=t.queue,await this.dispatch(r,{queue:t.queue}),await this.failedStore.forget(e),!0}async retryAll(){let e=await this.failedStore.all(),t=0;for(let r of e)try{let a=this.jobRegistry.resolve(r.jobClass,r.payload);a.queue=r.queue,await this.dispatch(a,{queue:r.queue}),await this.failedStore.forget(r.id),t++}catch{}return t}async forgetFailed(e){return this.failedStore.forget(e)}async flushFailed(){return this.failedStore.flush()}resolveDriver(e){if(this.drivers.has(e))return this.drivers.get(e);let t=this.config.connections[e];if(!t)throw new Error(`Queue connection "${e}" is not defined.`);let r;switch(t.driver){case"sync":r=new h;break;case"memory":r=new C;break;case"database":r=new m(t.table??"svelar_jobs",this.jobRegistry);break;case"redis":r=new f(t,this.jobRegistry);break;default:throw new Error(`Unknown queue driver: ${t.driver}`)}return this.drivers.set(e,r),r}},A=class extends v{remainingJobs;constructor(e){super(),this.remainingJobs=[...e],this.maxAttempts=1}async handle(){for(let e of this.remainingJobs){let t=null,r=!1;for(let a=1;a<=e.maxAttempts;a++){e.attempts=a;try{await e.handle(),r=!0;break}catch(s){t=s,a<e.maxAttempts&&(e.retrying(a),e.retryDelay>0&&await new Promise(i=>setTimeout(i,e.retryDelay*1e3)))}}if(!r&&t)throw e.failed(t),new Error(`Chain stopped: ${e.constructor.name} failed after ${e.maxAttempts} attempt(s). Remaining jobs: [${this.remainingJobs.slice(this.remainingJobs.indexOf(e)+1).map(a=>a.constructor.name).join(", ")}]`)}}serialize(){return JSON.stringify({jobs:this.remainingJobs.map(e=>({jobClass:e.constructor.name,payload:e.serialize()}))})}},J=p("svelar.queue",()=>new E);export{v as Job,J as Queue};

package/dist/repositories/index.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Svelar Repository
+ *
+ * Base repository classes that abstract data access from business logic.
+ * Repositories wrap Model queries and provide a clean interface for
+ * services and actions to work with.
+ *
+ * @example
+ * ```ts
+ * import { Repository } from 'svelar/repositories';
+ * import { User } from '../models/User';
+ *
+ * class UserRepository extends Repository<User> {
+ *   model() {
+ *     return User;
+ *   }
+ *
+ *   async findByEmail(email: string): Promise<User | null> {
+ *     return this.query().where('email', email).first();
+ *   }
+ *
+ *   async findActive(): Promise<User[]> {
+ *     return this.query()
+ *       .where('active', true)
+ *       .orderBy('name')
+ *       .get();
+ *   }
+ *
+ *   async findWithPosts(id: number): Promise<User | null> {
+ *     return this.query()
+ *       .with('posts')
+ *       .find(id);
+ *   }
+ * }
+ * ```
+ */
+export interface PaginationMeta {
+    total: number;
+    page: number;
+    perPage: number;
+    lastPage: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+}
+export interface PaginatedResult<T> {
+    data: T[];
+    meta: PaginationMeta;
+}
+export interface SortOption {
+    column: string;
+    direction: 'asc' | 'desc';
+}
+export interface FilterCriteria {
+    column: string;
+    operator: '=' | '!=' | '>' | '<' | '>=' | '<=' | 'like' | 'in' | 'not_in';
+    value: any;
+}
+export declare abstract class Repository<TModel = any> {
+    /**
+     * Return the Model class this repository works with
+     */
+    abstract model(): any;
+    /**
+     * Get a fresh query builder for the model
+     */
+    protected query(): any;
+    /**
+     * Get all records
+     */
+    all(): Promise<TModel[]>;
+    /**
+     * Find a record by primary key
+     */
+    findById(id: any): Promise<TModel | null>;
+    /**
+     * Find a record by primary key or throw
+     */
+    findByIdOrFail(id: any): Promise<TModel>;
+    /**
+     * Find records matching a where clause
+     */
+    findWhere(column: string, value: any): Promise<TModel[]>;
+    /**
+     * Find the first record matching a where clause
+     */
+    findFirstWhere(column: string, value: any): Promise<TModel | null>;
+    /**
+     * Create a new record
+     */
+    create(attributes: Record<string, any>): Promise<TModel>;
+    /**
+     * Update a record by primary key
+     */
+    update(id: any, attributes: Record<string, any>): Promise<TModel>;
+    /**
+     * Delete a record by primary key
+     */
+    delete(id: any): Promise<void>;
+    /**
+     * Create multiple records
+     */
+    createMany(items: Record<string, any>[]): Promise<TModel[]>;
+    /**
+     * Delete records matching a where clause
+     */
+    deleteWhere(column: string, value: any): Promise<number>;
+    /**
+     * Count all records
+     */
+    count(): Promise<number>;
+    /**
+     * Count records matching a where clause
+     */
+    countWhere(column: string, value: any): Promise<number>;
+    /**
+     * Check if a record exists with the given criteria
+     */
+    exists(column: string, value: any): Promise<boolean>;
+    /**
+     * Paginate results
+     */
+    paginate(page?: number, perPage?: number): Promise<PaginatedResult<TModel>>;
+    /**
+     * Get the latest records
+     */
+    latest(limit?: number, column?: string): Promise<TModel[]>;
+    /**
+     * Get the oldest records
+     */
+    oldest(limit?: number, column?: string): Promise<TModel[]>;
+    /**
+     * Find or create a record
+     */
+    firstOrCreate(searchAttributes: Record<string, any>, createAttributes?: Record<string, any>): Promise<TModel>;
+    /**
+     * Update or create a record
+     */
+    updateOrCreate(searchAttributes: Record<string, any>, updateAttributes: Record<string, any>): Promise<TModel>;
+    /**
+     * Apply multiple filter criteria
+     */
+    filter(criteria: FilterCriteria[], sort?: SortOption): Promise<TModel[]>;
+    /**
+     * Pluck a single column from all records
+     */
+    pluck(column: string): Promise<any[]>;
+}

package/dist/repositories/index.js

@@ -0,0 +1 @@
+var o=class{query(){return this.model().query()}async all(){return this.model().all()}async findById(e){return this.model().find(e)}async findByIdOrFail(e){return this.model().findOrFail(e)}async findWhere(e,t){return this.model().where(e,t).get()}async findFirstWhere(e,t){return this.model().where(e,t).first()}async create(e){return this.model().create(e)}async update(e,t){let r=await this.findByIdOrFail(e);return await r.update(t),r}async delete(e){await(await this.findByIdOrFail(e)).delete()}async createMany(e){let t=[];for(let r of e)t.push(await this.create(r));return t}async deleteWhere(e,t){return this.query().where(e,t).delete()}async count(){return this.model().count()}async countWhere(e,t){return this.query().where(e,t).count()}async exists(e,t){return this.query().where(e,t).exists()}async paginate(e=1,t=15){let r=await this.query().paginate(e,t);return{data:r.data,meta:{total:r.total,page:r.currentPage,perPage:r.perPage,lastPage:r.lastPage,hasNextPage:r.currentPage<r.lastPage,hasPrevPage:r.currentPage>1}}}async latest(e,t="created_at"){let r=this.query().orderBy(t,"desc");return e&&r.limit(e),r.get()}async oldest(e,t="created_at"){let r=this.query().orderBy(t,"asc");return e&&r.limit(e),r.get()}async firstOrCreate(e,t){let r=Object.entries(e),a=this.query();for(let[i,s]of r)a=a.where(i,s);let n=await a.first();return n||this.create({...e,...t})}async updateOrCreate(e,t){let r=Object.entries(e),a=this.query();for(let[i,s]of r)a=a.where(i,s);let n=await a.first();return n?(await n.update(t),n):this.create({...e,...t})}async filter(e,t){let r=this.query();for(let{column:a,operator:n,value:i}of e)switch(n){case"in":r=r.whereIn(a,i);break;case"not_in":r=r.whereNotIn(a,i);break;case"like":r=r.where(a,"like",i);break;default:r=r.where(a,n,i)}return t&&(r=r.orderBy(t.column,t.direction)),r.get()}async pluck(e){return this.query().pluck(e)}};export{o as Repository};