arcanajs 3.0.1 → 4.0.0

package/dist/lib/arcanox/Model.d.ts

@@ -0,0 +1,203 @@
+import { QueryBuilder } from "./QueryBuilder";
+import { BelongsTo } from "./relations/BelongsTo";
+import { BelongsToMany } from "./relations/BelongsToMany";
+import { HasMany } from "./relations/HasMany";
+import { HasOne } from "./relations/HasOne";
+import type { DatabaseAdapter } from "./types";
+/**
+ * Relation types for arcanox relationships
+ */
+export type RelationType = "hasOne" | "hasMany" | "belongsTo" | "belongsToMany";
+export interface RelationConfig {
+    type: RelationType;
+    related: typeof Model;
+    foreignKey?: string;
+    localKey?: string;
+    pivotTable?: string;
+}
+import { Macroable } from "./support/Macroable";
+/**
+ * Base Model class - Arcanox ORM
+ */
+export declare class Model<T = any> extends Macroable {
+    protected static adapter: DatabaseAdapter;
+    protected static tableName: string;
+    protected static primaryKey: string;
+    protected static connection: string;
+    protected attributes: Record<string, any>;
+    protected original: Record<string, any>;
+    protected relations: Record<string, any>;
+    protected exists: boolean;
+    protected fillable: string[];
+    protected guarded: string[];
+    protected hidden: string[];
+    protected visible: string[];
+    protected casts: Record<string, string>;
+    protected dates: string[];
+    protected timestamps: boolean;
+    protected createdAt: string;
+    protected updatedAt: string;
+    protected softDeletes: boolean;
+    protected deletedAt: string;
+    /**
+     * Set the database adapter
+     */
+    static setAdapter(adapter: DatabaseAdapter): void;
+    /**
+     * Get the table name
+     */
+    static getTable(): string;
+    /**
+     * Create a new query builder instance
+     */
+    static query<T>(): QueryBuilder<T>;
+    /**
+     * Get all records
+     */
+    static all<T>(): Promise<T[]>;
+    /**
+     * Find a record by ID
+     */
+    static find<T>(id: any): Promise<T | null>;
+    /**
+     * Find a record by ID or throw exception
+     */
+    static findOrFail<T>(id: any): Promise<T>;
+    /**
+     * Create a WHERE query
+     */
+    static where<T>(column: string, operator: any, value?: any): QueryBuilder<T>;
+    /**
+     * Create a new record
+     */
+    static create<T>(data: Partial<T>): Promise<T>;
+    /**
+     * Update a record
+     */
+    static update<T>(id: any, data: Partial<T>): Promise<T>;
+    /**
+     * Delete a record
+     */
+    static destroy(id: any): Promise<boolean>;
+    /**
+     * First or create
+     */
+    static firstOrCreate<T>(attributes: Partial<T>, values?: Partial<T>): Promise<T>;
+    /**
+     * Update or create
+     */
+    static updateOrCreate<T>(attributes: Partial<T>, values?: Partial<T>): Promise<T>;
+    /**
+     * Hydrate a model instance from data
+     */
+    protected static hydrate<T>(data: any): T;
+    /**
+     * Fill model attributes
+     */
+    fill(attributes: Partial<T>): this;
+    /**
+     * Check if attribute is fillable
+     */
+    protected isFillable(key: string): boolean;
+    /**
+     * Set an attribute
+     */
+    setAttribute(key: string, value: any): void;
+    /**
+     * Get an attribute
+     */
+    getAttribute(key: string): any;
+    /**
+     * Cast attribute to specified type
+     */
+    protected castAttribute(key: string, value: any, isGetting?: boolean): any;
+    /**
+     * Save the model
+     */
+    save(): Promise<this>;
+    /**
+     * Update the model
+     */
+    update(attributes: Partial<T>): Promise<this>;
+    /**
+     * Delete the model
+     */
+    delete(): Promise<boolean>;
+    /**
+     * Force delete (ignore soft deletes)
+     */
+    forceDelete(): Promise<boolean>;
+    /**
+     * Restore soft deleted model
+     */
+    restore(): Promise<this>;
+    /**
+     * Sync original attributes
+     */
+    protected syncOriginal(): void;
+    /**
+     * Get dirty attributes (changed since last sync)
+     */
+    getDirty(): Record<string, any>;
+    /**
+     * Check if model is dirty
+     */
+    isDirty(): boolean;
+    constructor(attributes?: Partial<T>);
+    /**
+     * Convert model to JSON
+     */
+    toJSON(): Record<string, any>;
+    /**
+     * Define a one-to-one relationship
+     */
+    hasOne<R extends Model>(related: new () => R, foreignKey?: string, localKey?: string): HasOne<R>;
+    /**
+     * Define a one-to-many relationship
+     */
+    hasMany<R extends Model>(related: new () => R, foreignKey?: string, localKey?: string): HasMany<R>;
+    /**
+     * Define an inverse one-to-one or many relationship
+     */
+    belongsTo<R extends Model>(related: new () => R, foreignKey?: string, ownerKey?: string): BelongsTo<R>;
+    /**
+     * Define a many-to-many relationship
+     */
+    belongsToMany<R extends Model>(related: new () => R, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string): BelongsToMany<R>;
+    /**
+     * Guess the pivot table name (alphabetical order of model names)
+     */
+    protected guessPivotTable(related: Model): string;
+    /**
+     * Eager load relationships
+     */
+    static with<T>(relations: string | string[]): QueryBuilder<T>;
+    /**
+     * Set a loaded relationship
+     */
+    setRelation(relation: string, value: any): this;
+    /**
+     * Get a loaded relationship
+     */
+    getRelation(relation: string): any;
+    /**
+     * Check if a relationship is loaded
+     */
+    relationLoaded(relation: string): boolean;
+    /**
+     * Create a new query builder for the model
+     */
+    newQuery(): QueryBuilder<T>;
+    /**
+     * Helper: Convert string to snake_case
+     */
+    protected static snakeCase(str: string): string;
+    /**
+     * Helper: Pluralize string (simple implementation)
+     */
+    protected static pluralize(str: string): string;
+    /**
+     * Helper: Convert to StudlyCase
+     */
+    protected studly(str: string): string;
+}

