@objectstack/runtime 3.2.0 → 3.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/runtime",
-  "version": "3.2.0",
+  "version": "3.2.2",
   "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.0",
-    "@objectstack/rest": "3.2.0",
-    "@objectstack/spec": "3.2.0",
-    "@objectstack/types": "3.2.0"
+    "@objectstack/core": "3.2.2",
+    "@objectstack/rest": "3.2.2",
+    "@objectstack/spec": "3.2.2",
+    "@objectstack/types": "3.2.2"
   },
   "devDependencies": {
     "typescript": "^5.0.0",

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);
 
@@ -305,6 +305,59 @@ describe('HttpDispatcher', () => {
             });
         });
 
+        describe('handleAuth mock fallback (MSW/test mode)', () => {
+            beforeEach(() => {
+                // No auth service, no broker — simulates MSW/mock mode
+                (kernel as any).getService = vi.fn().mockResolvedValue(null);
+                (kernel as any).services = new Map();
+                (kernel as any).broker = null;
+            });
+
+            it('should mock sign-up/email endpoint', async () => {
+                const result = await dispatcher.handleAuth('/sign-up/email', 'POST', { email: 'test@example.com', name: 'Test' }, { request: {} });
+                expect(result.handled).toBe(true);
+                expect(result.response?.status).toBe(200);
+                expect(result.response?.body.user).toBeDefined();
+                expect(result.response?.body.user.email).toBe('test@example.com');
+                expect(result.response?.body.session).toBeDefined();
+            });
+
+            it('should mock sign-in/email endpoint', async () => {
+                const result = await dispatcher.handleAuth('/sign-in/email', 'POST', { email: 'test@example.com' }, { request: {} });
+                expect(result.handled).toBe(true);
+                expect(result.response?.status).toBe(200);
+                expect(result.response?.body.user).toBeDefined();
+                expect(result.response?.body.session).toBeDefined();
+            });
+
+            it('should mock get-session endpoint', async () => {
+                const result = await dispatcher.handleAuth('/get-session', 'GET', {}, { request: {} });
+                expect(result.handled).toBe(true);
+                expect(result.response?.status).toBe(200);
+                expect(result.response?.body).toEqual({ session: null, user: null });
+            });
+
+            it('should mock sign-out endpoint', async () => {
+                const result = await dispatcher.handleAuth('/sign-out', 'POST', {}, { request: {} });
+                expect(result.handled).toBe(true);
+                expect(result.response?.status).toBe(200);
+                expect(result.response?.body).toEqual({ success: true });
+            });
+
+            it('should mock login fallback when broker unavailable', async () => {
+                const result = await dispatcher.handleAuth('/login', 'POST', { email: 'test@example.com' }, { request: {} });
+                expect(result.handled).toBe(true);
+                expect(result.response?.status).toBe(200);
+                expect(result.response?.body.user).toBeDefined();
+                expect(result.response?.body.session).toBeDefined();
+            });
+
+            it('should return unhandled for unknown auth path in mock mode', async () => {
+                const result = await dispatcher.handleAuth('/unknown', 'GET', {}, { request: {} });
+                expect(result.handled).toBe(false);
+            });
+        });
+
         describe('handleStorage with async service', () => {
             it('should resolve storage service from Promise', async () => {
                 const mockStorage = {
@@ -439,13 +492,115 @@ describe('HttpDispatcher', () => {
         });
     });
 
+    // ═══════════════════════════════════════════════════════════════
+    // getServiceAsync preferred path
+    // ═══════════════════════════════════════════════════════════════
+
+    describe('getServiceAsync preferred path', () => {
+        it('should prefer getServiceAsync over getService for analytics', async () => {
+            const asyncAnalytics = {
+                query: vi.fn().mockResolvedValue({ rows: [1], total: 1 }),
+            };
+            (kernel as any).getServiceAsync = vi.fn().mockResolvedValue(asyncAnalytics);
+            (kernel as any).getService = vi.fn().mockImplementation(() => {
+                throw new Error("Service 'analytics' is async - use await");
+            });
+
+            const result = await dispatcher.handleAnalytics('query', 'POST', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(asyncAnalytics.query).toHaveBeenCalled();
+            expect((kernel as any).getServiceAsync).toHaveBeenCalledWith('analytics');
+        });
+
+        it('should prefer getServiceAsync over getService for auth', async () => {
+            const asyncAuth = {
+                handler: vi.fn().mockResolvedValue({ user: { id: '1' } }),
+            };
+            (kernel as any).getServiceAsync = vi.fn().mockResolvedValue(asyncAuth);
+            (kernel as any).getService = vi.fn().mockImplementation(() => {
+                throw new Error("Service 'auth' is async - use await");
+            });
+
+            const result = await dispatcher.handleAuth('', 'POST', {}, { request: {}, response: {} });
+            expect(result.handled).toBe(true);
+            expect(asyncAuth.handler).toHaveBeenCalled();
+            expect((kernel as any).getServiceAsync).toHaveBeenCalledWith('auth');
+        });
+
+        it('should prefer getServiceAsync over getService for automation', async () => {
+            const asyncAuto = {
+                listFlows: vi.fn().mockResolvedValue(['flow_async']),
+            };
+            (kernel as any).getServiceAsync = vi.fn().mockResolvedValue(asyncAuto);
+
+            const result = await dispatcher.handleAutomation('', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.body?.data?.flows).toEqual(['flow_async']);
+            expect((kernel as any).getServiceAsync).toHaveBeenCalledWith('automation');
+        });
+
+        it('should prefer getServiceAsync over getService for file-storage', async () => {
+            const asyncStorage = {
+                upload: vi.fn().mockResolvedValue({ id: 'file_1', url: '/files/1' }),
+            };
+            (kernel as any).getServiceAsync = vi.fn().mockResolvedValue(asyncStorage);
+
+            const result = await dispatcher.handleStorage('/upload', 'POST', { name: 'test.txt' }, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect((kernel as any).getServiceAsync).toHaveBeenCalledWith('file-storage');
+        });
+
+        it('should resolve protocol service via getServiceAsync for handleMetadata', async () => {
+            const asyncProtocol = {
+                saveMetaItem: vi.fn().mockResolvedValue({ success: true }),
+            };
+            (kernel as any).getServiceAsync = vi.fn().mockImplementation((name: string) => {
+                if (name === 'protocol') return Promise.resolve(asyncProtocol);
+                return Promise.resolve(null);
+            });
+            // Remove context.getService to ensure getServiceAsync is used
+            (kernel as any).context = {};
+
+            const result = await dispatcher.handleMetadata('/objects/my_obj', { request: {} }, 'PUT', { label: 'Test' });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(asyncProtocol.saveMetaItem).toHaveBeenCalled();
+            expect((kernel as any).getServiceAsync).toHaveBeenCalledWith('protocol');
+        });
+
+        it('should fall through when getServiceAsync returns null', async () => {
+            (kernel as any).getServiceAsync = vi.fn().mockResolvedValue(null);
+            const syncAnalytics = {
+                query: vi.fn().mockResolvedValue({ rows: [], total: 0 }),
+            };
+            (kernel as any).services = new Map([['analytics', syncAnalytics]]);
+
+            const result = await dispatcher.handleAnalytics('query', 'POST', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(syncAnalytics.query).toHaveBeenCalled();
+        });
+
+        it('should fall through when getServiceAsync throws', async () => {
+            (kernel as any).getServiceAsync = vi.fn().mockRejectedValue(new Error('not found'));
+            const syncAnalytics = {
+                query: vi.fn().mockResolvedValue({ rows: [], total: 0 }),
+            };
+            (kernel as any).services = new Map([['analytics', syncAnalytics]]);
+
+            const result = await dispatcher.handleAnalytics('query', 'POST', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(syncAnalytics.query).toHaveBeenCalled();
+        });
+    });
+
     // ═══════════════════════════════════════════════════════════════
     // handleData — expand/populate parameter flow
     // ═══════════════════════════════════════════════════════════════
 
     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', {},
@@ -684,4 +839,119 @@ describe('HttpDispatcher', () => {
             );
         });
     });
+
+    // ═══════════════════════════════════════════════════════════════
+    // handleI18n — i18n route dispatching
+    // ═══════════════════════════════════════════════════════════════
+
+    describe('handleI18n', () => {
+        let mockI18nService: any;
+
+        beforeEach(() => {
+            mockI18nService = {
+                getLocales: vi.fn().mockReturnValue(['en', 'zh-CN', 'ja']),
+                getTranslations: vi.fn().mockReturnValue({ 'o.account.label': '客户', 'o.account.fields.name': '名称' }),
+                getFieldLabels: vi.fn().mockReturnValue({ name: '名称', industry: '行业' }),
+            };
+
+            (kernel as any).getService = vi.fn().mockImplementation((name: string) => {
+                if (name === 'i18n') return mockI18nService;
+                return null;
+            });
+        });
+
+        it('should list locales via GET /locales', async () => {
+            const result = await dispatcher.handleI18n('/locales', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(result.response?.body?.data?.locales).toEqual(['en', 'zh-CN', 'ja']);
+            expect(mockI18nService.getLocales).toHaveBeenCalled();
+        });
+
+        it('should get translations via GET /translations/:locale', async () => {
+            const result = await dispatcher.handleI18n('/translations/zh-CN', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(result.response?.body?.data?.locale).toBe('zh-CN');
+            expect(result.response?.body?.data?.translations).toEqual({ 'o.account.label': '客户', 'o.account.fields.name': '名称' });
+            expect(mockI18nService.getTranslations).toHaveBeenCalledWith('zh-CN');
+        });
+
+        it('should get translations via GET /translations?locale=zh-CN (query param)', async () => {
+            const result = await dispatcher.handleI18n('/translations', 'GET', { locale: 'zh-CN' }, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(result.response?.body?.data?.locale).toBe('zh-CN');
+            expect(mockI18nService.getTranslations).toHaveBeenCalledWith('zh-CN');
+        });
+
+        it('should return 400 when translations requested without locale', async () => {
+            const result = await dispatcher.handleI18n('/translations', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(400);
+            expect(result.response?.body?.error?.message).toBe('Missing locale parameter');
+        });
+
+        it('should get field labels via GET /labels/:object/:locale', async () => {
+            const result = await dispatcher.handleI18n('/labels/account/zh-CN', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(result.response?.body?.data?.object).toBe('account');
+            expect(result.response?.body?.data?.locale).toBe('zh-CN');
+            expect(result.response?.body?.data?.labels).toEqual({ name: '名称', industry: '行业' });
+            expect(mockI18nService.getFieldLabels).toHaveBeenCalledWith('account', 'zh-CN');
+        });
+
+        it('should get field labels via GET /labels/:object?locale=zh-CN (query param)', async () => {
+            const result = await dispatcher.handleI18n('/labels/account', 'GET', { locale: 'zh-CN' }, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(result.response?.body?.data?.object).toBe('account');
+            expect(mockI18nService.getFieldLabels).toHaveBeenCalledWith('account', 'zh-CN');
+        });
+
+        it('should return 400 when labels requested without locale', async () => {
+            const result = await dispatcher.handleI18n('/labels/account', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(400);
+            expect(result.response?.body?.error?.message).toBe('Missing locale parameter');
+        });
+
+        it('should fallback to deriving labels from translations when getFieldLabels is missing', async () => {
+            delete mockI18nService.getFieldLabels;
+            mockI18nService.getTranslations.mockReturnValue({
+                'o.contact.fields.first_name': 'First Name',
+                'o.contact.fields.email': 'Email',
+                'o.contact.label': 'Contact',
+            });
+
+            const result = await dispatcher.handleI18n('/labels/contact/en', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(result.response?.body?.data?.labels).toEqual({
+                first_name: 'First Name',
+                email: 'Email',
+            });
+        });
+
+        it('should return 501 when i18n service is not available', async () => {
+            (kernel as any).getService = vi.fn().mockResolvedValue(null);
+            (kernel as any).services = new Map();
+
+            const result = await dispatcher.handleI18n('/locales', 'GET', {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(501);
+        });
+
+        it('should return unhandled for non-GET methods', async () => {
+            const result = await dispatcher.handleI18n('/locales', 'POST', {}, { request: {} });
+            expect(result.handled).toBe(false);
+        });
+
+        it('should dispatch /i18n routes via dispatch()', async () => {
+            const result = await dispatcher.dispatch('GET', '/i18n/locales', undefined, {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.body?.data?.locales).toEqual(['en', 'zh-CN', 'ja']);
+        });
+    });
 });