@adaas/a-server 0.0.21 → 0.0.23

package/src/lib/A-ServerRouter/A-ServerRouter.meta.ts

@@ -0,0 +1,48 @@
+import { A_ComponentMeta } from "@adaas/a-concept";
+import { A_ServerRouterMetaStructure, A_ServerRouterRouteDefinition } from "./A-ServerRouter.types";
+import { A_ServerRoute } from "@adaas/a-server/route/A-ServerRoute.entity";
+import { A_ServerRouterMetaKeys } from "./A-ServerRouter.constants";
+
+
+
+export class A_ServerRouterMeta extends A_ComponentMeta<A_ServerRouterMetaStructure> {
+
+
+    get routes(): Array<A_ServerRoute> {
+        return this.meta.get(A_ServerRouterMetaKeys.ROUTES_CONFIGS) as Array<A_ServerRoute> || [];
+    }
+
+
+    get definitions(): Map<string, A_ServerRouterRouteDefinition> {
+        return this.meta.get(A_ServerRouterMetaKeys.ROUTES) as Map<string, A_ServerRouterRouteDefinition> || new Map<string, A_ServerRouterRouteDefinition>();
+    }
+
+
+    addRoute(regexp: RegExp, route: A_ServerRouterRouteDefinition) {
+        const existingRoutes = this.meta.get(A_ServerRouterMetaKeys.ROUTES) as Map<string, A_ServerRouterRouteDefinition> || new Map<string, A_ServerRouterRouteDefinition>();
+        existingRoutes.set(regexp.source, route);
+        this.meta.set(A_ServerRouterMetaKeys.ROUTES, existingRoutes);
+
+        const existingRoutesConfigs = this.meta.get(A_ServerRouterMetaKeys.ROUTES_CONFIGS) as Array<A_ServerRoute> || [];
+        existingRoutesConfigs.push(route.route);
+        this.meta.set(A_ServerRouterMetaKeys.ROUTES_CONFIGS, existingRoutesConfigs);
+    }
+
+
+    removeRoute(route: A_ServerRoute) {
+        const existingRoutes = this.meta.get(A_ServerRouterMetaKeys.ROUTES) as Map<string, A_ServerRouterRouteDefinition> || new Map<string, A_ServerRouterRouteDefinition>();
+        existingRoutes.forEach((value, key) => {
+            if (value.route === route) {
+                existingRoutes.delete(key);
+            }
+        });
+        this.meta.set(A_ServerRouterMetaKeys.ROUTES, existingRoutes);
+
+        const existingRoutesConfigs = this.meta.get(A_ServerRouterMetaKeys.ROUTES_CONFIGS) as Array<A_ServerRoute> || [];
+        const index = existingRoutesConfigs.indexOf(route);
+        if (index !== -1) {
+            existingRoutesConfigs.splice(index, 1);
+        }
+        this.meta.set(A_ServerRouterMetaKeys.ROUTES_CONFIGS, existingRoutesConfigs);
+    }
+}

package/src/lib/A-ServerRouter/A-ServerRouter.types.ts

@@ -0,0 +1,27 @@
+import { A_Component, A_TYPES__ComponentMeta } from "@adaas/a-concept";
+import { A_ServerRoute } from "@adaas/a-server/route/A-ServerRoute.entity";
+import { A_ServerRouterMetaKeys } from "./A-ServerRouter.constants";
+
+
+
+
+
+export type A_ServerRouterRouteDefinition = {
+    component: A_Component,
+    handler: string,
+    route: A_ServerRoute
+}
+
+export type A_ServerRouterMetaStructure = {
+    [A_ServerRouterMetaKeys.ROUTES]: Map<string, A_ServerRouterRouteDefinition>
+    [A_ServerRouterMetaKeys.ROUTES_CONFIGS]: Array<A_ServerRoute>
+} & A_TYPES__ComponentMeta
+
+export type A_ServerRouterMetaKeyNames = typeof A_ServerRouterMetaKeys[keyof typeof A_ServerRouterMetaKeys]
+
+
+export type A_ServerRouterRouteConfig = {
+    path: string | RegExp;
+    version: string;
+    prefix: string;
+} 

