@arikajs/cli 0.0.4 → 0.0.6

package/dist/templates/app/.env.example

@@ -0,0 +1,47 @@
+APP_NAME=ArikaJs
+APP_ENV=development
+APP_PORT=3000
+APP_DEBUG=true
+APP_KEY=
+APP_URL=http://localhost:3000
+APP_TIMEZONE=UTC
+
+DB_CONNECTION=mysql
+DB_HOST=127.0.0.1
+DB_PORT=3306
+DB_DATABASE=arikajs
+DB_USERNAME=root
+DB_PASSWORD=
+
+REDIS_CLIENT=ioredis
+REDIS_HOST=127.0.0.1
+REDIS_PASSWORD=null
+REDIS_PORT=6379
+REDIS_DB=0
+
+MAIL_MAILER=log
+MAIL_HOST=127.0.0.1
+MAIL_PORT=2525
+MAIL_USERNAME=
+MAIL_PASSWORD=
+MAIL_ENCRYPTION=tls
+MAIL_FROM_ADDRESS="hello@example.com"
+MAIL_FROM_NAME="${APP_NAME}"
+
+FILESYSTEM_DISK=local
+
+AWS_ACCESS_KEY_ID=
+AWS_SECRET_ACCESS_KEY=
+AWS_DEFAULT_REGION=us-east-1
+AWS_BUCKET=
+AWS_URL=
+AWS_ENDPOINT=
+AWS_USE_PATH_STYLE_ENDPOINT=false
+
+LOG_CHANNEL=stack
+LOG_LEVEL=debug
+
+QUEUE_CONNECTION=sync
+
+CACHE_STORE=file
+CACHE_PREFIX=arika_cache

package/dist/templates/app/README.md

