@objectstack/runtime 1.0.6 → 1.0.8

package/src/app-plugin.ts

@@ -11,6 +11,7 @@ import { Plugin, PluginContext } from '@objectstack/core';
  */
 export class AppPlugin implements Plugin {
     name: string;
+    type = 'app';
     version?: string;
     
     private bundle: any;
@@ -96,5 +97,29 @@ export class AppPlugin implements Plugin {
         } else {
              ctx.logger.debug('No runtime.onEnable function found', { appId });
         }
+
+        // Data Seeding
+        // Check for 'data' in manifest (Legacy or Stack Definition)
+        const manifest = this.bundle.manifest || this.bundle;
+        if (manifest && Array.isArray(manifest.data)) {
+             ctx.logger.info(`[AppPlugin] Found initial data for ${appId}`, { count: manifest.data.length });
+             for (const dataset of manifest.data) {
+                 if (dataset.object && Array.isArray(dataset.records)) {
+                     ctx.logger.info(`[Seeder] Seeding ${dataset.records.length} records for ${dataset.object}`);
+                     for (const record of dataset.records) {
+                          try {
+                              // Use ObjectQL engine to insert data
+                              // This ensures driver resolution and hook execution
+                              // Use 'insert' which corresponds to 'create' in driver
+                              await ql.insert(dataset.object, record);
+                          } catch (err: any) {
+                              // Ignore duplicate errors if needed, or log/warn
+                              ctx.logger.warn(`[Seeder] Failed to insert ${dataset.object} record:`, { error: err.message });
+                          }
+                     }
+                 }
+             }
+             ctx.logger.info('[Seeder] Data seeding complete.');
+        }
     }
 }

package/src/driver-plugin.ts

@@ -16,6 +16,7 @@ import { Plugin, PluginContext } from '@objectstack/core';
  */
 export class DriverPlugin implements Plugin {
     name: string;
+    type = 'driver';
     version = '1.0.0';
     // dependencies = ['com.objectstack.engine.objectql']; // Removed: Driver is a producer, not strictly a consumer during init
 
@@ -39,6 +40,35 @@ export class DriverPlugin implements Plugin {
 
     start = async (ctx: PluginContext) => {
         // Drivers don't need start phase, initialization happens in init
+        // Auto-configure alias for shorter access if it follows reverse domain standard
+        if (this.name.startsWith('com.objectstack.driver.')) {
+            // const shortName = this.name.split('.').pop();
+            // Optional: ctx.registerService(`driver.${shortName}`, this.driver);
+        }
+
+        // Auto-configure 'default' datasource if none exists
+        // We do this in 'start' phase to ensure metadata service is likely available
+        try {
+            const metadata = ctx.getService<any>('metadata');
+            if (metadata && metadata.addDatasource) {
+                // Check if default datasource exists
+                const datasources = metadata.getDatasources ? metadata.getDatasources() : [];
+                const hasDefault = datasources.some((ds: any) => ds.name === 'default');
+
+                if (!hasDefault) {
+                    ctx.logger.info(`[DriverPlugin] No 'default' datasource found. Auto-configuring '${this.driver.name}' as default.`);
+                    await metadata.addDatasource({
+                        name: 'default',
+                        driver: this.driver.name, // The driver's internal name (e.g. com.objectstack.driver.memory)
+                    });
+                }
+            }
+        } catch (e) {
+            // Metadata service might not be ready or available, which is fine
+            // We just skip auto-configuration
+            ctx.logger.debug('[DriverPlugin] Failed to auto-configure default datasource (Metadata service missing?)', { error: e });
+        }
+
         ctx.logger.debug('Driver plugin started', { driverName: this.driver.name || 'unknown' });
     }
 }

package/src/rest-server.ts

@@ -213,6 +213,26 @@ export class RestServer {
             handler: async (_req: any, res: any) => {
                 try {
                     const discovery = await this.protocol.getDiscovery({});
+                    
+                    // Override discovery information with actual server configuration
+                    discovery.version = this.config.api.version;
+                    
+                    if (discovery.endpoints) {
+                        // Ensure endpoints match the actual mounted paths
+                        if (this.config.api.enableCrud) {
+                            discovery.endpoints.data = `${basePath}${this.config.crud.dataPrefix}`;
+                        }
+                        
+                        if (this.config.api.enableMetadata) {
+                            discovery.endpoints.metadata = `${basePath}${this.config.metadata.prefix}`;
+                        }
+
+                        // Align auth endpoint with the versioned base path if present
+                        if (discovery.endpoints.auth) {
+                            discovery.endpoints.auth = `${basePath}/auth`;
+                        }
+                    }
+
                     res.json(discovery);
                 } catch (error: any) {
                     res.status(500).json({ error: error.message });