@objectstack/nestjs 2.0.1 → 2.0.2

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @objectstack/nestjs@2.0.1 build /home/runner/work/spec/spec/packages/adapters/nestjs
+> @objectstack/nestjs@2.0.2 build /home/runner/work/spec/spec/packages/adapters/nestjs
 > tsup --config ../../../tsup.config.ts
 
 CLI Building entry: src/index.ts
@@ -14,11 +14,11 @@
 CJS You have emitDecoratorMetadata enabled but @swc/core was not installed, skipping swc plugin
 ESM dist/index.mjs     6.87 KB
 ESM dist/index.mjs.map 11.21 KB
-ESM ⚡️ Build success in 45ms
+ESM ⚡️ Build success in 50ms
 CJS dist/index.js     8.49 KB
 CJS dist/index.js.map 11.24 KB
-CJS ⚡️ Build success in 46ms
+CJS ⚡️ Build success in 50ms
 DTS Build start
-DTS ⚡️ Build success in 9209ms
+DTS ⚡️ Build success in 6716ms
 DTS dist/index.d.mts 8.75 KB
 DTS dist/index.d.ts  8.75 KB

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @objectstack/nestjs
 
+## 2.0.2
+
+### Patch Changes
+
+- @objectstack/runtime@2.0.2
+
 ## 2.0.1
 
 ### Patch Changes

package/package.json

