arikajs 0.10.2 → 0.10.4

package/src/providers/SessionServiceProvider.ts

@@ -1,68 +0,0 @@
-
-import { ServiceProvider } from '@arikajs/foundation';
-import { SessionManager } from '@arikajs/session';
-import { StartSession } from '@arikajs/session';
-import * as path from 'path';
-
-export class SessionServiceProvider extends ServiceProvider {
-    /**
-     * Register the session manager as a singleton.
-     */
-    public async register(): Promise<void> {
-        this.app.singleton(SessionManager, () => {
-            const config = this.app.config();
-            const basePath = (this.app as any).getBasePath();
-
-            const sessionConfig: any = {
-                driver: config.get('session.driver', 'file'),
-                lifetime: config.get('session.lifetime', 120),    // minutes
-                cookie: config.get('session.cookie', 'arika_session'),
-                path: config.get('session.path', '/'),
-                storagePath: config.get('session.storagePath',
-                    path.join(basePath, 'storage', 'sessions')),
-                secure: config.get('session.secure', false),
-                httpOnly: config.get('session.httpOnly', true),
-                sameSite: config.get('session.sameSite', 'Lax'),
-                locking: config.get('session.locking', false),
-                lockTimeout: config.get('session.lockTimeout', 10),
-                gcProbability: config.get('session.gcProbability', 0.01),
-                secret: config.get('app.key', 'fallback-secret-change-me'),
-            };
-
-            if (sessionConfig.driver === 'database') {
-                try {
-                    // Try to resolve the database manager from the container
-                    const dbManager = this.app.make('db');
-                    sessionConfig.connection = dbManager; // passing manager or connection directly
-                    sessionConfig.table = config.get('session.table', 'sessions');
-                } catch {
-                    // Framework fallback
-                }
-            }
-
-            if (sessionConfig.driver === 'redis') {
-                try {
-                    // Try to resolve redis from container or cache store
-                    const redis = this.app.make('redis') || (this.app.make('cache') as any).store('redis').getRedis();
-                    sessionConfig.connection = redis;
-                    sessionConfig.prefix = config.get('session.prefix', 'arika_session:');
-                } catch {
-                    // Framework fallback
-                }
-            }
-
-            return new SessionManager(sessionConfig);
-        });
-
-        this.app.singleton('session', () => this.app.make(SessionManager));
-
-        this.app.singleton(StartSession, () => {
-            return new StartSession(this.app.make(SessionManager));
-        });
-    }
-
-    /**
-     * Boot — nothing required.
-     */
-    public async boot(): Promise<void> { }
-}

package/src/providers/TranslationServiceProvider.ts

@@ -1,51 +0,0 @@
-import { ServiceProvider } from '@arikajs/foundation';
-import { Translator } from '@arikajs/localization';
-import path from 'path';
-import fs from 'fs';
-
-export class TranslationServiceProvider extends ServiceProvider {
-    /**
-     * Register the translation service.
-     */
-    public register(): void {
-        this.app.singleton(Translator, () => {
-            const config = (this.app as any).config();
-            const locale = config.get('app.locale', 'en');
-            const fallbackLocale = config.get('app.fallback_locale', 'en');
-
-            const translator = new Translator(locale, fallbackLocale);
-
-            // Load translations from resources/lang
-            this.loadTranslations(translator);
-
-            return translator;
-        });
-    }
-
-    /**
-     * Load translations from the application's language directory.
-     */
-    private loadTranslations(translator: Translator): void {
-        const langPath = path.join(process.cwd(), 'resources', 'lang');
-
-        if (!fs.existsSync(langPath)) {
-            return;
-        }
-
-        const locales = fs.readdirSync(langPath);
-
-        for (const locale of locales) {
-            const localePath = path.join(langPath, locale);
-            if (!fs.statSync(localePath).isDirectory()) continue;
-
-            const files = fs.readdirSync(localePath);
-            for (const file of files) {
-                if (file.endsWith('.json')) {
-                    const group = path.basename(file, '.json');
-                    const content = JSON.parse(fs.readFileSync(path.join(localePath, file), 'utf-8'));
-                    translator.load(locale, group, content);
-                }
-            }
-        }
-    }
-}

