@adaas/a-server 0.0.22 → 0.0.23

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

@@ -1,163 +0,0 @@
-import { A_Entity, A_Fragment, ASEID } from "@adaas/a-concept"
-import { A_SERVER_TYPES__AEntityFactoryConstructor1, A_SERVER_TYPES__AEntityFactoryConstructor2 } from "./A-EntityFactory.context.types";
-
-
-export class A_EntityFactory extends A_Fragment {
-
-
-    private _entities: Map<string, { new(...args: any[]): any }> = new Map();
-
-
-    constructor(
-        map: A_SERVER_TYPES__AEntityFactoryConstructor1
-    )
-    constructor(
-        entities: A_SERVER_TYPES__AEntityFactoryConstructor2
-    )
-    constructor(
-        map: A_SERVER_TYPES__AEntityFactoryConstructor1,
-        entities: A_SERVER_TYPES__AEntityFactoryConstructor2
-    )
-    constructor(
-        param1: A_SERVER_TYPES__AEntityFactoryConstructor1 | A_SERVER_TYPES__AEntityFactoryConstructor2,
-        param2?: A_SERVER_TYPES__AEntityFactoryConstructor2
-    ) {
-        super();
-
-        this._setEntities(param1);
-        this._setEntities(param2);
-    }
-
-
-    protected _setEntities(
-        entities: A_SERVER_TYPES__AEntityFactoryConstructor2 | A_SERVER_TYPES__AEntityFactoryConstructor1 = []
-    ) {
-        if (Array.isArray(entities)) {
-            entities.forEach((entity) => {
-                this._entities.set(entity.entity, entity);
-            });
-        } else {
-            Object.keys(entities).forEach((key) => {
-                this._entities.set(key, entities[key]);
-            });
-        }
-    }
-
-
-    add(
-       key: string,
-       entity: typeof A_Entity
-    ): void
-    add(
-        entity: typeof A_Entity
-    ): void
-    add(
-        param1: string | typeof A_Entity,
-        param2?: typeof A_Entity
-    ): void {
-        switch (true) {
-            case typeof param1 === 'string' && !!param2:
-                this._entities.set(param1, param2);
-
-                break;
-
-            case typeof param1 !== 'string':
-                this._entities.set(param1.entity, param1);
-
-                break;
-        }
-    }
-   
-
-
-    has(
-        aseid: ASEID
-    ): boolean
-    has(
-        /**
-         * The name of the entity
-         */
-        entity: string
-    ): boolean
-    has(
-        /**
-         * The ASEID of the entity
-         */
-        aseid: string
-    ): boolean
-    has(
-        param1: string | ASEID
-    ): boolean {
-        let name: string;
-
-        switch (true) {
-            case param1 instanceof ASEID:
-                name = param1.entity;
-
-                break;
-
-            case !(param1 instanceof ASEID) && ASEID.isASEID(param1):
-                name = new ASEID(param1).entity;
-
-                break;
-
-            default:
-                name = param1;
-
-                break;
-        }
-
-        return this._entities.has(name);
-    }
-
-
-    /**
-     * Resolves the entity constructor by the entity name
-     * 
-     * @param entity 
-     */
-    resolve(
-        entity: string
-    ): { new(...args: any[]): A_Entity } | undefined
-    resolve(
-        aseid: string
-    ): { new(...args: any[]): A_Entity } | undefined
-    resolve(
-        aseid: ASEID
-    ): { new(...args: any[]): A_Entity } | undefined
-    resolve(
-        param1: string | ASEID
-    ): { new(...args: any[]): A_Entity } | undefined {
-
-        let name: string;
-
-        switch (true) {
-            case param1 instanceof ASEID:
-                name = param1.entity;
-
-                break;
-
-            case typeof param1 === 'string' && ASEID.isASEID(param1):
-
-                name = new ASEID(param1).entity;
-
-                break;
-
-            default:
-                name = param1;
-
-                break;
-        }
-
-        return this._entities.get(name);
-    }
-
-
-
-    resolveByName(
-        name: string
-    ): { new(...args: any[]): A_Entity } | undefined {
-        return this._entities.get(name);
-    }
-
-}

package/src/context/A-EntityFactory/A-EntityFactory.context.types.ts

@@ -1,11 +0,0 @@
-import { A_Entity } from "@adaas/a-concept"
-
-
-
-export type A_SERVER_TYPES__AEntityFactoryConstructor1 = {
-    [Key in string]: typeof A_Entity
-}
-
-export type A_SERVER_TYPES__AEntityFactoryConstructor2 = Array<
-typeof A_Entity
->

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