@@ -0,0 +1,62 @@
+# ArikaJS Application
+
+Welcome to your new **ArikaJS** application! This project was generated with the ArikaJS CLI, providing you with a premium, type-safe, and high-performance foundation for your next web application or API.
+
+## 🚀 Getting Started
+
+### 1. Install Dependencies
+
+```bash
+npm install
+```
+
+### 2. Configure Environment
+
+Copy the `.env.example` file to `.env` and set your configuration value (like `APP_KEY` and database credentials).
+
+```bash
+cp .env.example .env
+```
+
+### 3. Generate Application Key
+
+```bash
+npx arika key:generate
+```
+
+### 4. Start Development Server
+
+```bash
+npm run dev
+```
+
+Your application will be running at `http://localhost:3000` 🎉
+
+## 🏗 Project Structure
+
+- `app/`: Contains your application logic (Controllers, Models, Middleware).
+- `bootstrap/`: Application bootstrapping and service provider registration.
+- `config/`: Configuration files for various system components.
+- `database/`: Migrations and seeders.
+- `public/`: Static assets (images, CSS, JS).
+- `resources/`: Views and templates.
+- `routes/`: Route definitions for Web and API.
+- `server.ts`: The entry point for the application.
+
+## 📚 Features
+
+- **Eloquent-style ORM**: Simple and powerful database interactions.
+- **Native Validation**: Easy request validation directly in your controllers.
+- **Service Container**: Robust dependency injection and service management.
+- **Middleware Pipeline**: Flexible request/response processing.
+- **Templating Engine**: Fast and intuitive HTML rendering.
+
+## 🤝 Community & Support
+
+- [GitHub Repository](https://github.com/arikajs/arikajs)
+- [Documentation](https://github.com/arikajs/arikajs#readme)
+- [Issue Tracker](https://github.com/arikajs/arikajs/issues)
+
+---
+
+**Built with ❤️ by the ArikaJS Team**

package/dist/templates/app/app/Exceptions/Handler.ts

@@ -0,0 +1,19 @@
+import { Handler as BaseHandler } from 'arikajs';
+
+export class Handler extends BaseHandler {
+    /**
+     * Report or log an exception.
+     */
+    public report(error: any): void {
+        super.report(error);
+    }
+
+    /**
+     * Register the exception handling callbacks for the application.
+     */
+    public register(): void {
+        //
+    }
+}
+
+

package/dist/templates/app/app/Http/Controllers/UserController.ts

@@ -0,0 +1,90 @@
+import { Request, Response } from 'arikajs';
+import { User } from '@Models/User';
+
+export class UserController {
+    /**
+     * Display a listing of the resource.
+     */
+    async index(req: Request, res: Response) {
+        const users = await User.all();
+        return res.json({ 
+            message: 'List of all users',
+            data: users 
+        });
+    }
+
+    /**
+     * Display the specified resource.
+     */
+    async show(req: Request, res: Response) {
+        const id = req.param('id');
+        const user = await User.find(id);
+
+        if (!user) {
+            return res.status(404).json({ message: 'User not found' });
+        }
+
+        return res.json({ 
+            message: 'User details',
+            data: user 
+        });
+    }
+
+    /**
+     * Store a newly created resource.
+     */
+    async store(req: Request, res: Response) {
+        const data = await req.validate({
+            name: 'required|string|max:255',
+            email: 'required|email|unique:users',
+            password: 'required|string|min:8',
+        });
+
+        const user = await User.create(data);
+
+        return res.status(201).json({ 
+            message: 'User created successfully',
+            data: user 
+        });
+    }
+
+    /**
+     * Update the specified resource.
+     */
+    async update(req: Request, res: Response) {
+        const id = req.param('id');
+        const user = await User.find(id);
+
+        if (!user) {
+            return res.status(404).json({ message: 'User not found' });
+        }
+
+        const data = await req.validate({
+            name: 'string|max:255',
+            email: `email|unique:users,email,${id}`,
+        });
+
+        await user.update(data);
+
+        return res.json({ 
+            message: 'User updated successfully',
+            data: user 
+        });
+    }
+
+    /**
+     * Remove the specified resource.
+     */
+    async destroy(req: Request, res: Response) {
+        const id = req.param('id');
+        const user = await User.find(id);
+
+        if (!user) {
+            return res.status(404).json({ message: 'User not found' });
+        }
+
+        await user.delete();
+
+        return res.json({ message: 'User deleted successfully' });
+    }
+}

package/dist/templates/app/app/Http/Kernel.ts

@@ -0,0 +1,43 @@
+import { Kernel as BaseKernel, StartSession, ViewMiddleware } from 'arikajs';
+import { Authenticate } from '@Middleware/Authenticate';
+import { RedirectIfAuthenticated } from '@Middleware/RedirectIfAuthenticated';
+import { EnsureEmailIsVerified } from '@Middleware/EnsureEmailIsVerified';
+import { VerifyCsrfToken } from '@Middleware/VerifyCsrfToken';
+import { TrimStrings } from '@Middleware/TrimStrings';
+import { TrustProxies } from '@Middleware/TrustProxies';
+
+export class Kernel extends BaseKernel {
+    constructor(app: any) {
+        super(app);
+
+        // Global middleware — runs on EVERY request (web + API).
+        this.middleware.push(
+            new TrustProxies(),
+            new TrimStrings(),
+        );
+
+        // Middleware groups — 'web' and 'api' groups.
+        Object.assign(this.middlewareGroups, {
+            web: [
+                StartSession,
+                ViewMiddleware,
+                new VerifyCsrfToken(),
+            ],
+            api: [
+                'throttle:120,60',
+            ],
+        });
+
+        // Named route middleware — aliases.
+        Object.assign(this.routeMiddleware, {
+            'auth': Authenticate,
+            'guest': RedirectIfAuthenticated,
+            'verified': EnsureEmailIsVerified,
+        });
+
+        // Sync with router
+        const router = this.app.getRouter();
+        router.setMiddlewareGroups(this.middlewareGroups);
+        router.setRouteMiddleware(this.routeMiddleware);
+    }
+}

package/dist/templates/app/app/Http/Middleware/Authenticate.ts

@@ -0,0 +1,10 @@
+import { Authenticate as Middleware, Request } from 'arikajs';
+
+export class Authenticate extends Middleware {
+    /**
+     * Get the path the user should be redirected to when they are not authenticated.
+     */
+    protected redirectTo(request: Request): string | null {
+        return request.expectsJson() ? null : '/auth/login';
+    }
+}

package/dist/templates/app/app/Http/Middleware/EnsureEmailIsVerified.ts

@@ -0,0 +1,18 @@
+import { Request, Response, Middleware } from 'arikajs';
+
+export class EnsureEmailIsVerified implements Middleware {
+    /**
+     * Handle an incoming request.
+     */
+    public async handle(request: Request, next: (request: Request) => Promise<Response>): Promise<Response> {
+        const user = await request.auth.user();
+
+        if (!user || (typeof user.hasVerifiedEmail === 'function' && !user.hasVerifiedEmail())) {
+            return request.expectsJson()
+                ? (request as any).res.json({ message: 'Your email address is not verified.' }, 403)
+                : (request as any).res.redirect('/auth/verify');
+        }
+
+        return await next(request);
+    }
+}

package/dist/templates/app/app/Http/Middleware/ExampleMiddleware.ts

@@ -0,0 +1,12 @@
+import { Request, Response } from 'arikajs';
+
+export class ExampleMiddleware {
+    /**
+     * Handle an incoming request.
+     */
+    public async handle(request: Request, next: (req: Request) => Promise<Response>): Promise<Response> {
+        // Perform some action...
+
+        return await next(request);
+    }
+}

package/dist/templates/app/app/Http/Middleware/RedirectIfAuthenticated.ts

@@ -0,0 +1,18 @@
+import { Request, Response } from 'arikajs';
+
+export class RedirectIfAuthenticated {
+    /**
+     * Handle an incoming request.
+     */
+    public async handle(request: Request, next: (request: Request) => Promise<Response>, ...guards: string[]): Promise<Response> {
+        const authGuards = guards.length > 0 ? guards : [undefined];
+
+        for (const guard of authGuards) {
+            if (await request.auth.guard(guard).check()) {
+                return (request as any).res.redirect('/dashboard');
+            }
+        }
+
+        return await next(request);
+    }
+}

package/dist/templates/app/app/Http/Middleware/TrimStrings.ts

@@ -0,0 +1,12 @@
+import { TrimStrings as Middleware } from 'arikajs';
+
+export class TrimStrings extends Middleware {
+    /**
+     * The names of the attributes that should not be trimmed.
+     */
+    protected except: string[] = [
+        'current_password',
+        'password',
+        'password_confirmation',
+    ];
+}

package/dist/templates/app/app/Http/Middleware/TrustProxies.ts

@@ -0,0 +1,23 @@
+import { Request, Response, Middleware } from 'arikajs';
+
+export class TrustProxies implements Middleware {
+    /**
+     * The trusted proxies for the application.
+     * Use '*' to trust all proxies, or an array of IP addresses.
+     */
+    protected proxies: string | string[] = '*';
+
+    /**
+     * The proxy header mappings.
+     */
+    protected headers: string = 'X-Forwarded-For | X-Forwarded-Host | X-Forwarded-Proto';
+
+    /**
+     * Handle an incoming request.
+     */
+    public async handle(request: Request, next: (request: Request) => Promise<Response>): Promise<Response> {
+        // In ArikaJS, proxy trust is currently configured in the config/http.ts file,
+        // but this middleware can be used to dynamically set trust logic if needed.
+        return await next(request);
+    }
+}

package/dist/templates/app/app/Http/Middleware/VerifyCsrfToken.ts

@@ -0,0 +1,10 @@
+import { VerifyCsrfToken as Middleware } from 'arikajs';
+
+export class VerifyCsrfToken extends Middleware {
+    /**
+     * The URIs that should be excluded from CSRF verification.
+     */
+    protected except: string[] = [
+        //
+    ];
+}

package/dist/templates/app/app/Models/User.ts

@@ -0,0 +1,15 @@
+import { Model } from 'arikajs';
+
+export class User extends Model {
+    protected static table = 'users';
+
+    protected fillable: string[] = [
+        'name',
+        'email',
+        'password',
+    ];
+
+    protected hidden: string[] = [
+        'password',
+    ];
+}

package/dist/templates/app/app/Providers/AppServiceProvider.ts

@@ -0,0 +1,17 @@
+import { ServiceProvider } from 'arikajs';
+
+export class AppServiceProvider extends ServiceProvider {
+    /**
+     * Register any application services.
+     */
+    public register(): void {
+        // 
+    }
+
+    /**
+     * Bootstrap any application services.
+     */
+    public boot(): void {
+        // 
+    }
+}

package/dist/templates/app/app/Providers/RouteServiceProvider.ts

@@ -0,0 +1,35 @@
+import { ServiceProvider, Route } from 'arikajs';
+import path from 'path';
+
+export class RouteServiceProvider extends ServiceProvider {
+    /**
+     * Register any application services.
+     */
+    public register(): void {
+        // 
+    }
+
+    /**
+     * Bootstrap any application services.
+     */
+    public boot(): void {
+        this.loadRoutes();
+    }
+
+    /**
+     * Load the application routes.
+     */
+    protected loadRoutes(): void {
+        const basePath = (this.app as any).getBasePath();
+
+        // 1. Load web routes (with session, CSRF, etc.)
+        Route.middleware('web').group(() => {
+            require(path.join(basePath, 'routes/web'));
+        });
+
+        // 2. Load API routes with /api prefix (stateless, auth via JWT)
+        Route.middleware('api').prefix('api').group(() => {
+            require(path.join(basePath, 'routes/api'));
+        });
+    }
+}

package/dist/templates/app/bootstrap/app.ts

@@ -0,0 +1,41 @@
+import { createApp } from 'arikajs';
+import path from 'path';
+
+const app = createApp(
+    path.resolve(__dirname, '../')
+);
+
+/*
+|--------------------------------------------------------------------------
+| Register Service Providers
+|--------------------------------------------------------------------------
+|
+| The service providers listed here will be automatically loaded on the
+| request to your application. Feel free to add your own services.
+|
+*/
+
+import { AppServiceProvider } from '@Providers/AppServiceProvider';
+import { RouteServiceProvider } from '@Providers/RouteServiceProvider';
+
+app.register(AppServiceProvider);
+app.register(RouteServiceProvider);
+
+/*
+|--------------------------------------------------------------------------
+| Register The Http Kernel
+|--------------------------------------------------------------------------
+|
+| Next, we need to bind the Http Kernel to the container so that it
+| can be resolved when handling requests.
+|
+*/
+
+import { Kernel } from '@Http/Kernel';
+import { Handler } from '@Exceptions/Handler';
+import { Kernel as BaseKernel, Handler as BaseHandler } from 'arikajs';
+
+app.singleton(BaseKernel, () => new Kernel(app));
+app.singleton(BaseHandler, () => new Handler());
+
+export default app;

package/dist/templates/app/config/app.ts

@@ -0,0 +1,10 @@
+import { env } from 'arikajs';
+
+export default {
+    name: env('APP_NAME', 'ArikaJS'),
+    env: env('APP_ENV', 'production'),
+    debug: env('APP_DEBUG', false), // env() handles boolean strings if we want, but let's check.
+    url: env('APP_URL', 'http://localhost'),
+    timezone: env('APP_TIMEZONE', 'UTC'),
+    key: env('APP_KEY'),
+};

package/dist/templates/app/config/cache.ts

@@ -0,0 +1,44 @@
+import { env } from 'arikajs';
+
+export default {
+    /**
+     * Default Cache Store
+     */
+    default: env('CACHE_STORE', 'file'),
+
+    /**
+     * Cache Stores
+     */
+    stores: {
+        file: {
+            driver: 'file',
+            path: 'storage/cache/data',
+        },
+
+        memory: {
+            driver: 'memory',
+        },
+
+        database: {
+            driver: 'database',
+            table: 'cache',
+            connection: null,
+            lock_connection: null,
+        },
+
+        redis: {
+            driver: 'redis',
+            connection: 'default',
+            mode: env('REDIS_MODE', 'standalone'), // standalone, sentinel, cluster
+            host: env('REDIS_HOST', '127.0.0.1'),
+            password: env('REDIS_PASSWORD', null),
+            port: env('REDIS_PORT', 6379),
+            database: env('REDIS_DB', 0),
+        },
+    },
+
+    /**
+     * Cache Key Prefix
+     */
+    prefix: env('CACHE_PREFIX', 'arika_cache'),
+};

package/dist/templates/app/config/database.ts

@@ -0,0 +1,63 @@
+import { env } from 'arikajs';
+
+export default {
+    /**
+     * Default Database Connection Name
+     */
+    default: env('DB_CONNECTION', 'mysql'),
+
+    /**
+     * Database Connections
+     */
+    connections: {
+        sqlite: {
+            driver: 'sqlite',
+            database: env('DB_DATABASE', './database.sqlite'),
+            charset: 'utf8',
+        },
+
+        mysql: {
+            driver: 'mysql',
+            host: env('DB_HOST', '127.0.0.1'),
+            port: env('DB_PORT', 3306),
+            database: env('DB_DATABASE', 'arikajs'),
+            username: env('DB_USERNAME', 'root'),
+            password: env('DB_PASSWORD', ''),
+            charset: 'utf8mb4',
+            timezone: 'local',
+            pool: {
+                min: 2,
+                max: 20
+            }
+        },
+
+        pgsql: {
+            driver: 'pgsql',
+            host: env('DB_HOST', '127.0.0.1'),
+            port: env('DB_PORT', 5432),
+            database: env('DB_DATABASE', 'arikajs'),
+            username: env('DB_USERNAME', 'postgres'),
+            password: env('DB_PASSWORD', ''),
+            charset: 'utf8',
+            timezone: 'local',
+            pool: {
+                min: 2,
+                max: 20
+            }
+        },
+
+        mongodb: {
+            driver: 'mongodb',
+            host: env('DB_HOST', '127.0.0.1'),
+            port: env('DB_PORT', 27017),
+            database: env('DB_DATABASE', 'arikajs'),
+            username: env('DB_USERNAME', ''),
+            password: env('DB_PASSWORD', ''),
+            options: {
+                useUnifiedTopology: true,
+                maxPoolSize: 10,
+                minPoolSize: 2
+            }
+        }
+    }
+};

package/dist/templates/app/config/filesystems.ts

@@ -0,0 +1,35 @@
+import { env } from 'arikajs';
+
+export default {
+    /**
+     * Default Filesystem Disk
+     */
+    default: env('FILESYSTEM_DISK', 'local'),
+
+    /**
+     * Filesystem Disks
+     */
+    disks: {
+        local: {
+            driver: 'local',
+            root: './storage/app',
+        },
+
+        public: {
+            driver: 'local',
+            root: './storage/public',
+            url: env('APP_URL', 'http://localhost:3000') + '/storage',
+        },
+
+        s3: {
+            driver: 's3',
+            key: env('AWS_ACCESS_KEY_ID'),
+            secret: env('AWS_SECRET_ACCESS_KEY'),
+            region: env('AWS_DEFAULT_REGION', 'us-east-1'),
+            bucket: env('AWS_BUCKET'),
+            url: env('AWS_URL'),
+            endpoint: env('AWS_ENDPOINT'),
+            forcePathStyle: env('AWS_USE_PATH_STYLE_ENDPOINT', false),
+        },
+    },
+};

package/dist/templates/app/config/http.ts

@@ -0,0 +1,6 @@
+import { env } from 'arikajs';
+
+export default {
+    port: env('APP_PORT', 3000),
+    host: env('APP_HOST', '0.0.0.0'),
+};