@objectstack/runtime 0.4.2 → 0.6.1

package/src/kernel.ts

@@ -1,203 +0,0 @@
-import { ServiceObject } from '@objectstack/spec/data';
-import { SchemaRegistry, ObjectQL } from '@objectstack/objectql';
-
-/**
- * ObjectStack Kernel (Microkernel)
- * 
- * The central container orchestrating the application lifecycle,
- * plugins, and the core ObjectQL engine.
- */
-export class ObjectStackKernel {
-  public ql?: ObjectQL; // Will be set by ObjectQLPlugin or fallback initialization
-  private plugins: any[];
-
-  constructor(plugins: any[] = []) {
-    this.plugins = plugins;
-    
-    // Check if any plugin provides ObjectQL via type: 'objectql'
-    // This aligns with the manifest schema that supports objectql as a package type
-    const hasObjectQLPlugin = plugins.some(p => 
-      p && typeof p === 'object' && p.type === 'objectql'
-    );
-    
-    if (!hasObjectQLPlugin) {
-      // Backward compatibility: Initialize ObjectQL directly if no plugin provides it
-      console.warn('[Kernel] No ObjectQL plugin found, using default initialization. Consider using ObjectQLPlugin.');
-      this.ql = new ObjectQL({
-        env: process.env.NODE_ENV || 'development'
-      });
-    }
-  }
-
-  /**
-   * Ensure ObjectQL engine is initialized
-   * @throws Error if ObjectQL is not available
-   */
-  private ensureObjectQL(): ObjectQL {
-    if (!this.ql) {
-      throw new Error('[Kernel] ObjectQL engine not initialized. Ensure ObjectQLPlugin is registered or kernel is properly initialized.');
-    }
-    return this.ql;
-  }
-
-  async start() {
-    console.log('[Kernel] Starting...');
-    
-    // 0. Register Provided Plugins
-    for (const p of this.plugins) {
-        // Check if it is a Runtime Plugin (System Capability)
-        if ('onStart' in p || 'install' in p) {
-             console.log(`[Kernel] Loading Runtime Plugin: ${p.name}`);
-             if (p.install) await p.install({ engine: this });
-             continue;
-        }
-        
-        // Otherwise treat as App Manifest
-        console.log(`[Kernel] Loading App Manifest: ${p.id || p.name}`);
-        SchemaRegistry.registerPlugin(p);
-        
-        // Register Objects from App/Plugin
-        if (p.objects) {
-            for (const obj of p.objects) {
-                SchemaRegistry.registerObject(obj);
-                console.log(`[Kernel] Registered Object: ${obj.name}`);
-            }
-        }
-    }
-
-    // 1. Load Drivers (Default to Memory if none provided in plugins)
-    // TODO: Detect driver from plugins. For now, we still hard load memory driver if needed?
-    // In strict mode, user should pass driver in plugins array (DriverManifest).
-    // check if driver is registered
-    
-    // For Backwards Compat / Easy Dev, try dynamic import of memory driver if installed
-    try {
-        // @ts-ignore
-        const { InMemoryDriver } = await import('@objectstack/driver-memory');
-        const driver = new InMemoryDriver();
-        this.ensureObjectQL().registerDriver(driver);
-    } catch (e) {
-        // Ignore if not present
-    }
-    
-    // 2. Initialize Engine
-    await this.ensureObjectQL().init();
-
-
-    // 3. Seed Data
-    await this.seed();
-
-    // 4. Start Runtime Plugins
-    for (const p of this.plugins) {
-        if (('onStart' in p) && typeof p.onStart === 'function') {
-            console.log(`[Kernel] Starting Plugin: ${p.name}`);
-            await p.onStart({ engine: this });
-        }
-    }
-  }
-
-  async seed() {
-    // If no driver registered yet, this might fail or wait. 
-    // In real world, we wait for 'ready' event.
-    try {
-        // Mock System Table
-        try {
-             // We don't have SystemStatus defined in schema usually, skipping for general engine
-             // await this.ql.insert('SystemStatus', { status: 'OK', uptime: 0 });
-        } catch {}
-
-        // Iterate over all registered plugins/apps and check for 'data' property in manifest
-
-        const plugins = SchemaRegistry.getRegisteredTypes(); // This returns types like 'plugin', 'app'
-        
-        // This is a bit hacky because we don't have a direct "getAllManifests" API exposed easily
-        // We will iterate known apps for now, or improve Registry API later.
-        // Actually, SchemaRegistry.listItems('app') returns the manifests!
-        
-        const apps = [...SchemaRegistry.listItems('app'), ...SchemaRegistry.listItems('plugin')];
-        
-        for (const appItem of apps) {
-            const app = appItem as any; // Cast to access data prop safely
-            if (app.data && Array.isArray(app.data)) {
-                console.log(`[Kernel] Seeding data for ${app.name || app.id}...`);
-                for (const seed of app.data) {
-                     try {
-                        // Check if data exists
-                        const existing = await this.ensureObjectQL().find(seed.object, { top: 1 });
-                        if (existing.length === 0) {
-                             console.log(`[Kernel] Inserting ${seed.records.length} records into ${seed.object}`);
-                             for (const record of seed.records) {
-                                 await this.ensureObjectQL().insert(seed.object, record);
-                             }
-                        }
-                     } catch (e) {
-                         console.warn(`[Kernel] Failed to seed ${seed.object}`, e);
-                     }
-                }
-            }
-        }
-
-    } catch(e) {
-        console.warn('Seed failed (driver might not be ready):', e);
-    }
-  }
-  
-  // Forward methods to ObjectQL
-  async find(objectName: string, query: any) {
-    this.ensureSchema(objectName);
-    const results = await this.ensureObjectQL().find(objectName, { top: 100 });
-    return { value: results, count: results.length };
-  }
-
-  async get(objectName: string, id: string) {
-    this.ensureSchema(objectName);
-    // Find One
-    const results = await this.ensureObjectQL().find(objectName, { top: 1 }); // Mock implementation
-    return results[0];
-  }
-
-  async create(objectName: string, data: any) {
-     this.ensureSchema(objectName);
-     return this.ensureObjectQL().insert(objectName, data);
-  }
-
-  async update(objectName: string, id: string, data: any) {
-    this.ensureSchema(objectName);
-    return this.ensureObjectQL().update(objectName, id, data);
-  }
-
-  async delete(objectName: string, id: string) {
-    this.ensureSchema(objectName);
-    return this.ensureObjectQL().delete(objectName, id);
-  }
-
-  // [New Methods for ObjectUI]
-  getMetadata(objectName: string) {
-    return this.ensureSchema(objectName);
-  }
-  
-  getView(objectName: string, viewType: 'list' | 'form' = 'list') {
-    const schema = this.ensureSchema(objectName);
-
-    // Auto-Scaffold Default View
-    if (viewType === 'list') {
-      return {
-        type: 'datagrid',
-        title: `${schema.label || objectName} List`,
-        columns: Object.keys(schema.fields || {}).map(key => ({
-            field: key,
-            label: schema.fields?.[key]?.label || key,
-            width: 150
-        })),
-        actions: ['create', 'edit', 'delete']
-      };
-    }
-    return null;
-  }
-
-  private ensureSchema(name: string): ServiceObject {
-    const schema = SchemaRegistry.getObject(name);
-    if (!schema) throw new Error(`Unknown object: ${name}`);
-    return schema;
-  }
-}

