@objectstack/objectql 1.0.10 → 1.0.12

package/src/engine.ts

@@ -140,31 +140,113 @@ export class ObjectQL implements IDataEngine {
 
   /**
    * Register contribution (Manifest)
+   * 
+   * Installs the manifest as a Package (the unit of installation),
+   * then decomposes it into individual metadata items (objects, apps, actions, etc.)
+   * and registers each into the SchemaRegistry.
+   * 
+   * Key: Package ≠ App. The manifest is the package. The apps[] array inside
+   * the manifest contains UI navigation definitions (AppSchema).
    */
   registerApp(manifest: any) {
-      const id = manifest.id;
-      this.logger.debug('Registering app manifest', { id });
+      const id = manifest.id || manifest.name;
+      const namespace = manifest.namespace as string | undefined;
+      this.logger.debug('Registering package manifest', { id, namespace });
 
-      // Register objects
+      // 1. Register the Package (manifest + lifecycle state)
+      SchemaRegistry.installPackage(manifest);
+      this.logger.debug('Installed Package', { id: manifest.id, name: manifest.name, namespace });
+
+      // 2. Register owned objects
       if (manifest.objects) {
           if (Array.isArray(manifest.objects)) {
              this.logger.debug('Registering objects from manifest (Array)', { id, objectCount: manifest.objects.length });
              for (const objDef of manifest.objects) {
-                SchemaRegistry.registerObject(objDef);
-                this.logger.debug('Registered Object', { object: objDef.name, from: id });
+                const fqn = SchemaRegistry.registerObject(objDef, id, namespace, 'own');
+                this.logger.debug('Registered Object', { fqn, from: id });
              }
           } else {
              this.logger.debug('Registering objects from manifest (Map)', { id, objectCount: Object.keys(manifest.objects).length });
              for (const [name, objDef] of Object.entries(manifest.objects)) {
                 // Ensure name in definition matches key
                 (objDef as any).name = name;
-                SchemaRegistry.registerObject(objDef as any);
-                this.logger.debug('Registered Object', { object: name, from: id });
+                const fqn = SchemaRegistry.registerObject(objDef as any, id, namespace, 'own');
+                this.logger.debug('Registered Object', { fqn, from: id });
              }
           }
       }
 
-      // Register contributions
+      // 2b. Register object extensions (fields added to objects owned by other packages)
+      if (Array.isArray(manifest.objectExtensions) && manifest.objectExtensions.length > 0) {
+          this.logger.debug('Registering object extensions', { id, count: manifest.objectExtensions.length });
+          for (const ext of manifest.objectExtensions) {
+              const targetFqn = ext.extend;
+              const priority = ext.priority ?? 200;
+              // Create a partial object definition for the extension
+              const extDef = {
+                  name: targetFqn, // Use the target FQN as name
+                  fields: ext.fields,
+                  label: ext.label,
+                  pluralLabel: ext.pluralLabel,
+                  description: ext.description,
+                  validations: ext.validations,
+                  indexes: ext.indexes,
+              };
+              // Register as extension (namespace is undefined since we're targeting by FQN)
+              SchemaRegistry.registerObject(extDef as any, id, undefined, 'extend', priority);
+              this.logger.debug('Registered Object Extension', { target: targetFqn, priority, from: id });
+          }
+      }
+
+      // 3. Register apps (UI navigation definitions) as their own metadata type
+      if (Array.isArray(manifest.apps) && manifest.apps.length > 0) {
+          this.logger.debug('Registering apps from manifest', { id, count: manifest.apps.length });
+          for (const app of manifest.apps) {
+              const appName = app.name || app.id;
+              if (appName) {
+                  SchemaRegistry.registerApp(app, id);
+                  this.logger.debug('Registered App', { app: appName, from: id });
+              }
+          }
+      }
+
+      // 4. If manifest itself looks like an App (has navigation), also register as app
+      //    This handles the case where the manifest IS the app definition (legacy/simple packages)
+      if (manifest.name && manifest.navigation && !manifest.apps?.length) {
+          SchemaRegistry.registerApp(manifest, id);
+          this.logger.debug('Registered manifest-as-app', { app: manifest.name, from: id });
+      }
+
+      // 5. Register all other metadata types generically
+      const metadataArrayKeys = [
+        'actions', 'dashboards', 'reports', 'flows', 'agents',
+        'apis', 'ragPipelines', 'profiles', 'sharingRules'
+      ];
+      for (const key of metadataArrayKeys) {
+          const items = (manifest as any)[key];
+          if (Array.isArray(items) && items.length > 0) {
+              this.logger.debug(`Registering ${key} from manifest`, { id, count: items.length });
+              for (const item of items) {
+                  const itemName = item.name || item.id;
+                  if (itemName) {
+                      SchemaRegistry.registerItem(key, item, 'name' as any, id);
+                  }
+              }
+          }
+      }
+
+      // 6. Register seed data as metadata (keyed by target object name)
+      const seedData = (manifest as any).data;
+      if (Array.isArray(seedData) && seedData.length > 0) {
+          this.logger.debug('Registering seed data datasets', { id, count: seedData.length });
+          for (const dataset of seedData) {
+              if (dataset.object) {
+                  SchemaRegistry.registerItem('data', dataset, 'object' as any, id);
+              }
+          }
+      }
+
+      // 6. Register contributions
        if (manifest.contributes?.kinds) {
           this.logger.debug('Registering kinds from manifest', { id, kindCount: manifest.contributes.kinds.length });
           for (const kind of manifest.contributes.kinds) {
@@ -202,6 +284,24 @@ export class ObjectQL implements IDataEngine {
     return SchemaRegistry.getObject(objectName);
   }
 
+  /**
+   * Resolve an object name to its Fully Qualified Name (FQN).
+   * 
+   * Short names like 'task' are resolved to FQN like 'todo__task'
+   * via SchemaRegistry lookup. If no match is found, the name is
+   * returned as-is (for ad-hoc / unregistered objects).
+   * 
+   * This ensures that all driver operations use a consistent key
+   * regardless of whether the caller uses the short name or FQN.
+   */
+  private resolveObjectName(name: string): string {
+    const schema = SchemaRegistry.getObject(name);
+    if (schema) {
+      return schema.name; // FQN from registry (e.g., 'todo__task')
+    }
+    return name; // Ad-hoc object, keep as-is
+  }
+
   /**
    * Helper to get the target driver
    */
@@ -311,6 +411,7 @@ export class ObjectQL implements IDataEngine {
   // ============================================
 
   async find(object: string, query?: DataEngineQueryOptions): Promise<any[]> {
+    object = this.resolveObjectName(object);
     this.logger.debug('Find operation starting', { object, query });
     const driver = this.getDriver(object);
     const ast = this.toQueryAST(object, query);
@@ -338,6 +439,7 @@ export class ObjectQL implements IDataEngine {
   }
 
   async findOne(objectName: string, query?: DataEngineQueryOptions): Promise<any> {
+    objectName = this.resolveObjectName(objectName);
     this.logger.debug('FindOne operation', { objectName });
     const driver = this.getDriver(objectName);
     const ast = this.toQueryAST(objectName, query);
@@ -349,6 +451,7 @@ export class ObjectQL implements IDataEngine {
   }
 
   async insert(object: string, data: any | any[], options?: DataEngineInsertOptions): Promise<any> {
+    object = this.resolveObjectName(object);
     this.logger.debug('Insert operation starting', { object, isBatch: Array.isArray(data) });
     const driver = this.getDriver(object);
 
@@ -386,6 +489,7 @@ export class ObjectQL implements IDataEngine {
   }
 
   async update(object: string, data: any, options?: DataEngineUpdateOptions): Promise<any> {
+     object = this.resolveObjectName(object);
      // NOTE: This signature is tricky because Driver expects (obj, id, data) usually.
      // DataEngine protocol puts filter in options.
      this.logger.debug('Update operation starting', { object });
@@ -433,6 +537,7 @@ export class ObjectQL implements IDataEngine {
   }
 
   async delete(object: string, options?: DataEngineDeleteOptions): Promise<any> {
+    object = this.resolveObjectName(object);
     this.logger.debug('Delete operation starting', { object });
     const driver = this.getDriver(object);
 
@@ -474,6 +579,7 @@ export class ObjectQL implements IDataEngine {
   }
 
   async count(object: string, query?: DataEngineCountOptions): Promise<number> {
+     object = this.resolveObjectName(object);
      const driver = this.getDriver(object);
      if (driver.count) {
          const ast = this.toQueryAST(object, { filter: query?.filter });
@@ -485,6 +591,7 @@ export class ObjectQL implements IDataEngine {
   }
 
   async aggregate(object: string, query: DataEngineAggregateOptions): Promise<any[]> {
+      object = this.resolveObjectName(object);
       const driver = this.getDriver(object);
       this.logger.debug(`Aggregate on ${object} using ${driver.name}`, query);
       // Driver needs support for raw aggregation or mapped aggregation

package/src/index.ts

@@ -1,5 +1,13 @@
 // Export Registry
-export { SchemaRegistry } from './registry.js';
+export { 
+  SchemaRegistry,
+  computeFQN,
+  parseFQN,
+  RESERVED_NAMESPACES,
+  DEFAULT_OWNER_PRIORITY,
+  DEFAULT_EXTENDER_PRIORITY,
+} from './registry.js';
+export type { ObjectContributor } from './registry.js';
 
 // Export Protocol Implementation
 export { ObjectStackProtocolImplementation } from './protocol.js';

package/src/plugin.ts

@@ -23,7 +23,9 @@ export class ObjectQLPlugin implements Plugin {
 
   init = async (ctx: PluginContext) => {
     if (!this.ql) {
-        this.ql = new ObjectQL(this.hostContext);
+        // Pass kernel logger to engine to avoid creating a separate pino instance
+        const hostCtx = { ...this.hostContext, logger: ctx.logger };
+        this.ql = new ObjectQL(hostCtx);
     }
     
     // Register as provider for Core Kernel Services

package/src/protocol.ts

@@ -58,10 +58,10 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         };
     }
 
-    async getMetaItems(request: { type: string }) {
+    async getMetaItems(request: { type: string; packageId?: string }) {
         return {
             type: request.type,
-            items: SchemaRegistry.listItems(request.type)
+            items: SchemaRegistry.listItems(request.type, request.packageId)
         };
     }
 
@@ -77,31 +77,72 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         const schema = SchemaRegistry.getObject(request.object);
         if (!schema) throw new Error(`Object ${request.object} not found`);
 
-        let view: any;
+        const fields = schema.fields || {};
+        const fieldKeys = Object.keys(fields);
+
         if (request.type === 'list') {
-            view = {
-                type: 'list',
-                object: request.object,
-                columns: Object.keys(schema.fields || {}).slice(0, 5).map(f => ({
-                    field: f,
-                    label: schema.fields[f].label || f
-                }))
+            // Intelligent Column Selection
+            // 1. Always include 'name' or name-like fields
+            // 2. Limit to 6 columns by default
+            const priorityFields = ['name', 'title', 'label', 'subject', 'email', 'status', 'type', 'category', 'created_at'];
+            
+            let columns = fieldKeys.filter(k => priorityFields.includes(k));
+            
+            // If few priority fields, add others until 5
+            if (columns.length < 5) {
+                const remaining = fieldKeys.filter(k => !columns.includes(k) && k !== 'id' && !fields[k].hidden);
+                columns = [...columns, ...remaining.slice(0, 5 - columns.length)];
+            }
+            
+            // Sort columns by priority then alphabet or schema order
+            // For now, just keep them roughly in order they appear in schema or priority list
+            
+            return {
+                list: {
+                    type: 'grid' as const,
+                    object: request.object,
+                    label: schema.label || schema.name,
+                    columns: columns.map(f => ({
+                        field: f,
+                        label: fields[f]?.label || f,
+                        sortable: true
+                    })),
+                    sort: fields['created_at'] ? ([{ field: 'created_at', order: 'desc' }] as any) : undefined,
+                    searchableFields: columns.slice(0, 3) // Make first few textual columns searchable
+                }
             };
         } else {
-             view = {
-                type: 'form',
-                object: request.object,
-                sections: [
-                    {
-                        label: 'General',
-                        fields: Object.keys(schema.fields || {}).map(f => ({
-                            field: f
-                        }))
-                    }
-                ]
+             // Form View Generation
+             // Simple single-section layout for now
+             const formFields = fieldKeys
+                .filter(k => k !== 'id' && k !== 'created_at' && k !== 'modified_at' && !fields[k].hidden)
+                .map(f => ({
+                    field: f,
+                    label: fields[f]?.label,
+                    required: fields[f]?.required,
+                    readonly: fields[f]?.readonly,
+                    type: fields[f]?.type,
+                    // Default to 2 columns for most, 1 for textareas
+                    colSpan: (fields[f]?.type === 'textarea' || fields[f]?.type === 'html') ? 2 : 1
+                }));
+
+             return {
+                form: {
+                    type: 'simple' as const,
+                    object: request.object,
+                    label: `Edit ${schema.label || schema.name}`,
+                    sections: [
+                        {
+                            label: 'General Information',
+                            columns: 2 as const,
+                            collapsible: false,
+                            collapsed: false,
+                            fields: formFields
+                        }
+                    ]
+                }
             };
         }
-        return view;
     }
 
     async findData(request: { object: string, query?: any }) {