@adaas/a-server 0.0.20 → 0.0.22

package/examples/simple-server/concept.ts

@@ -100,7 +100,14 @@ import { A_Config, A_ConfigLoader, A_Polyfill, ConfigReader, ENVConfigReader, Fi
                 '/assets/.*': 'https://test.com',
                 '/style.css': 'https://test.com'
             }),
-            new A_StaticConfig(['docs'])
+            new A_StaticConfig(
+                ['./public', './assets'], // Simple directories
+                [ // Custom aliases
+                    { path: '/api-docs', directory: './docs', alias: '/documentation' },
+                    { path: '/assets', directory: './static/assets' },
+                    { path: '/uploads', directory: './user-uploads' }
+                ]
+            )
         ],
         entities: []
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-server",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "SDK to create a server with ease. Build your backend server with modular structure and use it within or outside the ADAAS ecosystem.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -49,7 +49,7 @@
   "homepage": "https://github.com/ADAAS-org/adaas-a-server#readme",
   "dependencies": {
     "@adaas/a-concept": "^0.1.24",
-    "@adaas/a-utils": "^0.1.10"
+    "@adaas/a-utils": "^0.1.11"
   },
   "devDependencies": {
     "@types/chai": "^4.3.14",

package/src/components/A-ServerProxy/A-ServerProxy.component.ts

@@ -4,9 +4,7 @@ import { A_ProxyConfig } from "@adaas/a-server/context/A-ProxyConfig/A_ProxyConf
 import { A_Request } from "@adaas/a-server/entities/A-Request/A-Request.entity";
 import { A_Response } from "@adaas/a-server/entities/A-Response/A-Response.entity";
 import { A_Route } from "@adaas/a-server/entities/A-Route/A-Route.entity";
-import { A_Logger } from "@adaas/a-utils";
-import http from "http";
-import https from "https";
+import { A_Logger, A_Polyfill } from "@adaas/a-utils";
 
 
 export class A_ServerProxy extends A_Component {
@@ -25,7 +23,7 @@ export class A_ServerProxy extends A_Component {
     }
 
 
-    
+
     @A_Feature.Extend({
         name: A_SERVER_TYPES__ServerFeature.onRequest,
     })
@@ -33,9 +31,10 @@ export class A_ServerProxy extends A_Component {
         @A_Inject(A_Request) req: A_Request,
         @A_Inject(A_Response) res: A_Response,
         @A_Inject(A_ProxyConfig) proxyConfig: A_ProxyConfig,
-        @A_Inject(A_Logger) logger: A_Logger
+        @A_Inject(A_Logger) logger: A_Logger,
+        @A_Inject(A_Polyfill) polyfill: A_Polyfill
     ) {
-        return new Promise<void>((resolve, reject) => {
+        return new Promise<void>(async (resolve, reject) => {
             const { method, url } = req;
 
             const route = new A_Route(url, method);
@@ -51,7 +50,9 @@ export class A_ServerProxy extends A_Component {
                 config
             );
 
-            const client = config.protocol === "https:" ? https : http;
+            const client = await (config.protocol === "https:"
+                ? polyfill.https()
+                : polyfill.http());
 
             const proxyReq = client.request(
                 {

package/src/components/A-StaticLoader/A-StaticLoader.component.ts

@@ -1,27 +1,32 @@
 import { A_Component, A_Concept, A_Feature, A_Inject } from "@adaas/a-concept"
-import fs from "fs";
-import path from "path";
-import { URL } from "url";
 import { A_Request } from "@adaas/a-server/entities/A-Request/A-Request.entity";
 import { A_Response } from "@adaas/a-server/entities/A-Response/A-Response.entity";
 import { A_SERVER_TYPES__ServerFeature } from "@adaas/a-server/containers/A-Service/A-Service.container.types";
 import { A_Route } from "@adaas/a-server/entities/A-Route/A-Route.entity";
-import { A_StaticConfig } from "@adaas/a-server/context/A-StaticConfig/A-StaticConfig.context";
-import { A_Logger } from "@adaas/a-utils";
-
+import { A_StaticConfig, A_StaticAlias } from "@adaas/a-server/context/A-StaticConfig/A-StaticConfig.context";
+import { A_Logger, A_Polyfill } from "@adaas/a-utils";
 
 export class A_StaticLoader extends A_Component {
 
+    private _fsPolyfill: any;
+    private _pathPolyfill: any;
 
     @A_Concept.Load()
     async load(
         @A_Inject(A_Logger) logger: A_Logger,
-        @A_Inject(A_StaticConfig) config: A_StaticConfig
+        @A_Inject(A_StaticConfig) config: A_StaticConfig,
+        @A_Inject(A_Polyfill) polyfill: A_Polyfill
     ) {
+        // Initialize polyfills
+        this._fsPolyfill = await polyfill.fs();
+        this._pathPolyfill = await polyfill.path();
+
+        // Log configured aliases
+        const aliases = config.getEnabledAliases();
         logger.log(
             'pink',
-            `Static directories configured:`,
-            config.directories.join('\n')
+            `Static aliases configured:`,
+            aliases.map(alias => `${alias.alias} -> ${alias.directory}`).join('\n')
         );
     }
 
@@ -37,7 +42,8 @@ export class A_StaticLoader extends A_Component {
         @A_Inject(A_Request) req: A_Request,
         @A_Inject(A_Response) res: A_Response,
         @A_Inject(A_Logger) logger: A_Logger,
-        @A_Inject(A_StaticConfig) config: A_StaticConfig
+        @A_Inject(A_StaticConfig) config: A_StaticConfig,
+        @A_Inject(A_Polyfill) polyfill: A_Polyfill
     ) {
 
         if (req.method !== 'GET' && req.method !== 'HEAD') {
@@ -47,87 +53,252 @@ export class A_StaticLoader extends A_Component {
         const { method, url } = req;
         const route = new A_Route(url, method);
 
-        const staticDirConfig = config.has(route.path)
-
-        if (!staticDirConfig) {
+        // Check if this request matches any of our configured aliases
+        const alias = config.findMatchingAlias(route.path);
+        if (!alias) {
             return; // No static config for this path
         }
 
-        const staticDir = path.resolve(process.cwd(), staticDirConfig);
+        try {
+            // Ensure polyfills are available
+            const fs = this._fsPolyfill || await polyfill.fs();
+            const path = this._pathPolyfill || await polyfill.path();
+
+            const staticDir = path.resolve(process.cwd(), alias.directory);
+
+            // Validate static directory exists
+            if (!fs.existsSync(staticDir)) {
+                logger.log("red", `Static directory ${staticDir} does not exist.`);
+                return;
+            }
+
+            // Get the file path relative to the alias
+            const relativePath = route.path.replace(alias.path, '');
+            const safePath = this.safeFilePath(staticDir, relativePath, req.headers?.host, path, fs);
+            
+            await this.serveFile(safePath, res, logger, fs, path);
+        } catch (error: any) {
+            logger.error(`Static file serving error: ${error.message}`);
+            res.writeHead(404, { "Content-Type": "text/plain" });
+            res.send("File not found");
+        }
+    }
 
-        if (!fs.existsSync(staticDir) || !fs.statSync(staticDir).isDirectory()) {
-            logger.log("red", `Static directory ${staticDir} does not exist or is not a directory.`);
-            return;
+    /**
+     * Add a custom static file alias through the config
+     * @param alias - The URL path alias (e.g., '/assets')
+     * @param directory - The local directory path
+     * @param path - Optional custom path (defaults to alias)
+     * @param config - Static config instance
+     * @param logger - Logger instance for logging
+     */
+    public addAlias(
+        alias: string, 
+        directory: string, 
+        config: A_StaticConfig, 
+        logger?: A_Logger, 
+        path?: string
+    ): void {
+        config.addAlias(alias, directory, path);
+        
+        if (logger) {
+            logger.log('cyan', `Static alias added: ${alias} -> ${directory}`);
         }
+    }
 
-        await this.serveFile(route.path.startsWith('/') ? route.path.slice(1) : route.path, res);
+    /**
+     * Remove a static file alias through the config
+     * @param aliasPath - The path of the alias to remove
+     * @param config - Static config instance
+     * @param logger - Logger instance for logging
+     */
+    public removeAlias(aliasPath: string, config: A_StaticConfig, logger?: A_Logger): boolean {
+        const removed = config.removeAlias(aliasPath);
+        
+        if (removed && logger) {
+            logger.log('yellow', `Static alias removed: ${aliasPath}`);
+        }
+        
+        return removed;
     }
 
+    /**
+     * Get all configured aliases from config
+     * @param config - Static config instance
+     */
+    public getAliases(config: A_StaticConfig): A_StaticAlias[] {
+        return config.getAliases();
+    }
 
+    /**
+     * Enable or disable an alias
+     * @param aliasPath - The path of the alias
+     * @param enabled - Whether to enable or disable
+     * @param config - Static config instance
+     * @param logger - Logger instance for logging
+     */
+    public setAliasEnabled(
+        aliasPath: string, 
+        enabled: boolean, 
+        config: A_StaticConfig, 
+        logger?: A_Logger
+    ): boolean {
+        const result = config.setAliasEnabled(aliasPath, enabled);
+        
+        if (result && logger) {
+            logger.log('blue', `Static alias ${enabled ? 'enabled' : 'disabled'}: ${aliasPath}`);
+        }
+        
+        return result;
+    }
 
     protected getMimeType(ext: string): string {
         const mimeTypes: Record<string, string> = {
+            // Text
             ".html": "text/html",
-            ".js": "application/javascript",
+            ".htm": "text/html",
             ".css": "text/css",
+            ".txt": "text/plain",
+            ".md": "text/markdown",
+            ".xml": "application/xml",
+            
+            // JavaScript
+            ".js": "application/javascript",
+            ".mjs": "application/javascript",
+            ".jsx": "application/javascript",
+            ".ts": "application/typescript",
+            ".tsx": "application/typescript",
+            
+            // JSON
             ".json": "application/json",
+            ".jsonld": "application/ld+json",
+            
+            // Images
             ".png": "image/png",
             ".jpg": "image/jpeg",
             ".jpeg": "image/jpeg",
             ".gif": "image/gif",
             ".svg": "image/svg+xml",
             ".ico": "image/x-icon",
-            ".txt": "text/plain",
+            ".webp": "image/webp",
+            ".bmp": "image/bmp",
+            ".tiff": "image/tiff",
+            
+            // Fonts
+            ".woff": "font/woff",
+            ".woff2": "font/woff2",
+            ".ttf": "font/ttf",
+            ".otf": "font/otf",
+            ".eot": "application/vnd.ms-fontobject",
+            
+            // Audio/Video
+            ".mp3": "audio/mpeg",
+            ".wav": "audio/wav",
+            ".mp4": "video/mp4",
+            ".webm": "video/webm",
+            ".ogg": "application/ogg",
+            
+            // Archives
+            ".zip": "application/zip",
+            ".tar": "application/x-tar",
+            ".gz": "application/gzip",
+            
+            // Documents
+            ".pdf": "application/pdf",
+            ".doc": "application/msword",
+            ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+            ".xls": "application/vnd.ms-excel",
+            ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
         };
 
         return mimeTypes[ext.toLowerCase()] || "application/octet-stream";
     }
 
 
-    protected safeFilePath(staticDir: string, reqUrl: string, host?: string): string {
-        const parsedUrl = new URL(reqUrl || "/", `http://${host || "localhost"}`);
+    protected safeFilePath(staticDir: string, reqUrl: string, host: string = 'localhost', pathPolyfill: any, fsPolyfill: any): string {
+        const parsedUrl = new URL(reqUrl || "/", `http://${host}`);
         let pathname = decodeURIComponent(parsedUrl.pathname);
 
         // Prevent path traversal attacks
         pathname = pathname.replace(/\.\.[\/\\]/g, "");
 
-        let filePath = path.join(staticDir, pathname);
-        if (!fs.existsSync(filePath))
+        let filePath = pathPolyfill.join(staticDir, pathname);
+        
+        if (!fsPolyfill.existsSync(filePath)) {
             throw new Error(`File not found: ${filePath}`);
+        }
 
         return filePath;
     }
 
-
-    protected serveFile(filePath: string, res: A_Response): Promise<void> {
-
-
+    protected serveFile(
+        filePath: string, 
+        res: A_Response, 
+        logger: A_Logger, 
+        fsPolyfill: any, 
+        pathPolyfill: any
+    ): Promise<void> {
         return new Promise<void>((resolve, reject) => {
-
-            if (fs.existsSync(filePath)) {
-                const ext = path.extname(filePath);
-                const contentType = this.getMimeType(ext);
-
-                res.writeHead(200, { "Content-Type": contentType });
-                const stream = fs.createReadStream(filePath);
-                stream.pipe(res.original);
-
-                stream.on('end', () => {
-                    resolve();
-                });
-
-                stream.on("error", (err) => {
-                    reject(new Error(`File stream error: ${err.message}`));
-                });
-            } else {
-                reject(new Error(`File not found: ${filePath}`));
+            try {
+                if (fsPolyfill.existsSync(filePath)) {
+                    const ext = pathPolyfill.extname(filePath);
+                    const contentType = this.getMimeType(ext);
+
+                    // Set appropriate headers
+                    const headers: Record<string, string> = {
+                        "Content-Type": contentType,
+                        "Cache-Control": this.getCacheControl(ext),
+                        "X-Content-Type-Options": "nosniff"
+                    };
+
+                    res.writeHead(200, headers);
+                    const stream = fsPolyfill.createReadStream(filePath);
+                    
+                    if (stream && res.original) {
+                        stream.pipe(res.original);
+
+                        stream.on('end', () => {
+                            logger.log('green', `Successfully served: ${filePath}`);
+                            resolve();
+                        });
+
+                        stream.on("error", (err: any) => {
+                            logger.error(`File stream error: ${err.message}`);
+                            reject(new Error(`File stream error: ${err.message}`));
+                        });
+                    } else {
+                        res.writeHead(500, { "Content-Type": "text/plain" });
+                        res.send("Internal server error");
+                        reject(new Error("Failed to create file stream"));
+                    }
+                } else {
+                    res.writeHead(404, { "Content-Type": "text/plain" });
+                    res.send("File not found");
+                    reject(new Error(`File not found: ${filePath}`));
+                }
+            } catch (error: any) {
+                logger.error(`Error serving file: ${error.message}`);
+                res.writeHead(500, { "Content-Type": "text/plain" });
+                res.send("Internal server error");
+                reject(error);
             }
-
-
-            resolve();
         });
     }
 
+    protected getCacheControl(ext: string): string {
+        // Different cache strategies for different file types
+        const staticAssets = ['.css', '.js', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico', '.woff', '.woff2', '.ttf', '.otf'];
+        const dynamicContent = ['.html', '.htm'];
+        
+        if (staticAssets.includes(ext.toLowerCase())) {
+            return "public, max-age=31536000"; // 1 year for static assets
+        } else if (dynamicContent.includes(ext.toLowerCase())) {
+            return "public, max-age=3600"; // 1 hour for HTML
+        } else {
+            return "public, max-age=86400"; // 1 day for other files
+        }
+    }
+
 }
 
 

package/src/components/A-StaticLoader/A-StaticLoader.component.types.ts

@@ -1,110 +1,8 @@
-import { A_Component, A_Feature, A_Inject } from "@adaas/a-concept"
-import fs from "fs";
-import path from "path";
-import { URL } from "url";
-import { A_Request } from "@adaas/a-server/entities/A-Request/A-Request.entity";
-import { A_Response } from "@adaas/a-server/entities/A-Response/A-Response.entity";
-import { A_SERVER_TYPES__ServerFeature } from "@adaas/a-server/containers/A-Service/A-Service.container.types";
-import { A_Logger } from "@adaas/a-utils";
 
 
-export class A_StaticLoader extends A_Component {
-
-    // =======================================================
-    // ================ Method Definition=====================
-    // =======================================================
-
-    @A_Feature.Extend({
-        name: A_SERVER_TYPES__ServerFeature.onRequest,
-    })
-    async onRequest(
-        @A_Inject(A_Request) req: A_Request,
-        @A_Inject(A_Response) res: A_Response,
-        @A_Inject(A_Logger) logger: A_Logger
-    ) {
-
-        if (req.method !== 'GET' && req.method !== 'HEAD') {
-            return; // Only handle GET and HEAD requests
-        }
-
-        const staticDir = path.resolve(process.cwd(), 'public');
-
-        if (!fs.existsSync(staticDir) || !fs.statSync(staticDir).isDirectory()) {
-            logger.log("red", `Static directory ${staticDir} does not exist or is not a directory.`);
-            return;
-        }
-
-        const filePath = this.safeFilePath(staticDir, req.url || "/", req.headers.host);
-
-        await this.serveFile(filePath, res);
-    }
-
-
-
-    protected getMimeType(ext: string): string {
-        const mimeTypes: Record<string, string> = {
-            ".html": "text/html",
-            ".js": "application/javascript",
-            ".css": "text/css",
-            ".json": "application/json",
-            ".png": "image/png",
-            ".jpg": "image/jpeg",
-            ".jpeg": "image/jpeg",
-            ".gif": "image/gif",
-            ".svg": "image/svg+xml",
-            ".ico": "image/x-icon",
-            ".txt": "text/plain",
-        };
-
-        return mimeTypes[ext.toLowerCase()] || "application/octet-stream";
-    }
-
-
-    protected safeFilePath(staticDir: string, reqUrl: string, host?: string): string {
-        const parsedUrl = new URL(reqUrl || "/", `http://${host || "localhost"}`);
-        let pathname = decodeURIComponent(parsedUrl.pathname);
-
-        // Prevent path traversal attacks
-        pathname = pathname.replace(/\.\.[\/\\]/g, "");
-
-        let filePath = path.join(staticDir, pathname);
-
-        if (fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()) {
-            filePath = path.join(filePath, "index.html");
-        }
-
-        return filePath;
-    }
-
-
-    protected serveFile(filePath: string, res: A_Response): Promise<void> {
-
-        return new Promise<void>((resolve, reject) => {
-
-            if (fs.existsSync(filePath)) {
-                const ext = path.extname(filePath);
-                const contentType = this.getMimeType(ext);
-
-                res.writeHead(200, { "Content-Type": contentType });
-                const stream = fs.createReadStream(filePath);
-                stream.pipe(res.original);
-
-                stream.on('end', () => {
-                    resolve();
-                });
-
-                stream.on("error", (err) => {
-                    reject(new Error(`File stream error: ${err.message}`));
-                });
-            } else {
-                reject(new Error(`File not found: ${filePath}`));
-            }
-
-
-            resolve();
-        });
-    }
-
+export type A_SERVER_TYPES__StaticLoader_Init = {
+    /**
+     * Path to the static files directory
+     */
+    staticFilesPath: string,
 }
-
-

package/src/containers/A-Service/A-Service.container.ts

@@ -1,12 +1,12 @@
-import { createServer, IncomingMessage, Server, ServerResponse } from "http";
-import { A_SERVER_TYPES__ServerFeature, A_SERVER_TYPES__ServerFeatures } from "./A-Service.container.types";
+import type { IncomingMessage, Server, ServerResponse } from "http";
+import { A_SERVER_TYPES__ServerFeature } from "./A-Service.container.types";
 import { A_Server } from "@adaas/a-server/context/A-Server/A_Server.context";
 import { A_Request } from "@adaas/a-server/entities/A-Request/A-Request.entity";
 import { A_Response } from "@adaas/a-server/entities/A-Response/A-Response.entity";
-import crypto from 'crypto';
 import { A_SERVER_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY, A_TYPES__ServerENVVariables } from "@adaas/a-server/constants/env.constants";
-import { A_Concept, A_Container, A_Feature, A_IdentityHelper, A_Scope } from "@adaas/a-concept";
-import { A_Config, A_Logger } from "@adaas/a-utils";
+import { A_Concept, A_Container, A_Error, A_Feature, A_IdentityHelper, A_Inject, A_Scope } from "@adaas/a-concept";
+import { A_Config, A_Logger, A_Polyfill, IcryptoInterface } from "@adaas/a-utils";
+import { A_ServerLogger } from "@adaas/a-server/components/A-ServerLogger/A_ServerLogger.component";
 
 
 
@@ -22,11 +22,24 @@ export class A_Service extends A_Container {
     port!: number;
 
     @A_Concept.Load()
-    async load() {
+    async load(
+    ) {
+        // Initialize Logger
+        let logger: A_ServerLogger;
+        if (!this.scope.has(A_ServerLogger))
+            this.scope.register(A_ServerLogger);
 
-        let config: A_Config<A_TYPES__ServerENVVariables>;
-        let aServer: A_Server;
+        logger = this.scope.resolve(A_ServerLogger);
+
+        // Initialize Polyfill
+        let polyfill: A_Polyfill;
+        if (!this.scope.has(A_Polyfill))
+            this.scope.register(A_Polyfill);
 
+        polyfill = this.scope.resolve(A_Polyfill);
+
+        // Initialize Config
+        let config: A_Config<A_TYPES__ServerENVVariables>;
         if (!this.scope.has(A_Config<A_TYPES__ServerENVVariables>)) {
             const config = new A_Config<A_TYPES__ServerENVVariables>({
                 variables: [...Array.from(A_SERVER_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY)],
@@ -37,9 +50,10 @@ export class A_Service extends A_Container {
 
             this.scope.register(config);
         }
-
         config = this.scope.resolve(A_Config) as A_Config<A_TYPES__ServerENVVariables>;
 
+        let aServer: A_Server;
+
 
         if (!this.scope.has(A_Server)) {
             aServer = new A_Server({
@@ -52,8 +66,10 @@ export class A_Service extends A_Container {
         // Set the server to listen on port 3000
         this.port = config.get('A_SERVER_PORT');
 
+        const http = await polyfill.http();
+
         // Create the HTTP server
-        this.server = createServer(this.onRequest.bind(this));
+        this.server = http.createServer(this.onRequest.bind(this));
 
     }
 
@@ -147,7 +163,7 @@ export class A_Service extends A_Container {
             await res.status(200).send();
 
         } catch (error) {
-            
+
             const logger = this.scope.resolve(A_Logger);
 
             logger.error(error);
@@ -164,9 +180,11 @@ export class A_Service extends A_Container {
     ): Promise<{ req: A_Request, res: A_Response }> {
 
         if (!request.method || !request.url)
-            throw new Error('Request method or url is missing');
+            throw new A_Error('Request method or url is missing');
+
 
-        const id = this.generateRequestId(request.method, request.url);
+
+        const id = await this.generateRequestId(request.method, request.url);
 
         const req = new A_Request({ id, request, scope: this.scope.name });
         const res = new A_Response({ id, response, scope: this.scope.name });
@@ -177,17 +195,19 @@ export class A_Service extends A_Container {
         return { req, res };
     }
 
-    protected generateRequestId(
+    protected async generateRequestId(
         method: string,
         url: string
-    ): string {
+    ): Promise<string> {
+        const crypto = await this.scope.resolve(A_Polyfill).crypto();
+
         // Use the current time, request URL, and a few other details to create a unique ID
-        const hash = crypto.createHash('sha256');
         const timeId = A_IdentityHelper.generateTimeId();
         const randomValue = Math.random().toString(); // Adds extra randomness
 
-        hash.update(`${timeId}-${method}-${url}-${randomValue}`);
-        return `${timeId}-${hash.digest('hex')}`;
+        const hash = await crypto.createTextHash(`${timeId}-${method}-${url}-${randomValue}`, 'sha256');
+
+        return `${timeId}-${hash}`;
     }
 
     @A_Feature.Define({ invoke: true })