@objectql/core 4.1.0 → 4.2.0

package/src/ai/registry.ts

@@ -0,0 +1,81 @@
+/**
+ * ObjectQL - AI Runtime Registry
+ * Copyright (c) 2026-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import type {
+  AiRegistry,
+  AiModelDefinition,
+  ModelRegistry,
+  PromptRegistry,
+  PromptTemplate,
+} from '@objectql/types';
+
+const DEFAULT_PROMPT_VERSION = 'latest';
+
+export class InMemoryModelRegistry implements ModelRegistry {
+  private readonly models = new Map<string, AiModelDefinition>();
+
+  register(model: AiModelDefinition): void {
+    this.models.set(model.id, model);
+  }
+
+  get(id: string): AiModelDefinition | undefined {
+    return this.models.get(id);
+  }
+
+  list(): readonly AiModelDefinition[] {
+    return Array.from(this.models.values());
+  }
+
+  remove(id: string): void {
+    this.models.delete(id);
+  }
+}
+
+export class InMemoryPromptRegistry implements PromptRegistry {
+  private readonly prompts = new Map<string, Map<string, PromptTemplate>>();
+
+  register(template: PromptTemplate): void {
+    const version = template.version ?? DEFAULT_PROMPT_VERSION;
+    const byId = this.prompts.get(template.id) ?? new Map<string, PromptTemplate>();
+    byId.set(version, { ...template, version });
+    this.prompts.set(template.id, byId);
+  }
+
+  get(id: string, version?: string): PromptTemplate | undefined {
+    const byId = this.prompts.get(id);
+    if (!byId) return undefined;
+    if (version) return byId.get(version);
+    if (byId.has(DEFAULT_PROMPT_VERSION)) return byId.get(DEFAULT_PROMPT_VERSION);
+    return byId.values().next().value;
+  }
+
+  list(id?: string): readonly PromptTemplate[] {
+    if (id) {
+      return Array.from(this.prompts.get(id)?.values() ?? []);
+    }
+    return Array.from(this.prompts.values()).flatMap(map => Array.from(map.values()));
+  }
+
+  remove(id: string, version?: string): void {
+    if (!version) {
+      this.prompts.delete(id);
+      return;
+    }
+    const byId = this.prompts.get(id);
+    if (!byId) return;
+    byId.delete(version);
+    if (byId.size === 0) {
+      this.prompts.delete(id);
+    }
+  }
+}
+
+export const createDefaultAiRegistry = (): AiRegistry => ({
+  models: new InMemoryModelRegistry(),
+  prompts: new InMemoryPromptRegistry(),
+});

package/src/app.ts

@@ -20,7 +20,9 @@ import {
     HookContext,
     ActionHandler,
     ActionContext,
-    LoaderPlugin
+    LoaderPlugin,
+    Logger,
+    ConsoleLogger
 } from '@objectql/types';
 import { ObjectKernel, type Plugin } from '@objectstack/runtime';
 import { ObjectQL as RuntimeObjectQL, SchemaRegistry } from '@objectstack/objectql';
@@ -54,12 +56,16 @@ export class ObjectQL implements IObjectQL {
     private hookManager = new CompiledHookManager();
     private localActions = new Map<string, any>();
     
+    // Structured logger
+    private logger: Logger;
+    
     // Store config for lazy loading in init()
     private config: ObjectQLConfig;
 
     constructor(config: ObjectQLConfig) {
         this.config = config;
         this.datasources = config.datasources || {};
+        this.logger = config.logger ?? new ConsoleLogger({ name: '@objectql/core', level: 'info' });
         
         if (config.connection) {
              throw new Error("Connection strings are not supported in core directly. Use @objectql/platform-node's createDriverFromConnection or pass a driver instance to 'datasources'.");
@@ -145,20 +151,22 @@ export class ObjectQL implements IObjectQL {
                  }
             },
             unregisterPackage: (packageName: string) => {
+                 // Use the official @objectstack/objectql 1.1.0 API for object cleanup
+                 if (typeof SchemaRegistry.unregisterObjectsByPackage === 'function') {
+                     SchemaRegistry.unregisterObjectsByPackage(packageName);
+                 }
+                 // Also clean up non-object metadata items by package
                  const metadata = (SchemaRegistry as any).metadata;
                  if (metadata && metadata instanceof Map) {
                      for (const [type, collection] of metadata.entries()) {
                          if (collection instanceof Map) {
                              for (const [key, item] of collection.entries()) {
-                                 // console.log(`[App] Check ${type} ${key} pkg=${(item as any).package}`);
                                  if ((item as any).package === packageName) {
                                      collection.delete(key);
                                  }
                              }
                          }
                      }
-                 } else {
-                     console.warn('Metadata is not a Map');
                  }
             }
         };
@@ -385,13 +393,13 @@ export class ObjectQL implements IObjectQL {
             throw new Error(`Driver for datasource '${datasourceName}' does not support schema introspection`);
         }
         
-        console.log(`Introspecting datasource '${datasourceName}'...`);
+        this.logger.info(`Introspecting datasource '${datasourceName}'...`);
         const introspectedSchema = await driver.introspectSchema();
         
         // Convert introspected schema to ObjectQL objects
         const objects = convertIntrospectedSchemaToObjects(introspectedSchema, options);
         
-        console.log(`Discovered ${objects.length} table(s), registering as objects...`);
+        this.logger.info(`Discovered ${objects.length} table(s), registering as objects...`);
         
         // Register each discovered object
         for (const obj of objects) {
@@ -404,14 +412,14 @@ export class ObjectQL implements IObjectQL {
     async close() {
         for (const [name, driver] of Object.entries(this.datasources)) {
             if (driver.disconnect) {
-                console.log(`Closing driver '${name}'...`);
+                this.logger.debug(`Closing driver '${name}'...`);
                 await driver.disconnect();
             }
         }
     }
 
     async init() {
-        console.log('[ObjectQL] Initializing with ObjectKernel...');
+        this.logger.info('Initializing with ObjectKernel...');
         
         // Start the kernel - this will install and start all plugins
         if ((this.kernel as any).start) {
@@ -419,7 +427,7 @@ export class ObjectQL implements IObjectQL {
         } else if ((this.kernel as any).bootstrap) {
             await (this.kernel as any).bootstrap();
         } else {
-             console.warn('ObjectKernel does not have start() or bootstrap() method');
+             this.logger.warn('ObjectKernel does not have start() or bootstrap() method');
              
              // Manually initialize plugins if kernel doesn't support lifecycle
              for (const plugin of this.kernelPlugins) {
@@ -431,7 +439,7 @@ export class ObjectQL implements IObjectQL {
                          await (plugin as any).start(this.kernel);
                      }
                  } catch (error) {
-                     console.error(`Failed to initialize plugin ${(plugin as any).name || 'unknown'}:`, error);
+                     this.logger.error(`Failed to initialize plugin ${(plugin as any).name || 'unknown'}`, error as Error);
                      // Continue with other plugins even if one fails
                  }
              }
@@ -475,7 +483,7 @@ export class ObjectQL implements IObjectQL {
         // Let's pass all objects to all configured drivers.
         for (const [name, driver] of Object.entries(this.datasources)) {
             if (driver.init) {
-                console.log(`Initializing driver '${name}'...`);
+                this.logger.debug(`Initializing driver '${name}'...`);
                 await driver.init(objects);
             }
         }
@@ -483,14 +491,14 @@ export class ObjectQL implements IObjectQL {
         // Process Initial Data
         await this.processInitialData();
         
-        console.log('[ObjectQL] Initialization complete');
+        this.logger.info('Initialization complete');
     }
 
     private async processInitialData() {
         const dataEntries = (this.kernel as any).metadata.list('data');
         if (dataEntries.length === 0) return;
 
-        console.log(`Processing ${dataEntries.length} initial data files...`);
+        this.logger.info(`Processing ${dataEntries.length} initial data files...`);
         
         // We need a system context to write data
         const ctx = this.createContext({ isSystem: true });
@@ -514,7 +522,7 @@ export class ObjectQL implements IObjectQL {
             }
 
             if (!objectName || !records || !Array.isArray(records)) {
-                console.warn(`Skipping invalid data entry:`, entry);
+                this.logger.warn('Skipping invalid data entry', { entry: String(entry) });
                 continue;
             }
 
@@ -531,10 +539,10 @@ export class ObjectQL implements IObjectQL {
                     // But without unique keys defined in data, we can't reliably dedup.
                     // Let's try to 'create' and catch errors.
                     await repo.create(record);
-                    console.log(`Initialized record for ${objectName}`);
+                    this.logger.debug(`Initialized record for ${objectName}`);
                 } catch (e: any) {
                     // Ignore duplicate key errors silently-ish
-                     console.warn(`Failed to insert initial data for ${objectName}: ${e.message}`);
+                     this.logger.warn(`Failed to insert initial data for ${objectName}: ${e.message}`);
                 }
             }
         }

package/src/gateway.ts

@@ -6,7 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { ApiRequest, ApiResponse, GatewayProtocol } from '@objectql/types';
+import { ApiRequest, ApiResponse, GatewayProtocol, Logger, ConsoleLogger } from '@objectql/types';
 
 export type RequestTransformer = (request: ApiRequest) => Promise<ApiRequest>;
 export type ResponseTransformer = (response: ApiResponse) => Promise<ApiResponse>;
@@ -19,9 +19,11 @@ export class ObjectGateway {
     private protocols: GatewayProtocol[] = [];
     private requestTransforms: RequestTransformer[] = [];
     private responseTransforms: ResponseTransformer[] = [];
+    private logger: Logger;
 
-    constructor(protocols: GatewayProtocol[] = []) {
+    constructor(protocols: GatewayProtocol[] = [], logger?: Logger) {
         this.protocols = protocols;
+        this.logger = logger ?? new ConsoleLogger({ name: '@objectql/gateway', level: 'info' });
     }
 
     /**
@@ -78,7 +80,9 @@ export class ObjectGateway {
         try {
             response = await protocol.handle(req);
         } catch (error: any) {
-            console.error(`[ObjectGateway] Error in ${protocol.name}:`, error);
+            this.logger.error(`Error in ${protocol.name}`, error as Error, {
+                protocol: protocol.name,
+            });
             response = {
                 status: 500,
                 headers: { 'Content-Type': 'application/json' },

package/src/index.ts

@@ -9,15 +9,29 @@
 // Re-export types from @objectstack packages for API compatibility
 export type { ObjectKernel } from '@objectstack/runtime';
 export type { ObjectStackProtocolImplementation } from '@objectstack/objectql';
-// Note: @objectstack/objectql types temporarily commented out due to type incompatibilities
-// in the published package. Will be re-enabled when package is updated.
-// export type { ObjectQL as ObjectQLEngine, SchemaRegistry } from '@objectstack/objectql';
+
+// Re-export new @objectstack/objectql 1.1.0 FQN (Fully Qualified Name) utilities
+export {
+    computeFQN,
+    parseFQN,
+    RESERVED_NAMESPACES,
+    DEFAULT_OWNER_PRIORITY,
+    DEFAULT_EXTENDER_PRIORITY,
+    SchemaRegistry,
+} from '@objectstack/objectql';
+export type { ObjectContributor } from '@objectstack/objectql';
 
 // Export ObjectStack spec types for driver development
-import { Data, System } from '@objectstack/spec';
-export type QueryAST = Data.QueryAST;
-export type DriverInterface = Data.DriverInterface;
-export type DriverOptions = Data.DriverOptions;
+import { Data, System, Automation } from '@objectstack/spec';
+import { z } from 'zod';
+export { QueryAST } from '@objectql/types';
+export type DriverInterface = z.infer<typeof Data.DriverInterfaceSchema>;
+export type DriverOptions = z.infer<typeof Data.DriverOptionsSchema>;
+
+// Re-export new @objectstack/spec 1.1.0 types
+export type StateMachineConfig = z.infer<typeof Automation.StateMachineSchema>;
+export type ObjectOwnership = z.infer<typeof Data.ObjectOwnershipEnum>;
+export type ObjectExtension = z.infer<typeof Data.ObjectExtensionSchema>;
 
 export * from './gateway';
 
@@ -34,3 +48,6 @@ export * from './util';
 
 // Export kernel optimizations
 export * from './optimizations';
+
+// Export AI runtime
+export * from './ai';

package/src/optimizations/CompiledHookManager.ts

@@ -6,6 +6,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+import { Logger, ConsoleLogger } from '@objectql/types';
+
 /**
  * Hook definition
  */