package/dist/lib/arcanox/QueryBuilder.d.ts

@@ -0,0 +1,141 @@
+import type { JoinClause, OrderByClause, WhereClause } from "./types";
+import { Macroable } from "./support/Macroable";
+/**
+ * Query Builder - Fluent interface for building database queries
+ * Arcanox Query Builder
+ */
+export declare class QueryBuilder<T = any> extends Macroable {
+    protected tableName: string;
+    protected selectColumns: string[];
+    protected whereClauses: WhereClause[];
+    protected orderByClauses: OrderByClause[];
+    protected joinClauses: JoinClause[];
+    protected limitValue?: number;
+    protected offsetValue?: number;
+    protected adapter: any;
+    constructor(table: string, adapter: any);
+    /**
+     * Select specific columns
+     */
+    select(...columns: string[]): this;
+    /**
+     * Add a WHERE clause
+     */
+    where(column: string, operator: any, value?: any): this;
+    /**
+     * Add an OR WHERE clause
+     */
+    orWhere(column: string, operator: any, value?: any): this;
+    /**
+     * WHERE IN clause
+     */
+    whereIn(column: string, values: any[]): this;
+    /**
+     * WHERE NOT IN clause
+     */
+    whereNotIn(column: string, values: any[]): this;
+    /**
+     * WHERE BETWEEN clause
+     */
+    whereBetween(column: string, range: [any, any]): this;
+    /**
+     * WHERE NULL clause
+     */
+    whereNull(column: string): this;
+    /**
+     * WHERE NOT NULL clause
+     */
+    whereNotNull(column: string): this;
+    /**
+     * Add ORDER BY clause
+     */
+    orderBy(column: string, direction?: "ASC" | "DESC" | "asc" | "desc"): this;
+    /**
+     * Add LIMIT clause
+     */
+    limit(count: number): this;
+    /**
+     * Add OFFSET clause
+     */
+    offset(count: number): this;
+    /**
+     * Add JOIN clause
+     */
+    join(table: string, first: string, operator: string, second: string, type?: "INNER" | "LEFT" | "RIGHT"): this;
+    /**
+     * Add LEFT JOIN clause
+     */
+    leftJoin(table: string, first: string, operator: string, second: string): this;
+    /**
+     * Add RIGHT JOIN clause
+     */
+    rightJoin(table: string, first: string, operator: string, second: string): this;
+    protected eagerLoads: string[];
+    protected model: any;
+    /**
+     * Set the model class
+     */
+    setModel(model: any): this;
+    /**
+     * Eager load relationships
+     */
+    with(relations: string | string[]): this;
+    /**
+     * Execute query and get all results
+     */
+    get(): Promise<T[]>;
+    /**
+     * Eager load relations
+     */
+    protected eagerLoadRelations(results: any[]): Promise<any[]>;
+    /**
+     * Get first result
+     */
+    first(): Promise<T | null>;
+    /**
+     * Find by ID
+     */
+    find(id: any): Promise<T | null>;
+    /**
+     * Count results
+     */
+    count(): Promise<number>;
+    /**
+     * Get specific column values
+     */
+    pluck(column: string): Promise<any[]>;
+    /**
+     * Sum of column
+     */
+    sum(column: string): Promise<number>;
+    /**
+     * Average of column
+     */
+    avg(column: string): Promise<number>;
+    /**
+     * Minimum value of column
+     */
+    min(column: string): Promise<any>;
+    /**
+     * Maximum value of column
+     */
+    max(column: string): Promise<any>;
+    /**
+     * Check if any records exist
+     */
+    exists(): Promise<boolean>;
+    /**
+     * Paginate results
+     */
+    paginate(page?: number, perPage?: number): Promise<{
+        data: T[];
+        total: number;
+        perPage: number;
+        currentPage: number;
+        lastPage: number;
+    }>;
+    /**
+     * Clone the query builder
+     */
+    clone(): QueryBuilder<T>;
+}

