@acorex/platform 20.6.0-next.9 → 21.0.0-next.1

package/fesm2022/acorex-platform-domain.mjs

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, makeEnvironmentProviders, inject, NgModule, Injectable } from '@angular/core';
-import { AXMEntityCrudServiceImpl } from '@acorex/platform/layout/entity';
+import { AXPEntityService } from '@acorex/platform/layout/entity';
 import { AXPCommandRegistry, AXPQueryRegistry, AXPRuntimeModule } from '@acorex/platform/runtime';
 
 const AXP_ENTITY_CRUD_SETUP = new InjectionToken('AXP_ENTITY_CRUD_SETUP');
@@ -12,36 +12,124 @@ function provideEntity(entityKeys) {
             useFactory: () => {
                 const commandRegistry = inject(AXPCommandRegistry);
                 const queryRegistry = inject(AXPQueryRegistry);
+                const entityService = inject(AXPEntityService);
                 for (const entityKey of entityKeys) {
-                    const service = new AXMEntityCrudServiceImpl(entityKey);
+                    const dataAccessor = entityService.withEntity(entityKey).data();
                     // Register Commands
                     commandRegistry.register(`${entityKey}:Create`, async () => ({
                         execute: async (input) => {
-                            const id = await service.insertOne(input);
-                            return service.getOne(id);
+                            try {
+                                const id = await dataAccessor.create(input);
+                                const entity = await dataAccessor.byKey(id);
+                                if (!entity) {
+                                    throw new Error('Entity not found after creation');
+                                }
+                                return {
+                                    success: true,
+                                    data: entity,
+                                };
+                            }
+                            catch (error) {
+                                return {
+                                    success: false,
+                                    message: {
+                                        text: error instanceof Error ? error.message : 'Failed to create entity',
+                                    },
+                                };
+                            }
                         }
                     }));
                     commandRegistry.register(`${entityKey}:Update`, async () => ({
-                        execute: ({ id, ...rest }) => service.updateOne(id, rest)
+                        execute: async ({ id, ...rest }) => {
+                            try {
+                                const updated = await dataAccessor.update(id, rest);
+                                return {
+                                    success: true,
+                                    data: updated,
+                                };
+                            }
+                            catch (error) {
+                                return {
+                                    success: false,
+                                    message: {
+                                        text: error instanceof Error ? error.message : 'Failed to update entity',
+                                    },
+                                };
+                            }
+                        }
                     }));
                     commandRegistry.register(`${entityKey}:Delete`, async () => ({
-                        execute: (id) => service.deleteOne(id)
+                        execute: async (id) => {
+                            try {
+                                await dataAccessor.delete(id);
+                                return {
+                                    success: true,
+                                };
+                            }
+                            catch (error) {
+                                return {
+                                    success: false,
+                                    message: {
+                                        text: error instanceof Error ? error.message : 'Failed to delete entity',
+                                    },
+                                };
+                            }
+                        }
                     }));
                     // Register Queries
                     queryRegistry.register(`${entityKey}:GetById`, async () => ({
-                        fetch: (id) => service.getOne(id)
+                        fetch: (id) => dataAccessor.byKey(id)
                     }));
                     queryRegistry.register(`${entityKey}:GetList`, async () => ({
-                        fetch: (request) => service.query(request)
+                        fetch: (request) => dataAccessor.query(request)
                     }));
+                    // Implement getRoots, getChildren, and getByCategory using query with appropriate filters
                     queryRegistry.register(`${entityKey}:GetRoots`, async () => ({
-                        fetch: (request) => service.getRoots(request)
+                        fetch: async (request) => {
+                            return await dataAccessor.query({
+                                skip: 0,
+                                take: 1000,
+                                filter: {
+                                    field: 'parentId',
+                                    operator: {
+                                        type: 'isEmpty',
+                                    },
+                                    value: true,
+                                },
+                            });
+                        }
                     }));
                     queryRegistry.register(`${entityKey}:GetChildren`, async () => ({
-                        fetch: (request) => service.getChildren(request)
+                        fetch: async (request) => {
+                            const parentKey = request.parentKey ?? 'parentId';
+                            return await dataAccessor.query({
+                                skip: 0,
+                                take: 1000,
+                                filter: {
+                                    field: parentKey,
+                                    operator: {
+                                        type: 'equal',
+                                    },
+                                    value: request.parentId,
+                                },
+                            });
+                        }
                     }));
                     queryRegistry.register(`${entityKey}:GetByCategory`, async () => ({
-                        fetch: (request) => service.getByCategory(request)
+                        fetch: async (request) => {
+                            const categoryKey = request.categoryKey ?? 'categoryIds';
+                            return await dataAccessor.query({
+                                skip: 0,
+                                take: 1000,
+                                filter: {
+                                    field: categoryKey,
+                                    operator: {
+                                        type: 'contains',
+                                    },
+                                    value: request.categoryId,
+                                },
+                            });
+                        }
                     }));
                 }
                 return true;