package/src/providers/ValidationServiceProvider.ts

@@ -1,24 +0,0 @@
-
-import { ServiceProvider } from '@arikajs/foundation';
-import { Validator } from '@arikajs/validation';
-import { ValidateRequestMiddleware } from '../http/Middleware/ValidateRequestMiddleware';
-
-export class ValidationServiceProvider extends ServiceProvider {
-    /**
-     * Register validation services.
-     */
-    public async register() {
-        this.app.singleton('validator', () => {
-            return {
-                make: (data: any, rules: any, messages: any = {}) => {
-                    return new Validator(data, rules, messages);
-                }
-            };
-        });
-
-        // Register the validation middleware
-        this.app.bind(ValidateRequestMiddleware, () => {
-            return new ValidateRequestMiddleware();
-        });
-    }
-}

package/src/providers/ViewServiceProvider.ts

@@ -1,46 +0,0 @@
-
-import { ServiceProvider } from '@arikajs/foundation';
-import { View } from '@arikajs/view';
-import path from 'path';
-import { ViewMiddleware } from '../http/Middleware/ViewMiddleware';
-
-export class ViewServiceProvider extends ServiceProvider {
-    /**
-     * Register the service provider.
-     */
-    public async register(): Promise<void> {
-        this.app.singleton(View, () => {
-            const config = this.app.config();
-            const viewsPath = config.get('view.paths', [
-                path.join((this.app as any).getBasePath(), 'resources/views')
-            ])[0] as string;
-
-            const cachePath = config.get('view.cache_path',
-                path.join((this.app as any).getBasePath(), 'storage/framework/views')
-            ) as string;
-
-            const view = new View({
-                viewsPath,
-                cachePath,
-                cache: config.get('app.env') === 'production'
-            });
-
-            view.helper('config', (key: string, defaultValue?: any) => config.get(key, defaultValue));
-
-            return view;
-        });
-
-        this.app.singleton('view', () => this.app.make(View));
-
-        this.app.singleton(ViewMiddleware, () => {
-            return new ViewMiddleware(this.app.make(View));
-        });
-    }
-
-    /**
-     * Boot the service provider.
-     */
-    public async boot(): Promise<void> {
-        //
-    }
-}

package/tests/Framework.test.ts

