@objectstack/runtime 3.3.0 → 4.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/runtime",
-  "version": "3.3.0",
+  "version": "4.0.0",
   "license": "Apache-2.0",
   "description": "ObjectStack Core Runtime & Query Engine",
   "type": "module",
@@ -15,14 +15,14 @@
   },
   "dependencies": {
     "zod": "^4.3.6",
-    "@objectstack/core": "3.3.0",
-    "@objectstack/rest": "3.3.0",
-    "@objectstack/spec": "3.3.0",
-    "@objectstack/types": "3.3.0"
+    "@objectstack/core": "4.0.0",
+    "@objectstack/rest": "4.0.0",
+    "@objectstack/spec": "4.0.0",
+    "@objectstack/types": "4.0.0"
   },
   "devDependencies": {
-    "typescript": "^5.0.0",
-    "vitest": "^4.1.0"
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
   },
   "scripts": {
     "build": "tsup --config ../../tsup.config.ts",

package/src/http-dispatcher.root.test.ts

@@ -46,6 +46,21 @@ describe('HttpDispatcher Root Handling', () => {
         expect(data.routes.metadata).toBe('/meta');
     });
 
+    it('should handle GET /discovery (protocol-standard route)', async () => {
+        const context = { request: {} };
+        const result = await dispatcher.dispatch('GET', '/discovery', undefined, {}, context);
+
+        expect(result.handled).toBe(true);
+        expect(result.response).toBeDefined();
+        expect(result.response?.status).toBe(200);
+        
+        const data = result.response?.body?.data;
+        expect(data).toBeDefined();
+        expect(data.name).toBe('ObjectOS');
+        expect(data.version).toBe('1.0.0');
+        expect(data.routes).toBeDefined();
+    });
+
     it('should NOT handle POST request to root path ("")', async () => {
         const context = { request: {} };
         const method = 'POST';

package/src/http-dispatcher.test.ts

@@ -645,9 +645,10 @@ describe('HttpDispatcher', () => {
             );
 
             expect(result.handled).toBe(true);
+            // top → limit and skip → offset are normalized by the dispatcher
             expect(mockBroker.call).toHaveBeenCalledWith(
                 'data.query',
-                { object: 'task', query },
+                { object: 'task', query: { populate: 'assignee,project', limit: '10', offset: '0' } },
                 { request: {} }
             );
         });

package/src/http-dispatcher.ts

@@ -585,8 +585,49 @@ export class HttpDispatcher {
         } else {
             // GET /data/:object (List)
             if (m === 'GET') {
+                // ── Normalize HTTP transport params → Spec canonical (QueryAST) ──
+                // HTTP GET query params use transport-level names (filter, sort, top,
+                // skip, select, expand) which are normalized here to canonical
+                // QueryAST field names (where, orderBy, limit, offset, fields,
+                // expand) before forwarding to the broker layer.
+                // The protocol.ts findData() method performs a deeper normalization
+                // pass, but pre-normalizing here ensures the broker always receives
+                // Spec-canonical keys.
+                const normalized: Record<string, unknown> = { ...query };
+
+                // filter/filters → where
+                // Note: `filter` is the canonical HTTP *transport* parameter name
+                // (see HttpFindQueryParamsSchema). It is normalized here to the
+                // canonical *QueryAST* field name `where` before broker dispatch.
+                // `filters` (plural) is a deprecated alias for `filter`.
+                if (normalized.filter != null || normalized.filters != null) {
+                    normalized.where = normalized.where ?? normalized.filter ?? normalized.filters;
+                    delete normalized.filter;
+                    delete normalized.filters;
+                }
+                // select → fields
+                if (normalized.select != null && normalized.fields == null) {
+                    normalized.fields = normalized.select;
+                    delete normalized.select;
+                }
+                // sort → orderBy
+                if (normalized.sort != null && normalized.orderBy == null) {
+                    normalized.orderBy = normalized.sort;
+                    delete normalized.sort;
+                }
+                // top → limit
+                if (normalized.top != null && normalized.limit == null) {
+                    normalized.limit = normalized.top;
+                    delete normalized.top;
+                }
+                // skip → offset
+                if (normalized.skip != null && normalized.offset == null) {
+                    normalized.offset = normalized.skip;
+                    delete normalized.skip;
+                }
+
                 // Spec: broker returns FindDataResponse = { object, records, total?, hasMore? }
-                const result = await broker.call('data.query', { object: objectName, query }, { request: context.request });
+                const result = await broker.call('data.query', { object: objectName, query: normalized }, { request: context.request });
                 return { handled: true, response: this.success(result) };
             }
 
@@ -1154,9 +1195,10 @@ export class HttpDispatcher {
     async dispatch(method: string, path: string, body: any, query: any, context: HttpProtocolContext): Promise<HttpDispatcherResult> {
         const cleanPath = path.replace(/\/$/, ''); // Remove trailing slash if present, but strict on clean paths
 
-        // 0. Root Discovery Endpoint (GET /)
-        // Handles request to base URL (e.g. /api/v1) which MSW strips to empty string
-        if (cleanPath === '' && method === 'GET') {
+        // 0. Discovery Endpoint (GET /discovery or GET /)
+        // Standard route: /discovery (protocol-compliant)
+        // Legacy route: / (empty path, for backward compatibility — MSW strips base URL)
+        if ((cleanPath === '/discovery' || cleanPath === '') && method === 'GET') {
              // We use '' as prefix since we are internal dispatcher
              const info = await this.getDiscoveryInfo('');
              return { 

package/src/seed-loader.ts

@@ -324,8 +324,8 @@ export class SeedLoaderService implements ISeedLoaderService {
   ): Promise<string | null> {
     try {
       const records = await this.engine.find(targetObject, {
-        filter: { [targetField]: value },
-        select: ['id'],
+        where: { [targetField]: value },
+        fields: ['id'],
         limit: 1,
       });
       if (records && records.length > 0) {
@@ -612,7 +612,7 @@ export class SeedLoaderService implements ISeedLoaderService {
     const map = new Map<string, any>();
     try {
       const records = await this.engine.find(objectName, {
-        select: ['id', externalId],
+        fields: ['id', externalId],
       });
       for (const record of records || []) {
         const key = String(record[externalId] ?? '');

package/tsconfig.json

@@ -2,7 +2,8 @@
   "extends": "../../tsconfig.json",
   "compilerOptions": {
     "outDir": "./dist",
-    "rootDir": "./src"
+    "rootDir": "./src",
+    "types": ["node"]
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist", "**/*.spec.ts", "**/*.test.ts"]