arcanajs 3.0.0 → 4.0.0

package/dist/lib/arcanox/schema/Blueprint.d.ts

@@ -0,0 +1,183 @@
+import type { ColumnDefinition } from "../types";
+/**
+ * Column definition builder - fluent interface for defining columns
+ */
+export declare class ColumnBuilder {
+    private definition;
+    constructor(name: string, type: string, length?: number);
+    /**
+     * Make column nullable
+     */
+    nullable(): this;
+    /**
+     * Set default value
+     */
+    default(value: any): this;
+    /**
+     * Make column unique
+     */
+    unique(): this;
+    /**
+     * Make column primary key
+     */
+    primary(): this;
+    /**
+     * Make column auto-increment
+     */
+    autoIncrement(): this;
+    /**
+     * Make column unsigned (for numbers)
+     */
+    unsigned(): this;
+    /**
+     * Get the column definition
+     */
+    getDefinition(): ColumnDefinition;
+}
+/**
+ * Foreign key definition builder
+ */
+export declare class ForeignKeyBuilder {
+    private column;
+    private referencedTable?;
+    private referencedColumn?;
+    private onDeleteAction?;
+    private onUpdateAction?;
+    constructor(column: string);
+    /**
+     * Set referenced table and column
+     */
+    references(column: string): this;
+    /**
+     * Set referenced table
+     */
+    on(table: string): this;
+    /**
+     * Set ON DELETE action
+     */
+    onDelete(action: "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION"): this;
+    /**
+     * Set ON UPDATE action
+     */
+    onUpdate(action: "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION"): this;
+    /**
+     * Get foreign key SQL
+     */
+    toSQL(): string;
+}
+/**
+ * Blueprint - defines table structure
+ * Arcanox's Schema Blueprint
+ */
+export declare class Blueprint {
+    private tableName;
+    private columns;
+    private indexes;
+    private foreignKeys;
+    private primaryKeys;
+    constructor(tableName: string);
+    /**
+     * Add auto-incrementing ID column
+     */
+    id(name?: string): ColumnBuilder;
+    /**
+     * Add UUID column
+     */
+    uuid(name?: string): ColumnBuilder;
+    /**
+     * Add string column
+     */
+    string(name: string, length?: number): ColumnBuilder;
+    /**
+     * Add text column
+     */
+    text(name: string): ColumnBuilder;
+    /**
+     * Add integer column
+     */
+    integer(name: string): ColumnBuilder;
+    /**
+     * Add big integer column
+     */
+    bigInteger(name: string): ColumnBuilder;
+    /**
+     * Add decimal column
+     */
+    decimal(name: string, precision?: number, scale?: number): ColumnBuilder;
+    /**
+     * Add float column
+     */
+    float(name: string): ColumnBuilder;
+    /**
+     * Add double column
+     */
+    double(name: string): ColumnBuilder;
+    /**
+     * Add boolean column
+     */
+    boolean(name: string): ColumnBuilder;
+    /**
+     * Add date column
+     */
+    date(name: string): ColumnBuilder;
+    /**
+     * Add datetime column
+     */
+    datetime(name: string): ColumnBuilder;
+    /**
+     * Add timestamp column
+     */
+    timestamp(name: string): ColumnBuilder;
+    /**
+     * Add created_at and updated_at timestamps
+     */
+    timestamps(): void;
+    /**
+     * Add deleted_at timestamp for soft deletes
+     */
+    softDeletes(name?: string): ColumnBuilder;
+    /**
+     * Add JSON column
+     */
+    json(name: string): ColumnBuilder;
+    /**
+     * Add enum column
+     */
+    enum(name: string, values: string[]): ColumnBuilder;
+    /**
+     * Add foreign key constraint
+     */
+    foreign(column: string): ForeignKeyBuilder;
+    /**
+     * Add index
+     */
+    index(columns: string | string[], name?: string): void;
+    /**
+     * Add unique index
+     */
+    unique(columns: string | string[], name?: string): void;
+    /**
+     * Set primary key
+     */
+    primary(columns: string | string[]): void;
+    /**
+     * Get all columns
+     */
+    getColumns(): ColumnDefinition[];
+    /**
+     * Get table name
+     */
+    getTableName(): string;
+    /**
+     * Get indexes
+     */
+    getIndexes(): {
+        columns: string[];
+        unique: boolean;
+        name?: string;
+    }[];
+    /**
+     * Get foreign keys
+     */
+    getForeignKeys(): ForeignKeyBuilder[];
+}

