@objectstack/runtime 0.1.0

package/src/engine.ts

@@ -0,0 +1,189 @@
+import { DriverInterface, DriverOptions, QueryAST, ObjectStackManifest, ManifestSchema } from '@objectstack/spec';
+import { SchemaRegistry } from './registry';
+
+/**
+ * Host Context provided to plugins
+ */
+export interface PluginContext {
+  ql: ObjectQL;
+  logger: Console;
+  // Extensible map for host-specific globals (like HTTP Router, etc.)
+  [key: string]: any;
+}
+
+/**
+ * ObjectQL Engine
+ */
+export class ObjectQL {
+  private drivers = new Map<string, DriverInterface>();
+  private defaultDriver: string | null = null;
+  private plugins = new Map<string, any>();
+  
+  // Host provided context additions (e.g. Server router)
+  private hostContext: Record<string, any> = {};
+
+  constructor(hostContext: Record<string, any> = {}) {
+    this.hostContext = hostContext;
+    console.log(`[ObjectQL] Engine Instance Created`);
+  }
+
+  /**
+   * Load and Register a Plugin
+   */
+  async use(manifestPart: any, runtimePart?: any) {
+    // 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}`);
+      SchemaRegistry.registerPlugin(manifest as ObjectStackManifest);
+
+      // Register Objects from App/Plugin
+      if (manifest.objects) {
+        for (const obj of manifest.objects) {
+            // Ensure object name is registered globally
+            SchemaRegistry.registerObject(obj);
+            console.log(`[ObjectQL] Registered Object: ${obj.name}`);
+        }
+      }
+
+      // Register contributions
+       if (manifest.contributes?.kinds) {
+          for (const kind of manifest.contributes.kinds) {
+            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 as any).default || runtimePart;
+       if (pluginDef.onEnable) {
+          const context: PluginContext = {
+            ql: this,
+            logger: console,
+            // Expose the driver registry helper explicitly if needed
+            drivers: {
+                register: (driver: DriverInterface) => this.registerDriver(driver)
+            },
+            ...this.hostContext
+          };
+          
+          await pluginDef.onEnable(context);
+       }
+    }
+  }
+
+  /**
+   * Register a new storage driver
+   */
+  registerDriver(driver: DriverInterface, isDefault: boolean = 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
+   */
+  private getDriver(object: string): DriverInterface {
+    // 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: string, filters: any = {}, options?: DriverOptions) {
+    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: QueryAST = {
+       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: string, data: Record<string, any>, options?: DriverOptions) {
+    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: string, id: string, data: Record<string, any>, options?: DriverOptions) {
+    const driver = this.getDriver(object);
+    console.log(`[ObjectQL] Updating ${object} ${id}...`);
+    return driver.update(object, id, data, options);
+  }
+
+  async delete(object: string, id: string, options?: DriverOptions) {
+    const driver = this.getDriver(object);
+    console.log(`[ObjectQL] Deleting ${object} ${id}...`);
+    return driver.delete(object, id, options);
+  }
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+// Export core engine
+export { ObjectQL } from './engine';
+export { SchemaRegistry } from './registry';
+export { DataEngine } from './data-engine';
+export { ObjectStackRuntimeProtocol } from './protocol';
+
+
+
+// Re-export common types from spec for convenience
+export type { DriverInterface, DriverOptions, QueryAST } from '@objectstack/spec';

package/src/protocol.ts

@@ -0,0 +1,129 @@
+import { SchemaRegistry } from './registry';
+import { DataEngine } from './data-engine';
+
+export interface ApiRequest {
+    params: Record<string, string>;
+    query: Record<string, string | string[]>;
+    body?: any;
+}
+
+export class ObjectStackRuntimeProtocol {
+    private engine: DataEngine;
+
+    constructor(engine: DataEngine) {
+        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/registry.ts

@@ -0,0 +1,107 @@
+import { ServiceObject, App, ObjectStackManifest } from '@objectstack/spec';
+
+/**
+ * Global Schema Registry
+ * Unified storage for all metadata types (Objects, Apps, Flows, Layouts, etc.)
+ */
+export class SchemaRegistry {
+  // Nested Map: Type -> Name/ID -> MetadataItem
+  private static metadata = new Map<string, Map<string, any>>();
+
+  /**
+   * 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 = 'name' as keyof T) {
+    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<T>(type: string, name: string): T | undefined {
+    return this.metadata.get(type)?.get(name) as T;
+  }
+
+  /**
+   * Universal List Method
+   */
+  static listItems<T>(type: string): T[] {
+    return Array.from(this.metadata.get(type)?.values() || []) as T[];
+  }
+
+  /**
+   * Get all registered metadata types (Kinds)
+   */
+  static getRegisteredTypes(): string[] {
+    return Array.from(this.metadata.keys());
+  }
+
+  // ==========================================
+  // Typed Helper Methods (Shortcuts)
+  // ==========================================
+
+  /**
+   * Object Helpers
+   */
+  static registerObject(schema: ServiceObject) {
+    this.registerItem('object', schema, 'name');
+  }
+
+  static getObject(name: string): ServiceObject | undefined {
+    return this.getItem<ServiceObject>('object', name);
+  }
+
+  static getAllObjects(): ServiceObject[] {
+    return this.listItems<ServiceObject>('object');
+  }
+
+  /**
+   * App Helpers
+   */
+  static registerApp(app: App) {
+    this.registerItem('app', app, 'name');
+  }
+
+  static getApp(name: string): App | undefined {
+    return this.getItem<App>('app', name);
+  }
+
+  static getAllApps(): App[] {
+    return this.listItems<App>('app');
+  }
+
+  /**
+   * Plugin Helpers
+   */
+  static registerPlugin(manifest: ObjectStackManifest) {
+    this.registerItem('plugin', manifest, 'id');
+  }
+
+  static getAllPlugins(): ObjectStackManifest[] {
+    return this.listItems<ObjectStackManifest>('plugin');
+  }
+
+  /**
+   * Kind (Metadata Type) Helpers
+   */
+  static registerKind(kind: { id: string, globs: string[] }) {
+    this.registerItem('kind', kind, 'id');
+  }
+  
+  static getAllKinds(): { id: string, globs: string[] }[] {
+    return this.listItems('kind');
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"]
+}