package/dist/lib/arcanox/adapters/MongoAdapter.d.ts

@@ -0,0 +1,22 @@
+import { ColumnDefinition, Connection, DatabaseAdapter, DatabaseConfig, SelectOptions } from "../types";
+export declare class MongoAdapter implements DatabaseAdapter {
+    private client;
+    private db;
+    connect(config: DatabaseConfig): Promise<Connection>;
+    disconnect(): Promise<void>;
+    createTable(tableName: string, columns: ColumnDefinition[]): Promise<void>;
+    dropTable(tableName: string): Promise<void>;
+    hasTable(tableName: string): Promise<boolean>;
+    hasColumn(tableName: string, columnName: string): Promise<boolean>;
+    select(table: string, options: SelectOptions): Promise<any[]>;
+    insert(table: string, data: Record<string, any>): Promise<any>;
+    update(table: string, id: any, data: Record<string, any>): Promise<any>;
+    delete(table: string, id: any): Promise<boolean>;
+    beginTransaction(): Promise<void>;
+    raw(query: string, params?: any[]): Promise<any>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    private buildFilter;
+    private buildProjection;
+    private normalizeId;
+}

package/dist/lib/arcanox/adapters/MySQLAdapter.d.ts

@@ -0,0 +1,27 @@
+import type { ColumnDefinition, Connection, DatabaseAdapter, DatabaseConfig, SelectOptions } from "../types";
+/**
+ * MySQL Database Adapter
+ */
+export declare class MySQLAdapter implements DatabaseAdapter {
+    private pool;
+    private connection;
+    connect(config: DatabaseConfig): Promise<Connection>;
+    disconnect(): Promise<void>;
+    query(sql: string, params?: any[]): Promise<any>;
+    execute(sql: string, params?: any[]): Promise<any>;
+    createTable(tableName: string, columns: ColumnDefinition[]): Promise<void>;
+    dropTable(tableName: string): Promise<void>;
+    hasTable(tableName: string): Promise<boolean>;
+    hasColumn(tableName: string, columnName: string): Promise<boolean>;
+    select(table: string, options: SelectOptions): Promise<any[]>;
+    insert(table: string, data: Record<string, any>): Promise<any>;
+    update(table: string, id: any, data: Record<string, any>): Promise<any>;
+    delete(table: string, id: any): Promise<boolean>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    raw(query: string, params?: any[]): Promise<any>;
+    private buildWhereCondition;
+    private mapType;
+    private formatValue;
+}

