@adaas/a-server 0.0.22 → 0.0.23

package/src/lib/A-Server/A-HttpServer.constants.ts

@@ -0,0 +1,9 @@
+
+
+
+export const A_HttpServerFeatures = {
+    onBeforeRequest: '_A_HTTPServer_onBeforeRequest',
+    onRequest: '_A_HTTPServer_onRequest',
+    onAfterRequest: '_A_HTTPServer_onAfterRequest',
+} as const
+

package/src/lib/A-Server/A-HttpServer.container.ts

@@ -0,0 +1,251 @@
+import type { IncomingMessage, Server, ServerResponse } from "http";
+import { A_HttpServerFeatures } from "./A-HttpServer.constants";
+import { A_Request } from "@adaas/a-server/request/A-Request.entity";
+import { A_Response } from "@adaas/a-server/response/A-Response.entity";
+import { A_TYPES__ServerENVVariables } from "@adaas/a-server/constants/env.constants";
+import { A_Dependency, A_Error, A_Feature, A_IdentityHelper, A_Inject, A_Scope } from "@adaas/a-concept";
+import { A_ServerRoute } from "@adaas/a-server/route/A-ServerRoute.entity";
+import { A_HttpServerRequestMethod } from "./A-HttpServer.types";
+import { A_HttpServerError } from "./A-HttpServer.error";
+import { A_RequestFeatures } from "@adaas/a-server/request/A-Request.constants";
+import { A_HttpServerRequestContext } from "@adaas/a-server/request/A-HttpServerRequest.context";
+import { A_ServerLogger } from "@adaas/a-server/logger/A-ServerLogger.component";
+import { A_Service, A_ServiceFeatures } from "@adaas/a-utils/a-service";
+import { A_Polyfill } from "@adaas/a-utils/a-polyfill";
+import { A_Config } from "@adaas/a-utils/a-config";
+
+
+
+
+/**
+ * A-Service is a container that can run different types of services, such as HTTP servers, workers, etc.
+ * Depending on the provided config and configuration, it will load the necessary components and start the service.
+ * 
+ */
+export class A_HttpServer extends A_Service {
+
+    protected server!: Server;
+
+
+    static get onBeforeRequest() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: A_HttpServerFeatures.onBeforeRequest,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+    static get onRequest() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: A_HttpServerFeatures.onRequest,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+    static get onAfterRequest() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: A_HttpServerFeatures.onAfterRequest,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+
+
+    @A_Feature.Extend()
+    protected async [A_ServiceFeatures.onStart](
+
+        @A_Dependency.Required()
+        @A_Inject(A_Polyfill) polyfill: A_Polyfill,
+
+        @A_Dependency.Required()
+        @A_Inject(A_Config) config: A_Config<A_TYPES__ServerENVVariables>,
+
+    ): Promise<void> {
+        const http = await polyfill.http();
+
+        // Create the HTTP server
+        this.server = http.createServer(this.handleRequest.bind(this));
+
+        // Start listening on the specified port
+        await this.listen(config.get('A_SERVER_PORT'));
+    }
+
+    @A_Feature.Extend()
+    protected async [A_ServiceFeatures.onAfterStart](
+        @A_Inject(A_Config) config: A_Config<A_TYPES__ServerENVVariables>,
+        @A_Inject(A_ServerLogger) logger: A_ServerLogger,
+    ): Promise<void> {
+        logger.serverReady({
+            port: config.get('A_SERVER_PORT'),
+            app: {
+                name: this.scope.name,
+            }
+        });
+    }
+
+    protected async [A_ServiceFeatures.onStop](...args: any[]): Promise<void> {
+        await this.close();
+    }
+
+    close() {
+        return new Promise<void>((resolve, reject) => {
+            this.server.close(() => {
+                resolve();
+            });
+        });
+    }
+
+    listen(port: number) {
+        return new Promise<void>((resolve, reject) => {
+            this.server.listen(port, () => {
+                resolve();
+            });
+        });
+    }
+
+
+    // ======================================================================================
+    // ============================= A_HttpServer Lifecycle =================================
+    // ======================================================================================
+
+    @A_Feature.Extend()
+    protected async [A_HttpServerFeatures.onBeforeRequest](...args: any[]) { }
+
+    @A_Feature.Extend()
+    protected async [A_HttpServerFeatures.onRequest](...args: any[]) { }
+
+    @A_Feature.Extend()
+    protected async [A_HttpServerFeatures.onAfterRequest](...args: any[]) { }
+
+
+    // ======================================================================================
+    // ============================= A_HttpServer Methods =================================
+    // ======================================================================================
+
+    async handleRequest(
+        request: IncomingMessage,
+        response: ServerResponse
+    ) {
+        const route = new A_ServerRoute(
+            request.url || '',
+            request.method as A_HttpServerRequestMethod
+        );
+
+        const id = A_IdentityHelper.generateTimeId();
+        const shard = `${request.method}-${route.path.replace('/', '-')}`;
+
+        const req = new A_Request({ id, shard, request, scope: this.scope.name });
+        const res = new A_Response({ id, shard, response, scope: this.scope.name });
+        const context = new A_HttpServerRequestContext(request, response);
+
+        const scope = new A_Scope({
+            name: id,
+            entities: [req, res],
+            fragments: [route, context]
+        }).inherit(this.scope);
+
+        try {
+            const onBeforeRequestFeature = new A_Feature({
+                name: A_HttpServerFeatures.onBeforeRequest,
+                component: this
+            });
+
+            const onRequestFeature = new A_Feature({
+                name: A_HttpServerFeatures.onRequest,
+                component: this
+            });
+
+            const onAfterRequestFeature = new A_Feature({
+                name: A_HttpServerFeatures.onAfterRequest,
+                component: this
+            });
+
+            await new Promise<void>(async (resolve, reject) => {
+
+                const cleanup = () => {
+                    onBeforeRequestFeature.interrupt();
+                    onRequestFeature.interrupt();
+                    onAfterRequestFeature.interrupt();
+
+                    req.off(A_RequestFeatures.onError, cleanup);
+                    req.off(A_RequestFeatures.onClose, cleanup);
+                    req.off(A_RequestFeatures.onTimeout, cleanup);
+
+
+                    reject(scope.resolve(A_Error)!);
+                }
+
+
+                req.on(A_RequestFeatures.onError, cleanup.bind(this));
+                req.on(A_RequestFeatures.onClose, cleanup.bind(this));
+
+                try {
+                    await req.load();
+                    await res.load();
+
+
+                    await onBeforeRequestFeature.process(scope);
+
+                    await onRequestFeature.process(scope);
+
+                    await onAfterRequestFeature.process(scope);
+
+
+                    req.clearTimeout();
+                    await res.status(200).send();
+
+                    resolve();
+                } catch (error) {
+
+                    req.clearTimeout();
+                    reject(error);
+                }
+            });
+
+        } catch (error) {
+
+            let wrappedError;
+
+            switch (true) {
+                case error instanceof A_HttpServerError:
+                    wrappedError = error;
+                    break;
+
+                case error instanceof A_Error && error.originalError instanceof A_HttpServerError:
+                    wrappedError = error.originalError;
+                    break;
+
+                default:
+                    wrappedError = new A_HttpServerError({
+                        status: 500,
+                        description: 'An error occurred while processing the request.',
+                        originalError: error
+                    })
+                    break;
+            }
+
+
+            scope.register(wrappedError);
+
+            await res.fail(wrappedError);
+
+            await this.call(A_ServiceFeatures.onError, scope);
+        }
+
+        scope.destroy();
+    }
+
+}
+
+
+
+
+
+
+
+

