@adaas/a-server 0.0.21 → 0.0.23

package/src/{components → middlewares}/A-ServerCORS/A_ServerCORS.component.ts

@@ -1,18 +1,23 @@
-import { A_Component, A_Feature, A_Inject } from '@adaas/a-concept';
-import { A_SERVER_TYPES__CorsConfig } from './A_ServerCORS.component.types';
-import { A_SERVER_DEFAULTS__CorsConfig } from './A_ServerCORS.component.defaults';
-import { A_SERVER_TYPES__ServerFeature } from '@adaas/a-server/containers/A-Service/A-Service.container.types';
-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_Config } from '@adaas/a-utils';
+import { A_Feature, A_Inject } from '@adaas/a-concept';
+import { A_ServiceFeatures } from '@adaas/a-utils/a-service';
+import { A_Request } from '@adaas/a-server/request/A-Request.entity';
+import { A_Response } from '@adaas/a-server/response/A-Response.entity';
+import { A_HttpServerFeatures } from '@adaas/a-server/server/A-HttpServer.constants';
+import { A_Config } from '@adaas/a-utils/a-config';
+import { A_ServerMiddleware } from '@adaas/a-server/middleware/A-ServerMiddleware.component';
+import { A_SERVER_TYPES__CorsConfig } from './A_ServerCORS.types';
+import { A_SERVER_DEFAULTS__CorsConfig } from './A_ServerCORS.constants';
+import { A_HttpServer } from '@adaas/a-server/server/A-HttpServer.container';
 
 
-export class A_ServerCORS extends A_Component {
+
+
+export class A_ServerCORS extends A_ServerMiddleware {
 
     private config!: A_SERVER_TYPES__CorsConfig;
 
     @A_Feature.Extend({
-        name: A_SERVER_TYPES__ServerFeature.beforeStart
+        name: A_ServiceFeatures.onBeforeStart
     })
     async init(
         @A_Inject(A_Config) config: A_Config<['ORIGIN', 'METHODS', 'HEADERS', 'CREDENTIALS', 'MAX_AGE']>,
@@ -27,9 +32,7 @@ export class A_ServerCORS extends A_Component {
     }
 
 
-    @A_Feature.Extend({
-        name: A_SERVER_TYPES__ServerFeature.beforeRequest
-    })
+    @A_HttpServer.onAfterRequest
     public apply(
         @A_Inject(A_Request) aReq: A_Request,
         @A_Inject(A_Response) aRes: A_Response,
@@ -48,7 +51,7 @@ export class A_ServerCORS extends A_Component {
         }
 
         // Handle preflight OPTIONS requests
-        if (aReq.req.method === 'OPTIONS') {
+        if (aReq.method === 'OPTIONS') {
             aRes.status(204).send();
         }
     }

package/src/{components/A-ServerCORS/A_ServerCORS.component.defaults.ts → middlewares/A-ServerCORS/A_ServerCORS.constants.ts}

@@ -1,4 +1,4 @@
-import { A_SERVER_TYPES__CorsConfig } from "./A_ServerCORS.component.types";
+import { A_SERVER_TYPES__CorsConfig } from "./A_ServerCORS.types";
 
 
 
@@ -8,4 +8,4 @@ export const A_SERVER_DEFAULTS__CorsConfig: A_SERVER_TYPES__CorsConfig = {
     headers: ['Content-Type'],
     credentials: false,
     maxAge: 0
-};
+} as const;

package/src/{components → repositories}/A-EntityRepository/A-EntityRepository.component.ts

@@ -1,34 +1,52 @@
-import { A_Caller, A_Component, A_Entity, A_Feature, A_Inject, A_Scope, A_TYPES__Entity_Constructor } from "@adaas/a-concept";
-import { A_TYPES__EntityFeatures } from "@adaas/a-concept/dist/src/global/A-Entity/A-Entity.constants";
+import { A_Caller, A_Entity, A_Feature, A_Inject, A_Scope, A_TYPES__Entity_Constructor, A_TYPES__EntityFeatures } from "@adaas/a-concept";
 import { A_HTTPChannel } from "@adaas/a-server/channels/A-Http/A-Http.channel";
-import { A_EntityList } from "@adaas/a-server/entities/A_EntityList/A_EntityList.entity";
-import { A_Manifest } from "@adaas/a-utils";
+import { A_ServerEntityList } from "@adaas/a-server/entity-list/A-EntityList.entity";
+import { A_Command, A_CommandFeatures, A_TYPES__Command_Serialized } from "@adaas/a-utils/a-command";
+import { A_Manifest } from "@adaas/a-utils/a-manifest";
 
 
 
 
-export class A_EntityRepository extends A_Component {
+export class A_EntityRepository extends A_HTTPChannel {
+
+
+    @A_Feature.Extend({
+        name: A_CommandFeatures.onExecute,
+    })
+    async execute(
+        @A_Inject(A_Caller) command: A_Command,
+        @A_Inject(A_Scope) scope: A_Scope,
+    ) {
+        // Check if the scope has a manifest and if the entity is allowed to load
+        if (
+            scope.has(A_Manifest) && !scope.resolve(A_Manifest)!
+                .isAllowed(command.constructor, 'load')
+                .for(command.constructor as A_TYPES__Entity_Constructor)
+        )
+            return;
+
+        const response = await this.post<A_TYPES__Command_Serialized>(`/a-command/v1/${command.aseid.entity}`, command.toJSON());
+
+        command.fromJSON(response.data!);
+    }
 
     @A_Feature.Extend({
         name: A_TYPES__EntityFeatures.LOAD,
-        scope: {
-            include: [A_EntityList]
-        }
+        scope: [A_ServerEntityList]
     })
     async list(
-        @A_Inject(A_HTTPChannel) channel: A_HTTPChannel,
-        @A_Inject(A_Caller) entity: A_EntityList,
+        @A_Inject(A_Caller) entity: A_ServerEntityList,
         @A_Inject(A_Scope) scope: A_Scope,
     ) {
         // Check if the scope has a manifest and if the entity is allowed to load
         if (
-            scope.has(A_Manifest) && !scope.resolve(A_Manifest)
+            scope.has(A_Manifest) && !scope.resolve(A_Manifest)!
                 .isAllowed(entity.constructor, 'load')
                 .for(entity.constructor as A_TYPES__Entity_Constructor)
         )
             return;
 
-        const response = await channel.get(`/a-list/${entity.aseid.entity}`);
+        const response = await this.get(`/a-list/v1/${entity.aseid.entity}`);
 
         entity.fromJSON(response.data);
     }
@@ -36,24 +54,21 @@ export class A_EntityRepository extends A_Component {
 
     @A_Feature.Extend({
         name: A_TYPES__EntityFeatures.LOAD,
-        scope: {
-            exclude: [A_EntityList]
-        }
+        scope: [A_ServerEntityList]
     })
     async load(
-        @A_Inject(A_HTTPChannel) channel: A_HTTPChannel,
         @A_Inject(A_Caller) entity: A_Entity,
         @A_Inject(A_Scope) scope: A_Scope,
     ) {
         // Check if the scope has a manifest and if the entity is allowed to load
         if (
-            scope.has(A_Manifest) && !scope.resolve(A_Manifest)
+            scope.has(A_Manifest) && !scope.resolve(A_Manifest)!
                 .isAllowed(entity.constructor, 'load')
                 .for(entity.constructor as A_TYPES__Entity_Constructor)
         )
             return;
 
-        const response = await channel.get(`/a-entity/${entity.aseid.toString()}`);
+        const response = await this.get(`/a-entity/v1/${entity.aseid.toString()}`);
 
         entity.fromJSON(response.data);
     }
@@ -61,24 +76,21 @@ export class A_EntityRepository extends A_Component {
 
     @A_Feature.Extend({
         name: A_TYPES__EntityFeatures.SAVE,
-        scope: {
-            exclude: [A_EntityList]
-        }
+        scope: [A_ServerEntityList]
     })
     async save(
-        @A_Inject(A_HTTPChannel) channel: A_HTTPChannel,
         @A_Inject(A_Caller) entity: A_Entity,
         @A_Inject(A_Scope) scope: A_Scope,
     ) {
         // Check if the scope has a manifest and if the entity is allowed to save
         if (
-            scope.has(A_Manifest) && !scope.resolve(A_Manifest)
+            scope.has(A_Manifest) && !scope.resolve(A_Manifest)!
                 .isAllowed(entity.constructor, 'save')
                 .for(entity.constructor as A_TYPES__Entity_Constructor)
         )
             return;
 
-        const response = await channel.post(`/a-entity/${entity.aseid.toString()}`, entity.toJSON());
+        const response = await this.post(`/a-entity/v1/${entity.aseid.toString()}`, entity.toJSON());
 
         entity.fromJSON(response.data);
     }
@@ -86,24 +98,21 @@ export class A_EntityRepository extends A_Component {
 
     @A_Feature.Extend({
         name: A_TYPES__EntityFeatures.DESTROY,
-        scope: {
-            exclude: [A_EntityList]
-        }
+        scope: [A_ServerEntityList]
     })
     async destroy(
-        @A_Inject(A_HTTPChannel) channel: A_HTTPChannel,
         @A_Inject(A_Caller) entity: A_Entity,
         @A_Inject(A_Scope) scope: A_Scope,
     ) {
         // Check if the scope has a manifest and if the entity is allowed to destroy
         if (
-            scope.has(A_Manifest) && !scope.resolve(A_Manifest)
+            scope.has(A_Manifest) && !scope.resolve(A_Manifest)!
                 .isAllowed(entity.constructor, 'destroy')
                 .for(entity.constructor as A_TYPES__Entity_Constructor)
         )
             return;
 
-        const response = await channel.delete(`/a-entity/${entity.aseid.toString()}`);
+        const response = await this.delete(`/a-entity/v1/${entity.aseid.toString()}`);
 
         entity.fromJSON(response.data);
     }

package/tests/A-HttpChannel.test.ts

@@ -1,7 +1,7 @@
-import { A_Context, A_Feature, A_Inject, A_Scope } from '@adaas/a-concept';
+import { A_Feature, A_Inject, A_Scope } from '@adaas/a-concept';
+import { A_ChannelRequest } from '@adaas/a-utils/a-channel';
 import { A_HTTPChannel } from '@adaas/a-server/channels/A-Http/A-Http.channel';
 import { A_SERVER_CONSTANTS__A_HttpChannel_Lifecycle } from '@adaas/a-server/channels/A-Http/A-Http.channel.constants';
-import { A_HTTPChannel_RequestContext } from '@adaas/a-server/context/A-HttpChannel/A-HttpChannel.context';
 
 jest.retryTimes(0);
 
@@ -14,12 +14,12 @@ describe('A-HttpChannel Tests', () => {
             components: [A_HTTPChannel]
         });
 
-
-        const channel = scope.resolve(A_HTTPChannel);
+        const channel = scope.resolve(A_HTTPChannel)!;
 
         expect(channel).toBeInstanceOf(A_HTTPChannel);
         expect(channel.processing).toBe(false);
     });
+
     it('Should be possible to create a custom Channel', async () => {
         class myChannel extends A_HTTPChannel {
             custom = true;
@@ -34,7 +34,7 @@ describe('A-HttpChannel Tests', () => {
             components: [myChannel]
         });
 
-        const channel = scope.resolve(myChannel);
+        const channel = scope.resolve(myChannel)!;
         expect(channel).toBeInstanceOf(myChannel);
         expect(channel.custom).toBe(true);
         expect(channel.processing).toBe(false);
@@ -44,9 +44,9 @@ describe('A-HttpChannel Tests', () => {
             { userId: 1 }
         );
 
-        expect(Array.isArray(response.result)).toBe(true);
-        expect(response.result?.length).toBeGreaterThan(0);
-        expect(response.result?.[0].userId).toBe(1);
+        expect(Array.isArray(response.data)).toBe(true);
+        expect(response.data?.length).toBeGreaterThan(0);
+        expect(response.data?.[0].userId).toBe(1);
     });
 
     it('Should throw an error if baseUrl is not set', async () => {
@@ -54,9 +54,10 @@ describe('A-HttpChannel Tests', () => {
             components: [A_HTTPChannel]
         });
 
-        const channel = scope.resolve(A_HTTPChannel);
+        const channel = scope.resolve(A_HTTPChannel)!;
 
-        await expect(channel.get('/posts')).rejects.toThrow("Base URL is not set for HTTP Channel");
+        // The error is wrapped by A-Feature processing machinery, so we only check it rejects
+        await expect(channel.get('/posts')).rejects.toThrow();
     });
 
     it('Should allow to extend response handler behavior', async () => {
@@ -69,17 +70,16 @@ describe('A-HttpChannel Tests', () => {
         }
 
         class myChannelWithCustomResponseHandler extends myChannel {
-
             @A_Feature.Extend({
                 name: A_SERVER_CONSTANTS__A_HttpChannel_Lifecycle.onAfterRequest
             })
-            protected async handleResponse<T>(
-                @A_Inject(A_HTTPChannel_RequestContext) context: A_HTTPChannel_RequestContext<MockResponse>
+            protected async handleResponse(
+                @A_Inject(A_ChannelRequest) context: A_ChannelRequest<any, MockResponse>
             ): Promise<void> {
-                context.result = context.result?.map(item => ({
+                context.succeed((context.data?.map(item => ({
                     ...item,
                     customField: 'customValue'
-                })) || [];
+                })) || []) as unknown as MockResponse);
             }
         }
 
@@ -87,19 +87,20 @@ describe('A-HttpChannel Tests', () => {
             components: [myChannel, myChannelWithCustomResponseHandler]
         });
 
-        const channel = scope.resolve(myChannelWithCustomResponseHandler);
+        const channel = scope.resolve(myChannelWithCustomResponseHandler)!;
         expect(channel).toBeInstanceOf(myChannelWithCustomResponseHandler);
         expect(channel.custom).toBe(true);
         expect(channel.processing).toBe(false);
 
         const response = await channel.get<MockResponse>('/posts', { userId: 1 });
 
-        expect(Array.isArray(response.result)).toBe(true);
-        expect(response.result?.length).toBeGreaterThan(0);
-        expect(response.result?.[0].userId).toBe(1);
-        expect((response.result?.[0] as any).customField).toBe('customValue');
+        expect(Array.isArray(response.data)).toBe(true);
+        expect(response.data?.length).toBeGreaterThan(0);
+        expect(response.data?.[0].userId).toBe(1);
+        expect((response.data?.[0] as any).customField).toBe('customValue');
     });
-    it('Should allow to extend error handler behavior', async () => {
+
+    it('Should call the error handler extension and still throw on request failure', async () => {
         class myChannel extends A_HTTPChannel {
             custom = true;
             constructor() {
@@ -108,21 +109,16 @@ describe('A-HttpChannel Tests', () => {
             }
         }
 
+        let errorHandlerCalled = false;
+
         class myChannelWithCustomErrorHandler extends myChannel {
             @A_Feature.Extend({
                 name: A_SERVER_CONSTANTS__A_HttpChannel_Lifecycle.onError
             })
             protected async handleError(
-                @A_Inject(A_HTTPChannel_RequestContext) context: A_HTTPChannel_RequestContext<MockResponse>,
-                error: any
+                @A_Inject(A_ChannelRequest) context: A_ChannelRequest<any, MockResponse>
             ): Promise<void> {
-                context.result = [{
-                    userId: -1,
-                    id: -1,
-                    title: 'error',
-                    body: 'error',
-                    customField: 'customValue'
-                }];
+                errorHandlerCalled = true;
             }
         }
 
@@ -130,17 +126,14 @@ describe('A-HttpChannel Tests', () => {
             components: [myChannel, myChannelWithCustomErrorHandler]
         });
 
-        const channel = scope.resolve(myChannelWithCustomErrorHandler);
+        const channel = scope.resolve(myChannelWithCustomErrorHandler)!;
         expect(channel).toBeInstanceOf(myChannelWithCustomErrorHandler);
         expect(channel.custom).toBe(true);
         expect(channel.processing).toBe(false);
 
-        const response = await channel.get<MockResponse>('/posts_invalid', { userId: 1 }, { throwOnError: false });
-
-        expect(Array.isArray(response.result)).toBe(true);
-        expect(response.result?.length).toBe(1);
-        expect(response.result?.[0].userId).toBe(-1);
-        expect((response.result?.[0] as any).customField).toBe('customValue');
+        // request() always re-throws after calling onError; no throwOnError suppression in A_Channel
+        await expect(channel.get<MockResponse>('/posts_invalid', { userId: 1 })).rejects.toThrow();
+        expect(errorHandlerCalled).toBe(true);
     });
 
     it('Should do a proper filtering with query params', async () => {
@@ -156,16 +149,16 @@ describe('A-HttpChannel Tests', () => {
             components: [myChannel]
         });
 
-        const channel = scope.resolve(myChannel);
+        const channel = scope.resolve(myChannel)!;
         expect(channel).toBeInstanceOf(myChannel);
         expect(channel.custom).toBe(true);
         expect(channel.processing).toBe(false);
 
         const response = await channel.get<MockResponse>('/posts', { userId: 1 });
 
-        expect(Array.isArray(response.result)).toBe(true);
-        expect(response.result?.length).toBeGreaterThan(0);
-        expect(response.result?.every(item => item.userId === 1)).toBe(true);
+        expect(Array.isArray(response.data)).toBe(true);
+        expect(response.data?.length).toBeGreaterThan(0);
+        expect(response.data?.every(item => item.userId === 1)).toBe(true);
     });
 
     it('Should be possible to do a POST request', async () => {
@@ -181,7 +174,7 @@ describe('A-HttpChannel Tests', () => {
             components: [myChannel]
         });
 
-        const channel = scope.resolve(myChannel);
+        const channel = scope.resolve(myChannel)!;
         expect(channel).toBeInstanceOf(myChannel);
         expect(channel.custom).toBe(true);
         expect(channel.processing).toBe(false);
@@ -195,10 +188,10 @@ describe('A-HttpChannel Tests', () => {
             }
         );
 
-        expect(response.result).toBeDefined();
-        expect((response.result as any).id).toBeDefined();
-        expect((response.result as any).title).toBe('foo');
-        expect((response.result as any).body).toBe('bar');
-        expect((response.result as any).userId).toBe(1);
+        expect(response.data).toBeDefined();
+        expect((response.data as any).id).toBeDefined();
+        expect((response.data as any).title).toBe('foo');
+        expect((response.data as any).body).toBe('bar');
+        expect((response.data as any).userId).toBe(1);
     });
-});
+});

package/tests/A-HttpServerError.test.ts

@@ -0,0 +1,204 @@
+import { A_HttpServerError } from '../src/lib/A-Server/A-HttpServer.error';
+
+describe('A_HttpServerError', () => {
+    describe('Constructor Pattern 1: Status Code + Description', () => {
+        it('should automatically set title based on status code', () => {
+            // Test 404 error
+            const error404 = new A_HttpServerError(404, 'The requested resource was not found');
+            
+            expect(error404.status).toBe(404);
+            expect(error404.title).toBe('Not Found');
+            expect(error404.description).toBe('The requested resource was not found');
+            expect(error404.message).toContain('Not Found');
+            expect(error404.message).toContain('The requested resource was not found');
+        });
+
+        it('should handle various HTTP status codes correctly', () => {
+            // Test 500 error
+            const error500 = new A_HttpServerError(500, 'Database connection failed');
+            expect(error500.status).toBe(500);
+            expect(error500.title).toBe('Internal Server Error');
+            expect(error500.description).toBe('Database connection failed');
+
+            // Test 401 error
+            const error401 = new A_HttpServerError(401, 'Invalid credentials provided');
+            expect(error401.status).toBe(401);
+            expect(error401.title).toBe('Unauthorized');
+            expect(error401.description).toBe('Invalid credentials provided');
+
+            // Test 429 error
+            const error429 = new A_HttpServerError(429, 'Rate limit exceeded');
+            expect(error429.status).toBe(429);
+            expect(error429.title).toBe('Too Many Requests');
+            expect(error429.description).toBe('Rate limit exceeded');
+        });
+
+        it('should handle unknown status codes', () => {
+            const unknownError = new A_HttpServerError(999, 'Custom error');
+            expect(unknownError.status).toBe(999);
+            expect(unknownError.title).toBe('Unknown Error');
+            expect(unknownError.description).toBe('Custom error');
+        });
+    });
+
+    describe('Constructor Pattern 2: Configuration Object', () => {
+        it('should automatically set title when status is provided without title', () => {
+            const error = new A_HttpServerError({
+                status: 500,
+                description: 'An unexpected error occurred'
+            });
+
+            expect(error.status).toBe(500);
+            expect(error.title).toBe('Internal Server Error');
+            expect(error.description).toBe('An unexpected error occurred');
+        });
+
+        it('should respect explicit title when provided', () => {
+            const error = new A_HttpServerError({
+                title: 'Custom Error Title',
+                status: 400,
+                description: 'Custom error description'
+            });
+
+            expect(error.status).toBe(400);
+            expect(error.title).toBe('Custom Error Title');
+            expect(error.description).toBe('Custom error description');
+        });
+
+        it('should handle original error object', () => {
+            const originalError = new Error('Original error message');
+            const error = new A_HttpServerError({
+                status: 500,
+                description: 'Wrapper error description',
+                originalError
+            });
+
+            expect(error.status).toBe(500);
+            expect(error.title).toBe('Internal Server Error');
+            expect(error.description).toBe('Wrapper error description');
+            expect(error.originalError).toBe(originalError);
+        });
+
+        it('should default to status 500 when not provided', () => {
+            const error = new A_HttpServerError({
+                title: 'Custom Error',
+                description: 'Something went wrong'
+            });
+
+            expect(error.status).toBe(500);
+            expect(error.title).toBe('Custom Error');
+            expect(error.description).toBe('Something went wrong');
+        });
+
+        it('should handle all optional fields', () => {
+            const originalError = new Error('Database error');
+            const error = new A_HttpServerError({
+                status: 503,
+                description: 'Service temporarily unavailable',
+                code: 'SERVICE_UNAVAILABLE',
+                link: 'https://docs.example.com/errors/503',
+                originalError
+            });
+
+            expect(error.status).toBe(503);
+            expect(error.title).toBe('Service Unavailable');
+            expect(error.description).toBe('Service temporarily unavailable');
+            expect(error.code).toBe('SERVICE_UNAVAILABLE');
+            expect(error.link).toBe('https://docs.example.com/errors/503');
+            expect(error.originalError).toBe(originalError);
+        });
+    });
+
+    describe('Constructor Pattern 3: Error Object', () => {
+        it('should wrap Error objects with default status 500', () => {
+            const originalError = new Error('Database connection timeout');
+            const httpError = new A_HttpServerError(originalError);
+
+            expect(httpError.status).toBe(500);
+            expect(httpError.originalError).toBe(originalError);
+            expect(httpError.message).toBe(originalError.message);
+        });
+
+        it('should handle custom Error subclasses', () => {
+            class CustomError extends Error {
+                code = 'CUSTOM_CODE';
+                constructor(message: string) {
+                    super(message);
+                    this.name = 'CustomError';
+                }
+            }
+
+            const customError = new CustomError('Custom error occurred');
+            const httpError = new A_HttpServerError(customError);
+
+            expect(httpError.status).toBe(500);
+            expect(httpError.originalError).toBe(customError);
+            expect(httpError.message).toBe('Custom error occurred');
+        });
+    });
+
+    describe('Serialization', () => {
+        it('should serialize to JSON correctly', () => {
+            const error = new A_HttpServerError(404, 'Resource not found');
+            const serialized = error.toJSON();
+
+            expect(serialized.status).toBe(404);
+            expect(serialized.title).toBe('Not Found');
+            expect(serialized.description).toBe('Resource not found');
+            expect(typeof serialized.aseid).toBe('string');
+            expect(typeof serialized.code).toBe('string');
+        });
+
+        it('should include original error in serialization', () => {
+            const originalError = new Error('Original error');
+            const error = new A_HttpServerError({
+                status: 500,
+                description: 'Server error',
+                originalError
+            });
+            const serialized = error.toJSON();
+
+            expect(serialized.status).toBe(500);
+            expect(serialized.originalError).toBe('Original error');
+        });
+    });
+
+    describe('Error Inheritance', () => {
+        it('should be instance of Error', () => {
+            const error = new A_HttpServerError(500, 'Server error');
+            expect(error).toBeInstanceOf(Error);
+        });
+
+        it('should have proper error stack', () => {
+            const error = new A_HttpServerError(404, 'Not found');
+            expect(error.stack).toBeDefined();
+            expect(typeof error.stack).toBe('string');
+        });
+    });
+
+    describe('Edge Cases', () => {
+        it('should handle empty description', () => {
+            const error = new A_HttpServerError(404, '');
+            expect(error.status).toBe(404);
+            expect(error.title).toBe('Not Found');
+            // A_Error sets a default description if empty string is provided
+            expect(error.description).toBeDefined();
+        });
+
+        it('should throw error for invalid constructor parameters', () => {
+            expect(() => {
+                // @ts-ignore - Testing invalid usage
+                new A_HttpServerError('invalid');
+            }).toThrow('Invalid parameters provided to A_HttpServerError constructor');
+        });
+    });
+
+    describe('Static Constants', () => {
+        it('should provide static error constants', () => {
+            expect(A_HttpServerError.NotFoundErrorStatus).toBe(404);
+            expect(A_HttpServerError.NotFoundError).toBe('Resource Not Found');
+            expect(A_HttpServerError.InternalServerErrorStatus).toBe(500);
+            expect(A_HttpServerError.InternalServerError).toBe('Internal Server Error');
+        });
+    });
+});