@@ -30,6 +32,9 @@ export class CompiledHookManager {
     
     // Keep track of all registered hooks for management
     private allHooks = new Map<string, Hook>();
+    
+    // Structured logger
+    private logger: Logger = new ConsoleLogger({ name: '@objectql/hook-manager', level: 'warn' });
 
     /**
      * Expand a pattern like "before*" to all matching events
@@ -135,7 +140,10 @@ export class CompiledHookManager {
             try {
                 return Promise.resolve(hook.handler(context));
             } catch (error) {
-                console.error(`Hook execution failed for ${event}:${objectName}`, error);
+                this.logger.error(`Hook execution failed for ${event}:${objectName}`, error as Error, {
+                    event,
+                    objectName,
+                });
                 return Promise.resolve();
             }
         }));

package/src/plugin.ts

@@ -7,12 +7,15 @@
  */
 
 import type { RuntimePlugin, RuntimeContext } from '@objectql/types';
+import { ConsoleLogger } from '@objectql/types';
+import type { Logger } from '@objectql/types';
 import { ValidatorPlugin, ValidatorPluginConfig } from '@objectql/plugin-validator';
 import { FormulaPlugin, FormulaPluginConfig } from '@objectql/plugin-formula';
 import { QueryService } from './query/query-service';
 import { QueryAnalyzer } from './query/query-analyzer';
 import { ObjectStackProtocolImplementation } from './protocol';
 import type { Driver } from '@objectql/types';
+import { createDefaultAiRegistry } from './ai';
 
 /**
  * Extended kernel with ObjectQL services
@@ -93,6 +96,7 @@ export interface ObjectQLPluginConfig {
 export class ObjectQLPlugin implements RuntimePlugin {
   name = '@objectql/core';
   version = '4.0.2';
+  private logger: Logger;
   
   constructor(private config: ObjectQLPluginConfig = {}, ql?: any) {
     // Set defaults
@@ -104,6 +108,7 @@ export class ObjectQLPlugin implements RuntimePlugin {
       enableQueryService: true,
       ...config
     };
+    this.logger = new ConsoleLogger({ name: '@objectql/core/plugin', level: 'info' });
   }
   
   /**
@@ -111,7 +116,7 @@ export class ObjectQLPlugin implements RuntimePlugin {
    * This is called during kernel initialization
    */
   async install(ctx: RuntimeContext): Promise<void> {
-    console.log(`[${this.name}] Installing plugin...`);
+    this.logger.info('Installing plugin...');
     
     const kernel = ctx.engine as ExtendedKernel;
     
@@ -127,9 +132,11 @@ export class ObjectQLPlugin implements RuntimePlugin {
           const driverName = driver.name || (index === 0 ? 'default' : `driver_${index + 1}`);
           datasources![driverName] = driver;
         });
-        console.log(`[${this.name}] Using drivers from kernel:`, Object.keys(datasources));
+        this.logger.info('Using drivers from kernel', {
+          drivers: Object.keys(datasources),
+        });
       } else {
-        console.warn(`[${this.name}] No datasources configured and no drivers found in kernel. Repository and QueryService will not be available.`);
+        this.logger.warn('No datasources configured and no drivers found in kernel. Repository and QueryService will not be available.');
       }
     }
     
