@objectstack/runtime 3.2.1 → 3.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/runtime",
-  "version": "3.2.1",
+  "version": "3.2.3",
   "license": "Apache-2.0",
   "description": "ObjectStack Core Runtime & Query Engine",
   "type": "module",
@@ -15,10 +15,10 @@
   },
   "dependencies": {
     "zod": "^4.3.6",
-    "@objectstack/core": "3.2.1",
-    "@objectstack/spec": "3.2.1",
-    "@objectstack/types": "3.2.1",
-    "@objectstack/rest": "3.2.1"
+    "@objectstack/core": "3.2.3",
+    "@objectstack/rest": "3.2.3",
+    "@objectstack/spec": "3.2.3",
+    "@objectstack/types": "3.2.3"
   },
   "devDependencies": {
     "typescript": "^5.0.0",

package/src/app-plugin.ts

@@ -1,6 +1,8 @@
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 
 import { Plugin, PluginContext } from '@objectstack/core';
+import { SeedLoaderService } from './seed-loader.js';
+import type { IMetadataService } from '@objectstack/spec/contracts';
 
 /**
  * AppPlugin
@@ -127,24 +129,60 @@ export class AppPlugin implements Plugin {
         
         if (seedDatasets.length > 0) {
              ctx.logger.info(`[AppPlugin] Found ${seedDatasets.length} seed datasets for ${appId}`);
-             for (const dataset of seedDatasets) {
-                 if (dataset.object && Array.isArray(dataset.records)) {
-                     const objectFQN = toFQN(dataset.object);
-                     ctx.logger.info(`[Seeder] Seeding ${dataset.records.length} records for ${objectFQN}`);
+
+             // Normalize dataset object names to FQN
+             const normalizedDatasets = seedDatasets
+                 .filter((d: any) => d.object && Array.isArray(d.records))
+                 .map((d: any) => ({
+                     ...d,
+                     object: toFQN(d.object),
+                 }));
+
+             // Use SeedLoaderService for metadata-driven loading with reference resolution
+             try {
+                 const metadata = ctx.getService('metadata') as IMetadataService | undefined;
+                 if (metadata) {
+                     const seedLoader = new SeedLoaderService(ql, metadata, ctx.logger);
+                     const { SeedLoaderRequestSchema } = await import('@objectstack/spec/data');
+                     const request = SeedLoaderRequestSchema.parse({
+                         datasets: normalizedDatasets,
+                         config: { defaultMode: 'upsert', multiPass: true },
+                     });
+                     const result = await seedLoader.load(request);
+                     ctx.logger.info('[Seeder] Seed loading complete', {
+                         inserted: result.summary.totalInserted,
+                         updated: result.summary.totalUpdated,
+                         errors: result.errors.length,
+                     });
+                 } else {
+                     // Fallback: basic insert when metadata service is not available
+                     ctx.logger.debug('[Seeder] No metadata service; using basic insert fallback');
+                     for (const dataset of normalizedDatasets) {
+                         ctx.logger.info(`[Seeder] Seeding ${dataset.records.length} records for ${dataset.object}`);
+                         for (const record of dataset.records) {
+                             try {
+                                 await ql.insert(dataset.object, record);
+                             } catch (err: any) {
+                                 ctx.logger.warn(`[Seeder] Failed to insert ${dataset.object} record:`, { error: err.message });
+                             }
+                         }
+                     }
+                     ctx.logger.info('[Seeder] Data seeding complete.');
+                 }
+             } catch (err: any) {
+                 // If SeedLoaderService fails (e.g., metadata not available), fall back to basic insert
+                 ctx.logger.warn('[Seeder] SeedLoaderService failed, falling back to basic insert', { error: err.message });
+                 for (const dataset of normalizedDatasets) {
                      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(objectFQN, record);
-                          } catch (err: any) {
-                              // Ignore duplicate errors if needed, or log/warn
-                              ctx.logger.warn(`[Seeder] Failed to insert ${objectFQN} record:`, { error: err.message });
-                          }
+                         try {
+                             await ql.insert(dataset.object, record);
+                         } catch (insertErr: any) {
+                             ctx.logger.warn(`[Seeder] Failed to insert ${dataset.object} record:`, { error: insertErr.message });
+                         }
                      }
                  }
+                 ctx.logger.info('[Seeder] Data seeding complete (fallback).');
              }
-             ctx.logger.info('[Seeder] Data seeding complete.');
         }
     }
 }

package/src/http-dispatcher.test.ts

@@ -216,7 +216,7 @@ describe('HttpDispatcher', () => {
             it('should resolve analytics service from Promise (async factory)', async () => {
                 const mockAnalytics = {
                     query: vi.fn().mockResolvedValue({ rows: [{ id: 1 }], total: 1 }),
-                    getMetadata: vi.fn().mockResolvedValue({ tables: ['t1'] }),
+                    getMeta: vi.fn().mockResolvedValue({ tables: ['t1'] }),
                     generateSql: vi.fn().mockResolvedValue({ sql: 'SELECT 1' }),
                 };
                 // Inject as Promise (simulates async factory registration)
@@ -245,7 +245,7 @@ describe('HttpDispatcher', () => {
 
             it('should handle GET /analytics/meta with async service', async () => {
                 const mockAnalytics = {
-                    getMetadata: vi.fn().mockResolvedValue({ tables: ['users', 'orders'] }),
+                    getMeta: vi.fn().mockResolvedValue({ tables: ['users', 'orders'] }),
                 };
                 (kernel as any).getService = vi.fn().mockResolvedValue(mockAnalytics);
 
@@ -600,7 +600,7 @@ describe('HttpDispatcher', () => {
 
     describe('handleData', () => {
         it('should pass expand and select to broker for GET /data/:object/:id', async () => {
-            mockBroker.call.mockResolvedValue({ object: 'order_item', id: 'oi_1', record: { _id: 'oi_1' } });
+            mockBroker.call.mockResolvedValue({ object: 'order_item', id: 'oi_1', record: { id: 'oi_1' } });
 
             const result = await dispatcher.handleData(
                 '/order_item/oi_1', 'GET', {},

package/src/http-dispatcher.ts

@@ -526,7 +526,7 @@ export class HttpDispatcher {
      * Handles Analytics requests
      * path: sub-path after /analytics/
      */
-    async handleAnalytics(path: string, method: string, body: any, context: HttpProtocolContext): Promise<HttpDispatcherResult> {
+    async handleAnalytics(path: string, method: string, body: any, _context: HttpProtocolContext): Promise<HttpDispatcherResult> {
         const analyticsService = await this.getService(CoreServiceName.enum.analytics);
         if (!analyticsService) return { handled: false }; // 404 handled by caller if unhandled
 
@@ -535,20 +535,20 @@ export class HttpDispatcher {
 
         // POST /analytics/query
         if (subPath === 'query' && m === 'POST') {
-            const result = await analyticsService.query(body, { request: context.request });
+            const result = await analyticsService.query(body);
             return { handled: true, response: this.success(result) };
         }
 
         // GET /analytics/meta
         if (subPath === 'meta' && m === 'GET') {
-            const result = await analyticsService.getMetadata({ request: context.request });
+            const result = await analyticsService.getMeta();
              return { handled: true, response: this.success(result) };
         }
 
         // POST /analytics/sql (Dry-run or debug)
         if (subPath === 'sql' && m === 'POST') {
              // Assuming service has generateSql method
-             const result = await analyticsService.generateSql(body, { request: context.request });
+             const result = await analyticsService.generateSql(body);
              return { handled: true, response: this.success(result) };
         }
 

package/src/index.ts

@@ -10,6 +10,7 @@ export type { RuntimeConfig } from './runtime.js';
 // Export Plugins
 export { DriverPlugin } from './driver-plugin.js';
 export { AppPlugin } from './app-plugin.js';
+export { SeedLoaderService } from './seed-loader.js';
 export { createDispatcherPlugin } from './dispatcher-plugin.js';
 export type { DispatcherPluginConfig } from './dispatcher-plugin.js';