@beeblock/svelar 0.4.0

package/dist/orm/Model.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Svelar Model
+ *
+ * Eloquent-like base Model class. Extend this for each database table.
+ *
+ * @example
+ * ```ts
+ * class User extends Model {
+ *   static table = 'users';
+ *   static timestamps = true;
+ *
+ *   declare id: number;
+ *   declare email: string;
+ *   declare name: string;
+ *
+ *   posts() {
+ *     return this.hasMany(Post, 'user_id');
+ *   }
+ * }
+ *
+ * const user = await User.find(1);
+ * const posts = await user.posts().load(user);
+ * ```
+ */
+import { QueryBuilder } from './QueryBuilder.js';
+import { HasOne, HasMany, BelongsTo, BelongsToMany } from './Relationship.js';
+import { type ModelObserver } from './Observer.js';
+export type ModelAttributes = Record<string, any>;
+export interface ModelHooks {
+    creating?: (model: Model) => Promise<void> | void;
+    created?: (model: Model) => Promise<void> | void;
+    updating?: (model: Model) => Promise<void> | void;
+    updated?: (model: Model) => Promise<void> | void;
+    saving?: (model: Model) => Promise<void> | void;
+    saved?: (model: Model) => Promise<void> | void;
+    deleting?: (model: Model) => Promise<void> | void;
+    deleted?: (model: Model) => Promise<void> | void;
+}
+export declare class Model {
+    /** The database table name */
+    static table: string;
+    /** Primary key column */
+    static primaryKey: string;
+    /** Whether the model uses auto-incrementing IDs */
+    static incrementing: boolean;
+    /** Whether the model manages created_at/updated_at */
+    static timestamps: boolean;
+    /** Column names for timestamps */
+    static createdAt: string;
+    static updatedAt: string;
+    /** Attribute casting definitions */
+    static casts: Record<string, 'string' | 'number' | 'boolean' | 'date' | 'json'>;
+    /** Columns that can be mass-assigned */
+    static fillable: string[];
+    /** Columns that are hidden from serialization */
+    static hidden: string[];
+    /** Database connection name (null = default) */
+    static connection: string | undefined;
+    /** Registered model hooks */
+    private static hooks;
+    /** Registered model observers */
+    private static observers;
+    /** Custom model events (e.g. ['published', 'archived']) */
+    static events: string[];
+    private attributes;
+    private originalAttributes;
+    private relations;
+    private exists;
+    constructor(attributes?: ModelAttributes);
+    static query<T extends Model>(this: new () => T): QueryBuilder<T>;
+    static find<T extends Model>(this: new () => T, id: any): Promise<T | null>;
+    static findOrFail<T extends Model>(this: new () => T, id: any): Promise<T>;
+    static all<T extends Model>(this: new () => T): Promise<T[]>;
+    static first<T extends Model>(this: new () => T): Promise<T | null>;
+    static firstOrFail<T extends Model>(this: new () => T): Promise<T>;
+    static where<T extends Model>(this: new () => T, column: string, operatorOrValue?: any, value?: any): QueryBuilder<T>;
+    static whereIn<T extends Model>(this: new () => T, column: string, values: any[]): QueryBuilder<T>;
+    static whereNull<T extends Model>(this: new () => T, column: string): QueryBuilder<T>;
+    static whereNotNull<T extends Model>(this: new () => T, column: string): QueryBuilder<T>;
+    static orderBy<T extends Model>(this: new () => T, column: string, direction?: 'asc' | 'desc'): QueryBuilder<T>;
+    static latest<T extends Model>(this: new () => T, column?: string): QueryBuilder<T>;
+    static oldest<T extends Model>(this: new () => T, column?: string): QueryBuilder<T>;
+    static with<T extends Model>(this: new () => T, ...relations: string[]): QueryBuilder<T>;
+    static count(this: typeof Model): Promise<number>;
+    static create<T extends Model>(this: new () => T, attributes: ModelAttributes): Promise<T>;
+    save(): Promise<void>;
+    update(attributes: ModelAttributes): Promise<void>;
+    delete(): Promise<void>;
+    refresh(): Promise<void>;
+    getAttribute(key: string): any;
+    setAttribute(key: string, value: any): void;
+    fill(attributes: ModelAttributes): void;
+    getAttributes(): ModelAttributes;
+    getOriginal(key?: string): any;
+    getDirty(): ModelAttributes;
+    isDirty(...keys: string[]): boolean;
+    isClean(...keys: string[]): boolean;
+    wasChanged(...keys: string[]): boolean;
+    protected hasOne(related: typeof Model, foreignKey: string, localKey?: string): HasOne;
+    protected hasMany(related: typeof Model, foreignKey: string, localKey?: string): HasMany;
+    protected belongsTo(related: typeof Model, foreignKey: string, ownerKey?: string): BelongsTo;
+    protected belongsToMany(related: typeof Model, pivotTable: string, foreignPivotKey: string, relatedPivotKey: string, parentKey?: string, relatedKey?: string): BelongsToMany;
+    setRelation(name: string, value: any): void;
+    getRelation(name: string): any;
+    relationLoaded(name: string): boolean;
+    toJSON(): ModelAttributes;
+    toObject(): ModelAttributes;
+    /** @internal Create a model instance from a database row */
+    static hydrate<T extends Model>(this: new () => T, row: Record<string, any>): T;
+    /** Register hooks for this model class */
+    static boot(hooks: ModelHooks): void;
+    /** Register an observer for this model class */
+    static observe(observer: ModelObserver): void;
+    /** Remove all observers for this model class */
+    static removeObservers(): void;
+    private fireHook;
+    /** Fire a custom model event */
+    fireEvent(eventName: string): Promise<void>;
+    private syncOriginal;
+    private getInsertableAttributes;
+    /** Getter-based table name accessor (for relationship classes) */
+    static get tableName(): string;
+}

package/dist/orm/Observer.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Svelar Model Observer
+ *
+ * Observers encapsulate model lifecycle logic in a dedicated class.
+ * Each method corresponds to a model event and receives the model instance.
+ *
+ * @example
+ * ```ts
+ * class UserObserver extends ModelObserver {
+ *   async created(user: User) {
+ *     await sendWelcomeEmail(user);
+ *   }
+ *
+ *   async deleting(user: User) {
+ *     await user.posts().query().delete();
+ *   }
+ * }
+ *
+ * User.observe(new UserObserver());
+ * ```
+ */
+import type { Model } from './Model.js';
+export type ModelEventName = 'creating' | 'created' | 'updating' | 'updated' | 'saving' | 'saved' | 'deleting' | 'deleted';
+export declare const MODEL_EVENTS: ModelEventName[];
+export declare abstract class ModelObserver {
+    creating?(model: Model): Promise<void> | void;
+    created?(model: Model): Promise<void> | void;
+    updating?(model: Model): Promise<void> | void;
+    updated?(model: Model): Promise<void> | void;
+    saving?(model: Model): Promise<void> | void;
+    saved?(model: Model): Promise<void> | void;
+    deleting?(model: Model): Promise<void> | void;
+    deleted?(model: Model): Promise<void> | void;
+}