@@ -147,7 +154,7 @@ export class ObjectQLPlugin implements RuntimePlugin {
       );
       kernel.queryAnalyzer = queryAnalyzer;
       
-      console.log(`[${this.name}] QueryService and QueryAnalyzer registered`);
+      this.logger.info('QueryService and QueryAnalyzer registered');
     }
     
     // Register components based on configuration
@@ -171,7 +178,23 @@ export class ObjectQLPlugin implements RuntimePlugin {
       await this.registerAI(kernel);
     }
     
-    console.log(`[${this.name}] Plugin installed successfully`);
+    // Register system service aliases
+    if (typeof (ctx as any).registerService === 'function') {
+        const registerService = (ctx as any).registerService.bind(ctx);
+        
+        // 1. Metadata service
+        if (kernel.metadata) {
+            registerService('metadata', kernel.metadata);
+            this.logger.debug('Registered metadata service alias');
+        }
+        
+        // 2. Data service (prefer QueryService, fallback to kernel)
+        const dataService = kernel.queryService || kernel;
+        registerService('data', dataService);
+        this.logger.debug('Registered data service alias');
+    }
+
+    this.logger.info('Plugin installed successfully');
   }
   
   /**
@@ -179,37 +202,11 @@ export class ObjectQLPlugin implements RuntimePlugin {
    * This is the initialization phase
    */
   async onStart(ctx: RuntimeContext): Promise<void> {
-    console.log(`[${this.name}] Starting plugin...`);
+    this.logger.debug('Starting plugin...');
     // Additional startup logic can be added here
   }
 
   // --- Adapter for @objectstack/core compatibility ---
