@objectql/core 4.2.0 → 4.2.2

package/src/app.ts

@@ -1,550 +1,167 @@
 /**
- * ObjectQL
+ * ObjectQL Bridge Class
  * 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.
+ * Extends the upstream @objectstack/objectql.ObjectQL engine with:
+ *  - Legacy constructor config (datasources map)
+ *  - MetadataRegistry integration (for ObjectLoader filesystem loading)
+ *
+ * This allows existing consumers to keep using:
+ *   const app = new ObjectQL({ datasources: { default: driver } });
+ *   const loader = new ObjectLoader(app.metadata);
+ *   await loader.load(dir);
+ *   await app.init();
  */
 
-import { 
-    MetadataRegistry,
-    MetadataItem,
-    Driver, 
-    ObjectConfig, 
-    ObjectQLContext, 
-    ObjectQLContextOptions, 
-    IObjectQL, 
-    ObjectQLConfig,
-    HookName,
-    HookHandler,
-    HookContext,
-    ActionHandler,
-    ActionContext,
-    LoaderPlugin,
-    Logger,
-    ConsoleLogger
-} from '@objectql/types';
-import { ObjectKernel, type Plugin } from '@objectstack/runtime';
-import { ObjectQL as RuntimeObjectQL, SchemaRegistry } from '@objectstack/objectql';
-import { ValidatorPlugin } from '@objectql/plugin-validator';
-import { FormulaPlugin } from '@objectql/plugin-formula';
-import { ObjectRepository } from './repository';
-import { convertIntrospectedSchemaToObjects } from './util';
-import { CompiledHookManager } from './optimizations/CompiledHookManager';
+import { ObjectQL as UpstreamObjectQL, SchemaRegistry } from '@objectstack/objectql';
+import type { ServiceObject } from '@objectstack/spec/data';
+import type { DriverInterface } from '@objectstack/core';
+import { MetadataRegistry } from '@objectql/types';
+import type { Driver } from '@objectql/types';
+
+// Runtime-safe accessor for compat methods that exist in @objectstack/objectql@3.0.1
+// but may not be visible to TypeScript due to module resolution variance.
+type UpstreamCompat = UpstreamObjectQL & {
+  registerObject(schema: ServiceObject, packageId?: string, namespace?: string): string;
+  getObject(name: string): ServiceObject | undefined;
+  getConfigs(): Record<string, ServiceObject>;
+  removePackage(packageId: string): void;
+};
 
 /**
- * ObjectQL
- * 
- * ObjectQL implementation that wraps ObjectKernel
- * to provide the plugin architecture.
+ * Legacy config shape accepted by the ObjectQL bridge constructor.
  */
-export class ObjectQL implements IObjectQL {
-    // Delegate to kernel for metadata, hooks, and actions
-    public get metadata(): MetadataRegistry {
-        return (this.kernel as any).metadata;
-    }
-    
-    private datasources: Record<string, Driver> = {};
-    private remotes: string[] = [];
-    
-    // ObjectStack Kernel Integration
-    private kernel!: ObjectKernel & Record<string, any>;
-    private ql: any;
-    private kernelPlugins: any[] = [];
-    
-    // Optimized managers
-    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'.");
-        }
-
-        // Use the imported RuntimeObjectQL, assuming it works as intended
-        this.ql = new RuntimeObjectQL(); 
-
-        // Note: ObjectQLPlugin removed as it now uses RuntimePlugin interface
-        // which is incompatible with the legacy Plugin interface from @objectstack/core
-        // For new code, use the microkernel pattern with RuntimePlugin directly
-        
-        // Add runtime plugins from config
-        if (config.plugins) {
-            for (const plugin of config.plugins) {
-                if (typeof plugin === 'string') {
-                    throw new Error("String plugins are not supported in core. Use @objectql/platform-node or pass plugin instance.");
-                } else {
-                    this.use(plugin as any);
-                }
-            }
-        }
-        
-        // Ensure default plugins are present
-        if (!this.kernelPlugins.some(p => p.name === 'validator')) {
-            this.use(new ValidatorPlugin());
-        }
-        if (!this.kernelPlugins.some(p => p.name === 'formula')) {
-            this.use(new FormulaPlugin());
-        }
-        
-        // Create the kernel with registered plugins
-        this.kernel = new (ObjectKernel as any)(this.kernelPlugins);
-        for (const plugin of this.kernelPlugins) {
-             // Fallback for kernels that support .use() but maybe didn't take them in constructor or if we need to support both
-             // NOTE: Modern ObjectKernel takes plugins in constructor.
-             if ((this.kernel as any).use) {
-                 // Try to avoid double registration if the kernel is smart, but since we don't know the kernel logic perfectly:
-                 // Ideally check if already added. But for now, we leave this for backward compat 
-                 // if ObjectKernel DOESN't take constructor args but HAS use().
-                 
-                 // However, we just instantiated it.
-                 // Let's assume constructor is the way if available.
-                 // But we keep this check for .use() just in case the constructor signature is different (e.g. empty)
-                 (this.kernel as any).use(plugin);
-             }
-        }
-
-        // Helper to unwrap content property (matching MetadataRegistry behavior)
-        const unwrapContent = (item: any) => {
-            if (item && item.content) {
-                return item.content;
-            }
-            return item;
-        };
+export interface ObjectQLConfig {
+  datasources?: Record<string, Driver | DriverInterface>;
+  [key: string]: unknown;
+}
 