package/src/objectql-plugin.ts

@@ -1,47 +0,0 @@
-import { ObjectQL } from '@objectstack/objectql';
-import { RuntimePlugin, RuntimeContext } from '@objectstack/types';
-
-/**
- * ObjectQL Engine Plugin
- * 
- * Registers the ObjectQL engine instance with the kernel.
- * This allows users to provide their own ObjectQL implementation or configuration.
- * 
- * Usage:
- * - new ObjectQLPlugin() - Creates new ObjectQL with default settings
- * - new ObjectQLPlugin(existingQL) - Uses existing ObjectQL instance
- * - new ObjectQLPlugin(undefined, { custom: 'context' }) - Creates new ObjectQL with custom context
- */
-export class ObjectQLPlugin implements RuntimePlugin {
-  name = 'com.objectstack.engine.objectql';
-  type = 'objectql' as const;
-  
-  private ql: ObjectQL;
-
-  /**
-   * @param ql - Existing ObjectQL instance to use (optional)
-   * @param hostContext - Host context for new ObjectQL instance (ignored if ql is provided)
-   */
-  constructor(ql?: ObjectQL, hostContext?: Record<string, any>) {
-    if (ql && hostContext) {
-      console.warn('[ObjectQLPlugin] Both ql and hostContext provided. hostContext will be ignored.');
-    }
-    
-    if (ql) {
-      this.ql = ql;
-    } else {
-      this.ql = new ObjectQL(hostContext || {
-        env: process.env.NODE_ENV || 'development'
-      });
-    }
-  }
-
-  /**
-   * Install the ObjectQL engine into the kernel
-   */
-  async install(ctx: RuntimeContext) {
-    // Attach the ObjectQL engine to the kernel
-    ctx.engine.ql = this.ql;
-    console.log('[ObjectQLPlugin] ObjectQL engine registered');
-  }
-}