-  async init(kernel: any): Promise<void> {
-      // The new core passes the kernel instance directly
-      // We wrap it to match the old RuntimeContext interface
-      const ctx = {
-          engine: kernel,
-          getKernel: () => kernel
-      };
-
-      // Register Protocol Service
-      // If kernel supports service registration (PluginContext or ExtendedKernel with custom registry)
-      if (kernel && typeof kernel.registerService === 'function') {
-          console.log(`[${this.name}] Registering protocol service...`);
-          const protocolShim = new ObjectStackProtocolImplementation(kernel as any);
-          kernel.registerService('protocol', protocolShim);
-      }
-
-      return this.install(ctx);
-  }
-
-  async start(kernel: any): Promise<void> {
-      const ctx = {
-          engine: kernel,
-          getKernel: () => kernel
-      };
-      return this.onStart(ctx);
-  }
   // ---------------------------------------------------
   
   /**
@@ -286,7 +283,7 @@ export class ObjectQLPlugin implements RuntimePlugin {
       return await driver.count(objectName, filters || {}, {});
     };
 
-    console.log(`[${this.name}] Repository pattern registered`);
+    this.logger.info('Repository pattern registered');
   }
   
   /**
@@ -294,8 +291,41 @@ export class ObjectQLPlugin implements RuntimePlugin {
    * @private
    */
   private async registerAI(kernel: any): Promise<void> {
-    // TODO: Implement AI registration
-    // For now, this is a placeholder to establish the structure
-    console.log(`[${this.name}] AI integration registered`);
+    if (!(kernel as any).ai) {
+      (kernel as any).ai = createDefaultAiRegistry();
+    }
+    this.logger.debug('AI integration registered');
   }
