@objectstack/runtime 0.1.0

package/dist/engine.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectQL = void 0;
+const registry_1 = require("./registry");
+/**
+ * ObjectQL Engine
+ */
+class ObjectQL {
+    constructor(hostContext = {}) {
+        this.drivers = new Map();
+        this.defaultDriver = null;
+        this.plugins = new Map();
+        // Host provided context additions (e.g. Server router)
+        this.hostContext = {};
+        this.hostContext = hostContext;
+        console.log(`[ObjectQL] Engine Instance Created`);
+    }
+    /**
+     * Load and Register a Plugin
+     */
+    async use(manifestPart, runtimePart) {
+        // 1. Validate / Register Manifest
+        if (manifestPart) {
+            // 1. Handle Module Imports (commonjs/esm interop)
+            // If the passed object is a module namespace with a default export, use that.
+            const manifest = manifestPart.default || manifestPart;
+            // In a real scenario, we might strictly parse this using Zod
+            // For now, simple ID check
+            const id = manifest.id || manifest.name;
+            if (!id) {
+                console.warn(`[ObjectQL] Plugin manifest missing ID (keys: ${Object.keys(manifest)})`, manifest);
+                // Don't return, try to proceed if it looks like an App (Apps might use 'name' instead of 'id')
+                // return; 
+            }
+            console.log(`[ObjectQL] Loading Plugin: ${id}`);
+            registry_1.SchemaRegistry.registerPlugin(manifest);
+            // Register Objects from App/Plugin
+            if (manifest.objects) {
+                for (const obj of manifest.objects) {
+                    // Ensure object name is registered globally
+                    registry_1.SchemaRegistry.registerObject(obj);
+                    console.log(`[ObjectQL] Registered Object: ${obj.name}`);
+                }
+            }
+            // Register contributions
+            if (manifest.contributes?.kinds) {
+                for (const kind of manifest.contributes.kinds) {
+                    registry_1.SchemaRegistry.registerKind(kind);
+                }
+            }
+            // Register Data Seeding (Lazy execution or immediate?)
+            // We store it in a temporary registry or execute immediately if engine is ready.
+            // Since `use` is init time, we might need to store it and run later in `seed()`.
+            // For this MVP, let's attach it to the manifest object in registry so DataEngine can find it.
+        }
+        // 2. Execute Runtime
+        if (runtimePart) {
+            const pluginDef = runtimePart.default || runtimePart;
+            if (pluginDef.onEnable) {
+                const context = {
+                    ql: this,
+                    logger: console,
+                    // Expose the driver registry helper explicitly if needed
+                    drivers: {
+                        register: (driver) => this.registerDriver(driver)
+                    },
+                    ...this.hostContext
+                };
+                await pluginDef.onEnable(context);
+            }
+        }
+    }
+    /**
+     * Register a new storage driver
+     */
+    registerDriver(driver, isDefault = false) {
+        if (this.drivers.has(driver.name)) {
+            console.warn(`[ObjectQL] Driver ${driver.name} is already registered. Skipping.`);
+            return;
+        }
+        this.drivers.set(driver.name, driver);
+        console.log(`[ObjectQL] Registered driver: ${driver.name} v${driver.version}`);
+        if (isDefault || this.drivers.size === 1) {
+            this.defaultDriver = driver.name;
+        }
+    }
+    /**
+     * Helper to get the target driver
+     */
+    getDriver(object) {
+        // TODO: Look up Object definition to see if it specifies a specific datasource/driver
+        // For now, always return default
+        if (!this.defaultDriver) {
+            throw new Error('[ObjectQL] No drivers registered!');
+        }
+        return this.drivers.get(this.defaultDriver);
+    }
+    /**
+     * Initialize the engine and all registered drivers
+     */
+    async init() {
+        console.log('[ObjectQL] Initializing drivers...');
+        for (const [name, driver] of this.drivers) {
+            try {
+                await driver.connect();
+            }
+            catch (e) {
+                console.error(`[ObjectQL] Failed to connect driver ${name}`, e);
+            }
+        }
+        // In a real app, we would sync schemas here
+    }
+    async destroy() {
+        for (const driver of this.drivers.values()) {
+            await driver.disconnect();
+        }
+    }
+    // ============================================
+    // Data Access Methods
+    // ============================================
+    async find(object, filters = {}, options) {
+        const driver = this.getDriver(object);
+        console.log(`[ObjectQL] Finding ${object} on ${driver.name}...`);
+        // Transform simplified filters to QueryAST
+        // This is a simplified "Mock" transform. 
+        // Real implementation would parse complex JSON or FilterBuilders.
+        const ast = {
+            object, // Add missing required field
+            // Pass through if it looks like AST, otherwise empty
+            // In this demo, we assume the caller passes a simplified object or raw AST
+            filters: filters.filters || undefined,
+            top: filters.top || 100,
+            sort: filters.sort || []
+        };
+        return driver.find(object, ast, options);
+    }
+    async insert(object, data, options) {
+        const driver = this.getDriver(object);
+        console.log(`[ObjectQL] Creating ${object} on ${driver.name}...`);
+        // 1. Validate Schema
+        // 2. Run "Before Insert" Triggers
+        const result = await driver.create(object, data, options);
+        // 3. Run "After Insert" Triggers
+        return result;
+    }
+    async update(object, id, data, options) {
+        const driver = this.getDriver(object);
+        console.log(`[ObjectQL] Updating ${object} ${id}...`);
+        return driver.update(object, id, data, options);
+    }
+    async delete(object, id, options) {
+        const driver = this.getDriver(object);
+        console.log(`[ObjectQL] Deleting ${object} ${id}...`);
+        return driver.delete(object, id, options);
+    }
+}
+exports.ObjectQL = ObjectQL;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { ObjectQL } from './engine';
+export { SchemaRegistry } from './registry';
+export { DataEngine } from './data-engine';
+export { ObjectStackRuntimeProtocol } from './protocol';
+export type { DriverInterface, DriverOptions, QueryAST } from '@objectstack/spec';

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectStackRuntimeProtocol = exports.DataEngine = exports.SchemaRegistry = exports.ObjectQL = void 0;
+// Export core engine
+var engine_1 = require("./engine");
+Object.defineProperty(exports, "ObjectQL", { enumerable: true, get: function () { return engine_1.ObjectQL; } });
+var registry_1 = require("./registry");
+Object.defineProperty(exports, "SchemaRegistry", { enumerable: true, get: function () { return registry_1.SchemaRegistry; } });
+var data_engine_1 = require("./data-engine");
+Object.defineProperty(exports, "DataEngine", { enumerable: true, get: function () { return data_engine_1.DataEngine; } });
+var protocol_1 = require("./protocol");
+Object.defineProperty(exports, "ObjectStackRuntimeProtocol", { enumerable: true, get: function () { return protocol_1.ObjectStackRuntimeProtocol; } });