@@ -1,140 +0,0 @@
-import test, { describe, it } from 'node:test';
-import assert from 'node:assert';
-import { createApp } from '../src';
-import { Router } from '@arikajs/router';
-import { ServerResponse } from 'node:http';
-
-describe('ArikaJS Framework', () => {
-    it('can create an application instance', () => {
-        const app = createApp();
-        assert.ok(app instanceof Object);
-        assert.ok(app.getRouter() instanceof Router);
-    });
-
-    it('can register routes through the app', () => {
-        const app = createApp();
-        app.get('/test', () => 'hello');
-
-        const matched = app.getRouter().match('GET', '/test');
-        assert.ok(matched !== null);
-        assert.strictEqual(matched.route.path, '/test');
-    });
-
-    it('boots correctly', async () => {
-        const app = createApp();
-        app.config().set('app.key', 'base64:sm957Y1wUYo8Uj8yL1fD7vX+X6y8gG+E6XpXnJz+I=');
-        await app.boot();
-        assert.ok(app.isBooted());
-    });
-
-    it('can handle requests through the kernel', async () => {
-        const app = createApp();
-        app.config().set('app.key', 'base64:sm957Y1wUYo8Uj8yL1fD7vX+X6y8gG+E6XpXnJz+I=');
-        app.config().set('logging', {
-            default: 'console',
-            channels: {
-                console: {
-                    driver: 'console'
-                }
-            }
-        });
-
-        app.get('/hello', () => ({ message: 'world' }));
-
-        await app.boot();
-
-        const { Kernel } = await import('../src/http/Kernel');
-        const { Request, Response } = await import('@arikajs/http');
-
-        const kernel = new Kernel(app);
-
-        // Mock Node.js response
-        const mockRes = {
-            setHeader: () => { },
-            writeHead: () => { },
-            end: () => { },
-            statusCode: 200
-        } as unknown as ServerResponse;
-
-        const request = new Request(app, { method: 'GET', url: '/hello', headers: {} } as any);
-        const response = new Response(mockRes);
-
-        const result = await kernel.handle(request, response);
-
-        assert.strictEqual(result.getContent(), JSON.stringify({ message: 'world' }));
-    });
-
-    it('handles CORS preflight requests', async () => {
-        const app = createApp();
-        app.config().set('app.key', 'base64:sm957Y1wUYo8Uj8yL1fD7vX+X6y8gG+E6XpXnJz+I=');
-        await app.boot();
-
-        const { Kernel } = await import('../src/http/Kernel');
-        const { Request, Response } = await import('@arikajs/http');
-        const { ServerResponse } = await import('node:http');
-
-        const kernel = new Kernel(app);
-
-        const mockRes = {
-            setHeader: (name: string, value: string) => {
-                mockRes.headers[name] = value;
-            },
-            writeHead: () => { },
-            end: () => { },
-            statusCode: 200,
-            headers: {} as Record<string, string>
-        } as unknown as ServerResponse & { headers: Record<string, string> };
-
-        const request = new Request(app, { method: 'OPTIONS', url: '/any', headers: {} } as any);
-        const response = new Response(mockRes);
-
-        const result = await kernel.handle(request, response);
-        kernel.terminate(request, result);
-
-        assert.strictEqual(mockRes.statusCode, 204);
-        assert.strictEqual(mockRes.headers['Access-Control-Allow-Origin'], '*');
-        assert.strictEqual(mockRes.headers['Access-Control-Allow-Methods'], 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
-    });
-
-    it('initializes the database manager and facade', async () => {
-        const app = createApp();
-        app.config().set('app.key', 'base64:sm957Y1wUYo8Uj8yL1fD7vX+X6y8gG+E6XpXnJz+I=');
-        app.config().set('database', {
-            default: 'sqlite',
-            connections: {
-                sqlite: {
-                    driver: 'sqlite',
-                    database: ':memory:'
-                }
-            }
-        });
-
-        await app.boot();
-
-        const { DatabaseManager, Database } = await import('@arikajs/database');
-
-        const manager = app.make(DatabaseManager);
-        assert.ok(manager instanceof DatabaseManager);
-        assert.strictEqual(manager, Database.getManager());
-    });
-
-    it('provides global helpers', async () => {
-        const appInstance = createApp();
-        appInstance.config().set('app.name', 'ArikaTest');
-
-        const { app: appHelper, config: configHelper } = await import('../src');
-
-        assert.strictEqual(appHelper(), appInstance);
-        assert.strictEqual(configHelper('app.name'), 'ArikaTest');
-    });
-
-    it('initializes the event facade', async () => {
-        const appInstance = createApp();
-        appInstance.config().set('app.key', 'base64:sm957Y1wUYo8Uj8yL1fD7vX+X6y8gG+E6XpXnJz+I=');
-
-        await appInstance.boot();
-
-        const { Event } = await import('@arikajs/events');
-        assert.ok(Event.getManager() !== null);
-    });
-});

package/tsconfig.json

@@ -1,25 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES2020",
-        "module": "CommonJS",
-        "moduleResolution": "Node",
-        "strict": true,
-        "esModuleInterop": true,
-        "forceConsistentCasingInFileNames": true,
-        "skipLibCheck": true,
-        "declaration": true,
-        "declarationMap": true,
-        "sourceMap": true,
-        "outDir": "dist",
-        "rootDir": "src",
-        "experimentalDecorators": true,
-        "emitDecoratorMetadata": true
-    },
-    "include": [
-        "src/**/*"
-    ],
-    "exclude": [
-        "node_modules",
-        "dist"
-    ]
-}