package/src/lib/A-ServerRouter/A-ServerRouterDefine.decorator.ts

@@ -0,0 +1,37 @@
+import { A_Component, A_Context, A_Feature_Define, A_Feature_Extend, A_TYPES__MetaLinkedComponentConstructors } from "@adaas/a-concept";
+import { A_ServerRouterMeta } from "./A-ServerRouter.meta";
+import { A_ServerRoute } from "../A-ServerRoute/A-ServerRoute.entity";
+import { A_ServerRouter } from "./A-ServerRouter.component";
+
+/**
+ * 
+ * This decorator should allow to set a default meta type for the class, this helps to avoid
+ * the need to create custom meta classes for each class.
+ * 
+ * @returns 
+ */
+export function A_ServerRouterDefineDecorator(route: A_ServerRoute) {
+    return function <TTarget extends A_TYPES__MetaLinkedComponentConstructors>(
+        target: A_Component,
+        propertyKey: string,
+        descriptor: PropertyDescriptor
+    ) {
+
+        const meta: A_ServerRouterMeta = A_Context.meta<A_ServerRouterMeta>(A_ServerRouter);
+
+        const searchKey = route.toAFeatureExtension(['A_ServerRouter', 'A_Service']);
+
+        meta.addRoute(searchKey, {
+            component: target,
+            handler: propertyKey,
+            route
+        });
+
+        A_Feature_Define({
+            name: searchKey.source,
+            invoke: false
+        })(target, propertyKey, descriptor)
+
+        return A_Feature_Extend(searchKey)(target, propertyKey, descriptor);
+    }
+}

package/src/lib/A-ServerStatic/A-ServerStatic.component.ts