package/dist/protocol.d.ts

@@ -0,0 +1,68 @@
+import { DataEngine } from './data-engine';
+export interface ApiRequest {
+    params: Record<string, string>;
+    query: Record<string, string | string[]>;
+    body?: any;
+}
+export declare class ObjectStackRuntimeProtocol {
+    private engine;
+    constructor(engine: DataEngine);
+    getDiscovery(): {
+        name: string;
+        version: string;
+        environment: string;
+        routes: {
+            discovery: string;
+            metadata: string;
+            data: string;
+            auth: string;
+            ui: string;
+        };
+        capabilities: {
+            search: boolean;
+            files: boolean;
+        };
+    };
+    getMetaTypes(): {
+        data: {
+            type: string;
+            href: string;
+            count: number;
+        }[];
+    };
+    getMetaItems(typePlural: string): {
+        data: {
+            self: string;
+            path?: string | undefined;
+            id: any;
+            name: any;
+            label: any;
+            type: any;
+            icon: any;
+            description: any;
+        }[];
+    };
+    getMetaItem(typePlural: string, name: string): {};
+    getUiView(objectName: string, type: 'list' | 'form'): {
+        type: string;
+        title: string;
+        columns: {
+            field: string;
+            label: string;
+            width: number;
+        }[];
+        actions: string[];
+    };
+    findData(objectName: string, query: any): Promise<{
+        value: Record<string, any>[];
+        count: number;
+    }>;
+    queryData(objectName: string, body: any): Promise<{
+        value: Record<string, any>[];
+        count: number;
+    }>;
+    getData(objectName: string, id: string): Promise<Record<string, any>>;
+    createData(objectName: string, body: any): Promise<Record<string, any>>;
+    updateData(objectName: string, id: string, body: any): Promise<Record<string, any>>;
+    deleteData(objectName: string, id: string): Promise<boolean>;
+}