package/src/protocol.ts

@@ -1,129 +0,0 @@
-import { SchemaRegistry } from '@objectstack/objectql';
-import { ObjectStackKernel } from './kernel';
-
-export interface ApiRequest {
-    params: Record<string, string>;
-    query: Record<string, string | string[]>;
-    body?: any;
-}
-
-export class ObjectStackRuntimeProtocol {
-    private engine: ObjectStackKernel;
-
-    constructor(engine: ObjectStackKernel) {
-        this.engine = engine;
-    }
-
-    // 1. Discovery
-    getDiscovery() {
-        return {
-            name: 'ObjectOS Server',
-            version: '1.0.0',
-            environment: process.env.NODE_ENV || 'development',
-            routes: {
-                discovery: '/api/v1',
-                metadata: '/api/v1/meta',
-                data: '/api/v1/data',
-                auth: '/api/v1/auth',
-                ui: '/api/v1/ui'
-            },
-            capabilities: {
-                search: true,
-                files: true
-            }
-        };
-    }
-
-    // 2. Metadata: List Types
-    getMetaTypes() {
-        const types = SchemaRegistry.getRegisteredTypes();
-        return {
-            data: types.map(type => ({
-                type,
-                href: `/api/v1/meta/${type}s`,
-                count: SchemaRegistry.listItems(type).length
-            }))
-        };
-    }
-
-    // 3. Metadata: List Items by Type
-    getMetaItems(typePlural: string) {
-        // Simple Singularization Mapping
-        const typeMap: Record<string, string> = {
-            'objects': 'object',
-            'apps': 'app',
-            'flows': 'flow',
-            'reports': 'report',
-            'plugins': 'plugin',
-            'kinds': 'kind'
-        };
-        const type = typeMap[typePlural] || typePlural;
-        const items = SchemaRegistry.listItems(type);
-
-        const summaries = items.map((item: any) => ({
-            id: item.id,
-            name: item.name,
-            label: item.label,
-            type: item.type,
-            icon: item.icon,
-            description: item.description,
-            ...(type === 'object' ? { path: `/api/v1/data/${item.name}` } : {}),
-            self: `/api/v1/meta/${typePlural}/${item.name || item.id}`
-        }));
-
-        return { data: summaries };
-    }
-
-    // 4. Metadata: Get Single Item
-    getMetaItem(typePlural: string, name: string) {
-        const typeMap: Record<string, string> = {
-            'objects': 'object',
-            'apps': 'app',
-            'flows': 'flow',
-            'reports': 'report',
-            'plugins': 'plugin',
-            'kinds': 'kind'
-        };
-        const type = typeMap[typePlural] || typePlural;
-        const item = SchemaRegistry.getItem(type, name);
-        if (!item) throw new Error(`Metadata not found: ${type}/${name}`);
-        return item;
-    }
-
-    // 5. UI: View Definition
-    getUiView(objectName: string, type: 'list' | 'form') {
-        const view = this.engine.getView(objectName, type);
-        if (!view) throw new Error('View not generated');
-        return view;
-    }
-
-    // 6. Data: Find
-    async findData(objectName: string, query: any) {
-        return await this.engine.find(objectName, query);
-    }
-
-    // 7. Data: Query (Advanced AST)
-    async queryData(objectName: string, body: any) {
-        return await this.engine.find(objectName, body);
-    }
-
-    // 8. Data: Get
-    async getData(objectName: string, id: string) {
-        return await this.engine.get(objectName, id);
-    }
-
-    // 9. Data: Create
-    async createData(objectName: string, body: any) {
-        return await this.engine.create(objectName, body);
-    }
-
-    // 10. Data: Update
-    async updateData(objectName: string, id: string, body: any) {
-        return await this.engine.update(objectName, id, body);
-    }
-
-    // 11. Data: Delete
-    async deleteData(objectName: string, id: string) {
-        return await this.engine.delete(objectName, id);
-    }
-}

package/src/types.ts

@@ -1,11 +0,0 @@
-import { ObjectStackKernel } from './kernel';
-
-export interface RuntimeContext {
-    engine: ObjectStackKernel;
-}
-
-export interface RuntimePlugin {
-    name: string;
-    install?: (ctx: RuntimeContext) => void | Promise<void>;
-    onStart?: (ctx: RuntimeContext) => void | Promise<void>;
-}