package/dist/lib/arcanox/schema/Migration.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Base Migration class
+ * All migrations should extend this class and implement up() and down() methods
+ */
+export declare abstract class Migration {
+    /**
+     * Run the migration
+     */
+    abstract up(): Promise<void>;
+    /**
+     * Reverse the migration
+     */
+    abstract down(): Promise<void>;
+}
+/**
+ * Migration status
+ */
+export interface MigrationStatus {
+    name: string;
+    batch: number;
+    ranAt: Date;
+}
+/**
+ * Migration record in database
+ */
+export interface MigrationRecord {
+    id?: number;
+    migration: string;
+    batch: number;
+    created_at?: Date;
+}
+/**
+ * Migration Runner - executes migrations
+ */
+export declare class MigrationRunner {
+    private adapter;
+    private migrationsTable;
+    private migrationsPath;
+    constructor(adapter: any, migrationsPath: string);
+    /**
+     * Ensure migrations table exists
+     */
+    private ensureMigrationsTable;
+    /**
+     * Get all ran migrations
+     */
+    private getRanMigrations;
+    /**
+     * Get pending migrations
+     */
+    private getPendingMigrations;
+    /**
+     * Run pending migrations
+     */
+    run(): Promise<void>;
+    /**
+     * Rollback last batch of migrations
+     */
+    rollback(steps?: number): Promise<void>;
+    /**
+     * Reset all migrations
+     */
+    reset(): Promise<void>;
+    /**
+     * Reset and re-run all migrations
+     */
+    fresh(): Promise<void>;
+    /**
+     * Get migration status
+     */
+    status(): Promise<MigrationStatus[]>;
+    /**
+     * Load migration class from file
+     */
+    private loadMigration;
+}

package/dist/lib/arcanox/schema/Schema.d.ts

@@ -0,0 +1,49 @@
+import type { DatabaseAdapter } from "../types";
+import { Blueprint } from "./Blueprint";
+/**
+ * Schema - ArcnanJS schema builder
+ * Provides fluent interface for creating and modifying database tables
+ */
+export declare class Schema {
+    private static adapter;
+    /**
+     * Set the database adapter
+     */
+    static setAdapter(adapter: DatabaseAdapter): void;
+    /**
+     * Create a new table
+     */
+    static create(tableName: string, callback: (table: Blueprint) => void): Promise<void>;
+    /**
+     * Modify an existing table
+     */
+    static table(tableName: string, callback: (table: Blueprint) => void): Promise<void>;
+    /**
+     * Drop a table
+     */
+    static drop(tableName: string): Promise<void>;
+    /**
+     * Drop a table if it exists
+     */
+    static dropIfExists(tableName: string): Promise<void>;
+    /**
+     * Rename a table
+     */
+    static rename(from: string, to: string): Promise<void>;
+    /**
+     * Check if a table exists
+     */
+    static hasTable(tableName: string): Promise<boolean>;
+    /**
+     * Check if a column exists in a table
+     */
+    static hasColumn(tableName: string, columnName: string): Promise<boolean>;
+    /**
+     * Get all tables
+     */
+    static getTables(): Promise<string[]>;
+    /**
+     * Get all columns for a table
+     */
+    static getColumns(tableName: string): Promise<string[]>;
+}

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

@@ -0,0 +1,4 @@
+export { Blueprint, ColumnBuilder, ForeignKeyBuilder } from "./Blueprint";
+export { Migration, MigrationRunner } from "./Migration";
+export type { MigrationRecord, MigrationStatus } from "./Migration";
+export { Schema } from "./Schema";

package/dist/lib/arcanox/seeder/Seeder.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Base Seeder class
+ */
+export declare abstract class Seeder {
+    /**
+     * Run the database seeds.
+     */
+    abstract run(): Promise<void>;
+    /**
+     * Call another seeder
+     */
+    call(SeederClass: new () => Seeder): Promise<void>;
+}

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

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

