@acorex/platform-generator 19.2.12 → 19.2.16

package/generators.json

@@ -14,6 +14,16 @@
       "factory": "./src/generators/create-module-entity/generator",
       "schema": "./src/generators/create-module-entity/schema.json",
       "description": "create-module-entity generator"
+    },
+    "create-tag-entity": {
+      "factory": "./src/generators/create-tag-entity/generator",
+      "schema": "./src/generators/create-tag-entity/schema.json",
+      "description": "create-tag-entity generator"
+    },
+    "create-widget": {
+      "factory": "./src/generators/create-widget/generator",
+      "schema": "./src/generators/create-widget/schema.json",
+      "description": "Create a new widget with all required components"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acorex/platform-generator",
-  "version": "19.2.12",
+  "version": "19.2.16",
   "dependencies": {
     "@nx/devkit": "19.2.2",
     "tslib": "^2.3.0"
@@ -18,5 +18,8 @@
   "typings": "./src/index.d.ts",
   "private": false,
   "generators": "./generators.json",
+  "bin": {
+    "acx-create-entity": "./src/bin/interactive-entity-creator.js"
+  },
   "types": "./src/index.d.ts"
 }

package/src/bin/interactive-entity-creator.js

@@ -0,0 +1,448 @@
+#!/usr/bin/env node
+
+const readline = require('readline');
+const { spawn } = require('child_process');
+const { join, resolve } = require('path');
+const fs = require('fs');
+
+// Find the root directory of the project
+function findProjectRoot() {
+  let currentDir = __dirname;
+  while (!fs.existsSync(join(currentDir, 'nx.json'))) {
+    const parentDir = resolve(currentDir, '..');
+    if (parentDir === currentDir) {
+      // We've reached the root of the filesystem
+      return process.cwd();
+    }
+    currentDir = parentDir;
+  }
+  return currentDir;
+}
+
+const projectRoot = findProjectRoot();
+
+// Function to validate module and entity names
+function validateName(name) {
+  // Ensure name is not empty
+  if (!name || name.trim() === '') {
+    return 'Name cannot be empty.';
+  }
+  
+  // Ensure name is not just a number
+  if (/^\d+$/.test(name)) {
+    return 'Name cannot be just a number. Please include at least one letter.';
+  }
+  
+  // Less restrictive validation that allows non-Latin characters
+  // Just check for spaces, special characters, and make sure it starts with a letter or non-Latin character
+  if (/^[^a-zA-Z\p{L}]|\s|[^\w\p{L}]/u.test(name)) {
+    return 'Name must start with a letter and cannot contain spaces or special characters.';
+  }
+  
+  return null; // No error
+}
+
+// Check for --dryRun flag at the beginning
+const isDryRun = process.argv.includes('--dryRun');
+
+// Create an interface for readline
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+// Define widget catalog - copied from widget-catalog.ts
+const widgetCatalog = {
+  text: 'text-editor',
+  email: 'email-editor',
+  password: 'password-editor',
+  phone: 'phone-editor',
+  largeText: 'large-text-editor',
+  richText: 'rich-text-editor',
+  number: 'number-editor',
+  numberUnit: 'number-unit-editor',
+  select: 'select-editor',
+  checkbox: 'checkbox-editor',
+  toggle: 'toggle-editor',
+  dateTime: 'date-time-editor',
+  color: 'color-editor',
+  link: 'link-editor',
+  contact: 'contact-editor',
+  tagable: 'tagable-editor',
+  file: 'file',
+  gallery: 'gallery',
+  signature: 'signature',
+  map: 'map',
+  lookup: 'lookup-editor',
+  selectionList: 'selection-list-editor',
+  table: 'table-editor',
+  qrcode: 'qrcode',
+  singleFileBox: 'single-file-box-editor',
+  metaData: 'meta-data-editor'
+};
+
+// Define widget to data type mapping
+const widgetToDataType = {
+  'text-editor': 'string',
+  'email-editor': 'string',
+  'password-editor': 'string',
+  'phone-editor': 'string',
+  'large-text-editor': 'string',
+  'rich-text-editor': 'string',
+  'number-editor': 'number',
+  'number-unit-editor': 'number',
+  'select-editor': 'object',
+  'checkbox-editor': 'boolean',
+  'toggle-editor': 'boolean',
+  'date-time-editor': 'date',
+  'color-editor': 'string',
+  'link-editor': 'string',
+  'contact-editor': 'object',
+  'tagable-editor': 'string',
+  'file': 'object',
+  'gallery': 'object',
+  'signature': 'string',
+  'map': 'object',
+  'lookup-editor': 'object',
+  'selection-list-editor': 'array',
+  'table-editor': 'array',
+  'qrcode': 'string',
+  'single-file-box-editor': 'object',
+  'meta-data-editor': 'object'
+};
+
+// Widget groups for better display
+const widgetGroups = {
+  'Basic': ['text-editor', 'large-text-editor', 'rich-text-editor', 'number-editor', 'checkbox-editor', 'toggle-editor'],
+  'Input': ['email-editor', 'password-editor', 'phone-editor', 'date-time-editor', 'color-editor'],
+  'Complex': ['select-editor', 'lookup-editor', 'selection-list-editor', 'table-editor'],
+  'Media': ['file', 'gallery', 'signature', 'map', 'qrcode']
+};
+
+// Define default colSpan based on widget type
+const widgetToColSpan = {
+  'text-editor': 6,
+  'email-editor': 6,
+  'password-editor': 6,
+  'phone-editor': 6,
+  'large-text-editor': 12,
+  'rich-text-editor': 12,
+  'number-editor': 4,
+  'number-unit-editor': 6,
+  'select-editor': 6,
+  'checkbox-editor': 4,
+  'toggle-editor': 4,
+  'date-time-editor': 6,
+  'color-editor': 4,
+  'link-editor': 6,
+  'contact-editor': 8,
+  'tagable-editor': 8,
+  'file': 6,
+  'gallery': 12,
+  'signature': 8,
+  'map': 12,
+  'lookup-editor': 6,
+  'selection-list-editor': 8,
+  'table-editor': 12,
+  'qrcode': 6,
+  'single-file-box-editor': 6,
+  'meta-data-editor': 8
+};
+
+// Create data object to store all user input
+const data = {
+  moduleName: '',
+  name: '',
+  properties: [],
+  dataTypes: [],
+  required: [],
+  colSpans: [],
+  orders: [],
+  widgets: [], // Used locally but not passed to NX generator
+  icon: 'fa-light fa-default',
+  enableSorts: [],
+  enableFilters: [],
+  enableInlineFilters: [],
+  inColumn: [] // اضافه کردن آرایه جدید برای ذخیره وضعیت نمایش در ستون
+};
+
+// Run the prompts in sequence
+async function runPrompts() {
+  console.log('\n=== AcoreX Platform Interactive Entity Generator ===\n');
+  
+  // Get module name with validation
+  while (true) {
+    data.moduleName = await askQuestion('Module name: ');
+    const error = validateName(data.moduleName);
+    if (error) {
+      console.log(`Error: ${error}`);
+    } else {
+      break;
+    }
+  }
+  
+  // Get entity name with validation
+  while (true) {
+    data.name = await askQuestion('Entity name: ');
+    const error = validateName(data.name);
+    if (error) {
+      console.log(`Error: ${error}`);
+    } else {
+      break;
+    }
+  }
+  
+  // Get properties
+  console.log('\nEnter properties (type "done" when finished):');
+  let propCount = 1;
+  while (true) {
+    const prop = await askQuestion(`Property ${propCount}: `);
+    if (prop.toLowerCase() === 'done') {
+      break;
+    }
+    data.properties.push(prop);
+    
+    // Get widget for this property
+    const widget = await selectWidget(`Select widget for "${prop}": `);
+    data.widgets.push(widget);
+    
+    // Automatically determine data type based on widget
+    const dataType = widgetToDataType[widget] || 'string';
+    data.dataTypes.push(dataType);
+    
+    // Ask if this property is required
+    const isRequired = await askQuestion(`Is "${prop}" required? (y/n): `, 'n');
+    if (isRequired.toLowerCase() === 'y') {
+      data.required.push(prop);
+    }
+    
+    // Ask if this property should be displayed in columns
+    const showInColumn = await askQuestion(`Show "${prop}" in table columns? (y/n): `, 'y');
+    data.inColumn.push(showInColumn.toLowerCase() === 'y' ? 'true' : 'false');
+    
+    // Get colSpan for this property (1-12)
+    const defaultColSpan = widgetToColSpan[widget] || 6;
+    const colSpan = await askQuestion(`Column span for "${prop}" (1-12): `, defaultColSpan.toString());
+    data.colSpans.push(parseInt(colSpan));
+    
+    // Get order for this property
+    const defaultOrder = propCount; // Default order is sequential
+    const order = await askQuestion(`Display order for "${prop}" (default: ${defaultOrder}): `, defaultOrder.toString());
+    data.orders.push(parseInt(order));
+    
+    // Ask about sort
+    const enableSort = await askQuestion(`Enable sorting for "${prop}"? (y/n): `, 'y');
+    data.enableSorts.push(enableSort.toLowerCase() === 'y' ? 'true' : 'false');
+    
+    // Ask about filter
+    const enableFilter = await askQuestion(`Enable filtering for "${prop}"? (y/n): `, 'y');
+    data.enableFilters.push(enableFilter.toLowerCase() === 'y' ? 'true' : 'false');
+    
+    // Ask about inline filter
+    const enableInlineFilter = await askQuestion(`Enable inline filtering for "${prop}"? (y/n): `, 'n');
+    data.enableInlineFilters.push(enableInlineFilter.toLowerCase() === 'y' ? 'true' : 'false');
+    
+    propCount++;
+  }
+  
+  // Get icon
+  console.log('\nSelect an icon:');
+  console.log('1. Default icon (fa-light fa-default)');
+  console.log('2. Box (fa-solid fa-box)');
+  console.log('3. User (fa-solid fa-user)');
+  console.log('4. Shopping cart (fa-solid fa-shopping-cart)');
+  console.log('5. File (fa-solid fa-file)');
+  console.log('6. Custom icon');
+  
+  const iconChoice = await askQuestion('Select option (1-6): ', '1');
+  const iconOptions = [
+    'fa-light fa-default',
+    'fa-solid fa-box',
+    'fa-solid fa-user',
+    'fa-solid fa-shopping-cart',
+    'fa-solid fa-file'
+  ];
+  
+  if (iconChoice >= 1 && iconChoice <= 5) {
+    data.icon = iconOptions[iconChoice - 1];
+  } else if (iconChoice == 6) {
+    data.icon = await askQuestion('Enter custom icon (format: fa-solid fa-xyz): ', 'fa-solid fa-star');
+  }
+  
+  // Show summary
+  console.log('\n=== Summary ===');
+  console.log(`Module: ${data.moduleName}`);
+  console.log(`Entity: ${data.name}`);
+  console.log('Properties:');
+  
+  // Sort properties by order for display
+  const propSummary = data.properties.map((prop, i) => ({
+    name: prop,
+    widget: data.widgets[i],
+    dataType: data.dataTypes[i],
+    required: data.required.includes(prop),
+    colSpan: data.colSpans[i],
+    order: data.orders[i],
+    enableSort: data.enableSorts[i],
+    enableFilter: data.enableFilters[i],
+    enableInlineFilter: data.enableInlineFilters[i],
+    inColumn: data.inColumn[i]
+  }));
+  
+  // Sort by order
+  propSummary.sort((a, b) => a.order - b.order);
+  
+  propSummary.forEach(prop => {
+    console.log(`  - ${prop.name} (Widget: ${prop.widget}, Type: ${prop.dataType}${prop.required ? ', Required' : ''}, ColSpan: ${prop.colSpan}, Order: ${prop.order}, Sort: ${prop.enableSort ? 'Enabled' : 'Disabled'}, Filter: ${prop.enableFilter ? 'Enabled' : 'Disabled'}, Inline Filter: ${prop.enableInlineFilter ? 'Enabled' : 'Disabled'}, In Column: ${prop.inColumn === 'true' ? 'Yes' : 'No'})`);
+  });
+  
+  console.log(`Icon: ${data.icon}`);
+  
+  const confirm = await askQuestion('\nGenerate entity with these settings? (y/n): ', 'y');
+  if (confirm.toLowerCase() === 'y') {
+    runNxGenerator();
+  } else {
+    console.log('Operation cancelled');
+    rl.close();
+  }
+}
+
+// Helper function to ask questions and get answers
+function askQuestion(question, defaultAnswer) {
+  return new Promise(resolve => {
+    const prompt = defaultAnswer ? `${question} [${defaultAnswer}] ` : question;
+    
+    rl.question(prompt, (answer) => {
+      // If answer is empty and there's a default, use the default
+      const result = answer.trim() === '' && defaultAnswer ? defaultAnswer : answer.trim();
+      resolve(result);
+    });
+  });
+}
+
+// Helper function to select a widget with filtering capability
+async function selectWidget(prompt) {
+  console.log(`\n${prompt}`);
+  console.log('Available widgets (you can type to filter):');
+  
+  // Display widgets by groups
+  for (const [groupName, groupWidgets] of Object.entries(widgetGroups)) {
+    console.log(`\n${groupName} widgets:`);
+    groupWidgets.forEach((widget, index) => {
+      const widgetKey = Object.entries(widgetCatalog).find(([key, value]) => value === widget)?.[0] || '';
+      console.log(`  ${(index + 1).toString().padStart(2)}: ${widget} (${widgetKey})`);
+    });
+  }
+  
+  // Handling widget selection with filtering
+  let selectedWidget = '';
+  while (!selectedWidget) {
+    const input = await askQuestion('\nEnter widget name or number (or part of name to filter): ');
+    
+    // Check if input is a number
+    if (!isNaN(input) && input > 0 && input <= Object.values(widgetCatalog).length) {
+      const allWidgets = Object.values(widgetCatalog);
+      selectedWidget = allWidgets[parseInt(input) - 1];
+    } 
+    // Check if input exactly matches a widget name
+    else if (Object.values(widgetCatalog).includes(input)) {
+      selectedWidget = input;
+    }
+    // Check if input matches a widget key
+    else if (widgetCatalog[input]) {
+      selectedWidget = widgetCatalog[input];
+    }
+    // Filter widgets by input
+    else {
+      const filteredWidgets = Object.entries(widgetCatalog)
+        .filter(([key, value]) => 
+          key.toLowerCase().includes(input.toLowerCase()) || 
+          value.toLowerCase().includes(input.toLowerCase())
+        );
+      
+      if (filteredWidgets.length === 1) {
+        selectedWidget = filteredWidgets[0][1]; // Pick the only match
+      } 
+      else if (filteredWidgets.length > 1) {
+        console.log('\nFiltered widgets:');
+        filteredWidgets.forEach(([key, value], index) => {
+          console.log(`  ${(index + 1).toString().padStart(2)}: ${value} (${key})`);
+        });
+        
+        const selection = await askQuestion('Select number or continue typing to filter more: ');
+        if (!isNaN(selection) && selection > 0 && selection <= filteredWidgets.length) {
+          selectedWidget = filteredWidgets[parseInt(selection) - 1][1];
+        }
+      } 
+      else {
+        console.log('No matches found. Try again.');
+      }
+    }
+  }
+  
+  return selectedWidget;
+}
+
+// Run the NX generator with collected data
+function runNxGenerator() {
+  // Handle special cases and ensure proper formatting
+  
+  // For empty required array, use "_none_"
+  const requiredValue = data.required.length === 0 ? "_none_" : data.required.join(',');
+  
+  // Ensure single values for colSpans and orders have trailing commas
+  let colSpansStr = data.colSpans.join(',');
+  if (data.colSpans.length === 1) {
+    colSpansStr = colSpansStr + ',';
+  }
+  
+  let ordersStr = data.orders.join(',');
+  if (data.orders.length === 1) {
+    ordersStr = ordersStr + ',';
+  }
+  
+  // Prepare arguments properly
+  const command = `cd "${projectRoot}" && npx nx g @acorex-platform/generator:create-module-entity` +
+    ` --moduleName=${data.moduleName}` +
+    ` --name=${data.name}` +
+    ` --properties=${data.properties.join(',')}` +
+    ` --dataTypes=${data.dataTypes.join(',')}` +
+    ` --required=${requiredValue}` +
+    ` --colSpans=${colSpansStr}` +
+    ` --orders=${ordersStr}` +
+    ` --icon="${data.icon}"` +
+    ` --enableSorts=${data.enableSorts.join(',')}` +
+    ` --enableFilters=${data.enableFilters.join(',')}` +
+    ` --enableInlineFilters=${data.enableInlineFilters.join(',')}` +
+    ` --inColumn=${data.inColumn.join(',')}` +
+    (isDryRun ? ' --dryRun' : '');
+  
+  console.log(`\nRunning: ${command}`);
+  
+  try {
+    // Execute the command as a shell command to ensure proper environment
+    const { execSync } = require('child_process');
+    const options = { 
+      stdio: 'inherit',
+      shell: true 
+    };
+    
+    execSync(command, options);
+    console.log(`\nGenerator completed successfully`);
+  } catch (error) {
+    console.error(`\nGenerator failed with error: ${error.message}`);
+    
+    // Show more detailed error information
+    if (error.stderr) {
+      console.error(`Error details: ${error.stderr.toString()}`);
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+// Start the prompts
+runPrompts().catch(err => {
+  console.error('An error occurred:', err);
+  rl.close();
+}); 

package/src/bin/test-entity-creator.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+
+// Check for --dryRun flag at the beginning
+const isDryRun = process.argv.includes('--dryRun');
+
+// Store predefined data
+const data = {
+  moduleName: 'test',
+  name: 't1',
+  properties: ['title', 'name'],
+  widgets: ['text-editor', 'text-editor'],
+  dataTypes: ['string', 'string'],
+  required: ['name'],
+  colSpans: [6, 6],
+  orders: [1, 2],
+  icon: 'fa-light fa-default'
+};
+
+console.log('\n=== AcoreX Platform Interactive Entity Generator (Test Mode) ===\n');
+console.log('Using predefined values:');
+console.log(`Module: ${data.moduleName}`);
+console.log(`Entity: ${data.name}`);
+console.log(`Properties: ${data.properties.join(', ')}`);
+console.log(`Required: ${data.required.join(', ')}`);
+console.log(`Icon: ${data.icon}`);
+
+// Run the NX generator with the predefined data
+function runNxGenerator() {
+  // Format the command
+  const command = `cd ../../.. && npx nx g @acorex-platform/generator:create-module-entity --moduleName=${data.moduleName} --name=${data.name} --properties=${data.properties.join(',')} --dataTypes=${data.dataTypes.join(',')} --required=${data.required.join(',')} --colSpans=${data.colSpans.join(',')} --orders=${data.orders.join(',')} --icon="${data.icon}"${isDryRun ? ' --dryRun' : ''}`;
+  
+  console.log(`\nRunning: ${command}`);
+  
+  try {
+    // Execute the command
+    const output = execSync(command, { stdio: 'inherit' });
+    console.log('\nGenerator completed successfully');
+    return 0;
+  } catch (error) {
+    console.error(`\nGenerator failed with error: ${error.message}`);
+    return 1;
+  }
+}
+
+// Run the generator
+process.exit(runNxGenerator()); 

package/src/generators/app-module/files/src/app/app.module.ts.template

@@ -7,7 +7,6 @@ import { BrowserModule } from '@angular/platform-browser';
 import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
 import { RouterModule, provideRouter, withEnabledBlockingInitialNavigation } from '@angular/router';
 import { EffectsModule } from '@ngrx/effects';
-import { StoreModule } from '@ngrx/store';
 import { StoreDevtoolsModule } from '@ngrx/store-devtools';
 import { AppComponent } from './app.component';
 import { appRoutes } from './app.routes';
@@ -41,8 +40,6 @@ import { AXMSampleEntityModule } from './modules/<%= name %>/sample/sample.modul
       bindToComponentInputs: true,
       onSameUrlNavigation: 'reload',
     }),
-    StoreModule.forRoot([]),
-    EffectsModule.forRoot(),
     AXFormatModule.forRoot(),
     AXValidationModule.forRoot(),
     //

package/src/generators/app-module/files/src/app/modules/root/sample/sample.service.ts.template

@@ -1,4 +1,4 @@
-import { AXMEntityCrudServiceImpl } from '@acorex/platform/common';
+import { AXMEntityCrudServiceImpl } from '@acorex/platform/layout/entity';
 import { Injectable } from '@angular/core';
 import { AXMSampleModuleConst } from '../const';
 import { AXMSampleEntityModel } from './sample.types';

package/src/generators/app-module/files/src/app/modules/root/sample/sample.types.ts.template

@@ -1,4 +1,4 @@
-import { AXPEntityModel } from '@acorex/platform/common';
+import { AXPEntityModel } from '@acorex/platform/layout/entity';
 
 export interface AXMSampleEntityModel extends AXPEntityModel<string> {
    firstname?: string;

package/src/generators/create-app-module/files/__fileName__/src/index.ts__tmpl__

@@ -0,0 +1,9 @@
+export * from './lib/<%= fileName %>.module';
+//export * from './lib/components';
+export * from './lib/const';
+//export * from './lib/entities';
+export * from './lib/entity.provider';
+export * from './lib/menu.provider';
+export * from './lib/search-command.provider';
+export * from './lib/setting.provider';
+//export * from './lib/pages';

package/src/generators/create-app-module/files/__fileName__/src/lib/__fileName__.module.ts__tmpl__

@@ -0,0 +1,44 @@
+import { NgModule } from "@angular/core";
+import { AXP_PERMISSION_PROVIDER } from '@acorex/platform/auth';
+import { AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER } from '@acorex/platform/common';
+import { AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
+import { AXMMenuProvider } from './menu.provider';
+import { AXMEntityProvider } from './entity.provider';
+import { AXMPermissionProvider } from './permission.provider';  
+import { AXMSettingProvider } from './setting.provider';
+import { AXMSearchCommandProvider } from './search-command.provider';
+
+@NgModule({
+  imports: [],
+  exports: [],
+  declarations: [],
+  providers : [
+    
+    {
+      provide: AXP_MENU_PROVIDER,
+      useClass: AXMMenuProvider,
+      multi: true,
+    },
+    {
+      provide: AXP_ENTITY_DEFINITION_LOADER,
+      useClass: AXMEntityProvider,
+      multi: true,
+    },
+    {
+          provide: AXP_SETTING_DEFINITION_PROVIDER,
+          useClass: AXMSettingProvider,
+          multi: true,
+        },
+        {
+          provide: AXP_SEARCH_PROVIDER,
+          useClass: AXMSearchCommandProvider,
+          multi: true,
+        },
+        {
+          provide: AXP_PERMISSION_PROVIDER,
+          useClass: AXMPermissionProvider,
+          multi: true,
+        },
+  ]
+})
+export class AXM<%= className %>Module {}

package/src/generators/create-app-module/files/__fileName__/src/lib/const.ts__tmpl__

@@ -0,0 +1,19 @@
+const config = {
+  i18n: '<%= fileName %>',
+};
+export const RootConfig = {
+  config,
+  module: {
+    module: '<%= name %>',
+    name: '<%= className %>',
+    title: `t('module-name', {scope:"${config.i18n}"})`,
+    icon: 'fa-light fa-file-invoice',
+  },
+  entities: {
+    // category: {
+    //   name: 'Category',
+    //  title: 't("category", { scope: "common" })',
+    //  icon: 'fa-light fa-list'
+    // },
+  },
+};

package/src/generators/create-app-module/files/__fileName__/src/lib/entity.provider.ts__tmpl__

@@ -0,0 +1,33 @@
+import { AXPEntity } from '@acorex/platform/common';
+import {
+  AXPEntityDefinitionLoader,
+  AXPEntityDefinitionPreloader,
+  AXPEntityPreloadEntity,
+} from '@acorex/platform/layout/entity';
+import { Injectable, Injector, inject } from '@angular/core';
+import { RootConfig } from './const';
+
+@Injectable()
+export class AXMEntityProvider implements AXPEntityDefinitionLoader, AXPEntityDefinitionPreloader {
+  private injector = inject(Injector);
+
+  public preload(): AXPEntityPreloadEntity[] {
+    const module = RootConfig.module.name;
+    return Array.from(Object.values(RootConfig.entities)).map((entity: any) => ({
+      module: module,
+      entity: entity.name,
+    }));
+  }
+
+  async get(moduleName: string, entityName: string): Promise<AXPEntity | null> {
+    if (moduleName == RootConfig.module.name) {
+      switch (
+        entityName
+        // case RootConfig.entities.sample.name:
+        //   return (await import('./entities/sample/sample.entity')).factory(this.injector);
+      ) {
+      }
+    }
+    return null;
+  }
+}