arcanajs 4.0.0 → 5.0.1

package/dist/lib/mail/types/MailConfig.d.ts

@@ -0,0 +1,146 @@
+import { Transporter } from "nodemailer";
+/**
+ * Supported mail transport drivers
+ */
+export type MailDriver = "smtp" | "sendgrid" | "mailgun" | "ses" | "log";
+/**
+ * SMTP Configuration
+ */
+export interface SMTPConfig {
+    host: string;
+    port: number;
+    secure?: boolean;
+    auth?: {
+        user: string;
+        pass: string;
+    };
+    tls?: {
+        rejectUnauthorized?: boolean;
+    };
+}
+/**
+ * SendGrid Configuration
+ */
+export interface SendGridConfig {
+    apiKey: string;
+}
+/**
+ * Mailgun Configuration
+ */
+export interface MailgunConfig {
+    apiKey: string;
+    domain: string;
+    host?: string;
+}
+/**
+ * AWS SES Configuration
+ */
+export interface SESConfig {
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+}
+/**
+ * Mail Queue Configuration
+ */
+export interface MailQueueConfig {
+    enabled: boolean;
+    driver: "memory" | "redis";
+    redis?: {
+        host: string;
+        port: number;
+        password?: string;
+        db?: number;
+    };
+    retries?: number;
+    retryDelay?: number;
+}
+/**
+ * Mail Template Configuration
+ */
+export interface MailTemplateConfig {
+    engine: "ejs" | "handlebars";
+    viewsPath: string;
+    layoutsPath?: string;
+    defaultLayout?: string;
+    inlineCss?: boolean;
+}
+/**
+ * Default Sender Configuration
+ */
+export interface MailFromConfig {
+    address: string;
+    name?: string;
+}
+/**
+ * Main Mail Configuration
+ */
+export interface MailConfig {
+    /**
+     * Default mail driver to use
+     */
+    default: MailDriver;
+    /**
+     * Default "from" address and name
+     */
+    from: MailFromConfig;
+    /**
+     * SMTP Configuration
+     */
+    smtp?: SMTPConfig;
+    /**
+     * SendGrid Configuration
+     */
+    sendgrid?: SendGridConfig;
+    /**
+     * Mailgun Configuration
+     */
+    mailgun?: MailgunConfig;
+    /**
+     * AWS SES Configuration
+     */
+    ses?: SESConfig;
+    /**
+     * Queue Configuration
+     */
+    queue?: MailQueueConfig;
+    /**
+     * Template Configuration
+     */
+    templates?: MailTemplateConfig;
+    /**
+     * Reply-to address
+     */
+    replyTo?: MailFromConfig;
+}
+/**
+ * Mail Message Options
+ */
+export interface MailMessage {
+    to: string | string[];
+    from?: MailFromConfig;
+    subject: string;
+    html?: string;
+    text?: string;
+    cc?: string | string[];
+    bcc?: string | string[];
+    replyTo?: string;
+    attachments?: MailAttachment[];
+    headers?: Record<string, string>;
+    priority?: "high" | "normal" | "low";
+}
+/**
+ * Mail Attachment
+ */
+export interface MailAttachment {
+    filename: string;
+    content?: string | Buffer;
+    path?: string;
+    contentType?: string;
+    cid?: string;
+}
+/**
+ * Nodemailer Transporter Type
+ */
+export type MailTransporter = Transporter;

package/dist/lib/mail/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./MailConfig";

package/dist/lib/mail/utils/TemplateRenderer.d.ts

@@ -0,0 +1,34 @@
+import { MailTemplateConfig } from "../types";
+/**
+ * Template renderer for email views
+ */
+export declare class TemplateRenderer {
+    private static config?;
+    /**
+     * Initialize the template renderer
+     */
+    static init(config: MailTemplateConfig): void;
+    /**
+     * Render a template to HTML
+     */
+    static render(templateName: string, data?: Record<string, any>): Promise<{
+        html: string;
+        text: string;
+    }>;
+    /**
+     * Render EJS template
+     */
+    private static renderEJS;
+    /**
+     * Render Handlebars template
+     */
+    private static renderHandlebars;
+    /**
+     * Apply layout to rendered content
+     */
+    private static applyLayout;
+    /**
+     * Convert HTML to plain text
+     */
+    private static htmlToText;
+}