package/dist/protocol.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectStackRuntimeProtocol = void 0;
+const registry_1 = require("./registry");
+class ObjectStackRuntimeProtocol {
+    constructor(engine) {
+        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 = registry_1.SchemaRegistry.getRegisteredTypes();
+        return {
+            data: types.map(type => ({
+                type,
+                href: `/api/v1/meta/${type}s`,
+                count: registry_1.SchemaRegistry.listItems(type).length
+            }))
+        };
+    }
+    // 3. Metadata: List Items by Type
+    getMetaItems(typePlural) {
+        // Simple Singularization Mapping
+        const typeMap = {
+            'objects': 'object',
+            'apps': 'app',
+            'flows': 'flow',
+            'reports': 'report',
+            'plugins': 'plugin',
+            'kinds': 'kind'
+        };
+        const type = typeMap[typePlural] || typePlural;
+        const items = registry_1.SchemaRegistry.listItems(type);
+        const summaries = items.map((item) => ({
+            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, name) {
+        const typeMap = {
+            'objects': 'object',
+            'apps': 'app',
+            'flows': 'flow',
+            'reports': 'report',
+            'plugins': 'plugin',
+            'kinds': 'kind'
+        };
+        const type = typeMap[typePlural] || typePlural;
+        const item = registry_1.SchemaRegistry.getItem(type, name);
+        if (!item)
+            throw new Error(`Metadata not found: ${type}/${name}`);
+        return item;
+    }
+    // 5. UI: View Definition
+    getUiView(objectName, type) {
+        const view = this.engine.getView(objectName, type);
+        if (!view)
+            throw new Error('View not generated');
+        return view;
+    }
+    // 6. Data: Find
+    async findData(objectName, query) {
+        return await this.engine.find(objectName, query);
+    }
+    // 7. Data: Query (Advanced AST)
+    async queryData(objectName, body) {
+        return await this.engine.find(objectName, body);
+    }
+    // 8. Data: Get
+    async getData(objectName, id) {
+        return await this.engine.get(objectName, id);
+    }
+    // 9. Data: Create
+    async createData(objectName, body) {
+        return await this.engine.create(objectName, body);
+    }
+    // 10. Data: Update
+    async updateData(objectName, id, body) {
+        return await this.engine.update(objectName, id, body);
+    }
+    // 11. Data: Delete
+    async deleteData(objectName, id) {
+        return await this.engine.delete(objectName, id);
+    }
+}
+exports.ObjectStackRuntimeProtocol = ObjectStackRuntimeProtocol;

package/dist/registry.d.ts

@@ -0,0 +1,55 @@
+import { ServiceObject, App, ObjectStackManifest } from '@objectstack/spec';
+/**
+ * Global Schema Registry
+ * Unified storage for all metadata types (Objects, Apps, Flows, Layouts, etc.)
+ */
+export declare class SchemaRegistry {
+    private static metadata;
+    /**
+     * Universal Register Method
+     * @param type The category of metadata (e.g., 'object', 'app', 'plugin')
+     * @param item The metadata item itself
+     * @param keyField The property to use as the unique key (default: 'name')
+     */
+    static registerItem<T>(type: string, item: T, keyField?: keyof T): void;
+    /**
+     * Universal Get Method
+     */
+    static getItem<T>(type: string, name: string): T | undefined;
+    /**
+     * Universal List Method
+     */
+    static listItems<T>(type: string): T[];
+    /**
+     * Get all registered metadata types (Kinds)
+     */
+    static getRegisteredTypes(): string[];
+    /**
+     * Object Helpers
+     */
+    static registerObject(schema: ServiceObject): void;
+    static getObject(name: string): ServiceObject | undefined;
+    static getAllObjects(): ServiceObject[];
+    /**
+     * App Helpers
+     */
+    static registerApp(app: App): void;
+    static getApp(name: string): App | undefined;
+    static getAllApps(): App[];
+    /**
+     * Plugin Helpers
+     */
+    static registerPlugin(manifest: ObjectStackManifest): void;
+    static getAllPlugins(): ObjectStackManifest[];
+    /**
+     * Kind (Metadata Type) Helpers
+     */
+    static registerKind(kind: {
+        id: string;
+        globs: string[];
+    }): void;
+    static getAllKinds(): {
+        id: string;
+        globs: string[];
+    }[];
+}

package/dist/registry.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaRegistry = void 0;
+/**
+ * Global Schema Registry
+ * Unified storage for all metadata types (Objects, Apps, Flows, Layouts, etc.)
+ */
+class SchemaRegistry {
+    /**
+     * Universal Register Method
+     * @param type The category of metadata (e.g., 'object', 'app', 'plugin')
+     * @param item The metadata item itself
+     * @param keyField The property to use as the unique key (default: 'name')
+     */
+    static registerItem(type, item, keyField = 'name') {
+        if (!this.metadata.has(type)) {
+            this.metadata.set(type, new Map());
+        }
+        const collection = this.metadata.get(type);
+        const key = String(item[keyField]);
+        if (collection.has(key)) {
+            console.warn(`[Registry] Overwriting ${type}: ${key}`);
+        }
+        collection.set(key, item);
+        console.log(`[Registry] Registered ${type}: ${key}`);
+    }
+    /**
+     * Universal Get Method
+     */
+    static getItem(type, name) {
+        return this.metadata.get(type)?.get(name);
+    }
+    /**
+     * Universal List Method
+     */
+    static listItems(type) {
+        return Array.from(this.metadata.get(type)?.values() || []);
+    }
+    /**
+     * Get all registered metadata types (Kinds)
+     */
+    static getRegisteredTypes() {
+        return Array.from(this.metadata.keys());
+    }
+    // ==========================================
+    // Typed Helper Methods (Shortcuts)
+    // ==========================================
+    /**
+     * Object Helpers
+     */
+    static registerObject(schema) {
+        this.registerItem('object', schema, 'name');
+    }
+    static getObject(name) {
+        return this.getItem('object', name);
+    }
+    static getAllObjects() {
+        return this.listItems('object');
+    }
+    /**
+     * App Helpers
+     */
+    static registerApp(app) {
+        this.registerItem('app', app, 'name');
+    }
+    static getApp(name) {
+        return this.getItem('app', name);
+    }
+    static getAllApps() {
+        return this.listItems('app');
+    }
+    /**
+     * Plugin Helpers
+     */
+    static registerPlugin(manifest) {
+        this.registerItem('plugin', manifest, 'id');
+    }
+    static getAllPlugins() {
+        return this.listItems('plugin');
+    }
+    /**
+     * Kind (Metadata Type) Helpers
+     */
+    static registerKind(kind) {
+        this.registerItem('kind', kind, 'id');
+    }
+    static getAllKinds() {
+        return this.listItems('kind');
+    }
+}
+exports.SchemaRegistry = SchemaRegistry;
+// Nested Map: Type -> Name/ID -> MetadataItem
+SchemaRegistry.metadata = new Map();

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@objectstack/runtime",
+  "version": "0.1.0",
+  "description": "ObjectStack Core Runtime & Query Engine",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "@objectstack/spec": "0.1.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w"
+  }
+}

package/src/data-engine.ts

@@ -0,0 +1,169 @@
+import { ServiceObject } from '@objectstack/spec';
+import { SchemaRegistry } from './registry';
+import { ObjectQL } from './engine';
+
+/**
+ * Server Data Engine Wrapper
+ * 
+ * This class is now a thin wrapper that initializes the ObjectQL Engine 
+ * with the appropriate Server-Side configuration (Registry, Drivers).
+ * 
+ * The core logic has been moved to @objectstack/objectql.
+ */
+export class DataEngine {
+  public ql: ObjectQL;
+  private plugins: any[];
+
+  constructor(plugins: any[] = []) {
+    // 1. Initialize Engine with Host Context (Simulated OS services)
+    this.ql = new ObjectQL({
+        env: process.env.NODE_ENV || 'development'
+    });
+    this.plugins = plugins;
+  }
+
+  async start() {
+    console.log('[DataEngine] Starting...');
+    
+    // 0. Register Provided Plugins
+    this.plugins.forEach(p => {
+        console.log(`[DataEngine] Loading Plugin: ${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(`[DataEngine] 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.ql.registerDriver(driver);
+    } catch (e) {
+        // Ignore if not present
+    }
+    
+    // 2. Initialize Engine
+    await this.ql.init();
+
+
+    // 3. Seed Data
+    await this.seed();
+  }
+
+  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(`[DataEngine] Seeding data for ${app.name || app.id}...`);
+                for (const seed of app.data) {
+                     try {
+                        // Check if data exists
+                        const existing = await this.ql.find(seed.object, { top: 1 });
+                        if (existing.length === 0) {
+                             console.log(`[DataEngine] Inserting ${seed.records.length} records into ${seed.object}`);
+                             for (const record of seed.records) {
+                                 await this.ql.insert(seed.object, record);
+                             }
+                        }
+                     } catch (e) {
+                         console.warn(`[DataEngine] 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.ql.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.ql.find(objectName, { top: 1 }); // Mock implementation
+    return results[0];
+  }
+
+  async create(objectName: string, data: any) {
+     this.ensureSchema(objectName);
+     return this.ql.insert(objectName, data);
+  }
+
+  async update(objectName: string, id: string, data: any) {
+    this.ensureSchema(objectName);
+    return this.ql.update(objectName, id, data);
+  }
+
+  async delete(objectName: string, id: string) {
+    this.ensureSchema(objectName);
+    return this.ql.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;
+  }
+}