package/dist/orm/QueryBuilder.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Svelar QueryBuilder
+ *
+ * Eloquent-like fluent query builder that compiles to raw SQL.
+ * Works across SQLite, PostgreSQL, and MySQL through the Connection manager.
+ */
+export type WhereOperator = '=' | '!=' | '<>' | '>' | '>=' | '<' | '<=' | 'LIKE' | 'NOT LIKE' | 'IN' | 'NOT IN' | 'IS' | 'IS NOT' | 'BETWEEN';
+export type OrderDirection = 'asc' | 'desc';
+export type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'CROSS';
+interface PaginationResult<T> {
+    data: T[];
+    total: number;
+    page: number;
+    perPage: number;
+    lastPage: number;
+    hasMore: boolean;
+}
+export declare class QueryBuilder<TModel = any> {
+    private tableName;
+    private selectColumns;
+    private whereClauses;
+    private joinClauses;
+    private orderClauses;
+    private groupByColumns;
+    private havingClauses;
+    private limitValue;
+    private offsetValue;
+    private eagerLoads;
+    private isDistinct;
+    private connectionName?;
+    private cteClauses;
+    private unionClauses;
+    private modelClass?;
+    constructor(table: string, modelClass?: any, connectionName?: string);
+    select(...columns: string[]): this;
+    addSelect(...columns: string[]): this;
+    distinct(): this;
+    from(table: string): this;
+    where(column: string, operatorOrValue?: any, value?: any): this;
+    orWhere(column: string, operatorOrValue?: any, value?: any): this;
+    whereIn(column: string, values: any[]): this;
+    whereNotIn(column: string, values: any[]): this;
+    whereNull(column: string): this;
+    whereNotNull(column: string): this;
+    whereBetween(column: string, range: [any, any]): this;
+    whereRaw(sql: string, bindings?: any[]): this;
+    whereNested(callback: (query: QueryBuilder) => void, bool?: 'AND' | 'OR'): this;
+    orWhereNested(callback: (query: QueryBuilder) => void): this;
+    whereExists(callback: (query: QueryBuilder) => void): this;
+    whereNotExists(callback: (query: QueryBuilder) => void): this;
+    whereSub(column: string, operator: string, callback: (query: QueryBuilder) => void): this;
+    orWhereRaw(sql: string, bindings?: any[]): this;
+    orWhereIn(column: string, values: any[]): this;
+    orWhereNull(column: string): this;
+    orWhereNotNull(column: string): this;
+    withCTE(name: string, callback: (query: QueryBuilder) => void, recursive?: boolean): this;
+    withRecursiveCTE(name: string, callback: (query: QueryBuilder) => void): this;
+    withRawCTE(name: string, sql: string, bindings?: any[], recursive?: boolean): this;
+    union(callback: (query: QueryBuilder) => void): this;
+    unionAll(callback: (query: QueryBuilder) => void): this;
+    join(table: string, first: string, operator: string, second: string): this;
+    leftJoin(table: string, first: string, operator: string, second: string): this;
+    rightJoin(table: string, first: string, operator: string, second: string): this;
+    crossJoin(table: string): this;
+    orderBy(column: string, direction?: OrderDirection): this;
+    latest(column?: string): this;
+    oldest(column?: string): this;
+    groupBy(...columns: string[]): this;
+    having(column: string, operator: string, value: any): this;
+    limit(count: number): this;
+    offset(skip: number): this;
+    take(count: number): this;
+    skip(count: number): this;
+    with(...relations: string[]): this;
+    get(): Promise<TModel[]>;
+    first(): Promise<TModel | null>;
+    firstOrFail(): Promise<TModel>;
+    find(id: any, primaryKey?: string): Promise<TModel | null>;
+    findOrFail(id: any, primaryKey?: string): Promise<TModel>;
+    count(column?: string): Promise<number>;
+    sum(column: string): Promise<number>;
+    avg(column: string): Promise<number>;
+    max(column: string): Promise<any>;
+    min(column: string): Promise<any>;
+    exists(): Promise<boolean>;
+    doesntExist(): Promise<boolean>;
+    pluck(column: string): Promise<any[]>;
+    value(column: string): Promise<any>;
+    chunk(size: number, callback: (items: TModel[], page: number) => Promise<boolean | void>): Promise<void>;
+    when(condition: boolean | any, callback: (query: this) => this): this;
+    selectRaw(expression: string): this;
+    upsert(data: Record<string, any>, conflictColumns: string[], updateColumns?: string[]): Promise<any>;
+    insertMany(rows: Record<string, any>[]): Promise<any>;
+    firstOrCreate(search: Record<string, any>, create?: Record<string, any>): Promise<TModel>;
+    updateOrCreate(search: Record<string, any>, update: Record<string, any>): Promise<TModel>;
+    whereColumn(first: string, operatorOrSecond: string, second?: string): this;
+    havingRaw(sql: string, bindings?: any[]): this;
+    orderByRaw(sql: string): this;
+    selectSub(callback: (query: QueryBuilder) => void, alias: string): this;
+    private _selectBindings?;
+    truncate(): Promise<void>;
+    paginate(page?: number, perPage?: number): Promise<PaginationResult<TModel>>;
+    insert(data: Record<string, any>): Promise<any>;
+    insertGetId(data: Record<string, any>, primaryKey?: string): Promise<number>;
+    update(data: Record<string, any>): Promise<number>;
+    delete(): Promise<number>;
+    increment(column: string, amount?: number): Promise<void>;
+    decrement(column: string, amount?: number): Promise<void>;
+    toSQL(): {
+        sql: string;
+        bindings: any[];
+    };
+    clone(): QueryBuilder<TModel>;
+    private buildWhere;
+    private buildAggregate;
+    private hydrateMany;
+    private loadRelations;
+}
+export {};

package/dist/orm/Relationship.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Svelar Relationships
+ *
+ * Eloquent-like relationship definitions:
+ * HasOne, HasMany, BelongsTo, BelongsToMany
+ */
+import { QueryBuilder } from './QueryBuilder.js';
+export declare abstract class Relation<TParent = any, TRelated = any> {
+    protected parentModel: any;
+    protected relatedModel: any;
+    constructor(parent: any, related: any);
+    /** Load related models for a single parent */
+    abstract load(parent: TParent): Promise<TRelated>;
+    /** Eager load related models for a collection of parents */
+    abstract eagerLoad(parents: TParent[], relationName: string): Promise<void>;
+    /** Get a query builder for the related model */
+    query(): QueryBuilder;
+}
+export declare class HasOne extends Relation {
+    private foreignKey;
+    private localKey;
+    constructor(parent: any, related: any, foreignKey: string, localKey?: string);
+    load(parent: any): Promise<any>;
+    eagerLoad(parents: any[], relationName: string): Promise<void>;
+    create(attributes: Record<string, any>): Promise<any>;
+}
+export declare class HasMany extends Relation {
+    private foreignKey;
+    private localKey;
+    constructor(parent: any, related: any, foreignKey: string, localKey?: string);
+    load(parent: any): Promise<any[]>;
+    eagerLoad(parents: any[], relationName: string): Promise<void>;
+    create(attributes: Record<string, any>): Promise<any>;
+    createMany(items: Record<string, any>[]): Promise<any[]>;
+}
+export declare class BelongsTo extends Relation {
+    private foreignKey;
+    private ownerKey;
+    constructor(parent: any, related: any, foreignKey: string, ownerKey?: string);
+    load(parent: any): Promise<any>;
+    eagerLoad(parents: any[], relationName: string): Promise<void>;
+    associate(model: any): any;
+    dissociate(): any;
+}
+export declare class BelongsToMany extends Relation {
+    private pivotTable;
+    private foreignPivotKey;
+    private relatedPivotKey;
+    private parentKey;
+    private relatedKey;
+    constructor(parent: any, related: any, pivotTable: string, foreignPivotKey: string, relatedPivotKey: string, parentKey?: string, relatedKey?: string);
+    load(parent: any): Promise<any[]>;
+    eagerLoad(parents: any[], relationName: string): Promise<void>;
+    attach(id: any, pivot?: Record<string, any>): Promise<void>;
+    detach(id?: any): Promise<void>;
+    sync(ids: any[]): Promise<void>;
+    toggle(ids: any[]): Promise<void>;
+}