@@ -1,36 +0,0 @@
-import { A_Fragment } from "@adaas/a-concept";
-import { A_SERVER_TYPES__ServerMethod } from "@adaas/a-server/containers/A-Service/A-Service.container.types";
-import { A_SERVER_TYPES__HttpChannelRequestParams } from "@adaas/a-server/channels/A-Http/A-Http.channel.types";
-
-
-
-
-
-export class A_HTTPChannel_RequestContext<
-    T extends any = any
-> extends A_Fragment {
-    url: string;
-    method: A_SERVER_TYPES__ServerMethod;
-    data?: any;
-    config?: Partial<A_SERVER_TYPES__HttpChannelRequestParams['config']>;
-
-    constructor(params: A_SERVER_TYPES__HttpChannelRequestParams) {
-        super();
-
-        const {
-            method,
-            url,
-            data,
-            config,
-        } = params;
-
-        this.url = url;
-        this.method = method;
-        this.data = data;
-        this.config = config;
-    }
-
-    result?: T;
-    error?: any;
-
-}

package/src/context/A-Server/A_Server.context.types.ts

@@ -1,9 +0,0 @@
-import { A_Route } from "@adaas/a-server/entities/A-Route/A-Route.entity"
-
-
-export type A_SERVER_TYPES__ServerConstructor = {
-    name: string,
-    version: string,
-    routes: A_Route[],
-    port: number,
-}

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

@@ -1,163 +0,0 @@
-import type { IncomingHttpHeaders, IncomingMessage } from "http";
-import { A_Context, A_Entity, A_IdentityHelper, ASEID, } from '@adaas/a-concept';
-import {
-    A_SERVER_TYPES__RequestConstructor,
-    A_SERVER_TYPES__RequestEvent,
-    A_SERVER_TYPES__RequestMethods,
-    A_SERVER_TYPES__RequestSerialized
-} from "./A-Request.entity.types";
-import { A_Route } from '../A-Route/A-Route.entity';
-import { A_ServerError } from "@adaas/a-server/components/A-ServerError/A-ServerError.class";
-
-
-export class A_Request<
-    _ReqBodyType = any,
-    _ResponseType = any,
-    _ParamsType extends Record<string, string> = any,
-    _QueryType = any,
->
-    extends A_Entity<
-        A_SERVER_TYPES__RequestConstructor,
-        A_SERVER_TYPES__RequestSerialized
-    > {
-
-    static get namespace(): string {
-        return 'a-server';
-    }
-
-    req!: IncomingMessage;
-
-    body: _ReqBodyType = {} as _ReqBodyType;
-    params: _ParamsType = {} as _ParamsType;
-    query: _QueryType = {} as _QueryType;
-    response?: _ResponseType;
-
-    error?: A_ServerError;
-
-    /**
-     * Duration of the request in milliseconds
-     */
-    duration: number = 0;
-
-    fromNew(newEntity: A_SERVER_TYPES__RequestConstructor): void {
-        this.req = newEntity.request;
-
-        this.aseid = new ASEID({
-            concept: A_Context.root.name,
-            scope: newEntity.scope,
-            entity: (this.constructor as typeof A_Request).entity,
-            id: newEntity.id
-        });
-    }
-
-    get startedAt(): Date | undefined {
-        const timeId = A_IdentityHelper.parseTimeId(this.aseid.id.split('-')[0]);
-
-        return timeId ? new Date(timeId.timestamp) : undefined;
-    }
-
-
-
-    // Getter for request URL
-    public get url(): string {
-        return this.req.url!;
-    }
-
-    // Getter for request method
-    public get method(): A_SERVER_TYPES__RequestMethods {
-        return (String(this.req.method).toUpperCase() as A_SERVER_TYPES__RequestMethods) || 'DEFAULT';
-    }
-
-    get headers(): IncomingHttpHeaders {
-        return this.req.headers;
-    }
-
-
-    get route(): A_Route {
-        return new A_Route(this.url, this.method);
-    }
-
-
-    pipe(
-        destination: NodeJS.WritableStream,
-        options?: { end?: boolean | undefined; }
-    ): NodeJS.WritableStream {
-        return this.req.pipe(destination, options);
-    }
-
-
-
-    async init(): Promise<void> {
-        this.req.on('error', async (err) => {
-            this.error = new A_ServerError(err);
-            await this.call(A_SERVER_TYPES__RequestEvent.Error);
-        });
-
-        this.params = this.extractParams(this.url) as _ParamsType;
-        this.query = this.extractQuery(this.url) as _QueryType;
-    }
-
-
-    extractParams(url: string): Record<string, string> {
-        // Remove query string (anything after ?)
-        const cleanUrl = url.split('?')[0];
-
-        const urlSegments = cleanUrl.split('/').filter(Boolean);
-        const maskSegments = this.url.split('/').filter(Boolean);
-
-        const params: Record<string, string> = {};
-
-        for (let i = 0; i < maskSegments.length; i++) {
-            const maskSegment = maskSegments[i];
-            const urlSegment = urlSegments[i];
-
-            if (maskSegment.startsWith(':')) {
-                const paramName = maskSegment.slice(1); // Remove ':' from mask
-                params[paramName] = urlSegment;
-            } else if (maskSegment !== urlSegment) {
-                // If static segments don’t match → fail
-                return {};
-            }
-        }
-
-        return params;
-    }
-
-    extractQuery(url: string): Record<string, string> {
-        const query: Record<string, string> = {};
-
-        // Take only the part after "?"
-        const queryString = url.split('?')[1];
-        if (!queryString) return query;
-
-        // Remove fragment (#...) if present
-        const cleanQuery = queryString.split('#')[0];
-
-        // Split into key=value pairs
-        for (const pair of cleanQuery.split('&')) {
-            if (!pair) continue;
-            const [key, value = ''] = pair.split('=');
-            query[decodeURIComponent(key)] = decodeURIComponent(value);
-        }
-
-        return query;
-    }
-
-
-
-    parseBody(): Promise<any> {
-        return new Promise((resolve, reject) => {
-            let body = '';
-            this.req.on('data', chunk => body += chunk);
-            this.req.on('end', () => {
-                try {
-                    resolve(JSON.parse(body));
-                } catch (err) {
-                    reject(err);
-                }
-            });
-            this.req.on('error', reject);
-        });
-    }
-
-} 

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