package/dist/lib/arcanox/support/Macroable.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Macroable trait
+ * Allows adding custom methods to a class at runtime
+ */
+export declare class Macroable {
+    protected static macros: Record<string, Function>;
+    /**
+     * Register a custom macro
+     */
+    static macro(name: string, macro: Function): void;
+    /**
+     * Mix another object into the class
+     */
+    static mixin(mixin: Record<string, Function>): void;
+    /**
+     * Check if macro exists
+     */
+    static hasMacro(name: string): boolean;
+}

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

@@ -0,0 +1,76 @@
+/**
+ * Database connection interface
+ */
+export interface Connection {
+    query(sql: string, params?: any[]): Promise<any>;
+    execute(sql: string, params?: any[]): Promise<any>;
+    close(): Promise<void>;
+}
+/**
+ * Database adapter interface - implements database-specific operations
+ */
+export interface DatabaseAdapter {
+    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>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    raw(query: string, params?: any[]): Promise<any>;
+}
+export interface DatabaseConfig {
+    type: "postgres" | "mysql" | "mongodb";
+    host: string;
+    port: number;
+    database: string;
+    username?: string;
+    password?: string;
+    ssl?: boolean;
+    pool?: {
+        min?: number;
+        max?: number;
+    };
+}
+export interface ColumnDefinition {
+    name: string;
+    type: string;
+    length?: number;
+    nullable?: boolean;
+    default?: any;
+    unique?: boolean;
+    primary?: boolean;
+    autoIncrement?: boolean;
+    unsigned?: boolean;
+}
+export interface SelectOptions {
+    columns?: string[];
+    where?: WhereClause[];
+    orderBy?: OrderByClause[];
+    limit?: number;
+    offset?: number;
+    joins?: JoinClause[];
+}
+export interface WhereClause {
+    column: string;
+    operator: "=" | "!=" | ">" | "<" | ">=" | "<=" | "LIKE" | "IN" | "NOT IN" | "BETWEEN" | "IS NULL" | "IS NOT NULL";
+    value: any;
+    boolean?: "AND" | "OR";
+}
+export interface OrderByClause {
+    column: string;
+    direction: "ASC" | "DESC";
+}
+export interface JoinClause {
+    type: "INNER" | "LEFT" | "RIGHT";
+    table: string;
+    first: string;
+    operator: string;
+    second: string;
+}

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

@@ -0,0 +1,6 @@
+export { Macroable, Model, MongoAdapter, MySQLAdapter, PostgresAdapter, QueryBuilder, } from "./arcanox";
+export type { DatabaseAdapter, DatabaseConfig } from "./arcanox";
+export { Blueprint, Migration, MigrationRunner, Schema, } from "./arcanox/schema";
+export type { MigrationStatus } from "./arcanox/schema";
+export { Factory } from "./arcanox/factory";
+export { Seeder } from "./arcanox/seeder";

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

@@ -0,0 +1,11 @@
+export { default as Body } from "./shared/components/Body";
+export { default as Head } from "./shared/components/Head";
+export { default as Link } from "./shared/components/Link";
+export { default as NavLink } from "./shared/components/NavLink";
+export { default as Page } from "./shared/components/Page";
+export { default as hydrateArcanaJS } from "./client/index";
+export { default as useLocation } from "./shared/hooks/useLocation";
+export { default as usePage } from "./shared/hooks/usePage";
+export { default as useParams } from "./shared/hooks/useParams";
+export { default as useQuery } from "./shared/hooks/useQuery";
+export { default as useRouter } from "./shared/hooks/useRouter";

package/dist/lib/{index.d.ts → index.server.d.ts}

@@ -1,19 +1,15 @@
 import { Express } from "express";
 import ArcanaJSServer, { ArcanaJSConfig } from "./server/ArcanaJSServer";
-export { default as Body } from "./shared/components/Body";
-export { default as Head } from "./shared/components/Head";
-export { default as Link } from "./shared/components/Link";
-export { default as NavLink } from "./shared/components/NavLink";
-export { default as Page } from "./shared/components/Page";
-export { default as hydrateArcanaJS } from "./client/index";
-export { default as useLocation } from "./shared/hooks/useLocation";
-export { default as usePage } from "./shared/hooks/usePage";
-export { default as useParams } from "./shared/hooks/useParams";
-export { default as useQuery } from "./shared/hooks/useQuery";
-export { default as useRouter } from "./shared/hooks/useRouter";
 export { default as ArcanaJSServer } from "./server/ArcanaJSServer";
