arcanajs 4.0.0 → 5.0.1

package/dist/cli/utils/toPascalCase.d.ts

@@ -0,0 +1 @@
+export declare const toPascalCase: (str: string) => string;

package/dist/cli/utils/writeFile.d.ts

@@ -0,0 +1 @@
+export declare const writeFile: (dir: string, fileName: string, content: string) => Promise<void>;

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

@@ -16,6 +16,9 @@ export interface RelationConfig {
     pivotTable?: string;
 }
 import { Macroable } from "./support/Macroable";
+declare global {
+    var ArcanaDatabaseAdapter: DatabaseAdapter | undefined;
+}
 /**
  * Base Model class - Arcanox ORM
  */
@@ -43,6 +46,10 @@ export declare class Model<T = any> extends Macroable {
      * Set the database adapter
      */
     static setAdapter(adapter: DatabaseAdapter): void;
+    /**
+     * Get the database adapter
+     */
+    protected static getAdapter(): DatabaseAdapter;
     /**
      * Get the table name
      */

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

@@ -1,5 +1,10 @@
-import { Container } from "../../server/Container";
-export declare class DatabaseProvider {
-    static register(container: Container): Promise<void>;
-    static close(container: Container): Promise<void>;
+import { ServiceProvider } from "../../server/support/ServiceProvider";
+/**
+ * Database Service Provider
+ *
+ * Registers and bootstraps the database system
+ */
+export declare class DatabaseProvider extends ServiceProvider {
+    register(): Promise<void>;
+    shutdown(): Promise<void>;
 }

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

@@ -1,11 +1,22 @@
 import type { DatabaseAdapter } from "../types";
 import { Blueprint } from "./Blueprint";
+/**
+ * Schema - ArcnanJS schema builder
+ * Provides fluent interface for creating and modifying database tables
+ */
+declare global {
+    var ArcanaDatabaseAdapter: DatabaseAdapter | undefined;
+}
 /**
  * Schema - ArcnanJS schema builder
  * Provides fluent interface for creating and modifying database tables
  */
 export declare class Schema {
     private static adapter;
+    /**
+     * Get the database adapter
+     */
+    private static getAdapter;
     /**
      * Set the database adapter
      */

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

@@ -27,12 +27,14 @@ export interface DatabaseAdapter {
 }
 export interface DatabaseConfig {
     type: "postgres" | "mysql" | "mongodb";
-    host: string;
-    port: number;
+    host?: string;
+    port?: number;
     database: string;
     username?: string;
     password?: string;
     ssl?: boolean;
+    url?: string;
+    uri?: string;
     pool?: {
         min?: number;
         max?: number;

package/dist/lib/auth/AuthProvider.d.ts

@@ -0,0 +1,10 @@
+import { ServiceProvider } from "../server/support/ServiceProvider";
+/**
+ * Authentication Service Provider
+ *
+ * Registers and bootstraps the authentication system
+ */
+export declare class AuthProvider extends ServiceProvider {
+    register(): Promise<void>;
+    boot(): Promise<void>;
+}

package/dist/lib/auth/JWTService.d.ts

@@ -0,0 +1,11 @@
+import jwt from "jsonwebtoken";
+import { AuthConfig, JWTPayload } from "./types";
+export declare class JWTService {
+    private static config;
+    static init(config: AuthConfig["jwt"]): void;
+    static generateToken(payload: JWTPayload, options?: jwt.SignOptions): string;
+    static generateRefreshToken(payload: JWTPayload): string;
+    static verifyToken(token: string): Promise<JWTPayload>;
+    static revokeToken(token: string): Promise<void>;
+    static refreshAccessToken(refreshToken: string): Promise<string>;
+}

package/dist/lib/auth/SessionManager.d.ts

@@ -0,0 +1,4 @@
+import { AuthConfig } from "./types";
+export declare class SessionManager {
+    static createMiddleware(config: AuthConfig["session"]): import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+}

package/dist/lib/auth/middleware/AuthMiddleware.d.ts

@@ -0,0 +1,5 @@
+import { NextFunction, Request, Response } from "express";
+import { Middleware } from "../../server/http/Middleware";
+export declare class AuthMiddleware implements Middleware {
+    handle(req: Request, res: Response, next: NextFunction): Promise<void>;
+}

package/dist/lib/auth/middleware/AuthenticatedMiddleware.d.ts

@@ -0,0 +1,5 @@
+import { NextFunction, Request, Response } from "express";
+import { Middleware } from "../../server/http/Middleware";
+export declare class AuthenticatedMiddleware implements Middleware {
+    handle(req: Request, res: Response, next: NextFunction): void;
+}

package/dist/lib/auth/middleware/GuestMiddleware.d.ts

@@ -0,0 +1,5 @@
+import { NextFunction, Request, Response } from "express";
+import { Middleware } from "../../server/http/Middleware";
+export declare class GuestMiddleware implements Middleware {
+    handle(req: Request, res: Response, next: NextFunction): void;
+}

package/dist/lib/auth/middleware/RoleMiddleware.d.ts

@@ -0,0 +1,7 @@
+import { NextFunction, Request, Response } from "express";
+import { Middleware } from "../../server/http/Middleware";
+export declare class RoleMiddleware implements Middleware {
+    private roles;
+    constructor(...roles: string[]);
+    handle(req: Request, res: Response, next: NextFunction): void;
+}

package/dist/lib/auth/types/AuthConfig.d.ts

@@ -0,0 +1,24 @@
+export interface AuthConfig {
+    jwt: {
+        secret: string;
+        accessTokenExpiry?: string | number;
+        refreshTokenExpiry?: string | number;
+        algorithm?: "HS256" | "RS256";
+    };
+    session: {
+        secret: string;
+        name?: string;
+        maxAge?: number;
+        secure?: boolean;
+        redis?: {
+            host: string;
+            port: number;
+            password?: string;
+            db?: number;
+        };
+    };
+    tokenBlacklist?: {
+        enabled: boolean;
+        storage: "memory" | "redis";
+    };
+}

package/dist/lib/auth/types/JWTPayload.d.ts

@@ -0,0 +1,10 @@
+export interface JWTPayload {
+    sub: string;
+    email?: string;
+    roles?: string[];
+    permissions?: string[];
+    iat?: number;
+    exp?: number;
+    jti?: string;
+    [key: string]: any;
+}

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

@@ -0,0 +1,2 @@
+export * from "./AuthConfig";
+export * from "./JWTPayload";

package/dist/lib/auth/utils/PasswordHasher.d.ts

@@ -0,0 +1,16 @@
+export declare class PasswordHasher {
+    private static readonly SALT_ROUNDS;
+    /**
+     * Hash a password.
+     * @param password The password to hash.
+     * @returns The hashed password.
+     */
+    static hash(password: string): Promise<string>;
+    /**
+     * Verify a password against a hash.
+     * @param password The plain text password.
+     * @param hash The hashed password.
+     * @returns True if the password matches the hash.
+     */
+    static verify(password: string, hash: string): Promise<boolean>;
+}

package/dist/lib/auth/utils/TokenBlacklist.d.ts

@@ -0,0 +1,9 @@
+import { AuthConfig } from "../types";
+export declare class TokenBlacklist {
+    private static redisClient;
+    private static memoryStore;
+    private static config;
+    static init(config: AuthConfig["tokenBlacklist"], redisConfig?: AuthConfig["session"]["redis"]): Promise<void>;
+    static add(token: string, expiresInSeconds: number): Promise<void>;
+    static isRevoked(token: string): Promise<boolean>;
+}

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

@@ -1,6 +1,20 @@
-export { Macroable, Model, MongoAdapter, MySQLAdapter, PostgresAdapter, QueryBuilder, } from "./arcanox";
-export type { DatabaseAdapter, DatabaseConfig } from "./arcanox";
+/// <reference path="../types/global.d.ts" />
+
+export { MongoAdapter } from "./arcanox/adapters/MongoAdapter";
+export { MySQLAdapter } from "./arcanox/adapters/MySQLAdapter";
+export { PostgresAdapter } from "./arcanox/adapters/PostgresAdapter";
+export { Model } from "./arcanox/Model";
+export { QueryBuilder } from "./arcanox/QueryBuilder";
+export { BelongsTo } from "./arcanox/relations/BelongsTo";
+export { BelongsToMany } from "./arcanox/relations/BelongsToMany";
+export { HasMany } from "./arcanox/relations/HasMany";
+export { HasOne } from "./arcanox/relations/HasOne";
+export { Relation } from "./arcanox/relations/Relation";
+export { Macroable } from "./arcanox/support/Macroable";
+export type { ColumnDefinition, Connection, DatabaseAdapter, DatabaseConfig, JoinClause, OrderByClause, SelectOptions, WhereClause, } from "./arcanox/types";
 export { Blueprint, Migration, MigrationRunner, Schema, } from "./arcanox/schema";
 export type { MigrationStatus } from "./arcanox/schema";
 export { Factory } from "./arcanox/factory";
 export { Seeder } from "./arcanox/seeder";
+export * from "./arcanox/extensions/MongoExtensions";
+export { DatabaseProvider } from "./arcanox/providers/DatabaseProvider";

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

@@ -0,0 +1,11 @@
+/// <reference path="../types/global.d.ts" />
+
+export { AuthProvider } from "./auth/AuthProvider";
+export { JWTService } from "./auth/JWTService";
+export { AuthenticatedMiddleware } from "./auth/middleware/AuthenticatedMiddleware";
+export { AuthMiddleware } from "./auth/middleware/AuthMiddleware";
+export { GuestMiddleware } from "./auth/middleware/GuestMiddleware";
+export { RoleMiddleware } from "./auth/middleware/RoleMiddleware";
+export { SessionManager } from "./auth/SessionManager";
+export type { AuthConfig, JWTPayload } from "./auth/types";
+export { PasswordHasher } from "./auth/utils/PasswordHasher";

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

@@ -1,3 +1,5 @@
+/// <reference path="../types/global.d.ts" />
+
 export { default as Body } from "./shared/components/Body";
 export { default as Head } from "./shared/components/Head";
 export { default as Link } from "./shared/components/Link";

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

@@ -0,0 +1,8 @@
+/// <reference path="../types/global.d.ts" />
+
+export { Mailable } from "./mail/Mailable";
+export { MailProvider } from "./mail/MailProvider";
+export { MailService } from "./mail/MailService";
+export { MailQueue } from "./mail/queue/MailQueue";
+export type { MailAttachment, MailConfig, MailDriver, MailFromConfig, MailgunConfig, MailMessage, MailQueueConfig, MailTemplateConfig, SendGridConfig, SESConfig, SMTPConfig, } from "./mail/types";
+export { TemplateRenderer } from "./mail/utils/TemplateRenderer";

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

@@ -1,15 +1,13 @@
+/// <reference path="../types/global.d.ts" />
+
 import { Express } from "express";
 import ArcanaJSServer, { ArcanaJSConfig } from "./server/ArcanaJSServer";
 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 type { Middleware } from "./server/http/Middleware";
 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
  *
@@ -25,7 +23,7 @@ export { Validator } from "./server/validation/Validator";
  * const app = express();
  * const server = createArcanaServer(app, {
  *   port: 3000,
- *   viewsDir: 'src/views',
+ *   viewsDir: 'src/resources/views',
  * });
  *
  * server.start();

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

@@ -0,0 +1,6 @@
+/// <reference path="../types/global.d.ts" />
+
+export { FormRequest } from "./server/http/FormRequest";
+export { JsonResource } from "./server/http/JsonResource";
+export { ValidationException } from "./validation/ValidationException";
+export { Validator } from "./validation/Validator";

package/dist/lib/mail/MailProvider.d.ts

@@ -0,0 +1,10 @@
+import { ServiceProvider } from "../server/support/ServiceProvider";
+/**
+ * Mail Service Provider
+ *
+ * Registers and bootstraps the mail system
+ */
+export declare class MailProvider extends ServiceProvider {
+    register(): Promise<void>;
+    boot(): Promise<void>;
+}

package/dist/lib/mail/MailService.d.ts

@@ -0,0 +1,57 @@
+import { Mailable } from "./Mailable";
+import { MailConfig, MailMessage } from "./types";
+/**
+ * Core mail service for sending emails
+ */
+export declare class MailService {
+    private static config?;
+    private static transporter?;
+    /**
+     * Initialize the mail service
+     */
+    static init(config: MailConfig): Promise<void>;
+    /**
+     * Create nodemailer transporter based on configuration
+     */
+    private static createTransporter;
+    /**
+     * Create SMTP transporter
+     */
+    private static createSMTPTransporter;
+    /**
+     * Create SendGrid transporter
+     */
+    private static createSendGridTransporter;
+    /**
+     * Create Mailgun transporter
+     */
+    private static createMailgunTransporter;
+    /**
+     * Create AWS SES transporter
+     */
+    private static createSESTransporter;
+    /**
+     * Create log-only transporter (for testing)
+     */
+    private static createLogTransporter;
+    /**
+     * Send an email immediately
+     */
+    static send(mailable: Mailable | MailMessage): Promise<void>;
+    /**
+     * Queue an email for async sending
+     */
+    static queue(mailable: Mailable): Promise<void>;
+    /**
+     * Send a raw email message
+     */
+    static sendRaw(message: MailMessage): Promise<void>;
+    /**
+     * Get the mail configuration
+     */
+    static getConfig(): MailConfig | undefined;
+    /**
+     * Verify transporter connection
+     */
+    static verify(): Promise<boolean>;
+}

package/dist/lib/mail/Mailable.d.ts

@@ -0,0 +1,106 @@
+import { MailAttachment, MailMessage } from "./types";
+/**
+ * Abstract base class for creating email messages
+ *
+ * @example
+ * ```typescript
+ * class WelcomeEmail extends Mailable {
+ *   constructor(private user: User) {
+ *     super();
+ *   }
+ *
+ *   build() {
+ *     return this
+ *       .to(this.user.email)
+ *       .subject('Welcome to ArcanaJS!')
+ *       .view('emails/welcome', { name: this.user.name });
+ *   }
+ * }
+ *
+ * // Send the email
+ * await new WelcomeEmail(user).send();
+ * ```
+ */
+export declare abstract class Mailable {
+    protected message: Partial<MailMessage>;
+    protected viewName?: string;
+    protected viewData?: Record<string, any>;
+    /**
+     * Build the email message
+     * Must be implemented by subclasses
+     */
+    abstract build(): this;
+    /**
+     * Set the recipient(s)
+     */
+    to(address: string | string[], name?: string): this;
+    /**
+     * Set the sender
+     */
+    from(address: string, name?: string): this;
+    /**
+     * Set the email subject
+     */
+    subject(subject: string): this;
+    /**
+     * Set the email view template
+     */
+    view(template: string, data?: Record<string, any>): this;
+    /**
+     * Set HTML content directly
+     */
+    html(content: string): this;
+    /**
+     * Set plain text content
+     */
+    text(content: string): this;
+    /**
+     * Add CC recipient(s)
+     */
+    cc(address: string | string[]): this;
+    /**
+     * Add BCC recipient(s)
+     */
+    bcc(address: string | string[]): this;
+    /**
+     * Set reply-to address
+     */
+    replyTo(address: string): this;
+    /**
+     * Add an attachment
+     */
+    attach(attachment: MailAttachment): this;
+    /**
+     * Attach a file from path
+     */
+    attachFromPath(path: string, filename?: string): this;
+    /**
+     * Attach data as a file
+     */
+    attachData(content: string | Buffer, filename: string, contentType?: string): this;
+    /**
+     * Set email priority
+     */
+    priority(level: "high" | "normal" | "low"): this;
+    /**
+     * Add custom headers
+     */
+    withHeaders(headers: Record<string, string>): this;
+    /**
+     * Get the built message
+     * @internal
+     */
+    getMessage(): {
+        message: Partial<MailMessage>;
+        viewName?: string;
+        viewData?: Record<string, any>;
+    };
+    /**
+     * Send the email immediately
+     */
+    send(): Promise<void>;
+    /**
+     * Queue the email for async sending
+     */
+    queue(): Promise<void>;
+}

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

@@ -0,0 +1,6 @@
+export * from "./Mailable";
+export * from "./MailProvider";
+export * from "./MailService";
+export * from "./queue";
+export * from "./types";
+export * from "./utils";

package/dist/lib/mail/queue/MailQueue.d.ts

@@ -0,0 +1,51 @@
+import { Mailable } from "../Mailable";
+import { MailQueueConfig } from "../types";
+/**
+ * Mail queue for async email processing
+ */
+export declare class MailQueue {
+    private static config?;
+    private static queue;
+    private static processing;
+    private static redisClient?;
+    /**
+     * Initialize the mail queue
+     */
+    static init(config: MailQueueConfig): Promise<void>;
+    /**
+     * Initialize Redis connection
+     */
+    private static initRedis;
+    /**
+     * Add a job to the queue
+     */
+    static add(mailable: Mailable): Promise<void>;
+    /**
+     * Start processing the queue
+     */
+    private static startProcessing;
+    /**
+     * Process next job in queue
+     */
+    private static processNext;
+    /**
+     * Handle failed job
+     */
+    private static handleFailedJob;
+    /**
+     * Store failed job for manual review
+     */
+    private static storeFailedJob;
+    /**
+     * Generate unique job ID
+     */
+    private static generateId;
+    /**
+     * Get queue size
+     */
+    static size(): Promise<number>;
+    /**
+     * Clear the queue
+     */
+    static clear(): Promise<void>;
+}

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

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