@adaas/a-server 0.0.22 → 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/{components/A-StaticLoader/A-StaticLoader.component.ts → lib/A-ServerStatic/A-ServerStatic.component.ts}

@@ -1,10 +1,12 @@
 import { A_Component, A_Concept, A_Feature, A_Inject } from "@adaas/a-concept"
-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_SERVER_TYPES__ServerFeature } from "@adaas/a-server/containers/A-Service/A-Service.container.types";
-import { A_Route } from "@adaas/a-server/entities/A-Route/A-Route.entity";
-import { A_StaticConfig, A_StaticAlias } from "@adaas/a-server/context/A-StaticConfig/A-StaticConfig.context";
-import { A_Logger, A_Polyfill } from "@adaas/a-utils";
+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 {
 
@@ -23,10 +25,10 @@ export class A_StaticLoader extends A_Component {
 
         // Log configured aliases
         const aliases = config.getEnabledAliases();
-        logger.log(
-            'pink',
+        logger.info('cyan',
+
             `Static aliases configured:`,
-            aliases.map(alias => `${alias.alias} -> ${alias.directory}`).join('\n')
+            ...aliases.map(alias => `${alias.alias} -> ${alias.directory}`)
         );
     }
 
@@ -36,9 +38,9 @@ export class A_StaticLoader extends A_Component {
     // =======================================================
 
     @A_Feature.Extend({
-        name: A_SERVER_TYPES__ServerFeature.onRequest,
+        before: /.*/
     })
-    async onRequest(
+    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,
@@ -51,7 +53,7 @@ export class A_StaticLoader extends A_Component {
         }
 
         const { method, url } = req;
-        const route = new A_Route(url, method);
+        const route = new A_ServerRoute(url, method);
 
         // Check if this request matches any of our configured aliases
         const alias = config.findMatchingAlias(route.path);
@@ -75,12 +77,18 @@ export class A_StaticLoader extends A_Component {
             // 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) {
-            logger.error(`Static file serving error: ${error.message}`);
-            res.writeHead(404, { "Content-Type": "text/plain" });
-            res.send("File not found");
+            throw new A_HttpServerError({
+                status: 500,
+                title: 'Static File Serving Error',
+                description: `Error serving static file for ${route.path}: ${error.message}`,
+                originalError: error
+            });
         }
     }
 
@@ -93,14 +101,14 @@ export class A_StaticLoader extends A_Component {
      * @param logger - Logger instance for logging
      */
     public addAlias(
-        alias: string, 
-        directory: string, 
-        config: A_StaticConfig, 
-        logger?: A_Logger, 
+        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}`);
         }
@@ -114,11 +122,11 @@ export class A_StaticLoader extends A_Component {
      */
     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;
     }
 
@@ -138,17 +146,17 @@ export class A_StaticLoader extends A_Component {
      * @param logger - Logger instance for logging
      */
     public setAliasEnabled(
-        aliasPath: string, 
-        enabled: boolean, 
-        config: A_StaticConfig, 
+        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;
     }
 
@@ -161,18 +169,18 @@ export class A_StaticLoader extends A_Component {
             ".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",
@@ -183,26 +191,26 @@ export class A_StaticLoader extends A_Component {
             ".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",
@@ -223,7 +231,7 @@ export class A_StaticLoader extends A_Component {
         pathname = pathname.replace(/\.\.[\/\\]/g, "");
 
         let filePath = pathPolyfill.join(staticDir, pathname);
-        
+
         if (!fsPolyfill.existsSync(filePath)) {
             throw new Error(`File not found: ${filePath}`);
         }
@@ -232,10 +240,10 @@ export class A_StaticLoader extends A_Component {
     }
 
     protected serveFile(
-        filePath: string, 
-        res: A_Response, 
-        logger: A_Logger, 
-        fsPolyfill: any, 
+        filePath: string,
+        res: A_Response,
+        logger: A_Logger,
+        fsPolyfill: any,
         pathPolyfill: any
     ): Promise<void> {
         return new Promise<void>((resolve, reject) => {
@@ -252,35 +260,46 @@ export class A_StaticLoader extends A_Component {
                     };
 
                     res.writeHead(200, headers);
+
                     const stream = fsPolyfill.createReadStream(filePath);
-                    
+
                     if (stream && res.original) {
                         stream.pipe(res.original);
 
                         stream.on('end', () => {
-                            logger.log('green', `Successfully served: ${filePath}`);
                             resolve();
                         });
 
                         stream.on("error", (err: any) => {
-                            logger.error(`File stream error: ${err.message}`);
-                            reject(new Error(`File stream error: ${err.message}`));
+                            reject(new A_HttpServerError({
+                                status: 500,
+                                title: 'File Stream Error',
+                                description: `Error reading file stream for ${filePath}: ${err.message}`,
+                                originalError: err
+                            }));
                         });
                     } else {
-                        res.writeHead(500, { "Content-Type": "text/plain" });
-                        res.send("Internal server error");
-                        reject(new Error("Failed to create file stream"));
+                        reject(new A_HttpServerError({
+                            status: 500,
+                            title: 'Response Stream Error',
+                            description: `Unable to pipe file stream for ${filePath}`,
+                        }));
                     }
                 } else {
-                    res.writeHead(404, { "Content-Type": "text/plain" });
-                    res.send("File not found");
-                    reject(new Error(`File not found: ${filePath}`));
+                    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}`);
-                res.writeHead(500, { "Content-Type": "text/plain" });
-                res.send("Internal server error");
-                reject(error);
+                reject(new A_HttpServerError({
+                    status: 500,
+                    title: 'Internal Server Error',
+                    description: `Error serving file: ${error.message}`,
+                    originalError: error
+                }));
             }
         });
     }
@@ -289,7 +308,7 @@ export class A_StaticLoader extends A_Component {
         // 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())) {

package/src/{context/A-StaticConfig/A-StaticConfig.context.ts → lib/A-ServerStatic/A-ServerStatic.context.ts}

@@ -1,5 +1,4 @@
 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;
@@ -34,10 +33,10 @@ export class A_StaticConfig extends A_Fragment {
 
         this.directories = directories;
         this._directoryConfigs = directoryConfigs;
-        
+
         // Initialize default aliases from directories
         this.initializeDefaultAliases();
-        
+
         // Initialize custom aliases from directoryConfigs
         this.initializeCustomAliases();
     }
@@ -79,7 +78,7 @@ export class A_StaticConfig extends A_Fragment {
             directory,
             enabled: true
         };
-        
+
         this._aliases.set(staticAlias.path, staticAlias);
     }
 
@@ -212,8 +211,19 @@ export class A_StaticConfig extends A_Fragment {
      * @param path 
      * @returns 
      */
-    has(path: string): false | string {
+    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 : false;
+        return alias ? alias.directory : undefined;
     }
 }

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);
     }