@adaas/a-server 0.0.20 → 0.0.22

package/src/context/A-StaticConfig/A-StaticConfig.context.ts

@@ -1,36 +1,219 @@
 import { A_Fragment } from "@adaas/a-concept";
 import { A_Route } from "@adaas/a-server/entities/A-Route/A-Route.entity";
 
+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>
+    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[] = []
+        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;
+    }
 
     /**
-     * Checks if a given path is configured in the proxy
-     * 
+     * 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): false | string {
-
-        const found = this.directories.find(dir => {
-            return new RegExp(`^\/${dir.startsWith('/') ? dir.slice(1) : dir}/?.*`).test(path)
-        });
-        return !!found && found;
+        const alias = this.findMatchingAlias(path);
+        return alias ? alias.directory : false;
     }
 }

package/src/entities/A-Request/A-Request.entity.ts

@@ -1,4 +1,4 @@
-import { IncomingHttpHeaders, IncomingMessage } from "http";
+import type { IncomingHttpHeaders, IncomingMessage } from "http";
 import { A_Context, A_Entity, A_IdentityHelper, ASEID, } from '@adaas/a-concept';
 import {
     A_SERVER_TYPES__RequestConstructor,

package/src/entities/A-Request/A-Request.entity.types.ts

@@ -1,4 +1,4 @@
-import { IncomingMessage } from "http";
+import type { IncomingMessage } from "http";
 import { A_Request } from "./A-Request.entity";
 import { A_TYPES__Entity_Serialized } from "@adaas/a-concept";
 

package/src/entities/A-Response/A-Response.entity.ts

@@ -5,7 +5,7 @@ import {
     A_Scope,
     ASEID,
 } from "@adaas/a-concept";
-import {
+import type {
     IncomingHttpHeaders,
     ServerResponse
 } from "http";

package/src/entities/A-Response/A-Response.entity.types.ts

@@ -1,5 +1,5 @@
 import { A_TYPES__Entity_Serialized } from "@adaas/a-concept";
-import { ServerResponse } from "http";
+import type { ServerResponse } from "http";
 
 
 export type A_SERVER_TYPES__ResponseConstructor = {

package/tsconfig.build.json

@@ -1,28 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2018",
-    "module": "esnext",
-    "jsx": "react-jsx",
-    "strict": true,
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "experimentalDecorators": true,
-    "skipLibCheck": true,
-    "baseUrl": ".",
-    "paths": {
-      "@adaas/a-server/constants/*": ["src/constants/*"],
-      "@adaas/a-server/defaults/*": ["src/defaults/*"],
-      "@adaas/a-server/decorators/*": ["src/decorators/*"],
-      "@adaas/a-server/helpers/*": ["src/helpers/*"],
-      "@adaas/a-server/examples/*": ["src/examples/*"],
-      "@adaas/a-server/entities/*": ["src/entities/*"],
-      "@adaas/a-server/channels/*": ["src/channels/*"],
-      "@adaas/a-server/context/*": ["src/context/*"],
-      "@adaas/a-server/components/*": ["src/components/*"],
-      "@adaas/a-server/containers/*": ["src/containers/*"]
-    }
-  },
-  "include": ["src/**/*", "index.ts"],
-  "exclude": ["node_modules", "dist"]
-}