+export { Container } from "./server/Container";
 export { Express, NextFunction, Request, Response } from "express";
+export { FormRequest } from "./server/http/FormRequest";
+export { JsonResource } from "./server/http/JsonResource";
+export type { Middleware } from "./server/http/Middleware";
 export { default as Route } from "./server/Router";
+export { ServiceProvider } from "./server/support/ServiceProvider";
+export { ValidationException } from "./server/validation/ValidationException";
+export { Validator } from "./server/validation/Validator";
 /**
  * Create an ArcanaJS server with the given Express app
  *

package/dist/lib/server/ArcanaJSServer.d.ts

@@ -1,5 +1,6 @@
 import { Express, RequestHandler } from "express";
 import React from "react";
+import { ServiceProvider } from "./support/ServiceProvider";
 export interface ArcanaJSConfig<TDb = any> {
     port?: number | string;
     views?: Record<string, React.FC<any>>;
@@ -18,30 +19,55 @@ export interface ArcanaJSConfig<TDb = any> {
     dbConnect?: () => Promise<TDb> | TDb;
     /** Automatically register SIGINT/SIGTERM handlers to call stop(). Default: true */
     autoHandleSignals?: boolean;
+    /** Service providers to load */
+    providers?: (new (app: ArcanaJSServer) => ServiceProvider)[];
 }
 declare global {
     namespace Express {
-        interface Request {
+        interface Response {
             /**
-             * Normalized DB object optionally attached to the request by ArcanaJSServer.
-             * It may be either the raw client, or an object like `{ client, db, close }`.
+             * Sends a success response with a standard format.
+             *
+             * @param data - The data payload to include in the response (default: {}).
+             * @param message - A descriptive message for the success (default: "Success").
+             * @param status - The HTTP status code to return (default: 200).
+             * @returns The Express Response object.
              */
-            db?: any;
+            success: (data?: string | object | null, message?: string, status?: number) => Response;
+            /**
+             * Sends an error response with a standard format.
+             *
+             * @param message - A descriptive message for the error (default: "Error").
+             * @param status - The HTTP status code to return (default: 500).
+             * @param error - Additional error details or object (default: null).
+             * @param data - Optional data payload to include in the error response (default: null).
+             * @returns The Express Response object.
+             */
+            error: (message?: string, status?: number, error?: string | object | null, data?: string | object | null) => Response;
+            /**
+             * Renders a React page using ArcanaJS SSR.
+             *
+             * @param page - The name of the page component to render.
+             * @param data - Initial data to pass to the page component (default: {}).
+             * @param params - Route parameters (default: {}).
+             * @returns The Express Response object.
+             */
+            renderPage(page: string, data?: any, params?: Record<string, string>): Response;
         }
     }
 }
+import { Container } from "./Container";
 declare class ArcanaJSServer<TDb = any> {
     app: Express;
+    container: Container;
     private config;
     private serverInstance?;
     private _sigintHandler?;
     private _sigtermHandler?;
+    private providers;
     constructor(config: ArcanaJSConfig<TDb>);
-    /**
-     * Normalize different DB client shapes into a single object exposing:
-     * { client?: any, db?: any, close: async () => void }
-     */
-    private normalizeDb;
+    private registerProviders;
+    private bootProviders;
     private initialize;
     private loadViewsFromContext;
     private loadViewsFromAlias;

package/dist/lib/server/Container.d.ts

@@ -0,0 +1,31 @@
+import "reflect-metadata";
+export type ClassConstructor<T = any> = new (...args: any[]) => T;
+export type FactoryFunction<T = any> = (container: Container) => T;
+export declare class Container {
+    private static instance;
+    private bindings;
+    private singletons;
+    constructor();
+    /**
+     * Get the global container instance
+     */
+    static getInstance(): Container;
+    /**
+     * Bind a class or factory to the container
+     */
+    bind<T>(key: string | ClassConstructor<T>, value: ClassConstructor<T> | FactoryFunction<T>): void;
+    /**
+     * Bind a singleton to the container
+     */
+    singleton<T>(key: string | ClassConstructor<T>, value: ClassConstructor<T> | FactoryFunction<T>): void;
+    /**
+     * Resolve a dependency from the container
+     */
+    make<T>(key: string | ClassConstructor<T>): T;
+    /**
+     * Instantiate a class, resolving its dependencies
+     */
+    private build;
+    private isConstructor;
+}
+export declare const container: Container;

package/dist/lib/server/MiddlewareBinder.d.ts

@@ -0,0 +1,4 @@
+import { NextFunction, Request, Response } from "express";
+export default class MiddlewareBinder {
+    static handle(middleware: any, method?: string): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+}

package/dist/lib/server/ResponseHandlerMiddleware.d.ts

@@ -1,27 +1,2 @@
 import type { NextFunction, Request, Response } from "express";
-declare global {
-    namespace Express {
-        interface Response {
-            /**
-             * Sends a success response with a standard format.
-             *
-             * @param data - The data payload to include in the response (default: {}).
-             * @param message - A descriptive message for the success (default: "Success").
-             * @param status - The HTTP status code to return (default: 200).
-             * @returns The Express Response object.
-             */
-            success: (data?: string | object | null, message?: string, status?: number) => Response;
-            /**
-             * Sends an error response with a standard format.
-             *
-             * @param message - A descriptive message for the error (default: "Error").
-             * @param status - The HTTP status code to return (default: 500).
-             * @param error - Additional error details or object (default: null).
-             * @param data - Optional data payload to include in the error response (default: null).
-             * @returns The Express Response object.
-             */
-            error: (message?: string, status?: number, error?: string | object | null, data?: string | object | null) => Response;
-        }
-    }
-}
 export declare const responseHandler: (req: Request, res: Response, next: NextFunction) => void;

package/dist/lib/server/Router.d.ts

@@ -1,4 +1,4 @@
-import express, { Router as ExpressRouter, RequestHandler } from "express";
+import express, { Router as ExpressRouter } from "express";
 /**
  * Provides Routing syntax for defining routes with prefixes, middlewares, and groups
  */
@@ -14,7 +14,7 @@ export declare class Router {
     /**
      * Add middleware to the current stack
      */
-    middleware(...middleware: RequestHandler[]): Router;
+    middleware(...middleware: any[]): Router;
     /**
      * Add prefix to the current stack
      */
@@ -47,6 +47,11 @@ export declare class Router {
      * Define an OPTIONS route
      */
     options(path: string, ...args: any[]): Router;
+    /**
+     * Define a resource route
+     * Registers index, create, store, show, edit, update, destroy routes
+     */
+    resource(path: string, controller: any): Router;
     /**
      * Get the underlying Express router
      */
@@ -63,6 +68,10 @@ export declare class Router {
      * Add a route to the router
      */
     private _addRoute;
+    /**
+     * Resolve middleware to RequestHandler
+     */
+    private _resolveMiddleware;
     /**
      * Build the full path with prefixes
      */
@@ -78,7 +87,7 @@ export declare class Router {
 export declare class Route {
     private static _router;
     static create(): Router;
-    static middleware(...middleware: RequestHandler[]): Router;
+    static middleware(...middleware: any[]): Router;
     static prefix(prefix: string): Router;
     static group(callback: (router: Router) => void): Router;
     static get(path: string, ...args: any[]): Router;

package/dist/lib/server/http/FormRequest.d.ts

@@ -0,0 +1,10 @@
+import { Request } from "express";
+export declare abstract class FormRequest {
+    protected req: Request;
+    constructor(req: Request);
+    abstract rules(): Record<string, string>;
+    authorize(): boolean;
+    validate(): Promise<Record<string, any>>;
+    input(key: string, defaultValue?: any): any;
+    all(): any;
+}

package/dist/lib/server/http/JsonResource.d.ts

@@ -0,0 +1,13 @@
+export declare class JsonResource {
+    resource: any;
+    constructor(resource: any);
+    static make(resource: any): JsonResource;
+    static collection(resource: any[]): AnonymousResourceCollection;
+    resolve(request?: any): any;
+    toArray(request?: any): any;
+}
+export declare class AnonymousResourceCollection extends JsonResource {
+    collects: any;
+    constructor(resource: any[], collects: any);
+    resolve(request?: any): any;
+}