+
+    // --- Adapter for @objectstack/core compatibility ---
+    init = async (kernel: any): Promise<void> => {
+        // The new core passes the kernel instance directly
+        // We wrap it to match the old RuntimeContext interface
+        const ctx: any = {
+            engine: kernel,
+            getKernel: () => kernel
+        };
+
+        // Register Protocol Service
+        // If kernel supports service registration (PluginContext or ExtendedKernel with custom registry)
+        if (kernel && typeof kernel.registerService === 'function') {
+            this.logger.info('Registering protocol service...');
+            const protocolShim = new ObjectStackProtocolImplementation(kernel);
+             kernel.registerService('protocol', protocolShim);
+             
+             // Register 'objectql' service for AppPlugin compatibility
+             kernel.registerService('objectql', this);
+             this.logger.debug('Registered objectql service');
+        }
+
+        return this.install(ctx);
+    }
+
+    start = async (kernel: any): Promise<void> => {
+        const ctx: any = {
+            engine: kernel,
+            getKernel: () => kernel
+        };
+        return this.onStart(ctx);
+    }
 }

package/src/protocol.ts

@@ -72,6 +72,19 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         return this.getMetaItem(args);
     }
 
+    /**
+     * Save Metadata Item
+     */
+    async saveMetaItem(args: { type: string; name: string; item?: any }): Promise<{ success: boolean; message?: string }> {
+        const { type, name, item } = args;
+        if (this.engine.metadata && typeof this.engine.metadata.register === 'function') {
+            const data = { ...(item || {}), name }; // Ensure name is in data
+            this.engine.metadata.register(type, data);
+            return { success: true };
+        }
+        throw new Error('Engine does not support saving metadata');
+    }
+
     /**
      * Get UI View
      */