package/src/lib/A-Server/A-HttpServer.error.ts

@@ -0,0 +1,165 @@
+import { A_Error } from '@adaas/a-concept';
+import { A_HttpServerError_Init, A_HttpServerError_Serialized } from './A-HttpServer.types';
+
+
+export class A_HttpServerError extends A_Error<A_HttpServerError_Init, A_HttpServerError_Serialized> {
+
+    static readonly NotFoundErrorStatus: number = 404;
+    static readonly NotFoundError = 'Resource Not Found';
+
+    static readonly InternalServerErrorStatus: number = 500;
+    static readonly InternalServerError = 'Internal Server Error';
+
+    /**
+     * HTTP status code to title mapping
+     */
+    private static readonly HTTP_STATUS_TITLES: Record<number, string> = {
+        // 4xx Client Errors
+        400: 'Bad Request',
+        401: 'Unauthorized',
+        402: 'Payment Required',
+        403: 'Forbidden',
+        404: 'Not Found',
+        405: 'Method Not Allowed',
+        406: 'Not Acceptable',
+        407: 'Proxy Authentication Required',
+        408: 'Request Timeout',
+        409: 'Conflict',
+        410: 'Gone',
+        411: 'Length Required',
+        412: 'Precondition Failed',
+        413: 'Payload Too Large',
+        414: 'URI Too Long',
+        415: 'Unsupported Media Type',
+        416: 'Range Not Satisfiable',
+        417: 'Expectation Failed',
+        418: 'I\'m a teapot',
+        421: 'Misdirected Request',
+        422: 'Unprocessable Entity',
+        423: 'Locked',
+        424: 'Failed Dependency',
+        425: 'Too Early',
+        426: 'Upgrade Required',
+        428: 'Precondition Required',
+        429: 'Too Many Requests',
+        431: 'Request Header Fields Too Large',
+        451: 'Unavailable For Legal Reasons',
+
+        // 5xx Server Errors
+        500: 'Internal Server Error',
+        501: 'Not Implemented',
+        502: 'Bad Gateway',
+        503: 'Service Unavailable',
+        504: 'Gateway Timeout',
+        505: 'HTTP Version Not Supported',
+        506: 'Variant Also Negotiates',
+        507: 'Insufficient Storage',
+        508: 'Loop Detected',
+        510: 'Not Extended',
+        511: 'Network Authentication Required'
+    };
+
+    status!: number;
+
+    /**
+     * Gets the appropriate title for a given HTTP status code
+     */
+    private static getHttpStatusTitle(status: number): string {
+        return this.HTTP_STATUS_TITLES[status] || 'Unknown Error';
+    }
+
+    constructor(
+        /**
+         * A_Error Constructor params with required title
+         */
+        params: A_HttpServerError_Init
+    )
+    constructor(
+        /**
+         * Simplified params with optional title - will auto-generate from status
+         */
+        params: { status?: number; description?: string; code?: string; scope?: string; link?: string; originalError?: Error | unknown }
+    )
+    constructor(
+        /**
+         * HTTP Status Code of the error
+         */
+        status: number,
+        /**
+         * Error description
+         */
+        description: string
+    )
+    constructor(
+        /**
+         * Original JS Error
+         */
+        error: Error
+    )
+    constructor(
+        param1: A_HttpServerError_Init | { status?: number; description?: string; code?: string; scope?: string; link?: string; originalError?: Error | unknown } | Error | number,
+        param2?: string
+    ) {
+        // Handle the different constructor overloads
+        switch (true) {
+            // Pattern: new A_HttpServerError(404, 'The requested resource was not found')
+            case typeof param1 === 'number' && typeof param2 === 'string':
+                super({
+                    title: A_HttpServerError.getHttpStatusTitle(param1),
+                    description: param2
+                });
+                this.status = param1;
+                break;
+
+            // Pattern: new A_HttpServerError(someErrorObject)
+            case param1 instanceof Error:
+                super(param1);
+                this.status = 500; // Default status for Error objects
+                break;
+
+            // Pattern: new A_HttpServerError({ status: 500, description: '...', originalError: ... })
+            case typeof param1 === 'object' && param1 !== null && !(param1 instanceof Error):
+                const params = param1 as any;
+                
+                // If title is provided, use the full A_Error init
+                if ('title' in params && params.title) {
+                    super(params as A_HttpServerError_Init);
+                    this.status = params.status || 500;
+                } else {
+                    // Auto-generate title from status
+                    const title = params.status ? A_HttpServerError.getHttpStatusTitle(params.status) : 'Internal Server Error';
+                    super({
+                        title: title,
+                        description: params.description,
+                        code: params.code,
+                        scope: params.scope,
+                        link: params.link,
+                        originalError: params.originalError
+                    });
+                    this.status = params.status || 500;
+                }
+                break;
+
+            default:
+                // Fallback for any other case
+                throw new Error('Invalid parameters provided to A_HttpServerError constructor');
+        }
+    }
+
+
+    protected fromConstructor(params: A_HttpServerError_Init): void {
+        super.fromConstructor(params);
+        if (params.status) {
+            this.status = params.status;
+        }
+    }
+
+
+    toJSON(): A_HttpServerError_Serialized {
+        return {
+            ...super.toJSON(),
+            status: this.status
+        }
+    }
+}
+