-        // Stub legacy accessors
-        (this.kernel as any).metadata = {
-            register: (type: string, item: any) => SchemaRegistry.registerItem(type, item, item.id ? 'id' : 'name'),
-            get: (type: string, name: string) => {
-                const item = SchemaRegistry.getItem(type, name) as any;
-                return unwrapContent(item);
-            },
-            getEntry: (type: string, name: string) => SchemaRegistry.getItem(type, name),
-            list: (type: string) => {
-                const items = SchemaRegistry.listItems(type);
-                return items.map(unwrapContent);
-            },
-            unregister: (type: string, name: string) => {
-                 // Use the official unregisterItem API when available (added in @objectstack/objectql v0.9.2)
-                 // Fallback to direct metadata access for older versions or test mocks
-                 if (typeof SchemaRegistry.unregisterItem === 'function') {
-                     SchemaRegistry.unregisterItem(type, name);
-                 } else {
-                     // Fallback: try to access metadata Map directly
-                     const metadata = (SchemaRegistry as any).metadata;
-                     if (metadata && metadata instanceof Map) {
-                         const collection = metadata.get(type);
-                         if (collection && collection instanceof Map) {
-                             collection.delete(name);
-                         }
-                     }
-                 }
-            },
-            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()) {
-                                 if ((item as any).package === packageName) {
-                                     collection.delete(key);
-                                 }
-                             }
-                         }
-                     }
-                 }
-            }
-        };
-        const kernelHooks = (this.kernel as any).hooks || {};
-        Object.assign(kernelHooks, {
-            register: (event: string, objectName: string, handler: any, packageName?: string) => {
-                this.hookManager.registerHook(event, objectName, handler, packageName);
-            },
-            removePackage: (packageName: string) => {
-                this.hookManager.removePackage(packageName);
-            },
-            trigger: async (event: string, objectName: string, ctx: any) => {
-                await this.hookManager.runHooks(event, objectName, ctx);
-            }
+/**
+ * ObjectQL — drop-in replacement that bridges the upstream engine
+ * with the @objectql/types MetadataRegistry used by ObjectLoader.
+ */
+export class ObjectQL extends UpstreamObjectQL {
+  /**
+   * Filesystem metadata registry populated by ObjectLoader.
+   * After calling loader.load(), call app.init() to sync these
+   * entries into the upstream SchemaRegistry & driver layer.
+   */
+  readonly metadata = new MetadataRegistry();
+
+  /** Typed self-reference for compat methods */
+  private get compat(): UpstreamCompat { return this as unknown as UpstreamCompat; }
+
+  private pendingDrivers: Array<{ name: string; driver: DriverInterface; isDefault: boolean }> = [];
+
+  // Explicitly declare inherited methods to ensure they're in the type definition
+  declare registerObject: (schema: ServiceObject, packageId?: string, namespace?: string) => string;
+
+  constructor(config: ObjectQLConfig = {}) {
+    // Upstream constructor only accepts hostContext
+    super();
+
+    // Store drivers for registration during init()
+    if (config.datasources) {
+      for (const [name, driver] of Object.entries(config.datasources)) {
+        // Always set driver.name to the config key so datasource(name) lookups work
+        (driver as any).name = name;
+        // Cast: local Driver interface is structurally compatible with upstream DriverInterface
+        this.pendingDrivers.push({
+          name,
+          driver: driver as DriverInterface,
+          isDefault: name === 'default'
         });
-        if (!(this.kernel as any).hooks) {
-            (this.kernel as any).hooks = kernelHooks;
-        }
-        (this.kernel as any).actions = {
-            register: (objectName: string, actionName: string, handler: any, packageName?: string) => {
-                const key = `${objectName}:${actionName}`;
-                (handler as any)._package = packageName;
-                this.localActions.set(key, handler);
-            },
-            removePackage: (packageName: string) => {
-                for (const [key, handler] of this.localActions.entries()) {
-                    if ((handler as any)._package === packageName) {
-                        this.localActions.delete(key);
-                    }
-                }
-            },
-            execute: async (objectName: string, actionName: string, ctx: any) => {
-                const handler = this.localActions.get(`${objectName}:${actionName}`);
-                if (handler) {
-                    return handler(ctx);
-                }
-                throw new Error(`Action '${actionName}' on object '${objectName}' not found`);
-            }
-        };
-        
-        // Register initial metadata if provided
-        if (config.registry) {
-            // Copy metadata from provided registry to kernel's registry
-            for (const type of config.registry.getTypes()) {
-                const items = config.registry.list(type);
-                for (const item of items) {
-                    // Safely extract the item's id/name
-                    const itemId = typeof item === 'object' && item !== null 
-                        ? (item as { name?: string; id?: string }).name || (item as { name?: string; id?: string }).id || 'unknown'
-                        : 'unknown';
-                    
-                    (this.kernel as any).metadata.register(type, {
-                        type,
-                        id: itemId,
-                        content: item
-                    });
-                }
-            }
-        }
-    }
-    
-    use(plugin: Plugin) {
-        this.kernelPlugins.push(plugin);
-        if (this.kernel && (this.kernel as any).use) {
-            (this.kernel as any).use(plugin);
-        }
-    }
-
-    removePackage(name: string) {
-        // Delegate to kernel managers
-        (this.kernel as any).metadata.unregisterPackage(name);
-        (this.kernel as any).hooks.removePackage(name);
-        (this.kernel as any).actions.removePackage(name);
-    }
-
-    on(event: HookName, objectName: string, handler: HookHandler, packageName?: string) {
-        // Delegate to kernel hook manager
-        // We wrap the handler to bridge ObjectQL's rich context types with runtime's base types
-        // The runtime HookContext supports all fields via index signature, so this is safe
-        const wrappedHandler = handler as unknown as any;
-        (this.kernel as any).hooks.register(event, objectName, wrappedHandler, packageName);
-    }
-
-    async triggerHook(event: HookName, objectName: string, ctx: HookContext) {
-        // Delegate to kernel hook manager
-        // Runtime HookContext supports ObjectQL-specific fields via index signature
-        await (this.kernel as any).hooks.trigger(event, objectName, ctx);
-    }
-
-    registerAction(objectName: string, actionName: string, handler: ActionHandler, packageName?: string) {
-        // Delegate to kernel action manager
-        // We wrap the handler to bridge ObjectQL's rich context types with runtime's base types
-        // The runtime ActionContext supports all fields via index signature, so this is safe
-        const wrappedHandler = handler as unknown as any;
-        (this.kernel as any).actions.register(objectName, actionName, wrappedHandler, packageName);
-    }
-
-    async executeAction(objectName: string, actionName: string, ctx: ActionContext) {
-        // Delegate to kernel action manager
-        // Runtime ActionContext supports ObjectQL-specific fields via index signature
-        return await (this.kernel as any).actions.execute(objectName, actionName, ctx);
-    }
-
-    createContext(options: ObjectQLContextOptions): ObjectQLContext {
-        const ctx: ObjectQLContext = {
-            userId: options.userId,
-            spaceId: options.spaceId,
-            roles: options.roles || [],
-            isSystem: options.isSystem,
-            object: (name: string) => {
-                return new ObjectRepository(name, ctx, this);
-            },
-            transaction: async (callback: (ctx: ObjectQLContext) => Promise<any>) => {
-                 const driver = this.datasources['default'];
-                 if (!driver || !driver.beginTransaction) {
-                      return callback(ctx);
-                 }
-
-                 let trx: any;
-                 try {
-                     trx = await driver.beginTransaction();
-                 } catch (e) {
-                     throw e;
-                 }
-
-                 const trxCtx: ObjectQLContext = {
-                     ...ctx,
-                     transactionHandle: trx,
-                     transaction: async (cb: (ctx: ObjectQLContext) => Promise<any>) => cb(trxCtx)
-                 };
-
-                 try {
-                     const result = await callback(trxCtx);
-                     if (driver.commitTransaction) await driver.commitTransaction(trx);
-                     return result;
-                 } catch (error) {
-                     if (driver.rollbackTransaction) await driver.rollbackTransaction(trx);
-                     throw error;
-                 }
-            },
-            sudo: () => {
-                 return this.createContext({ ...options, isSystem: true });
-            }
-        };
-        return ctx;
-    }
-
-    /**
-     * Get the underlying ObjectKernel instance
-     * 
-     * This provides access to the kernel for advanced usage scenarios
-     * where you need direct access to the plugin architecture.
-     * 
-     * @returns The ObjectKernel instance
-     * @throws Error if called before init()
-     */
-    getKernel(): ObjectKernel {
-        if (!this.kernel) {
-            throw new Error('Kernel not initialized. Call init() first.');
-        }
-        return this.kernel;
-    }
-
-    registerObject(object: ObjectConfig) {
-        // Normalize fields
-        if (object.fields) {
-            for (const [key, field] of Object.entries(object.fields)) {
-                if (field && !field.name) {
-                    field.name = key;
-                }
-            }
-        }
-        (this.kernel as any).metadata.register('object', object);
-    }
-
-    unregisterObject(name: string) {
-        (this.kernel as any).metadata.unregister('object', name);
-    }
-
-    getObject(name: string): ObjectConfig | undefined {
-        const item = (this.kernel as any).metadata.get('object', name);
-        return item?.content || item;
-    }
-
-    getConfigs(): Record<string, ObjectConfig> {
-        const result: Record<string, ObjectConfig> = {};
-        const items = (this.kernel as any).metadata.list('object') || [];
-        for (const item of items) {
-            const config = item.content || item;
-            if (config?.name) {
-                result[config.name] = config;
-            }
-        }
-        return result;
-    }
-
-    datasource(name: string): Driver {
-        const driver = this.datasources[name];
-        if (!driver) {
-            throw new Error(`Datasource '${name}' not found`);
-        }
-        return driver;
-    }
-
-    /**
-     * Introspect the database schema and automatically register objects.
-     * This allows connecting to an existing database without defining metadata.
-     * 
-     * @param datasourceName - The name of the datasource to introspect (default: 'default')
-     * @param options - Optional configuration for schema conversion
-     * @returns Array of registered ObjectConfig
-     */
-    async introspectAndRegister(
-        datasourceName: string = 'default',
-        options?: {
-            excludeTables?: string[];
-            includeTables?: string[];
-            skipSystemColumns?: boolean;
-        }
-    ): Promise<ObjectConfig[]> {
-        const driver = this.datasource(datasourceName);
-        
-        if (!driver.introspectSchema) {
-            throw new Error(`Driver for datasource '${datasourceName}' does not support schema introspection`);
-        }
-        
-        this.logger.info(`Introspecting datasource '${datasourceName}'...`);
-        const introspectedSchema = await driver.introspectSchema();
-        
-        // Convert introspected schema to ObjectQL objects
-        const objects = convertIntrospectedSchemaToObjects(introspectedSchema, options);
-        
-        this.logger.info(`Discovered ${objects.length} table(s), registering as objects...`);
-        
-        // Register each discovered object
-        for (const obj of objects) {
-            this.registerObject(obj);
-        }
-        
-        return objects;
-    }
-
-    async close() {
-        for (const [name, driver] of Object.entries(this.datasources)) {
-            if (driver.disconnect) {
-                this.logger.debug(`Closing driver '${name}'...`);
-                await driver.disconnect();
-            }
-        }
-    }
-
-    async init() {
-        this.logger.info('Initializing with ObjectKernel...');
-        
-        // Start the kernel - this will install and start all plugins
-        if ((this.kernel as any).start) {
-            await (this.kernel as any).start();
-        } else if ((this.kernel as any).bootstrap) {
-            await (this.kernel as any).bootstrap();
-        } else {
-             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) {
-                 try {
-                     if (typeof (plugin as any).init === 'function') {
-                         await (plugin as any).init(this.kernel);
-                     }
-                     if (typeof (plugin as any).start === 'function') {
-                         await (plugin as any).start(this.kernel);
-                     }
-                 } catch (error) {
-                     this.logger.error(`Failed to initialize plugin ${(plugin as any).name || 'unknown'}`, error as Error);
-                     // Continue with other plugins even if one fails
-                 }
-             }
-        }
-        
-        // TEMPORARY: Set driver for backward compatibility during migration
-        // This allows the kernel mock to delegate to the driver
-        const defaultDriver = this.datasources['default'];
-        if (typeof (this.kernel as any).setDriver === 'function') {
-            if (defaultDriver) {
-                (this.kernel as any).setDriver(defaultDriver);
-            }
-        }
-
-        // TEMPORARY: Patch kernel with CRUD methods dynamically if missing
-        // This ensures the repository can delegate to the kernel even if using the new @objectstack/core kernel
-        if (typeof (this.kernel as any).create !== 'function' && defaultDriver) {
-             (this.kernel as any).create = (object: string, doc: any, options: any) => defaultDriver.create(object, doc, options);
-             (this.kernel as any).update = (object: string, id: any, doc: any, options: any) => defaultDriver.update(object, id, doc, options);
-             (this.kernel as any).delete = (object: string, id: any, options: any) => defaultDriver.delete(object, id, options);
-             (this.kernel as any).find = async (object: string, query: any, options: any) => {
-                 const res = await defaultDriver.find(object, query, options);
-                 return { value: res || [], count: (res || []).length };
-             };
-             (this.kernel as any).findOne = (object: string, id: any, options: any) => defaultDriver.findOne(object, id, options);
-             (this.kernel as any).get = (object: string, id: any) => defaultDriver.findOne(object, id); 
-             (this.kernel as any).count = (object: string, query: any, options: any) => defaultDriver.count(object, query, options);
-        }
-
-        // Load In-Memory Objects (Dynamic Layer)
-        if (this.config.objects) {
-            for (const [key, obj] of Object.entries(this.config.objects)) {
-                this.registerObject(obj);
-            }
-        }
-
-        const registryItems = (this.kernel as any).metadata.list('object');
-        const objects = (registryItems || []).map((item: any) => item.content || item) as ObjectConfig[];
-        
-        // Init Datasources
-        // Let's pass all objects to all configured drivers.
-        for (const [name, driver] of Object.entries(this.datasources)) {
-            if (driver.init) {
-                this.logger.debug(`Initializing driver '${name}'...`);
-                await driver.init(objects);
-            }
-        }
-
-        // Process Initial Data
-        await this.processInitialData();
-        
-        this.logger.info('Initialization complete');
-    }
-
-    private async processInitialData() {
-        const dataEntries = (this.kernel as any).metadata.list('data');
-        if (dataEntries.length === 0) return;
-
-        this.logger.info(`Processing ${dataEntries.length} initial data files...`);
-        
-        // We need a system context to write data
-        const ctx = this.createContext({ isSystem: true });
-
-        for (const entry of dataEntries) {
-            // Unwrapping metadata content if present
-            const dataContent = (entry as any).content || entry;
-
-            // Expected format:
-            // 1. { object: 'User', records: [...] }
-            // 2. [ record1, record2 ] (with name property added by loader inferred from filename)
-            
-            let objectName = dataContent.object;
-            let records = dataContent.records;
-
-            if (Array.isArray(dataContent)) {
-                records = dataContent;
-                if (!objectName && (dataContent as any).name) {
-                    objectName = (dataContent as any).name;
-                }
-            }
-
-            if (!objectName || !records || !Array.isArray(records)) {
-                this.logger.warn('Skipping invalid data entry', { entry: String(entry) });
-                continue;
-            }
-
-            const repo = ctx.object(objectName);
-            
-            for (const record of records) {
-                try {
-                    // Check existence if a unique key is provided?
-                    // For now, let's assume if it has an ID, we check it.
-                    // Or we could try to find existing record by some key matching logic.
-                    // Simple approach: create. If it fails (constraint), ignore.
-                    
-                    // Actually, a better approach for initial data is "upsert" or "create if not exists".
-                    // But without unique keys defined in data, we can't reliably dedup.
-                    // Let's try to 'create' and catch errors.
-                    await repo.create(record);
-                    this.logger.debug(`Initialized record for ${objectName}`);
-                } catch (e: any) {
-                    // Ignore duplicate key errors silently-ish
-                     this.logger.warn(`Failed to insert initial data for ${objectName}: ${e.message}`);
-                }
-            }
-        }
-    }
+      }
+    }
+  }
+
+  /**
+   * Initialize the engine.
+   *
+   * Before calling the upstream init (which connects drivers and syncs schemas),
+   * bridge all objects loaded via ObjectLoader into the upstream SchemaRegistry.
+   */
+  async init(): Promise<void> {
+    // Register any pending drivers from the constructor config
+    for (const { driver, isDefault } of this.pendingDrivers) {
+      (this as any).registerDriver(driver, isDefault);
+    }
+    this.pendingDrivers = [];
+
+    this.syncMetadataToRegistry();
+    return super.init();
+  }
+
+  /**
+   * Sync all filesystem-loaded metadata into the upstream SchemaRegistry.
+   * Called automatically by init(), but can also be called manually.
+   */
+  private syncMetadataToRegistry(): void {
+    // Bridge filesystem-loaded objects → upstream SchemaRegistry
+    const objects = this.metadata.list<any>('object');
+    for (const obj of objects) {
+      if (obj && obj.name) {
+        // Only register if not already in SchemaRegistry
+        if (!SchemaRegistry.getObject(obj.name)) {
+          super.registerObject(obj as ServiceObject, '__filesystem__');
+        }
+      }
+    }
+
+    // Bridge filesystem-loaded hooks → upstream hook system
+    const hooks = this.metadata.list<any>('hook');
+    for (const hookEntry of hooks) {
+      if (hookEntry && typeof hookEntry === 'object') {
+        const objectName = (hookEntry as any).id || (hookEntry as any).objectName;
+        for (const [event, handler] of Object.entries(hookEntry)) {
+          if (typeof handler === 'function' && event !== 'id' && event !== 'objectName') {
+            this.registerHook(event, handler as any, { object: objectName });
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Get an object definition by name.
+   *
+   * Checks the upstream SchemaRegistry first, then falls back to the
+   * local MetadataRegistry for objects loaded via ObjectLoader but
+   * not yet synced (i.e., init() hasn't been called yet).
+   */
+  override getObject(name: string): ServiceObject | undefined {
+    // Check upstream SchemaRegistry first (call parent)
+    const upstream = super.getObject(name);
+    if (upstream) return upstream;
+    // Fallback: check local MetadataRegistry (pre-init)
+    return this.metadata.get<ServiceObject>('object', name);
+  }
+
+  /**
+   * Get all registered object configs as a name→config map.
+   *
+   * Merges results from the upstream SchemaRegistry with the
+   * local MetadataRegistry (for pre-init objects).
+   */
+  override getConfigs(): Record<string, ServiceObject> {
+    // Get upstream objects first (call parent)
+    const result = super.getConfigs();
+    // Merge local MetadataRegistry entries not yet synced upstream
+    const localObjects = this.metadata.list<any>('object');
+    for (const obj of localObjects) {
+      if (obj && obj.name && !result[obj.name]) {
+        result[obj.name] = obj;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Remove all hooks, actions, and objects contributed by a package.
+   * Also cleans up the local MetadataRegistry.
+   */
+  override removePackage(packageId: string): void {
+    super.removePackage(packageId);
+    this.metadata.unregisterPackage(packageId);
+  }
 }