package/dist/lib/mail/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./TemplateRenderer";

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

@@ -1,7 +1,7 @@
 import { Express, RequestHandler } from "express";
 import React from "react";
 import { ServiceProvider } from "./support/ServiceProvider";
-export interface ArcanaJSConfig<TDb = any> {
+export interface ArcanaJSConfig {
     port?: number | string;
     views?: Record<string, React.FC<any>>;
     viewsDir?: string;
@@ -15,49 +15,19 @@ export interface ArcanaJSConfig<TDb = any> {
     distDir?: string;
     indexFile?: string;
     layout?: React.FC<any>;
-    /** Optional function to establish a DB connection. Should return a Promise resolving to the DB client/connection. */
-    dbConnect?: () => Promise<TDb> | TDb;
     /** Automatically register SIGINT/SIGTERM handlers to call stop(). Default: true */
     autoHandleSignals?: boolean;
+    /** Auth configuration */
+    auth?: any;
+    /** Mail configuration */
+    mail?: any;
+    /** Database configuration */
+    database?: any;
     /** Service providers to load */
     providers?: (new (app: ArcanaJSServer) => ServiceProvider)[];
 }
-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;
-            /**
-             * 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> {
+declare class ArcanaJSServer {
     app: Express;
     container: Container;
     private config;
@@ -65,14 +35,17 @@ declare class ArcanaJSServer<TDb = any> {
     private _sigintHandler?;
     private _sigtermHandler?;
     private providers;
-    constructor(config: ArcanaJSConfig<TDb>);
+    private initialized;
+    constructor(config: ArcanaJSConfig);
+    private initializeAsync;
+    private loadConfigurations;
     private registerProviders;
     private bootProviders;
-    private initialize;
+    private setupMiddleware;
     private loadViewsFromContext;
     private loadViewsFromAlias;
     private discoverViews;
-    start(): void;
+    start(): Promise<void>;
     /**
      * Stop the HTTP server and close DB connection if present.
      */

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

@@ -22,6 +22,14 @@ export declare class Container {
      * Resolve a dependency from the container
      */
     make<T>(key: string | ClassConstructor<T>): T;
+    /**
+     * Check if a service is registered in the container
+     */
+    has(key: string | ClassConstructor): boolean;
+    /**
+     * Alias for make() - resolve a dependency from the container
+     */
+    resolve<T>(key: string | ClassConstructor<T>): T;
     /**
      * Instantiate a class, resolving its dependencies
      */

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

@@ -1,2 +1,2 @@
 import { NextFunction, Request, Response } from "express";
-export declare const createDynamicRouter: (views: Record<string, any>) => (req: Request, res: Response, next: NextFunction) => Express.Response | undefined;
+export declare const createDynamicRouter: (views: Record<string, any>) => (req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;

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

@@ -1,65 +1,57 @@
-import express, { Router as ExpressRouter } from "express";
+import { Router as ExpressRouter } from "express";
 /**
- * Provides Routing syntax for defining routes with prefixes, middlewares, and groups
+ * Provides Routing syntax for defining routes with prefixes, middlewares, and groups for ArcanaJS Framework
  */
-export declare class Router {
+export declare class ArcanaJSRouter {
     private router;
     private middlewareStack;
     private prefixStack;
     constructor();
-    /**
-     * Create a new router instance
-     */
-    static create(): Router;
     /**
      * Add middleware to the current stack
      */
-    middleware(...middleware: any[]): Router;
+    middleware(...middleware: any[]): ArcanaJSRouter;
     /**
      * Add prefix to the current stack
      */
-    prefix(prefix: string): Router;
+    prefix(prefix: string): ArcanaJSRouter;
     /**
      * Create a route group
      */
-    group(callback: (router: Router) => void): Router;
+    group(callback: (router: ArcanaJSRouter) => void): ArcanaJSRouter;
     /**
      * Define a GET route
      */
-    get(path: string, ...args: any[]): Router;
+    get(path: string, ...args: any[]): ArcanaJSRouter;
     /**
      * Define a POST route
      */
-    post(path: string, ...args: any[]): Router;
+    post(path: string, ...args: any[]): ArcanaJSRouter;
     /**
      * Define a PUT route
      */
-    put(path: string, ...args: any[]): Router;
+    put(path: string, ...args: any[]): ArcanaJSRouter;
     /**
      * Define a DELETE route
      */
-    delete(path: string, ...args: any[]): Router;
+    delete(path: string, ...args: any[]): ArcanaJSRouter;
     /**
      * Define a PATCH route
      */
-    patch(path: string, ...args: any[]): Router;
+    patch(path: string, ...args: any[]): ArcanaJSRouter;
     /**
      * Define an OPTIONS route
      */
-    options(path: string, ...args: any[]): Router;
+    options(path: string, ...args: any[]): ArcanaJSRouter;
     /**
      * Define a resource route
      * Registers index, create, store, show, edit, update, destroy routes
      */
-    resource(path: string, controller: any): Router;
+    resource(path: string, controller: any): ArcanaJSRouter;
     /**
      * Get the underlying Express router
      */
     getRouter(): ExpressRouter;
-    /**
-     * Mount this router to an Express app or router
-     */
-    mount(app: express.Application | ExpressRouter, basePath?: string): void;
     /**
      * Clone the current router instance
      */
@@ -86,18 +78,16 @@ export declare class Router {
  */
 export declare class Route {
     private static _router;
-    static create(): 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;
-    static post(path: string, ...args: any[]): Router;
-    static put(path: string, ...args: any[]): Router;
-    static delete(path: string, ...args: any[]): Router;
-    static patch(path: string, ...args: any[]): Router;
-    static options(path: string, ...args: any[]): Router;
+    static middleware(...middleware: any[]): typeof Route;
+    static prefix(prefix: string): typeof Route;
+    static group(callback: (router: ArcanaJSRouter) => void): typeof Route;
+    static get(path: string, ...args: any[]): typeof Route;
+    static post(path: string, ...args: any[]): typeof Route;
+    static put(path: string, ...args: any[]): typeof Route;
+    static delete(path: string, ...args: any[]): typeof Route;
+    static patch(path: string, ...args: any[]): typeof Route;
+    static options(path: string, ...args: any[]): typeof Route;
+    static resource(path: string, controller: any): typeof Route;
     static getRouter(): ExpressRouter;
-    static mount(app: express.Application, basePath?: string): void;
-    static reset(): void;
 }
 export default Route;

package/dist/lib/server/support/ServiceProvider.d.ts

@@ -10,4 +10,8 @@ export declare abstract class ServiceProvider {
      * Bootstrap any application services.
      */
     boot(): void;
+    /**
+     * Shutdown any application services.
+     */
+    shutdown(): Promise<void>;
 }

package/dist/lib/validation/Validator.d.ts

@@ -0,0 +1,55 @@
+import type { DatabaseAdapter } from "../arcanox/types";
+export declare class Validator {
+    protected data: any;
+    protected rules: Record<string, string>;
+    protected errors: Record<string, string[]>;
+    protected databaseAdapter?: DatabaseAdapter;
+    /**
+     * Map of custom validator functions.
+     */
+    private static customValidators;
+    /**
+     * Register a custom validator.
+     */
+    static registerValidator(name: string, fn: (value: any, data: any, param?: string) => true | string | Promise<true | string>): void;
+    constructor(data: any, rules: Record<string, string>);
+    static make(data: any, rules: Record<string, string>): Validator;
+    /**
+     * Set the database adapter for database validation rules
+     */
+    setDatabaseAdapter(adapter: DatabaseAdapter): this;
+    fails(): Promise<boolean>;
+    passes(): Promise<boolean>;
+    errors_(): Record<string, string[]>;
+    validate(): Promise<Record<string, any>>;
+    protected validateRules(): Promise<Record<string, any>>;
+    /**
+     * Check if any rules require database adapter
+     */
+    protected needsDatabaseAdapter(): boolean;
+    /**
+     * Auto-inject database adapter from Container
+     */
+    protected autoInjectDatabaseAdapter(): Promise<void>;
+    protected getValue(field: string): any;
+    protected applyRule(field: string, value: any, rule: string): Promise<void>;
+    protected validateArrayContent(field: string, array: any[], type: string): Promise<void>;
+    protected validateMin(field: string, value: any, param: string): void;
+    protected validateMax(field: string, value: any, param: string): void;
+    protected isValidJson(value: any): boolean;
+    protected isEmpty(value: any): boolean;
+    /**
+     * Validate unique rule: unique:table,column,ignoreId,ignoreColumn
+     * Examples:
+     * - unique:users,email
+     * - unique:users,email,5 (ignore record with id=5)
+     * - unique:users,email,5,user_id (ignore record where user_id=5)
+     */
+    protected validateUnique(field: string, value: any, param: string): Promise<void>;
+    /**
+     * Validate exists rule: exists:table,column
+     * Example: exists:riads,id
+     */
+    protected validateExists(field: string, value: any, param: string): Promise<void>;
+    protected addError(field: string, message: string): void;
+}

package/dist/types/express.d.ts

@@ -0,0 +1,45 @@
+import "express-serve-static-core";
+
+declare module "express-serve-static-core" {
+  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
+    ): this;
+
+    /**
+     * 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 | undefined | unknown,
+      data?: string | object | null
+    ): this;
+
+    /**
+     * 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>): this;
+  }
+}

package/dist/types/global.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Global type declarations for ArcanaJS
+ * This file provides type support for CSS imports in projects using ArcanaJS
+ */
+
+/// <reference types="react" />
+/// <reference path="./express.d.ts" />
+
+// CSS Module declarations
+declare module "*.css" {
+  const content: { [className: string]: string };
+  export default content;
+}
+
+declare module "*.module.css" {
+  const classes: { [key: string]: string };
+  export default classes;
+}
+
+// SCSS declarations
+declare module "*.scss" {
+  const content: { [className: string]: string };
+  export default content;
+}
+
+declare module "*.module.scss" {
+  const classes: { [key: string]: string };
+  export default classes;
+}
+
+// SASS declarations
+declare module "*.sass" {
+  const content: { [className: string]: string };
+  export default content;
+}
+
+declare module "*.module.sass" {
+  const classes: { [key: string]: string };
+  export default classes;
+}
+
+// LESS declarations
+declare module "*.less" {
+  const content: { [className: string]: string };
+  export default content;
+}
+
+declare module "*.module.less" {
+  const classes: { [key: string]: string };
+  export default classes;
+}
+
+// Image file declarations
+declare module "*.png" {
+  const value: string;
+  export default value;
+}
+
+declare module "*.jpg" {
+  const value: string;
+  export default value;
+}
+
+declare module "*.jpeg" {
+  const value: string;
+  export default value;
+}
+
+declare module "*.gif" {
+  const value: string;
+  export default value;
+}
+
+declare module "*.svg" {
+  const value: string;
+  export default value;
+}
+
+declare module "*.webp" {
+  const value: string;
+  export default value;
+}
+
+// Font file declarations
+declare module "*.woff" {
+  const value: string;
+  export default value;
+}
+
+declare module "*.woff2" {
+  const value: string;
+  export default value;
+}
+
+declare module "*.ttf" {
+  const value: string;
+  export default value;
+}
+
+declare module "*.eot" {
+  const value: string;
+  export default value;
+}