@@ -0,0 +1,323 @@
+import { A_Component, A_Concept, A_Feature, A_Inject } from "@adaas/a-concept"
+import { A_Request } from "@adaas/a-server/request/A-Request.entity";
+import { A_Response } from "@adaas/a-server/response/A-Response.entity";
+import { A_StaticConfig, A_StaticAlias } from "./A-ServerStatic.context";
+import { A_HttpServerFeatures } from "@adaas/a-server/server/A-HttpServer.constants";
+import { A_HttpServerError } from "@adaas/a-server/server/A-HttpServer.error";
+import { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_Polyfill } from "@adaas/a-utils/a-polyfill";
+import { A_ServerRoute } from "@adaas/a-server/route/A-ServerRoute.entity";
+
+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_Polyfill) polyfill: A_Polyfill
+    ) {
+        // Initialize polyfills
+        this._fsPolyfill = await polyfill.fs();
+        this._pathPolyfill = await polyfill.path();
+
+        // Log configured aliases
+        const aliases = config.getEnabledAliases();
+        logger.info('cyan',
+
+            `Static aliases configured:`,
+            ...aliases.map(alias => `${alias.alias} -> ${alias.directory}`)
+        );
+    }
+
+
+    // =======================================================
+    // ================ Method Definition=====================
+    // =======================================================
+
+    @A_Feature.Extend({
+        before: /.*/
+    })
+    async [A_HttpServerFeatures.onRequest](
+        @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_Polyfill) polyfill: A_Polyfill
+    ) {
+
+        if (req.method !== 'GET' && req.method !== 'HEAD') {
+            return; // Only handle GET and HEAD requests
+        }
+
+        const { method, url } = req;
+        const route = new A_ServerRoute(url, method);
+
+        // 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
+        }
+
+        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);
+
+            logger.log('green', `Successfully served: ${safePath}`);
+
+        } catch (error: any) {
+            throw new A_HttpServerError({
+                status: 500,
+                title: 'Static File Serving Error',
+                description: `Error serving static file for ${route.path}: ${error.message}`,
+                originalError: error
+            });
+        }
+    }
+
+    /**
+     * 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}`);
+        }
+    }
+
+    /**
+     * 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",
+            ".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",
+            ".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 = '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 = pathPolyfill.join(staticDir, pathname);
+
+        if (!fsPolyfill.existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+
+        return filePath;
+    }
+
+    protected serveFile(
+        filePath: string,
+        res: A_Response,
+        logger: A_Logger,
+        fsPolyfill: any,
+        pathPolyfill: any
+    ): Promise<void> {
+        return new Promise<void>((resolve, reject) => {
+            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', () => {
+                            resolve();
+                        });
+
+                        stream.on("error", (err: any) => {
+                            reject(new A_HttpServerError({
+                                status: 500,
+                                title: 'File Stream Error',
+                                description: `Error reading file stream for ${filePath}: ${err.message}`,
+                                originalError: err
+                            }));
+                        });
+                    } else {
+                        reject(new A_HttpServerError({
+                            status: 500,
+                            title: 'Response Stream Error',
+                            description: `Unable to pipe file stream for ${filePath}`,
+                        }));
+                    }
+                } else {
+                    reject(new A_HttpServerError({
+                        status: 404,
+                        title: 'File Not Found',
+                        description: `File not found: ${filePath}`,
+                    }));
+                }
+            } catch (error: any) {
+                logger.error(`Error serving file: ${error.message}`);
+                reject(new A_HttpServerError({
+                    status: 500,
+                    title: 'Internal Server Error',
+                    description: `Error serving file: ${error.message}`,
+                    originalError: error
+                }));
+            }
+        });
+    }
+
+    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/lib/A-ServerStatic/A-ServerStatic.context.ts

@@ -0,0 +1,229 @@
+import { A_Fragment } from "@adaas/a-concept";
+
+export interface A_StaticAlias {
+    alias: string;
+    path: string;
+    directory: string;
+    enabled?: boolean;
+}
+
+export interface A_StaticDirectoryConfig {
+    path: string;
+    directory: string;
+    alias?: string;
+}
+
+export class A_StaticConfig extends A_Fragment {
+
+    readonly directories: Array<string>;
+    private _aliases: Map<string, A_StaticAlias> = new Map();
+    private _directoryConfigs: A_StaticDirectoryConfig[] = [];
+
+    constructor(
+        /**
+         * Setup directories to serve static files from, comma separated
+         */
+        directories: string[] = [],
+        /**
+         * Custom directory configurations with aliases
+         */
+        directoryConfigs: A_StaticDirectoryConfig[] = []
+    ) {
+        super();
+
+        this.directories = directories;
+        this._directoryConfigs = directoryConfigs;
+
+        // Initialize default aliases from directories
+        this.initializeDefaultAliases();
+
+        // Initialize custom aliases from directoryConfigs
+        this.initializeCustomAliases();
+    }
+
+    private initializeDefaultAliases(): void {
+        this.directories.forEach((dir, index) => {
+            const alias: A_StaticAlias = {
+                alias: `/static${index > 0 ? index : ''}`,
+                path: `/static${index > 0 ? index : ''}`,
+                directory: dir,
+                enabled: true
+            };
+            this._aliases.set(alias.path, alias);
+        });
+    }
+
+    private initializeCustomAliases(): void {
+        this._directoryConfigs.forEach((config) => {
+            const alias: A_StaticAlias = {
+                alias: config.alias || config.path,
+                path: config.path,
+                directory: config.directory,
+                enabled: true
+            };
+            this._aliases.set(alias.path, alias);
+        });
+    }
+
+    /**
+     * Add a custom static file alias
+     * @param alias - The URL path alias (e.g., '/assets')
+     * @param directory - The local directory path
+     * @param path - Optional custom path (defaults to alias)
+     */
+    public addAlias(alias: string, directory: string, path?: string): void {
+        const staticAlias: A_StaticAlias = {
+            alias,
+            path: path || alias,
+            directory,
+            enabled: true
+        };
+
+        this._aliases.set(staticAlias.path, staticAlias);
+    }
+
+    /**
+     * Remove a static file alias
+     * @param aliasPath - The path of the alias to remove
+     */
+    public removeAlias(aliasPath: string): boolean {
+        return this._aliases.delete(aliasPath);
+    }
+
+    /**
+     * Enable or disable an alias
+     * @param aliasPath - The path of the alias
+     * @param enabled - Whether to enable or disable
+     */
+    public setAliasEnabled(aliasPath: string, enabled: boolean): boolean {
+        const alias = this._aliases.get(aliasPath);
+        if (alias) {
+            alias.enabled = enabled;
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Get all configured aliases
+     */
+    public getAliases(): A_StaticAlias[] {
+        return Array.from(this._aliases.values());
+    }
+
+    /**
+     * Get enabled aliases only
+     */
+    public getEnabledAliases(): A_StaticAlias[] {
+        return Array.from(this._aliases.values()).filter(alias => alias.enabled !== false);
+    }
+
+    /**
+     * Find the best matching alias for a given request path
+     * @param requestPath - The request path to match
+     */
+    public findMatchingAlias(requestPath: string): A_StaticAlias | null {
+        let bestMatch: A_StaticAlias | null = null;
+        let longestMatch = 0;
+
+        for (const alias of this.getEnabledAliases()) {
+            if (requestPath.startsWith(alias.path) && alias.path.length > longestMatch) {
+                bestMatch = alias;
+                longestMatch = alias.path.length;
+            }
+        }
+
+        return bestMatch;
+    }
+
+    /**
+     * Check if an alias exists
+     * @param aliasPath - The path to check
+     */
+    public hasAlias(aliasPath: string): boolean {
+        return this._aliases.has(aliasPath);
+    }
+
+    /**
+     * Get a specific alias by path
+     * @param aliasPath - The path of the alias
+     */
+    public getAlias(aliasPath: string): A_StaticAlias | undefined {
+        return this._aliases.get(aliasPath);
+    }
+
+    /**
+     * Add multiple aliases at once
+     * @param aliases - Array of alias configurations
+     */
+    public addAliases(aliases: A_StaticDirectoryConfig[]): void {
+        aliases.forEach(config => {
+            this.addAlias(config.alias || config.path, config.directory, config.path);
+        });
+    }
+
+    /**
+     * Clear all aliases
+     */
+    public clearAliases(): void {
+        this._aliases.clear();
+    }
+
+    /**
+     * Update an existing alias
+     * @param aliasPath - The path of the alias to update
+     * @param updates - Partial updates to apply
+     */
+    public updateAlias(aliasPath: string, updates: Partial<A_StaticAlias>): boolean {
+        const alias = this._aliases.get(aliasPath);
+        if (alias) {
+            Object.assign(alias, updates);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Get statistics about configured aliases
+     */
+    public getStats(): {
+        total: number;
+        enabled: number;
+        disabled: number;
+        directories: string[];
+    } {
+        const aliases = this.getAliases();
+        const enabled = aliases.filter(a => a.enabled !== false);
+        const disabled = aliases.filter(a => a.enabled === false);
+        const directories = [...new Set(aliases.map(a => a.directory))];
+
+        return {
+            total: aliases.length,
+            enabled: enabled.length,
+            disabled: disabled.length,
+            directories
+        };
+    }
+
+    /**
+     * Checks if a given path is configured in the proxy (legacy method)
+     * @deprecated Use findMatchingAlias instead
+     * @param path 
+     * @returns 
+     */
+    has(path: string): boolean {
+        const alias = this.findMatchingAlias(path);
+        return alias ? !!alias.directory : false;
+    }
+
+    /**
+     * Gets the directory for a given path if configured (legacy method)
+     * 
+     * @param path 
+     * @returns 
+     */
+    get(path: string): string | undefined {
+        const alias = this.findMatchingAlias(path);
+        return alias ? alias.directory : undefined;
+    }
+}