package/dist/lib/arcanox/adapters/PostgresAdapter.d.ts

@@ -0,0 +1,27 @@
+import type { ColumnDefinition, Connection, DatabaseAdapter, DatabaseConfig, SelectOptions } from "../types";
+/**
+ * PostgreSQL Database Adapter
+ */
+export declare class PostgresAdapter implements DatabaseAdapter {
+    private pool;
+    private client;
+    connect(config: DatabaseConfig): Promise<Connection>;
+    disconnect(): Promise<void>;
+    query(sql: string, params?: any[]): Promise<any>;
+    execute(sql: string, params?: any[]): Promise<any>;
+    createTable(tableName: string, columns: ColumnDefinition[]): Promise<void>;
+    dropTable(tableName: string): Promise<void>;
+    hasTable(tableName: string): Promise<boolean>;
+    hasColumn(tableName: string, columnName: string): Promise<boolean>;
+    select(table: string, options: SelectOptions): Promise<any[]>;
+    insert(table: string, data: Record<string, any>): Promise<any>;
+    update(table: string, id: any, data: Record<string, any>): Promise<any>;
+    delete(table: string, id: any): Promise<boolean>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    raw(query: string, params?: any[]): Promise<any>;
+    private buildWhereCondition;
+    private mapType;
+    private formatValue;
+}

package/dist/lib/arcanox/extensions/MongoExtensions.d.ts

@@ -0,0 +1,33 @@
+/**
+ * MongoDB-specific extensions for QueryBuilder
+ * These extensions provide Mongoose-style functionality for MongoDB
+ */
+export interface PopulateOptions {
+    from?: string;
+    localField?: string;
+    foreignField?: string;
+    as?: string;
+    select?: string[];
+}
+/**
+ * TypeScript type augmentation for better IDE support
+ */
+declare module "../QueryBuilder" {
+    interface QueryBuilder<T> {
+        /**
+         * Populate a relationship using MongoDB's $lookup
+         * @param field - The field name to populate
+         * @param options - Population options
+         */
+        populate(field: string, options?: PopulateOptions): Promise<T[]>;
+        /**
+         * Execute the query (alias for get())
+         */
+        exec(): Promise<T[]>;
+        /**
+         * Execute a MongoDB aggregation pipeline
+         * @param pipeline - MongoDB aggregation pipeline stages
+         */
+        aggregate(pipeline: any[]): Promise<any[]>;
+    }
+}

package/dist/lib/arcanox/factory/Factory.d.ts

@@ -0,0 +1,26 @@
+import type { Faker } from "@faker-js/faker";
+import { Model } from "../Model";
+/**
+ * Base Factory class
+ */
+export declare abstract class Factory<T extends Model> {
+    protected abstract model: new () => T;
+    protected faker: Faker;
+    constructor();
+    /**
+     * Define the model's default state.
+     */
+    abstract definition(): Record<string, any>;
+    /**
+     * Create a new model instance with attributes.
+     */
+    make(attributes?: Partial<T>): T;
+    /**
+     * Create and save a new model instance.
+     */
+    create(attributes?: Partial<T>): Promise<T>;
+    /**
+     * Create multiple instances
+     */
+    createMany(count: number, attributes?: Partial<T>): Promise<T[]>;
+}

package/dist/lib/arcanox/factory/index.d.ts

@@ -0,0 +1 @@
+export { Factory } from "./Factory";

package/dist/lib/arcanox/index.d.ts

@@ -0,0 +1,13 @@
+export { MongoAdapter } from "./adapters/MongoAdapter";
+export { MySQLAdapter } from "./adapters/MySQLAdapter";
+export { PostgresAdapter } from "./adapters/PostgresAdapter";
+export { Model } from "./Model";
+export { QueryBuilder } from "./QueryBuilder";
+export { BelongsTo } from "./relations/BelongsTo";
+export { BelongsToMany } from "./relations/BelongsToMany";
+export { HasMany } from "./relations/HasMany";
+export { HasOne } from "./relations/HasOne";
+export { Relation } from "./relations/Relation";
+export { Macroable } from "./support/Macroable";
+export type { ColumnDefinition, Connection, DatabaseAdapter, DatabaseConfig, JoinClause, OrderByClause, SelectOptions, WhereClause, } from "./types";
+export * from "./extensions/MongoExtensions";