@@ -1,21 +1,24 @@
 {
   "name": "@objectstack/nestjs",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "peerDependencies": {
-    "@nestjs/common": "^10.0.0",
-    "@nestjs/core": "^10.0.0",
-    "@objectstack/runtime": "2.0.1"
+    "@nestjs/common": "^11.1.13",
+    "@nestjs/core": "^11.1.13",
+    "@objectstack/runtime": "2.0.2"
   },
   "devDependencies": {
-    "@nestjs/common": "^10.0.0",
-    "@nestjs/core": "^10.0.0",
+    "@nestjs/common": "^11.1.13",
+    "@nestjs/core": "^11.1.13",
     "typescript": "^5.0.0",
-    "@objectstack/runtime": "2.0.1"
+    "vitest": "^4.0.18",
+    "@objectstack/runtime": "2.0.2"
   },
   "scripts": {
-    "build": "tsup --config ../../../tsup.config.ts"
+    "build": "tsup --config ../../../tsup.config.ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
 }

package/src/__mocks__/runtime.ts

@@ -0,0 +1,16 @@
+// Stub for @objectstack/runtime - resolved via vitest alias
+import { vi } from 'vitest';
+
+export class HttpDispatcher {
+  getDiscoveryInfo = vi.fn().mockReturnValue({ version: '1.0' });
+  handleGraphQL = vi.fn().mockResolvedValue({ data: {} });
+  handleAuth = vi.fn().mockResolvedValue({ handled: true, response: { status: 200, body: { ok: true } } });
+  handleMetadata = vi.fn().mockResolvedValue({ handled: true, response: { status: 200, body: [] } });
+  handleData = vi.fn().mockResolvedValue({ handled: true, response: { status: 200, body: [] } });
+  handleStorage = vi.fn().mockResolvedValue({ handled: true, response: { status: 200, body: {} } });
+
+  constructor(_kernel: any) {}
+}
+
+export type ObjectKernel = any;
+export type HttpDispatcherResult = any;

package/src/nestjs.test.ts

@@ -0,0 +1,350 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock NestJS decorators as no-ops
+vi.mock('@nestjs/common', () => {
+  const classDecorator = () => (target: any) => target;
+  const methodDecorator = () => (_target: any, _key: string, descriptor: PropertyDescriptor) => descriptor;
+  const paramDecorator = () => () => (_target: any, _key: string, _index: number) => {};
+  return {
+    Module: classDecorator,
+    Global: () => (target: any) => target,
+    Controller: (_prefix?: string) => (target: any) => target,
+    Injectable: () => (target: any) => target,
+    Inject: (_token: any) => (_target: any, _key: string | undefined, _index: number) => {},
+    DynamicModule: class {},
+    Post: methodDecorator,
+    Get: methodDecorator,
+    All: methodDecorator,
+    Body: paramDecorator,
+    Query: paramDecorator,
+    Req: paramDecorator,
+    Res: paramDecorator,
+    createParamDecorator: (_fn: any) => () => (_target: any, _key: string, _index: number) => {},
+    ExecutionContext: class {},
+    Provider: class {},
+  };
+});
+
+import {
+  OBJECT_KERNEL,
+  ObjectStackModule,
+  ObjectStackService,
+  ObjectStackController,
+  DiscoveryController,
+} from './index.js';
+
+// --- Helpers ---
+
+function createMockKernel() {
+  return { id: 'test-kernel' } as any;
+}
+
+function createMockRes() {
+  const res: any = {
+    _status: 200,
+    _body: null,
+    _headers: {} as Record<string, string>,
+    _redirectUrl: null as string | null,
+    status(code: number) { res._status = code; return res; },
+    json(body: any) { res._body = body; return res; },
+    send(body: any) { res._body = body; return res; },
+    setHeader(k: string, v: string) { res._headers[k] = v; return res; },
+    redirect(url: string) { res._redirectUrl = url; return res; },
+  };
+  return res;
+}
+
+// --- Tests ---
+
+describe('OBJECT_KERNEL constant', () => {
+  it('is exported as a string token', () => {
+    expect(OBJECT_KERNEL).toBe('OBJECT_KERNEL');
+  });
+});
+
+describe('ObjectStackModule', () => {
+  it('forRoot returns a DynamicModule with correct shape', () => {
+    const kernel = createMockKernel();
+    const mod = ObjectStackModule.forRoot(kernel);
+
+    expect(mod).toBeDefined();
+    expect(mod.module).toBe(ObjectStackModule);
+    expect(mod.controllers).toContain(ObjectStackController);
+    expect(mod.controllers).toContain(DiscoveryController);
+    expect(mod.providers).toHaveLength(2);
+    expect(mod.exports).toHaveLength(2);
+  });
+
+  it('forRoot provides the kernel under OBJECT_KERNEL token', () => {
+    const kernel = createMockKernel();
+    const mod = ObjectStackModule.forRoot(kernel);
+
+    const kernelProvider = (mod.providers as any[])?.find(
+      (p: any) => p.provide === OBJECT_KERNEL,
+    );
+    expect(kernelProvider).toBeDefined();
+    expect(kernelProvider.useValue).toBe(kernel);
+  });
+
+  it('forRoot exports ObjectStackService', () => {
+    const kernel = createMockKernel();
+    const mod = ObjectStackModule.forRoot(kernel);
+
+    expect(mod.exports).toContain(ObjectStackService);
+  });
+});
+
+describe('ObjectStackService', () => {
+  let service: ObjectStackService;
+  let kernel: any;
+
+  beforeEach(() => {
+    kernel = createMockKernel();
+    service = new ObjectStackService(kernel);
+  });
+
+  it('creates an HttpDispatcher on construction', () => {
+    expect(service.dispatcher).toBeDefined();
+  });
+
+  it('getKernel returns the injected kernel', () => {
+    expect(service.getKernel()).toBe(kernel);
+  });
+});
+
+describe('ObjectStackController', () => {
+  let controller: ObjectStackController;
+  let service: ObjectStackService;
+  let res: ReturnType<typeof createMockRes>;
+
+  beforeEach(() => {
+    const kernel = createMockKernel();
+    service = new ObjectStackService(kernel);
+    controller = new ObjectStackController(service);
+    res = createMockRes();
+  });
+
+  it('has all expected route handler methods', () => {
+    expect(typeof controller.discovery).toBe('function');
+    expect(typeof controller.graphql).toBe('function');
+    expect(typeof controller.auth).toBe('function');
+    expect(typeof controller.metadata).toBe('function');
+    expect(typeof controller.data).toBe('function');
+    expect(typeof controller.storage).toBe('function');
+  });
+
+  describe('discovery()', () => {
+    it('returns discovery info from the dispatcher', () => {
+      const result = controller.discovery();
+      expect(result).toEqual({ data: { version: '1.0' } });
+      expect(service.dispatcher.getDiscoveryInfo).toHaveBeenCalledWith('/api');
+    });
+  });
+
+  describe('graphql()', () => {
+    it('dispatches to handleGraphQL and returns json', async () => {
+      const req = { headers: {} };
+      const body = { query: '{ objects { name } }' };
+
+      await controller.graphql(body, req, res);
+
+      expect(service.dispatcher.handleGraphQL).toHaveBeenCalledWith(body, { request: req });
+      expect(res._body).toEqual({ data: {} });
+    });
+
+    it('handles errors from handleGraphQL', async () => {
+      (service.dispatcher.handleGraphQL as any).mockRejectedValueOnce(
+        Object.assign(new Error('GQL Error'), { statusCode: 400 }),
+      );
+
+      await controller.graphql({}, {}, res);
+
+      expect(res._status).toBe(400);
+      expect(res._body.success).toBe(false);
+      expect(res._body.error.message).toBe('GQL Error');
+    });
+  });
+
+  describe('auth()', () => {
+    it('dispatches to handleAuth with extracted path', async () => {
+      const req = { params: { 0: 'login' }, url: '/api/auth/login', method: 'POST' };
+      const body = { username: 'admin' };
+
+      await controller.auth(req, res, body);
+
+      expect(service.dispatcher.handleAuth).toHaveBeenCalledWith(
+        'login', 'POST', body, { request: req, response: res },
+      );
+    });
+
+    it('falls back to URL parsing for path extraction', async () => {
+      const req = { params: {}, url: '/api/auth/callback?code=abc', method: 'GET' };
+
+      await controller.auth(req, res, {});
+
+      expect(service.dispatcher.handleAuth).toHaveBeenCalledWith(
+        'callback', 'GET', {}, { request: req, response: res },
+      );
+    });
+  });
+
+  describe('metadata()', () => {
+    it('dispatches to handleMetadata with extracted path', async () => {
+      const req = { params: { 0: '' }, url: '/api/meta/objects', method: 'GET' };
+
+      await controller.metadata(req, res, undefined);
+
+      expect(service.dispatcher.handleMetadata).toHaveBeenCalledWith(
+        '/objects', { request: req }, 'GET', undefined,
+      );
+    });
+  });
+
+  describe('data()', () => {
+    it('dispatches to handleData with extracted path', async () => {
+      const req = { params: { 0: '' }, url: '/api/data/account', method: 'GET' };
+      const query = { limit: '10' };
+
+      await controller.data(req, res, {}, query);
+
+      expect(service.dispatcher.handleData).toHaveBeenCalledWith(
+        '/account', 'GET', {}, query, { request: req },
+      );
+    });
+  });
+
+  describe('storage()', () => {
+    it('dispatches to handleStorage with extracted path', async () => {
+      const req = { params: { 0: '' }, url: '/api/storage/files/test.png', method: 'GET', file: null, files: {} };
+
+      await controller.storage(req, res);
+
+      expect(service.dispatcher.handleStorage).toHaveBeenCalledWith(
+        '/files/test.png', 'GET', undefined, { request: req },
+      );
+    });
+  });
+
+  describe('normalizeResponse (via handlers)', () => {
+    it('returns 404 when result is not handled', async () => {
+      (service.dispatcher.handleAuth as any).mockResolvedValueOnce({ handled: false });
+      const req = { params: { 0: 'noop' }, url: '/api/auth/noop', method: 'GET' };
+
+      await controller.auth(req, res, {});
+
+      expect(res._status).toBe(404);
+      expect(res._body.error.code).toBe(404);
+    });
+
+    it('sets custom headers from response', async () => {
+      (service.dispatcher.handleData as any).mockResolvedValueOnce({
+        handled: true,
+        response: { status: 201, body: { id: 1 }, headers: { 'X-Custom': 'yes' } },
+      });
+      const req = { params: {}, url: '/api/data/account', method: 'POST' };
+
+      await controller.data(req, res, {}, {});
+
+      expect(res._status).toBe(201);
+      expect(res._headers['X-Custom']).toBe('yes');
+      expect(res._body).toEqual({ id: 1 });
+    });
+
+    it('handles redirect results', async () => {
+      (service.dispatcher.handleAuth as any).mockResolvedValueOnce({
+        handled: true,
+        result: { type: 'redirect', url: 'https://example.com/callback' },
+      });
+      const req = { params: { 0: 'oauth' }, url: '/api/auth/oauth', method: 'GET' };
+
+      await controller.auth(req, res, {});
+
+      expect(res._redirectUrl).toBe('https://example.com/callback');
+    });
+
+    it('handles stream results', async () => {
+      const pipeFn = vi.fn();
+      (service.dispatcher.handleStorage as any).mockResolvedValueOnce({
+        handled: true,
+        result: {
+          type: 'stream',
+          stream: { pipe: pipeFn },
+          headers: { 'Content-Type': 'application/octet-stream' },
+        },
+      });
+      const req = { params: {}, url: '/api/storage/download', method: 'GET', file: null, files: {} };
+
+      await controller.storage(req, res);
+
+      expect(pipeFn).toHaveBeenCalledWith(res);
+      expect(res._headers['Content-Type']).toBe('application/octet-stream');
+    });
+
+    it('handles generic result objects with 200 status', async () => {
+      (service.dispatcher.handleData as any).mockResolvedValueOnce({
+        handled: true,
+        result: { foo: 'bar' },
+      });
+      const req = { params: {}, url: '/api/data/x', method: 'GET' };
+
+      await controller.data(req, res, {}, {});
+
+      expect(res._status).toBe(200);
+      expect(res._body).toEqual({ foo: 'bar' });
+    });
+
+    it('handles Response-like objects', async () => {
+      const mockHeaders = new Map([['content-type', 'text/plain']]);
+      (service.dispatcher.handleData as any).mockResolvedValueOnce({
+        handled: true,
+        result: {
+          status: 203,
+          headers: mockHeaders,
+          text: vi.fn().mockResolvedValue('hello world'),
+        },
+      });
+      const req = { params: {}, url: '/api/data/x', method: 'GET' };
+
+      await controller.data(req, res, {}, {});
+
+      expect(res._status).toBe(203);
+      expect(res._body).toBe('hello world');
+    });
+  });
+
+  describe('handleError', () => {
+    it('uses statusCode from error if available', async () => {
+      (service.dispatcher.handleGraphQL as any).mockRejectedValueOnce(
+        Object.assign(new Error('Forbidden'), { statusCode: 403, details: { reason: 'no access' } }),
+      );
+
+      await controller.graphql({}, {}, res);
+
+      expect(res._status).toBe(403);
+      expect(res._body.error.message).toBe('Forbidden');
+      expect(res._body.error.details).toEqual({ reason: 'no access' });
+    });
+
+    it('defaults to 500 when no statusCode', async () => {
+      (service.dispatcher.handleGraphQL as any).mockRejectedValueOnce(new Error('Unexpected'));
+
+      await controller.graphql({}, {}, res);
+
+      expect(res._status).toBe(500);
+      expect(res._body.error.code).toBe(500);
+    });
+  });
+});
+
+describe('DiscoveryController', () => {
+  it('redirects to /api', () => {
+    const controller = new DiscoveryController();
+    const res = createMockRes();
+
+    controller.discover(res);
+
+    expect(res._redirectUrl).toBe('/api');
+  });
+});

package/vitest.config.ts

@@ -0,0 +1,16 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { defineConfig } from 'vitest/config';
+import path from 'node:path';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+  },
+  resolve: {
+    alias: {
+      '@objectstack/runtime': path.resolve(__dirname, 'src/__mocks__/runtime.ts'),
+    },
+  },
+});