package/dist/orm/index.d.ts

@@ -0,0 +1,4 @@
+export { Model, type ModelAttributes, type ModelHooks } from './Model.js';
+export { QueryBuilder, type WhereOperator, type OrderDirection, type JoinType } from './QueryBuilder.js';
+export { Relation, HasOne, HasMany, BelongsTo, BelongsToMany } from './Relationship.js';
+export { ModelObserver, type ModelEventName, MODEL_EVENTS } from './Observer.js';

package/dist/orm/index.js

@@ -0,0 +1 @@
+function v(l,e){let t=Symbol.for(l),s=globalThis;return s[t]||(s[t]=e()),s[t]}var M=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 s=this.config.connections[t];if(!s)throw new Error(`Database connection "${t}" is not defined in configuration.`);let i=await this.createConnection(s);return this.connections.set(t,i),i.drizzle}async rawClient(e){let t=e??this.defaultName;return await this.connection(t),this.connections.get(t).rawClient}async raw(e,t=[],s){let i=await this.connection(s),n=this.getConfig(s);switch(n.driver){case"sqlite":{let r=await this.rawClient(s),o=t.map(u=>typeof u=="boolean"?u?1:0:u instanceof Date?u.toISOString():u),a=r.prepare(e),d=e.trimStart().toUpperCase();return d.startsWith("SELECT")||d.startsWith("PRAGMA")||d.startsWith("WITH")?a.all(...o):a.run(...o)}case"postgres":return(await this.rawClient(s))(e,...t);case"mysql":{let r=await this.rawClient(s),[o]=await r.execute(e,t);return o}default:throw new Error(`Unsupported driver: ${n.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 s=this.config.connections[t];if(!s)throw new Error(`Database connection "${t}" is not defined.`);return s}async disconnect(e){if(e){let t=this.connections.get(e);t&&(await this.closeConnection(t),this.connections.delete(e))}else{for(let[t,s]of this.connections)await this.closeConnection(s);this.connections.clear()}}isConnected(e){return this.connections.has(e??this.defaultName)}async transaction(e,t){let s=this.getConfig(t),i=await this.rawClient(t);switch(s.driver){case"sqlite":{i.exec("BEGIN");try{let n=await e();return i.exec("COMMIT"),n}catch(n){throw i.exec("ROLLBACK"),n}}case"postgres":{await i`BEGIN`;try{let n=await e();return await i`COMMIT`,n}catch(n){throw await i`ROLLBACK`,n}}case"mysql":{let n=await i.getConnection();await n.beginTransaction();try{let r=await e();return await n.commit(),n.release(),r}catch(r){throw await n.rollback(),n.release(),r}}default:throw new Error(`Unsupported driver: ${s.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 s=(await import("better-sqlite3")).default,{drizzle:i}=await import("drizzle-orm/better-sqlite3"),n=new s(t);return n.pragma("journal_mode = WAL"),n.pragma("foreign_keys = ON"),{drizzle:i(n),config:e,rawClient:n}}catch(s){let i;try{i=(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: ${s instanceof Error?s.message:String(s)}`)}let n=new i(t);n.exec("PRAGMA journal_mode = WAL"),n.exec("PRAGMA foreign_keys = ON");let r={prepare(a){let d=n.prepare(a);return{all(...u){return d.all(...u)},run(...u){return d.run(...u)},get(...u){return d.get(...u)}}},exec(a){n.exec(a)},pragma(a){return n.prepare(`PRAGMA ${a}`).all()},close(){n.close()}},o;try{let{drizzle:a}=await import("drizzle-orm/better-sqlite3");o=a(r)}catch{o=r}return{drizzle:o,config:e,rawClient:r}}}async createPostgresConnection(e){let t=(await import("postgres")).default,{drizzle:s}=await import("drizzle-orm/postgres-js"),i=e.url??`postgres://${e.user}:${e.password}@${e.host??"localhost"}:${e.port??5432}/${e.database}`,n=t(i);return{drizzle:s(n),config:e,rawClient:n}}async createMySQLConnection(e){let t=await import("mysql2/promise"),{drizzle:s}=await import("drizzle-orm/mysql2"),i=t.createPool({host:e.host??"localhost",port:e.port??3306,database:e.database,user:e.user,password:e.password,uri:e.url});return{drizzle:s(i),config:e,rawClient:i}}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{}}},c=v("svelar.connection",()=>new M);var y=class l{tableName;selectColumns=["*"];whereClauses=[];joinClauses=[];orderClauses=[];groupByColumns=[];havingClauses=[];limitValue=null;offsetValue=null;eagerLoads=[];isDistinct=!1;connectionName;cteClauses=[];unionClauses=[];modelClass;constructor(e,t,s){this.tableName=e,this.modelClass=t,this.connectionName=s}select(...e){return this.selectColumns=e.length>0?e:["*"],this}addSelect(...e){return this.selectColumns[0]==="*"?this.selectColumns=e:this.selectColumns.push(...e),this}distinct(){return this.isDistinct=!0,this}from(e){return this.tableName=e,this}where(e,t,s){return s===void 0?this.whereClauses.push({type:"basic",column:e,operator:"=",value:t,boolean:"AND"}):this.whereClauses.push({type:"basic",column:e,operator:t,value:s,boolean:"AND"}),this}orWhere(e,t,s){return s===void 0?this.whereClauses.push({type:"basic",column:e,operator:"=",value:t,boolean:"OR"}):this.whereClauses.push({type:"basic",column:e,operator:t,value:s,boolean:"OR"}),this}whereIn(e,t){return this.whereClauses.push({type:"in",column:e,values:t,boolean:"AND"}),this}whereNotIn(e,t){return this.whereClauses.push({type:"notIn",column:e,values:t,boolean:"AND"}),this}whereNull(e){return this.whereClauses.push({type:"null",column:e,boolean:"AND"}),this}whereNotNull(e){return this.whereClauses.push({type:"notNull",column:e,boolean:"AND"}),this}whereBetween(e,t){return this.whereClauses.push({type:"between",column:e,values:t,boolean:"AND"}),this}whereRaw(e,t=[]){return this.whereClauses.push({type:"raw",raw:e,values:t,boolean:"AND"}),this}whereNested(e,t="AND"){let s=new l(this.tableName,this.modelClass,this.connectionName);if(e(s),s.whereClauses.length>0){let{whereSQL:i,whereBindings:n}=s.buildWhere(),r=i.replace(/^WHERE /,"");this.whereClauses.push({type:"raw",raw:`(${r})`,values:n,boolean:t})}return this}orWhereNested(e){return this.whereNested(e,"OR")}whereExists(e){let t=new l("__placeholder__",void 0,this.connectionName);e(t);let{sql:s,bindings:i}=t.toSQL();return this.whereClauses.push({type:"exists",subSQL:s,subBindings:i,boolean:"AND"}),this}whereNotExists(e){let t=new l("__placeholder__",void 0,this.connectionName);e(t);let{sql:s,bindings:i}=t.toSQL();return this.whereClauses.push({type:"notExists",subSQL:s,subBindings:i,boolean:"AND"}),this}whereSub(e,t,s){let i=new l("__placeholder__",void 0,this.connectionName);s(i);let{sql:n,bindings:r}=i.toSQL();return this.whereClauses.push({type:"sub",column:e,operator:t,subSQL:n,subBindings:r,boolean:"AND"}),this}orWhereRaw(e,t=[]){return this.whereClauses.push({type:"raw",raw:e,values:t,boolean:"OR"}),this}orWhereIn(e,t){return this.whereClauses.push({type:"in",column:e,values:t,boolean:"OR"}),this}orWhereNull(e){return this.whereClauses.push({type:"null",column:e,boolean:"OR"}),this}orWhereNotNull(e){return this.whereClauses.push({type:"notNull",column:e,boolean:"OR"}),this}withCTE(e,t,s=!1){let i=new l("__placeholder__",void 0,this.connectionName);t(i);let{sql:n,bindings:r}=i.toSQL();return this.cteClauses.push({name:e,sql:n,bindings:r,recursive:s}),this}withRecursiveCTE(e,t){return this.withCTE(e,t,!0)}withRawCTE(e,t,s=[],i=!1){return this.cteClauses.push({name:e,sql:t,bindings:s,recursive:i}),this}union(e){let t=new l("__placeholder__",void 0,this.connectionName);e(t);let{sql:s,bindings:i}=t.toSQL();return this.unionClauses.push({sql:s,bindings:i,all:!1}),this}unionAll(e){let t=new l("__placeholder__",void 0,this.connectionName);e(t);let{sql:s,bindings:i}=t.toSQL();return this.unionClauses.push({sql:s,bindings:i,all:!0}),this}join(e,t,s,i){return this.joinClauses.push({type:"INNER",table:e,first:t,operator:s,second:i}),this}leftJoin(e,t,s,i){return this.joinClauses.push({type:"LEFT",table:e,first:t,operator:s,second:i}),this}rightJoin(e,t,s,i){return this.joinClauses.push({type:"RIGHT",table:e,first:t,operator:s,second:i}),this}crossJoin(e){return this.joinClauses.push({type:"CROSS",table:e,first:"",operator:"",second:""}),this}orderBy(e,t="asc"){return this.orderClauses.push({column:e,direction:t}),this}latest(e="created_at"){return this.orderBy(e,"desc")}oldest(e="created_at"){return this.orderBy(e,"asc")}groupBy(...e){return this.groupByColumns.push(...e),this}having(e,t,s){return this.havingClauses.push({type:"basic",column:e,operator:t,value:s,boolean:"AND"}),this}limit(e){return this.limitValue=e,this}offset(e){return this.offsetValue=e,this}take(e){return this.limit(e)}skip(e){return this.offset(e)}with(...e){return this.eagerLoads.push(...e),this}async get(){let{sql:e,bindings:t}=this.toSQL(),s=await c.raw(e,t,this.connectionName),i=this.hydrateMany(s);return this.eagerLoads.length>0&&this.modelClass&&await this.loadRelations(i),i}async first(){return this.limitValue=1,(await this.get())[0]??null}async firstOrFail(){let e=await this.first();if(!e)throw new Error(`No results found for query on "${this.tableName}".`);return e}async find(e,t="id"){return this.where(t,e).first()}async findOrFail(e,t="id"){return this.where(t,e).firstOrFail()}async count(e="*"){let{sql:t,bindings:s}=this.buildAggregate(`COUNT(${e})`),i=await c.raw(t,s,this.connectionName);return Number(i[0]?.aggregate??0)}async sum(e){let{sql:t,bindings:s}=this.buildAggregate(`SUM(${e})`),i=await c.raw(t,s,this.connectionName);return Number(i[0]?.aggregate??0)}async avg(e){let{sql:t,bindings:s}=this.buildAggregate(`AVG(${e})`),i=await c.raw(t,s,this.connectionName);return Number(i[0]?.aggregate??0)}async max(e){let{sql:t,bindings:s}=this.buildAggregate(`MAX(${e})`);return(await c.raw(t,s,this.connectionName))[0]?.aggregate??null}async min(e){let{sql:t,bindings:s}=this.buildAggregate(`MIN(${e})`);return(await c.raw(t,s,this.connectionName))[0]?.aggregate??null}async exists(){return await this.count()>0}async doesntExist(){return!await this.exists()}async pluck(e){return this.selectColumns=[e],(await c.raw(this.toSQL().sql,this.toSQL().bindings,this.connectionName)).map(s=>s[e])}async value(e){return this.selectColumns=[e],this.limitValue=1,(await c.raw(this.toSQL().sql,this.toSQL().bindings,this.connectionName))[0]?.[e]??null}async chunk(e,t){let s=1,i=!0;for(;i;){let n=this.clone();n.limitValue=e,n.offsetValue=(s-1)*e;let r=await n.get();if(r.length===0||await t(r,s)===!1||r.length<e)break;s++}}when(e,t){return e&&t(this),this}selectRaw(e){return this.selectColumns[0]==="*"?this.selectColumns=[e]:this.selectColumns.push(e),this}async upsert(e,t,s){let i=c.getDriver(this.connectionName),n=Object.keys(e),r=Object.values(e),o=r.map(()=>"?").join(", "),a=s??n.filter(u=>!t.includes(u)),d;if(i==="postgres"){let u=a.map(h=>`${h} = EXCLUDED.${h}`).join(", ");d=`INSERT INTO ${this.tableName} (${n.join(", ")}) VALUES (${o}) ON CONFLICT (${t.join(", ")}) DO UPDATE SET ${u}`}else if(i==="mysql"){let u=a.map(h=>`${h} = VALUES(${h})`).join(", ");d=`INSERT INTO ${this.tableName} (${n.join(", ")}) VALUES (${o}) ON DUPLICATE KEY UPDATE ${u}`}else{let u=a.map(h=>`${h} = excluded.${h}`).join(", ");d=`INSERT INTO ${this.tableName} (${n.join(", ")}) VALUES (${o}) ON CONFLICT (${t.join(", ")}) DO UPDATE SET ${u}`}return c.raw(d,r,this.connectionName)}async insertMany(e){if(e.length===0)return;let t=Object.keys(e[0]),s=[],i=[];for(let r of e){let o=t.map(a=>r[a]);s.push(...o),i.push(`(${o.map(()=>"?").join(", ")})`)}let n=`INSERT INTO ${this.tableName} (${t.join(", ")}) VALUES ${i.join(", ")}`;return c.raw(n,s,this.connectionName)}async firstOrCreate(e,t={}){for(let[r,o]of Object.entries(e))this.where(r,o);let s=await this.first();if(s)return s;let i={...e,...t},n=await new l(this.tableName,this.modelClass,this.connectionName).insertGetId(i);return new l(this.tableName,this.modelClass,this.connectionName).findOrFail(n)}async updateOrCreate(e,t){let s=new l(this.tableName,this.modelClass,this.connectionName);for(let[o,a]of Object.entries(e))s.where(o,a);let i=await s.first();if(i)return await new l(this.tableName,this.modelClass,this.connectionName).where(this.modelClass?.primaryKey??"id",i[this.modelClass?.primaryKey??"id"]).update(t),new l(this.tableName,this.modelClass,this.connectionName).findOrFail(i[this.modelClass?.primaryKey??"id"]);let n={...e,...t},r=await new l(this.tableName,this.modelClass,this.connectionName).insertGetId(n);return new l(this.tableName,this.modelClass,this.connectionName).findOrFail(r)}whereColumn(e,t,s){return s===void 0?this.whereClauses.push({type:"raw",raw:`${e} = ${t}`,values:[],boolean:"AND"}):this.whereClauses.push({type:"raw",raw:`${e} ${t} ${s}`,values:[],boolean:"AND"}),this}havingRaw(e,t=[]){return this.havingClauses.push({type:"raw",raw:e,values:t,boolean:"AND"}),this}orderByRaw(e){return this.orderClauses.push({column:e,direction:"asc"}),this.orderClauses[this.orderClauses.length-1].__raw=!0,this}selectSub(e,t){let s=new l("__placeholder__",void 0,this.connectionName);e(s);let{sql:i,bindings:n}=s.toSQL(),r=`(${i}) as ${t}`;return this.selectColumns[0]==="*"?this.selectColumns=[r]:this.selectColumns.push(r),this._selectBindings||(this._selectBindings=[]),this._selectBindings.push(...n),this}_selectBindings;async truncate(){c.getDriver(this.connectionName)==="sqlite"?(await c.raw(`DELETE FROM ${this.tableName}`,[],this.connectionName),await c.raw("DELETE FROM sqlite_sequence WHERE name = ?",[this.tableName],this.connectionName)):await c.raw(`TRUNCATE TABLE ${this.tableName}`,[],this.connectionName)}async paginate(e=1,t=15){let s=await this.clone().count(),i=Math.ceil(s/t);return this.limitValue=t,this.offsetValue=(e-1)*t,{data:await this.get(),total:s,page:e,perPage:t,lastPage:i,hasMore:e<i}}async insert(e){let t=Object.keys(e),s=Object.values(e),i=s.map(()=>"?").join(", "),n=`INSERT INTO ${this.tableName} (${t.join(", ")}) VALUES (${i})`;return c.raw(n,s,this.connectionName)}async insertGetId(e,t="id"){let s=c.getDriver(this.connectionName),i=Object.keys(e),n=Object.values(e),r=n.map(()=>"?").join(", "),o=`INSERT INTO ${this.tableName} (${i.join(", ")}) VALUES (${r})`;return s==="postgres"?(o+=` RETURNING ${t}`,(await c.raw(o,n,this.connectionName))[0]?.[t]):(await c.raw(o,n,this.connectionName),s==="sqlite"?(await c.raw("SELECT last_insert_rowid() as id",[],this.connectionName))[0]?.id:s==="mysql"?(await c.raw("SELECT LAST_INSERT_ID() as id",[],this.connectionName))[0]?.id:0)}async update(e){let t=Object.keys(e),s=Object.values(e),i=t.map(a=>`${a} = ?`).join(", "),{whereSQL:n,whereBindings:r}=this.buildWhere(),o=`UPDATE ${this.tableName} SET ${i}${n}`;return await c.raw(o,[...s,...r],this.connectionName),1}async delete(){let{whereSQL:e,whereBindings:t}=this.buildWhere(),s=`DELETE FROM ${this.tableName}${e}`;return await c.raw(s,t,this.connectionName),1}async increment(e,t=1){let{whereSQL:s,whereBindings:i}=this.buildWhere(),n=`UPDATE ${this.tableName} SET ${e} = ${e} + ?${s}`;await c.raw(n,[t,...i],this.connectionName)}async decrement(e,t=1){return this.increment(e,-t)}toSQL(){let e=[],t=[];if(this.cteClauses.length>0){let o=this.cteClauses.some(d=>d.recursive)?"WITH RECURSIVE":"WITH",a=this.cteClauses.map(d=>(t.push(...d.bindings),`${d.name} AS (${d.sql})`));e.push(`${o} ${a.join(", ")}`)}this._selectBindings?.length&&t.push(...this._selectBindings);let s=this.isDistinct?"DISTINCT ":"";e.push(`SELECT ${s}${this.selectColumns.join(", ")}`),e.push(`FROM ${this.tableName}`);for(let r of this.joinClauses)r.type==="CROSS"?e.push(`CROSS JOIN ${r.table}`):e.push(`${r.type} JOIN ${r.table} ON ${r.first} ${r.operator} ${r.second}`);let{whereSQL:i,whereBindings:n}=this.buildWhere();if(i&&(e.push(i.trim()),t.push(...n)),this.groupByColumns.length>0&&e.push(`GROUP BY ${this.groupByColumns.join(", ")}`),this.havingClauses.length>0){let r=[];for(let o of this.havingClauses)o.type==="raw"?(r.push(o.raw),o.values&&t.push(...o.values)):(r.push(`${o.column} ${o.operator} ?`),t.push(o.value));e.push(`HAVING ${r.join(" AND ")}`)}if(this.orderClauses.length>0){let r=this.orderClauses.map(o=>o.__raw?o.column:`${o.column} ${o.direction.toUpperCase()}`);e.push(`ORDER BY ${r.join(", ")}`)}if(this.limitValue!==null&&e.push(`LIMIT ${this.limitValue}`),this.offsetValue!==null&&e.push(`OFFSET ${this.offsetValue}`),this.unionClauses.length>0)for(let r of this.unionClauses)e.push(r.all?"UNION ALL":"UNION"),e.push(r.sql),t.push(...r.bindings);return{sql:e.join(" "),bindings:t}}clone(){let e=new l(this.tableName,this.modelClass,this.connectionName);return e.selectColumns=[...this.selectColumns],e.whereClauses=[...this.whereClauses],e.joinClauses=[...this.joinClauses],e.orderClauses=[...this.orderClauses],e.groupByColumns=[...this.groupByColumns],e.havingClauses=[...this.havingClauses],e.limitValue=this.limitValue,e.offsetValue=this.offsetValue,e.eagerLoads=[...this.eagerLoads],e.isDistinct=this.isDistinct,e.cteClauses=[...this.cteClauses],e.unionClauses=[...this.unionClauses],e}buildWhere(){if(this.whereClauses.length===0)return{whereSQL:"",whereBindings:[]};let e=[],t=[];for(let s=0;s<this.whereClauses.length;s++){let i=this.whereClauses[s],n=s===0?"WHERE":i.boolean;switch(i.type){case"basic":if((i.operator==="IS"||i.operator==="IS NOT")&&i.value===null){let a=(i.operator==="IS","null");e.push(`${n} ${i.column} ${i.operator} ${a}`)}else e.push(`${n} ${i.column} ${i.operator} ?`),t.push(i.value);break;case"in":let r=i.values.map(()=>"?").join(", ");e.push(`${n} ${i.column} IN (${r})`),t.push(...i.values);break;case"notIn":let o=i.values.map(()=>"?").join(", ");e.push(`${n} ${i.column} NOT IN (${o})`),t.push(...i.values);break;case"null":e.push(`${n} ${i.column} IS NULL`);break;case"notNull":e.push(`${n} ${i.column} IS NOT NULL`);break;case"between":e.push(`${n} ${i.column} BETWEEN ? AND ?`),t.push(i.values[0],i.values[1]);break;case"raw":e.push(`${n} ${i.raw}`),i.values&&t.push(...i.values);break;case"exists":e.push(`${n} EXISTS (${i.subSQL})`),i.subBindings&&t.push(...i.subBindings);break;case"notExists":e.push(`${n} NOT EXISTS (${i.subSQL})`),i.subBindings&&t.push(...i.subBindings);break;case"sub":e.push(`${n} ${i.column} ${i.operator} (${i.subSQL})`),i.subBindings&&t.push(...i.subBindings);break}}return{whereSQL:e.join(" "),whereBindings:t}}buildAggregate(e){let t=this.selectColumns;this.selectColumns=[`${e} as aggregate`];let s=this.toSQL();return this.selectColumns=t,s}hydrateMany(e){return this.modelClass?e.map(t=>this.modelClass.hydrate(t)):e}async loadRelations(e){if(!(!this.modelClass||e.length===0))for(let t of this.eagerLoads){let i=new this.modelClass()[t]?.();i&&typeof i.eagerLoad=="function"&&await i.eagerLoad(e,t)}}};var g=class{parentModel;relatedModel;constructor(e,t){this.parentModel=e,this.relatedModel=t}query(){return this.relatedModel.query()}},m=class extends g{constructor(t,s,i,n="id"){super(t,s);this.foreignKey=i;this.localKey=n}async load(t){let s=t.getAttribute(this.localKey);return this.relatedModel.query().where(this.foreignKey,s).first()}async eagerLoad(t,s){let i=t.map(o=>o.getAttribute(this.localKey)),n=await this.relatedModel.query().whereIn(this.foreignKey,i).get(),r=new Map;for(let o of n)r.set(o.getAttribute(this.foreignKey),o);for(let o of t){let a=o.getAttribute(this.localKey);o.setRelation(s,r.get(a)??null)}}async create(t){let s=this.parentModel.getAttribute(this.localKey);return this.relatedModel.create({...t,[this.foreignKey]:s})}},b=class extends g{constructor(t,s,i,n="id"){super(t,s);this.foreignKey=i;this.localKey=n}async load(t){let s=t.getAttribute(this.localKey);return this.relatedModel.query().where(this.foreignKey,s).get()}async eagerLoad(t,s){let i=t.map(o=>o.getAttribute(this.localKey)),n=await this.relatedModel.query().whereIn(this.foreignKey,i).get(),r=new Map;for(let o of n){let a=o.getAttribute(this.foreignKey);r.has(a)||r.set(a,[]),r.get(a).push(o)}for(let o of t){let a=o.getAttribute(this.localKey);o.setRelation(s,r.get(a)??[])}}async create(t){let s=this.parentModel.getAttribute(this.localKey);return this.relatedModel.create({...t,[this.foreignKey]:s})}async createMany(t){let s=[];for(let i of t)s.push(await this.create(i));return s}},f=class extends g{constructor(t,s,i,n="id"){super(t,s);this.foreignKey=i;this.ownerKey=n}async load(t){let s=t.getAttribute(this.foreignKey);return s==null?null:this.relatedModel.query().where(this.ownerKey,s).first()}async eagerLoad(t,s){let i=t.map(o=>o.getAttribute(this.foreignKey)).filter(o=>o!=null);if(i.length===0){for(let o of t)o.setRelation(s,null);return}let n=await this.relatedModel.query().whereIn(this.ownerKey,i).get(),r=new Map;for(let o of n)r.set(o.getAttribute(this.ownerKey),o);for(let o of t){let a=o.getAttribute(this.foreignKey);o.setRelation(s,r.get(a)??null)}}associate(t){return this.parentModel.setAttribute(this.foreignKey,t.getAttribute(this.ownerKey)),this.parentModel}dissociate(){return this.parentModel.setAttribute(this.foreignKey,null),this.parentModel}},w=class extends g{constructor(t,s,i,n,r,o="id",a="id"){super(t,s);this.pivotTable=i;this.foreignPivotKey=n;this.relatedPivotKey=r;this.parentKey=o;this.relatedKey=a}async load(t){let s=t.getAttribute(this.parentKey),i=this.relatedModel.tableName,r=(await c.raw(`SELECT ${this.relatedPivotKey} FROM ${this.pivotTable} WHERE ${this.foreignPivotKey} = ?`,[s])).map(o=>o[this.relatedPivotKey]);return r.length===0?[]:this.relatedModel.query().whereIn(this.relatedKey,r).get()}async eagerLoad(t,s){let i=t.map(h=>h.getAttribute(this.parentKey));if(i.length===0){for(let h of t)h.setRelation(s,[]);return}let n=i.map(()=>"?").join(", "),r=await c.raw(`SELECT * FROM ${this.pivotTable} WHERE ${this.foreignPivotKey} IN (${n})`,i),o=[...new Set(r.map(h=>h[this.relatedPivotKey]))],a=o.length>0?await this.relatedModel.query().whereIn(this.relatedKey,o).get():[],d=new Map;for(let h of a)d.set(h.getAttribute(this.relatedKey),h);let u=new Map;for(let h of r){let p=h[this.foreignPivotKey],A=h[this.relatedPivotKey],L=d.get(A);L&&(u.has(p)||u.set(p,[]),u.get(p).push(L))}for(let h of t){let p=h.getAttribute(this.parentKey);h.setRelation(s,u.get(p)??[])}}async attach(t,s){let i=this.parentModel.getAttribute(this.parentKey),n={[this.foreignPivotKey]:i,[this.relatedPivotKey]:t,...s},r=Object.keys(n),o=Object.values(n),a=o.map(()=>"?").join(", ");await c.raw(`INSERT INTO ${this.pivotTable} (${r.join(", ")}) VALUES (${a})`,o)}async detach(t){let s=this.parentModel.getAttribute(this.parentKey);t?await c.raw(`DELETE FROM ${this.pivotTable} WHERE ${this.foreignPivotKey} = ? AND ${this.relatedPivotKey} = ?`,[s,t]):await c.raw(`DELETE FROM ${this.pivotTable} WHERE ${this.foreignPivotKey} = ?`,[s])}async sync(t){await this.detach();for(let s of t)await this.attach(s)}async toggle(t){let s=this.parentModel.getAttribute(this.parentKey);for(let i of t)(await c.raw(`SELECT 1 FROM ${this.pivotTable} WHERE ${this.foreignPivotKey} = ? AND ${this.relatedPivotKey} = ? LIMIT 1`,[s,i])).length>0?await this.detach(i):await this.attach(i)}};var T=class{listeners=new Map;wildcardListeners=[];onceListeners=new Map;listen(e,t){let s=typeof e=="string"?e:e.name;return this.listeners.has(s)||this.listeners.set(s,[]),this.listeners.get(s).push(t),()=>{let i=this.listeners.get(s);if(i){let n=i.indexOf(t);n>=0&&i.splice(n,1)}}}once(e,t){let s=typeof e=="string"?e:e.name;return this.onceListeners.has(s)||this.onceListeners.set(s,[]),this.onceListeners.get(s).push(t),()=>{let i=this.onceListeners.get(s);if(i){let n=i.indexOf(t);n>=0&&i.splice(n,1)}}}onAny(e){return this.wildcardListeners.push(e),()=>{let t=this.wildcardListeners.indexOf(e);t>=0&&this.wildcardListeners.splice(t,1)}}async dispatch(e){let t=e.constructor.name,s=this.listeners.get(t)??[];for(let n of s)await n(e);let i=this.onceListeners.get(t)??[];for(let n of i)await n(e);this.onceListeners.delete(t);for(let n of this.wildcardListeners)await n(t,e)}async emit(e,t){let s=this.listeners.get(e)??[];for(let n of s)await n(t);let i=this.onceListeners.get(e)??[];for(let n of i)await n(t);this.onceListeners.delete(e);for(let n of this.wildcardListeners)await n(e,t)}subscribe(e){e.subscribe(this)}forget(e){let t=typeof e=="string"?e:e.name;this.listeners.delete(t),this.onceListeners.delete(t)}flush(){this.listeners.clear(),this.onceListeners.clear(),this.wildcardListeners=[]}hasListeners(e){let t=typeof e=="string"?e:e.name;return(this.listeners.get(t)?.length??0)>0||(this.onceListeners.get(t)?.length??0)>0||this.wildcardListeners.length>0}listenerCount(e){let t=typeof e=="string"?e:e.name;return(this.listeners.get(t)?.length??0)+(this.onceListeners.get(t)?.length??0)}},C=v("svelar.event",()=>new T);var N=class l{static table;static primaryKey="id";static incrementing=!0;static timestamps=!0;static createdAt="created_at";static updatedAt="updated_at";static casts={};static fillable=[];static hidden=[];static connection=void 0;static hooks=new Map;static observers=new Map;static events=[];attributes={};originalAttributes={};relations={};exists=!1;constructor(e){return e&&this.fill(e),new Proxy(this,{get(t,s,i){return typeof s=="symbol"||s in t||typeof s!="string"||["table","primaryKey","incrementing","timestamps","casts","fillable","hidden","connection"].includes(s)?Reflect.get(t,s,i):typeof t[s]=="function"?t[s].bind(t):t.getAttribute(s)},set(t,s,i){return typeof s=="symbol"||s in t?Reflect.set(t,s,i):(t.setAttribute(s,i),!0)}})}static query(){let e=new this,t=this;return new y(t.table,this,t.connection)}static async find(e){let t=this;return this.query().find(e,t.primaryKey)}static async findOrFail(e){let t=this;return this.query().findOrFail(e,t.primaryKey)}static async all(){return this.query().get()}static async first(){return this.query().first()}static async firstOrFail(){return this.query().firstOrFail()}static where(e,t,s){return this.query().where(e,t,s)}static whereIn(e,t){return this.query().whereIn(e,t)}static whereNull(e){return this.query().whereNull(e)}static whereNotNull(e){return this.query().whereNotNull(e)}static orderBy(e,t){return this.query().orderBy(e,t)}static latest(e){return this.query().latest(e)}static oldest(e){return this.query().oldest(e)}static with(...e){return this.query().with(...e)}static async count(){return this.query().count()}static async create(e){let t=new this,s=this;if(t.fill(e),await t.fireHook("creating"),await t.fireHook("saving"),s.timestamps){let o=new Date().toISOString();t.setAttribute(s.createdAt,o),t.setAttribute(s.updatedAt,o)}let i=t.getInsertableAttributes(),r=await new y(s.table,this,s.connection).insertGetId(i,s.primaryKey);return s.incrementing&&r&&t.setAttribute(s.primaryKey,r),t.syncOriginal(),t.exists=!0,await t.fireHook("created"),await t.fireHook("saved"),t}async save(){let e=this.constructor;if(this.exists){await this.fireHook("updating"),await this.fireHook("saving"),e.timestamps&&this.setAttribute(e.updatedAt,new Date().toISOString());let t=this.getDirty();if(Object.keys(t).length>0){let s=this.getAttribute(e.primaryKey);await new y(e.table,this.constructor,e.connection).where(e.primaryKey,s).update(t)}this.syncOriginal(),await this.fireHook("updated"),await this.fireHook("saved")}else{if(await this.fireHook("creating"),await this.fireHook("saving"),e.timestamps){let n=new Date().toISOString();this.getAttribute(e.createdAt)||this.setAttribute(e.createdAt,n),this.setAttribute(e.updatedAt,n)}let t=this.getInsertableAttributes(),i=await new y(e.table,this.constructor,e.connection).insertGetId(t,e.primaryKey);e.incrementing&&i&&this.setAttribute(e.primaryKey,i),this.syncOriginal(),this.exists=!0,await this.fireHook("created"),await this.fireHook("saved")}}async update(e){this.fill(e),await this.save()}async delete(){let e=this.constructor;await this.fireHook("deleting");let t=this.getAttribute(e.primaryKey);await new y(e.table,this.constructor,e.connection).where(e.primaryKey,t).delete(),this.exists=!1,await this.fireHook("deleted")}async refresh(){let e=this.constructor,t=this.getAttribute(e.primaryKey),s=await this.constructor.find(t);s&&(this.attributes={...s.attributes},this.syncOriginal())}getAttribute(e){let t=this.constructor,s=this.attributes[e],i=t.casts[e];if(i&&s!==void 0&&s!==null)switch(i){case"number":return Number(s);case"boolean":return!!s;case"string":return String(s);case"date":return new Date(s);case"json":return typeof s=="string"?JSON.parse(s):s}return s}setAttribute(e,t){this.constructor.casts[e]==="json"&&typeof t!="string"?this.attributes[e]=JSON.stringify(t):this.attributes[e]=t}fill(e){let t=this.constructor;for(let[s,i]of Object.entries(e))t.fillable.length>0&&!t.fillable.includes(s)||this.setAttribute(s,i)}getAttributes(){return{...this.attributes}}getOriginal(e){return e?this.originalAttributes[e]:{...this.originalAttributes}}getDirty(){let e={};for(let[t,s]of Object.entries(this.attributes))s!==this.originalAttributes[t]&&(e[t]=s);return e}isDirty(...e){let t=this.getDirty();return e.length===0?Object.keys(t).length>0:e.some(s=>s in t)}isClean(...e){return!this.isDirty(...e)}wasChanged(...e){return this.isDirty(...e)}hasOne(e,t,s){return new m(this,e,t,s??this.constructor.primaryKey)}hasMany(e,t,s){return new b(this,e,t,s??this.constructor.primaryKey)}belongsTo(e,t,s){return new f(this,e,t,s??e.primaryKey)}belongsToMany(e,t,s,i,n,r){return new w(this,e,t,s,i,n??this.constructor.primaryKey,r??e.primaryKey)}setRelation(e,t){this.relations[e]=t}getRelation(e){return this.relations[e]}relationLoaded(e){return e in this.relations}toJSON(){let e=this.constructor,t={};for(let[s,i]of Object.entries(this.attributes))e.hidden.includes(s)||(t[s]=this.getAttribute(s));for(let[s,i]of Object.entries(this.relations))Array.isArray(i)?t[s]=i.map(n=>n instanceof l?n.toJSON():n):i instanceof l?t[s]=i.toJSON():t[s]=i;return t}toObject(){return this.toJSON()}static hydrate(e){let t=new this;return t.attributes={...e},t.syncOriginal(),t.exists=!0,t}static boot(e){this.hooks.set(this.name,e)}static observe(e){let t=this.observers.get(this.name)??[];t.push(e),this.observers.set(this.name,t)}static removeObservers(){this.observers.delete(this.name)}async fireHook(e){let t=this.constructor,s=l.hooks.get(t.name);s?.[e]&&await s[e](this),typeof this[e]=="function"&&await this[e]();let i=l.observers.get(t.name)??[];for(let r of i){let o=r[e];typeof o=="function"&&await o.call(r,this)}let n=t.name.toLowerCase();await C.emit(`${n}.${e}`,this)}async fireEvent(e){let t=this.constructor;if(!t.events.includes(e))throw new Error(`Event "${e}" is not declared in ${t.name}.events. Add it to: static events = ['${e}', ...];`);let s=l.observers.get(t.name)??[];for(let n of s){let r=n[e];typeof r=="function"&&await r.call(n,this)}let i=t.name.toLowerCase();await C.emit(`${i}.${e}`,this)}syncOriginal(){this.originalAttributes={...this.attributes}}getInsertableAttributes(){let e=this.constructor,t={...this.attributes};return e.incrementing&&t[e.primaryKey]===void 0&&delete t[e.primaryKey],t}static get tableName(){return this.table}};var $=["creating","created","updating","updated","saving","saved","deleting","deleted"],E=class{};export{f as BelongsTo,w as BelongsToMany,b as HasMany,m as HasOne,$ as MODEL_EVENTS,N as Model,E as ModelObserver,y as QueryBuilder,g as Relation};

package/dist/pagination/index.d.ts

@@ -0,0 +1,8 @@
+export interface PaginationResult<T> {
+    data: T[];
+    total: number;
+    page: number;
+    perPage: number;
+    lastPage: number;
+    hasMore: boolean;
+}

package/dist/pdf/GeneratePdfJob.d.ts

@@ -0,0 +1,99 @@
+/**
+ * GeneratePdfJob — Queue job for async PDF generation
+ *
+ * Dispatches PDF generation to a background worker instead of blocking
+ * the request. Works with any Svelar queue driver (sync, memory, database).
+ *
+ * @example
+ * ```ts
+ * import { Queue } from 'svelar/queue';
+ * import { GeneratePdfJob } from 'svelar/pdf/GeneratePdfJob';
+ *
+ * // Register once in src/app.ts
+ * Queue.register(GeneratePdfJob);
+ *
+ * // Dispatch from a controller
+ * await Queue.dispatch(new GeneratePdfJob({
+ *   type: 'html',
+ *   content: '<h1>Invoice</h1><p>Total: $99</p>',
+ *   outputPath: 'storage/invoices/inv-001.pdf',
+ *   options: { margins: { top: '1in', bottom: '1in' } },
+ * }));
+ *
+ * // With webhook (fires and forgets to Gotenberg)
+ * await Queue.dispatch(new GeneratePdfJob({
+ *   type: 'url',
+ *   content: 'https://example.com/report',
+ *   webhook: {
+ *     url: 'https://myapp.com/api/pdf/webhook',
+ *     errorUrl: 'https://myapp.com/api/pdf/webhook-error',
+ *   },
+ * }));
+ * ```
+ */
+export interface PdfJobPayload {
+    /** Type of conversion */
+    type: 'html' | 'url' | 'markdown' | 'office';
+    /** The HTML string, URL, markdown string, or file path */
+    content: string;
+    /** Optional file path to save the result (sync mode) */
+    outputPath?: string;
+    /** PDF options */
+    options?: {
+        margins?: {
+            top?: string;
+            bottom?: string;
+            left?: string;
+            right?: string;
+        };
+        landscape?: boolean;
+        scale?: number;
+        headerHtml?: string;
+        footerHtml?: string;
+        printBackground?: boolean;
+        waitDelay?: string;
+        waitForExpression?: string;
+        pdfFormat?: string;
+        pageSize?: {
+            width?: string;
+            height?: string;
+        };
+    };
+    /** Webhook options for async Gotenberg processing */
+    webhook?: {
+        url: string;
+        errorUrl: string;
+        method?: 'POST' | 'PUT' | 'PATCH';
+        extraHeaders?: Record<string, string>;
+    };
+    /** Callback event name to broadcast on completion (optional) */
+    broadcastEvent?: string;
+    /** Broadcast channel for completion notification (optional) */
+    broadcastChannel?: string;
+    /** Arbitrary metadata to pass through to webhook/broadcast */
+    meta?: Record<string, any>;
+}
+/**
+ * A queue job that generates a PDF using the Svelar PDF module.
+ *
+ * Supports sync generation (with file storage) and async webhook mode.
+ * Optionally broadcasts a completion event so the client can react.
+ */
+export declare class GeneratePdfJob {
+    payload: PdfJobPayload;
+    /** Queue job name for serialization */
+    static readonly jobName = "GeneratePdfJob";
+    /** Max retry attempts */
+    maxAttempts: number;
+    /** Retry delay in seconds */
+    retryDelay: number;
+    /** Queue name */
+    queue: string;
+    constructor(payload: PdfJobPayload);
+    handle(): Promise<void>;
+    failed(error: Error): void;
+    /** Serialize for database queue driver */
+    serialize(): Record<string, any>;
+    /** Restore from database queue driver */
+    restore(data: Record<string, any>): void;
+}