@@ -1,41 +0,0 @@
-import type { IncomingMessage } from "http";
-import { A_Request } from "./A-Request.entity";
-import { A_TYPES__Entity_Serialized } from "@adaas/a-concept";
-
-
-export type A_SERVER_TYPES__RequestConstructor = {
-    /**
-     * Should correspond to Response id
-     */
-    id: string,
-    request: IncomingMessage,
-    scope: string,
-};
-
-export type A_SERVER_TYPES__RequestSerialized = {
-} & A_TYPES__Entity_Serialized;
-
-
-
-export type A_SERVER_TYPES__RequestMethods = 'GET'
-    | 'POST'
-    | 'PUT'
-    | 'DELETE'
-    | 'PATCH'
-    | 'OPTIONS'
-    | 'HEAD'
-    | 'CONNECT'
-    | 'TRACE'
-    | 'DEFAULT'; // Default is used for routes that do not have a method specified
-
-
-export enum A_SERVER_TYPES__RequestEvent {
-    Error = 'error',
-    Finish = 'finish',
-    Data = 'data',
-    End = 'end',
-    Close = 'close',
-}
-
-
-export type A_SERVER_TYPES__RequestEventCallback = (request: A_Request) => void;

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

@@ -1,194 +0,0 @@
-import {
-    A_Context,
-    A_Entity,
-    A_Error,
-    A_Scope,
-    ASEID,
-} from "@adaas/a-concept";
-import type {
-    IncomingHttpHeaders,
-    ServerResponse
-} from "http";
-import {
-    A_SERVER_TYPES__ResponseConstructor,
-    A_SERVER_TYPES__ResponseEvent,
-    A_SERVER_TYPES__ResponseSerialized,
-    A_SERVER_TYPES__SendResponseObject
-} from "./A-Response.entity.types";
-import { A_ServerError } from "@adaas/a-server/components/A-ServerError/A-ServerError.class";
-import { A_Logger } from "@adaas/a-utils";
-
-
-
-
-export class A_Response<
-    _ResponseType = any
-> extends A_Entity<
-    A_SERVER_TYPES__ResponseConstructor,
-    A_SERVER_TYPES__ResponseSerialized
-> {
-
-
-
-    /**
-     * Duration of the request in milliseconds
-     */
-    duration: number = 0;
-
-    private res!: ServerResponse;
-    private data: Map<string, _ResponseType> = new Map();
-    error?: A_ServerError;
-
-
-    fromNew(newEntity: A_SERVER_TYPES__ResponseConstructor): void {
-        this.res = newEntity.response;
-
-        this.aseid = new ASEID({
-            concept: A_Context.root.name,
-            scope: newEntity.scope,
-            entity: (this.constructor as typeof A_Response).entity,
-            id: newEntity.id
-        });
-    }
-
-    get headersSent(): boolean {
-        return this.res.headersSent;
-    }
-
-    get original() {
-        return this.res;
-    }
-
-    get statusCode(): number {
-        return this.res.statusCode;
-    }
-
-    async init(): Promise<void> {
-        const startTime = process.hrtime();
-
-        this.res.on('finish', async () => {
-            const elapsedTime = process.hrtime(startTime);
-            const elapsedMilliseconds = elapsedTime[0] * 1000 + elapsedTime[1] / 1e6;
-
-            this.duration = elapsedMilliseconds;
-            await this.call(A_SERVER_TYPES__ResponseEvent.Finish);
-        });
-
-        this.res.on('close', async () => {
-            await this.call(A_SERVER_TYPES__ResponseEvent.Close)
-        });
-
-    }
-
-
-
-    public failed(error: A_ServerError | A_Error | Error | any): void {
-        switch (true) {
-            case error instanceof A_ServerError:
-                this.error = error;
-
-                break;
-
-            case error instanceof A_Error:
-                this.error = new A_ServerError(error);
-
-                break;
-
-            default:
-                this.error = new A_ServerError(error)
-
-                break;
-        }
-
-        return this.status(this.error.status).json(this.error);
-    }
-
-    // Send a plain text or JSON response
-    public send(
-        data: string | object = this.toResponse()
-    ): void {
-        const logger = A_Context.scope(this).resolve(A_Logger);
-        if (this.headersSent) {
-            logger.warning('Response headers already sent, cannot send response again.');
-            return;
-        }
-
-        try {
-            switch (true) {
-                case !!data && typeof data === 'object':
-                    return this.json(data);
-
-                case !!data && typeof data === 'string':
-                    this.res.setHeader('Content-Type', 'text/plain');
-                    this.res.writeHead(this.statusCode);
-                    this.res.end(data);
-
-                    return;
-
-                default:
-                    this.res.writeHead(this.statusCode);
-                    this.res.end(data);
-
-                    return;
-            }
-        } catch (error) {
-            logger.warning('Response send error:', error);
-        }
-    }
-
-    destroy(error: Error | unknown, scope?: A_Scope): Promise<any> {
-        this.res.end();
-        return super.destroy(scope);
-    }
-
-    // Explicit JSON response
-    public json(
-        data: object = this.toResponse()
-    ): void {
-        const logger = A_Context.scope(this).resolve(A_Logger);
-
-        if (this.headersSent) {
-            logger.warning('Response headers already sent, cannot send response again.');
-            return;
-        }
-        this.res.setHeader('Content-Type', 'application/json');
-        this.res.writeHead(this.statusCode);
-        this.res.end(JSON.stringify(data));
-    }
-
-    // Set HTTP status code
-    public status(code: number): this {
-        this.res.statusCode = code;
-        return this;
-    }
-
-    writeHead(statusCode: number, headers?: Record<string, string> | IncomingHttpHeaders | any) {
-        this.res.writeHead(statusCode, headers);
-    }
-
-
-    setHeader(key: string, value: string) {
-        this.res.setHeader(key, value);
-    }
-
-    getHeader(key: string): string | number | string[] | undefined {
-        return this.res.getHeader(key) as string | number | string[] | undefined;
-    }
-
-
-    add(key: string, data: _ResponseType) {
-        this.data.set(key, data);
-    }
-
-
-    toResponse(): A_SERVER_TYPES__SendResponseObject<_ResponseType> {
-        return Array.from(this.data.entries()).reduce((acc, [key, value]) => {
-            if (value instanceof A_Entity)
-                acc[key] = value.toJSON();
-            else
-
-                acc[key] = value;
-            return acc;
-        }, {});
-    }
-}

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

@@ -1,26 +0,0 @@
-import { A_TYPES__Entity_Serialized } from "@adaas/a-concept";
-import type { ServerResponse } from "http";
-
-
-export type A_SERVER_TYPES__ResponseConstructor = {
-    /**
-     * Should correspond to Request id
-     */
-    id: string,
-    scope: string,
-    response: ServerResponse,
-}
-
-export enum A_SERVER_TYPES__ResponseEvent {
-    Error = 'error',
-    Finish = 'finish',
-    Data = 'data',
-    End = 'end',
-    Close = 'close',
-}
-
-export type A_SERVER_TYPES__ResponseSerialized = A_TYPES__Entity_Serialized;
-
-
-export type A_SERVER_TYPES__SendResponseObject<_ResponseType = any> = 
-Record<string, _ResponseType> ;