package/dist/lib/arcanox/providers/DatabaseProvider.d.ts

@@ -0,0 +1,5 @@
+import { Container } from "../../server/Container";
+export declare class DatabaseProvider {
+    static register(container: Container): Promise<void>;
+    static close(container: Container): Promise<void>;
+}

package/dist/lib/arcanox/relations/BelongsTo.d.ts

@@ -0,0 +1,11 @@
+import { Model } from "../Model";
+import { QueryBuilder } from "../QueryBuilder";
+import { Relation } from "./Relation";
+export declare class BelongsTo<R extends Model = any> extends Relation<R> {
+    protected foreignKey: string;
+    protected ownerKey: string;
+    constructor(query: QueryBuilder<R>, parent: Model, foreignKey: string, ownerKey: string);
+    addConstraints(): void;
+    addEagerConstraints(models: Model[]): void;
+    match(models: Model[], results: R[], relation: string): Model[];
+}

package/dist/lib/arcanox/relations/BelongsToMany.d.ts

@@ -0,0 +1,15 @@
+import { Model } from "../Model";
+import { QueryBuilder } from "../QueryBuilder";
+import { Relation } from "./Relation";
+export declare class BelongsToMany<R extends Model = any> extends Relation<R> {
+    protected table: string;
+    protected foreignPivotKey: string;
+    protected relatedPivotKey: string;
+    protected parentKey: string;
+    protected relatedKey: string;
+    constructor(query: QueryBuilder<R>, parent: Model, table: string, foreignPivotKey: string, relatedPivotKey: string, parentKey: string, relatedKey: string);
+    addConstraints(): void;
+    protected performJoin(query?: QueryBuilder<R>): this;
+    addEagerConstraints(models: Model[]): void;
+    match(models: Model[], results: R[], relation: string): Model[];
+}

package/dist/lib/arcanox/relations/HasMany.d.ts

@@ -0,0 +1,11 @@
+import { Model } from "../Model";
+import { QueryBuilder } from "../QueryBuilder";
+import { Relation } from "./Relation";
+export declare class HasMany<R extends Model = any> extends Relation<R> {
+    protected foreignKey: string;
+    protected localKey: string;
+    constructor(query: QueryBuilder<R>, parent: Model, foreignKey: string, localKey: string);
+    addConstraints(): void;
+    addEagerConstraints(models: Model[]): void;
+    match(models: Model[], results: R[], relation: string): Model[];
+}

package/dist/lib/arcanox/relations/HasOne.d.ts

@@ -0,0 +1,11 @@
+import { Model } from "../Model";
+import { QueryBuilder } from "../QueryBuilder";
+import { Relation } from "./Relation";
+export declare class HasOne<R extends Model = any> extends Relation<R> {
+    protected foreignKey: string;
+    protected localKey: string;
+    constructor(query: QueryBuilder<R>, parent: Model, foreignKey: string, localKey: string);
+    addConstraints(): void;
+    addEagerConstraints(models: Model[]): void;
+    match(models: Model[], results: R[], relation: string): Model[];
+}

package/dist/lib/arcanox/relations/Relation.d.ts

@@ -0,0 +1,14 @@
+import { Model } from "../Model";
+import { QueryBuilder } from "../QueryBuilder";
+export declare abstract class Relation<R extends Model = any> {
+    protected query: QueryBuilder<R>;
+    protected parent: Model;
+    protected related: new () => R;
+    constructor(query: QueryBuilder<R>, parent: Model);
+    abstract addConstraints(): void;
+    abstract addEagerConstraints(models: Model[]): void;
+    abstract match(models: Model[], results: R[], relation: string): Model[];
+    getQuery(): QueryBuilder<R>;
+    get(): Promise<R[]>;
+    first(): Promise<R | null>;
+}