package/src/query/filter-translator.ts

@@ -8,7 +8,7 @@
 
 import type { Filter } from '@objectql/types';
 import { Data } from '@objectstack/spec';
-type FilterCondition = Data.FilterCondition;
+import { z } from 'zod';
 import { ObjectQLError } from '@objectql/types';
 
 /**
@@ -25,7 +25,7 @@ export class FilterTranslator {
     /**
      * Translate filters from ObjectQL format to ObjectStack FilterCondition format
      */
-    translate(filters?: Filter): FilterCondition | undefined {
+    translate(filters?: Filter): Filter | undefined {
         if (!filters) {
             return undefined;
         }
@@ -36,6 +36,6 @@ export class FilterTranslator {
         }
 
         // Both ObjectQL Filter and ObjectStack FilterCondition use the same format now
-        return filters as unknown as FilterCondition;
+        return filters;
     }
 }

package/src/query/query-analyzer.ts

@@ -7,8 +7,7 @@
  */
 
 import type { UnifiedQuery, ObjectConfig, MetadataRegistry } from '@objectql/types';
-import { Data } from '@objectstack/spec';
-type QueryAST = Data.QueryAST;
+import { QueryAST } from '@objectql/types';
 import { QueryService, QueryOptions } from './query-service';
 
 /**

package/src/query/query-builder.ts

@@ -6,16 +6,16 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import type { UnifiedQuery } from '@objectql/types';
-import { Data } from '@objectstack/spec';
+import type { UnifiedQuery, QueryAST } from '@objectql/types';
+// import { QueryAST } from './types'; (Removed)
 
 // Local QueryAST type extension to include all properties we need
-interface QueryAST extends Data.QueryAST {
-    top?: number;
-    expand?: Record<string, any>;
-    aggregations?: any[];
-    having?: any;
-}
+// interface QueryAST extends Data.QueryAST {
+//    top?: number;
+//    expand?: Record<string, any>;
+//    aggregations?: any[];
+//    having?: any;
+// }
 
 import { FilterTranslator } from './filter-translator';
 

package/src/query/query-service.ts

@@ -13,8 +13,7 @@ import type {
     Filter,
     MetadataRegistry
 } from '@objectql/types';
-import { Data } from '@objectstack/spec';
-type QueryAST = Data.QueryAST;
+import { QueryAST } from '@objectql/types';
 import { QueryBuilder } from './query-builder';
 import { QueryCompiler } from '../optimizations/QueryCompiler';
 

package/src/repository.ts

@@ -6,11 +6,11 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { ObjectQLContext, IObjectQL, ObjectConfig, Driver, UnifiedQuery, ActionContext, HookAPI, RetrievalHookContext, MutationHookContext, UpdateHookContext, ValidationContext, ValidationError, ValidationRuleResult, FormulaContext, Filter } from '@objectql/types';
+import { ObjectQLContext, IObjectQL, ObjectConfig, Driver, UnifiedQuery, ActionContext, HookAPI, RetrievalHookContext, MutationHookContext, UpdateHookContext, ValidationContext, ValidationError, ValidationRuleResult, FormulaContext, Filter, QueryAST } from '@objectql/types';
 import type { ObjectKernel } from '@objectstack/runtime';
 import { Data } from '@objectstack/spec';
-type QueryAST = Data.QueryAST;
-type SortNode = Data.SortNode;
+import { z } from 'zod';
+type SortNode = z.infer<typeof Data.SortNodeSchema>;
 
 export class ObjectRepository {
 
@@ -149,7 +149,14 @@ export class ObjectRepository {
         await this.app.triggerHook('beforeCount', this.objectName, hookCtx);
 
         // Execute via kernel (delegates to QueryService)
-        const result = await (this.getKernel() as any).count(this.objectName, hookCtx.query || {});
+        let result: number;
+        const kernel = this.getKernel() as any;
+        if (typeof kernel.count === 'function') {
+            result = await kernel.count(this.objectName, hookCtx.query || {});
+        } else {
+            // Fallback to driver if kernel doesn't support count
+            result = await this.getDriver().count(this.objectName, hookCtx.query || {});
+        }
 
         hookCtx.result = result;
         await this.app.triggerHook('afterCount', this.objectName, hookCtx);