package/src/lib/A-Server/A-HttpServer.types.ts

@@ -0,0 +1,37 @@
+import { A_TYPES__Error_Init, A_TYPES__Error_Serialized } from "@adaas/a-concept"
+import { A_HttpServerFeatures } from "./A-HttpServer.constants";
+
+
+export type A_HttpServerRequestMethod = 'GET'
+    | 'POST'
+    | 'PUT'
+    | 'DELETE'
+    | 'PATCH'
+    | 'OPTIONS'
+    | 'HEAD'
+    | 'CONNECT'
+    | 'TRACE'
+    | 'DEFAULT'; // Default is used for routes that do not have a method specified
+
+export type A_HttpServerFeatureNames = typeof A_HttpServerFeatures[keyof typeof A_HttpServerFeatures]
+
+
+
+export type A_HttpServerError_Init = {
+    /**
+     * HTTP Status Code of the error
+     */
+    status?: number;
+} & A_TYPES__Error_Init
+
+
+
+
+export type A_HttpServerError_Serialized = {
+    /**
+     * HTTP Status Code of the error
+     */
+    status: number
+} & A_TYPES__Error_Serialized
+
+

package/src/{context/A-Server/A_Server.context.ts → lib/A-Server/A-Server.context.ts}

@@ -1,14 +1,13 @@
-import {  A_Fragment } from "@adaas/a-concept";
-import { A_SERVER_TYPES__ServerConstructor } from "./A_Server.context.types";
-import { A_Route } from "@adaas/a-server/entities/A-Route/A-Route.entity";
-import { A_TYPES__Required } from "@adaas/a-concept/dist/src/types/A_Common.types";
+import { A_Fragment, A_TYPES__Required } from "@adaas/a-concept";
+import { A_SERVER_TYPES__ServerConstructor } from "./A-Server.types";
+import { A_ServerRoute } from "@adaas/a-server/route/A-ServerRoute.entity";
 
 
 export class A_Server extends A_Fragment {
 
     public port: number;
     public version: string;
-    protected _routes: A_Route[] = [];
+    protected _routes: A_ServerRoute[] = [];
 
     constructor(
         params: A_TYPES__Required<Partial<A_SERVER_TYPES__ServerConstructor>, [
@@ -19,7 +18,7 @@ export class A_Server extends A_Fragment {
         super(params);
 
         this.port = params.port;
-        this.name = params.name;
+        this._name = params.name;
         this.version = params.version || 'v1';
 
         this._routes = params.routes || this._routes;
@@ -29,7 +28,7 @@ export class A_Server extends A_Fragment {
     /**
      * A list of routes that the server will listen to
      */
-    get routes(): A_Route[] {
+    get routes(): A_ServerRoute[] {
         return this._routes
     }
 

package/src/lib/A-Server/A-Server.error.ts

@@ -0,0 +1,26 @@
+import { A_Error } from '@adaas/a-concept';
+import { A_SERVER_TYPES__ServerError_Init, A_SERVER_TYPES__ServerError_Serialized } from './A-Server.types';
+
+
+export class A_ServerError extends A_Error<A_SERVER_TYPES__ServerError_Init, A_SERVER_TYPES__ServerError_Serialized> {
+
+    status: number = 500;
+
+
+    protected fromConstructor(params: A_SERVER_TYPES__ServerError_Init): void {
+        super.fromConstructor(params);
+        if (params.status) {
+            this.status = params.status;
+        }
+    }
+
+
+    toJSON(): A_SERVER_TYPES__ServerError_Serialized {
+        return {
+            ...super.toJSON(),
+            status: this.status
+        }
+    }
+}
+
+

package/src/{components/A-ServerError/A-ServerError.types.ts → lib/A-Server/A-Server.types.ts}

@@ -1,6 +1,14 @@
 import { A_TYPES__Error_Init, A_TYPES__Error_Serialized } from "@adaas/a-concept"
+import { A_ServerRoute } from "@adaas/a-server/route/A-ServerRoute.entity"
 
 
+export type A_SERVER_TYPES__ServerConstructor = {
+    name: string,
+    version: string,
+    routes: A_ServerRoute[],
+    port: number,
+}
+
 
 export type A_SERVER_TYPES__ServerError_Init = {
     /**

package/src/{components/A-Controller/A-Controller.component.ts → lib/A-ServerController/A-ServerController.component.ts}

@@ -1,14 +1,14 @@
 import { A_Component, A_Container, A_Context, A_Feature, A_Inject, A_Scope } from "@adaas/a-concept";
-import { A_Router } from "../A-Router/A-Router.component";
-import { A_Response } from "@adaas/a-server/entities/A-Response/A-Response.entity";
-import { A_Request } from "@adaas/a-server/entities/A-Request/A-Request.entity";
+import { A_ServerRouter } from "@adaas/a-server/router/A-ServerRouter.component";
+import { A_Response } from "@adaas/a-server/response/A-Response.entity";
+import { A_Request } from "@adaas/a-server/request/A-Request.entity";
 
 
 
-export class A_Controller extends A_Component {
+export class A_ServerController extends A_Component {
 
 
-    @A_Router.Post({
+    @A_ServerRouter.Post({
         path: '/:component/:operation',
         version: 'v1',
         prefix: 'a-component'

package/src/{entities/A_EntityList/A_EntityList.entity.ts → lib/A-ServerEntityList/A-EntityList.entity.ts}

@@ -6,7 +6,7 @@ import {
     A_SERVER_TYPES__A_EntityListConstructor,
     A_SERVER_TYPES__A_EntityListPagination,
     A_SERVER_TYPES__A_EntityListSerialized
-} from "./A_EntityList.entity.types";
+} from "./A-EntityList.types";
 
 
 
@@ -15,7 +15,7 @@ import {
  * 
  * Entity that represents a list of entities with pagination of particular type
  */
-export class A_EntityList<
+export class A_ServerEntityList<
     EntityType extends A_Entity = A_Entity,
 > extends A_Entity<
     A_SERVER_TYPES__A_EntityListConstructor,

package/src/{entities/A_EntityList/A_EntityList.entity.types.ts → lib/A-ServerEntityList/A-EntityList.types.ts}

@@ -1,10 +1,10 @@
-import { A_Entity, A_TYPES__Entity_Serialized } from "@adaas/a-concept";
+import { A_Entity, A_TYPES__Entity_Constructor, A_TYPES__Entity_Serialized } from "@adaas/a-concept";
 
 
 export type A_SERVER_TYPES__A_EntityListConstructor = {
     name: string,
     scope: string,
-    constructor: { new(...args: any[]): A_Entity },
+    constructor: A_TYPES__Entity_Constructor,
 }
 
 export enum A_SERVER_TYPES__A_EntityListEvent {

package/src/{context/A-ListQueryFilter/A_ListQueryFilter.context.ts → lib/A-ServerListQuery/A-ServerListQueryFilter.context.ts}

@@ -2,7 +2,7 @@ import { A_Fragment } from "@adaas/a-concept";
 
 
 
-export class A_ListQueryFilter<FilterFields extends string[]> extends A_Fragment {
+export class A_ServerListQueryFilter<FilterFields extends string[]> extends A_Fragment {
 
     protected parsedQuery!: Record<FilterFields[number], string>;