@simplysm/service-server 13.0.68 → 13.0.70

package/tests/orm-service.spec.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { QueryDef } from "@simplysm/orm-common";
+
+vi.mock("@simplysm/orm-node", () => ({
+  createDbConn: vi.fn(),
+}));
+
+import { createDbConn } from "@simplysm/orm-node";
+import { OrmService } from "../src/services/orm-service";
+
+describe("OrmService.executeDefs", () => {
+  let mockExecute: ReturnType<typeof vi.fn>;
+  let methods: any;
+  let connId: number;
+
+  const twoDefs: QueryDef[] = [
+    {
+      type: "createTable",
+      table: { database: "db", name: "A" },
+      columns: [{ name: "id", dataType: { type: "bigint" } }],
+      primaryKey: ["id"],
+    },
+    {
+      type: "createTable",
+      table: { database: "db", name: "B" },
+      columns: [{ name: "id", dataType: { type: "bigint" } }],
+      primaryKey: ["id"],
+    },
+  ];
+
+  beforeEach(async () => {
+    mockExecute = vi.fn((queries: string[]) => Promise.resolve(queries.map(() => [])));
+
+    const mockConn = {
+      config: { dialect: "postgresql" as const },
+      isConnected: true,
+      connect: vi.fn(),
+      close: vi.fn(),
+      execute: mockExecute,
+      executeParametrized: vi.fn(),
+      bulkInsert: vi.fn(),
+      beginTransaction: vi.fn(),
+      commitTransaction: vi.fn(),
+      rollbackTransaction: vi.fn(),
+      on: vi.fn(),
+    };
+
+    vi.mocked(createDbConn).mockResolvedValue(mockConn as any);
+
+    const ctx = {
+      socket: { on: vi.fn() },
+      getConfig: vi.fn(() =>
+        Promise.resolve({
+          test: { dialect: "postgresql", host: "localhost", database: "db" },
+        }),
+      ),
+      clientName: "test",
+    };
+
+    methods = OrmService.factory(ctx as any);
+    connId = await methods.connect({ configName: "test" });
+    mockExecute.mockClear();
+  });
+
+  it("executes queries individually when options is undefined", async () => {
+    const result = await methods.executeDefs(connId, twoDefs);
+
+    // Should pass 2 separate queries, not 1 combined string
+    expect(mockExecute).toHaveBeenCalledTimes(1);
+    expect(mockExecute.mock.calls[0][0]).toHaveLength(2);
+
+    // Should return one result per def
+    expect(result).toHaveLength(2);
+  });
+
+  it("combines queries when options is explicitly all-null", async () => {
+    await methods.executeDefs(connId, twoDefs, [undefined, undefined]);
+
+    // Should pass 1 combined query string
+    expect(mockExecute).toHaveBeenCalledTimes(1);
+    expect(mockExecute.mock.calls[0][0]).toHaveLength(1);
+  });
+});

package/tests/service-executor.spec.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect } from "vitest";
+import { runServiceMethod } from "../src/core/service-executor";
+import { defineService, auth } from "../src/core/define-service";
+
+// Minimal mock server
+function createMockServer(services: any[]) {
+  return { options: { services, auth: { jwtSecret: "test" } } } as any;
+}
+
+describe("runServiceMethod with ServiceDefinition", () => {
+  it("executes a basic service method", async () => {
+    const EchoService = defineService("Echo", (_ctx) => ({
+      echo: (msg: string) => `Echo: ${msg}`,
+    }));
+
+    const server = createMockServer([EchoService]);
+    const result = await runServiceMethod(server, {
+      serviceName: "Echo",
+      methodName: "echo",
+      params: ["hello"],
+    });
+
+    expect(result).toBe("Echo: hello");
+  });
+
+  it("throws error when service not found", async () => {
+    const server = createMockServer([]);
+
+    await expect(
+      runServiceMethod(server, { serviceName: "Unknown", methodName: "test", params: [] }),
+    ).rejects.toThrow("Service [Unknown] not found.");
+  });
+
+  it("throws error when method not found", async () => {
+    const svc = defineService("Test", (_ctx) => ({
+      existing: () => "ok",
+    }));
+    const server = createMockServer([svc]);
+
+    await expect(
+      runServiceMethod(server, { serviceName: "Test", methodName: "nonexistent", params: [] }),
+    ).rejects.toThrow("Method [Test.nonexistent] not found.");
+  });
+
+  it("blocks unauthenticated access to auth-required service", async () => {
+    const svc = defineService(
+      "Protected",
+      auth((_ctx) => ({
+        secret: () => "secret",
+      })),
+    );
+    const server = createMockServer([svc]);
+
+    await expect(
+      runServiceMethod(server, { serviceName: "Protected", methodName: "secret", params: [] }),
+    ).rejects.toThrow("Login is required.");
+  });
+
+  it("blocks unauthorized role access", async () => {
+    const svc = defineService(
+      "Admin",
+      auth((_ctx) => ({
+        manage: auth(["admin"], () => "managed"),
+        view: () => "viewed",
+      })),
+    );
+    const server = createMockServer([svc]);
+
+    // Has auth but wrong role
+    await expect(
+      runServiceMethod(server, {
+        serviceName: "Admin",
+        methodName: "manage",
+        params: [],
+        http: { clientName: "test", authTokenPayload: { roles: ["user"], data: {} } as any },
+      }),
+    ).rejects.toThrow("Insufficient permissions.");
+  });
+
+  it("allows access with correct role", async () => {
+    const svc = defineService(
+      "Admin",
+      auth((_ctx) => ({
+        manage: auth(["admin"], () => "managed"),
+      })),
+    );
+    const server = createMockServer([svc]);
+
+    const result = await runServiceMethod(server, {
+      serviceName: "Admin",
+      methodName: "manage",
+      params: [],
+      http: { clientName: "test", authTokenPayload: { roles: ["admin"], data: {} } as any },
+    });
+
+    expect(result).toBe("managed");
+  });
+
+  it("provides context to factory", async () => {
+    const svc = defineService("Ctx", (ctx) => ({
+      getClientName: () => ctx.clientName,
+    }));
+    const server = createMockServer([svc]);
+
+    const result = await runServiceMethod(server, {
+      serviceName: "Ctx",
+      methodName: "getClientName",
+      params: [],
+      http: { clientName: "my-app", authTokenPayload: undefined },
+    });
+
+    expect(result).toBe("my-app");
+  });
+});

package/docs/authentication.md

@@ -1,114 +0,0 @@
-# Authentication
-
-## auth() Wrapper
-
-Use the `auth()` wrapper to set authentication requirements on services or methods. Only works when `ServiceServerOptions.auth` is configured.
-
-```typescript
-import { defineService, auth } from "@simplysm/service-server";
-
-// Service-level auth: all methods require login
-export const UserService = defineService("User", auth((ctx) => ({
-  // Login only required (inherits from service level)
-  getProfile: async (): Promise<unknown> => {
-    const userId = (ctx.authInfo as { userId: number; role: string })?.userId;
-    // ...
-  },
-
-  // Method-level auth: specific role required (overrides service level)
-  deleteUser: auth(["admin"], async (targetId: number): Promise<void> => {
-    // Only users with admin role can call
-  }),
-})));
-
-// No authentication required (no auth wrapper)
-export const PublicService = defineService("Public", (ctx) => ({
-  healthCheck: async (): Promise<string> => {
-    return "OK";
-  },
-}));
-```
-
-Auth behavior:
-
-| Target | `auth(factory)` | `auth(["admin"], fn)` |
-|-----------|----------------|-------------------------|
-| Service | All methods require login | All methods require admin role |
-| Method | Method requires login | Method requires admin role |
-| None | No auth required (Public) | - |
-
-Method-level `auth()` overrides service-level settings.
-
-## getServiceAuthPermissions
-
-Read auth permissions from an `auth()`-wrapped function. Returns `undefined` if the function is not wrapped with `auth()`. Primarily used internally by `runServiceMethod`, but exported for advanced use cases.
-
-```typescript
-import { defineService, auth, getServiceAuthPermissions } from "@simplysm/service-server";
-
-// For a method with auth wrapper
-const methodPerms = getServiceAuthPermissions(someMethod);
-// string[] if permissions are set, or undefined for public (no auth wrapper)
-
-// For a service definition
-const servicePerms = someServiceDef.authPermissions;
-// string[] if service-level auth is set, or undefined for public
-```
-
-| Signature | Returns | Description |
-|-----------|---------|------|
-| `getServiceAuthPermissions(fn: Function)` | `string[] \| undefined` | Returns the permission array attached by `auth()`, or `undefined` if not wrapped |
-
-## JWT Functions
-
-Standalone functions for JWT token generation and verification using the `jose` library (HS256 algorithm, 12-hour expiration).
-
-```typescript
-import { signJwt, verifyJwt, decodeJwt } from "@simplysm/service-server";
-
-// Generate token (12-hour expiration, HS256 algorithm)
-const token = await signJwt("my-secret-key", {
-  roles: ["admin", "user"],
-  data: { userId: 1, name: "John" },
-});
-
-// Verify token (throws on expiry or invalid signature)
-const payload = await verifyJwt("my-secret-key", token);
-// payload.roles: ["admin", "user"]
-// payload.data: { userId: 1, name: "John" }
-
-// Decode token without verification (synchronous, no secret needed)
-const decoded = decodeJwt(token);
-```
-
-| Function | Returns | Description |
-|----------|---------|------|
-| `signJwt<TAuthInfo>(jwtSecret, payload)` | `Promise<string>` | Generate a JWT token (HS256, 12-hour expiration) |
-| `verifyJwt<TAuthInfo>(jwtSecret, token)` | `Promise<AuthTokenPayload<TAuthInfo>>` | Verify token signature and expiration, return payload. Throws on invalid or expired tokens |
-| `decodeJwt<TAuthInfo>(token)` | `AuthTokenPayload<TAuthInfo>` | Decode token without verification (synchronous) |
-
-In most cases, use `ServiceServer` methods instead of calling these functions directly:
-
-```typescript
-// Generate token via server (preferred)
-const token = await server.generateAuthToken({
-  roles: ["admin"],
-  data: { userId: 1 },
-});
-
-// Verify token via server (preferred)
-const payload = await server.verifyAuthToken(token);
-```
-
-## AuthTokenPayload
-
-```typescript
-import type { AuthTokenPayload } from "@simplysm/service-server";
-
-interface AuthTokenPayload<TAuthInfo = unknown> extends JWTPayload {
-  /** User role list (used for permission check in auth wrapper) */
-  roles: string[];
-  /** Custom auth info (generic type) */
-  data: TAuthInfo;
-}
-```

package/docs/built-in-services.md

@@ -1,100 +0,0 @@
-# Built-in Services
-
-## OrmService
-
-Provides database connection/query/transaction via WebSocket. The `auth()` wrapper is applied, requiring login.
-
-```typescript
-import { createServiceServer, OrmService } from "@simplysm/service-server";
-
-const server = createServiceServer({
-  port: 8080,
-  rootPath: "/app/data",
-  auth: { jwtSecret: "secret" },
-  services: [OrmService],
-});
-```
-
-Define ORM config in `.config.json`:
-
-```json
-{
-  "orm": {
-    "default": {
-      "dialect": "mysql",
-      "host": "localhost",
-      "port": 3306,
-      "database": "mydb",
-      "user": "root",
-      "password": "password"
-    }
-  }
-}
-```
-
-Methods provided by `OrmService`:
-
-| Method | Returns | Description |
-|--------|---------|------|
-| `getInfo(opt)` | `Promise<{ dialect, database?, schema? }>` | Query DB connection info |
-| `connect(opt)` | `Promise<number>` | Create DB connection. Returns connection ID |
-| `close(connId)` | `Promise<void>` | Close DB connection |
-| `beginTransaction(connId, isolationLevel?)` | `Promise<void>` | Begin transaction |
-| `commitTransaction(connId)` | `Promise<void>` | Commit transaction |
-| `rollbackTransaction(connId)` | `Promise<void>` | Rollback transaction |
-| `executeParametrized(connId, query, params?)` | `Promise<unknown[][]>` | Execute parameterized query |
-| `executeDefs(connId, defs, options?)` | `Promise<unknown[][]>` | Execute QueryDef-based queries |
-| `bulkInsert(connId, tableName, columnDefs, records)` | `Promise<void>` | Bulk INSERT |
-
-When a WebSocket connection is closed, all DB connections opened from that socket are automatically cleaned up.
-
-Use `OrmServiceType` to share method signatures with the client:
-
-```typescript
-import type { OrmServiceType } from "@simplysm/service-server";
-// OrmServiceType = ServiceMethods<typeof OrmService>
-```
-
-## AutoUpdateService
-
-Supports auto-update for client apps. Searches for the latest version files by platform in the client directory. No auth is required.
-
-```typescript
-import { createServiceServer, AutoUpdateService } from "@simplysm/service-server";
-
-const server = createServiceServer({
-  port: 8080,
-  rootPath: "/app/data",
-  services: [AutoUpdateService],
-});
-```
-
-Update file structure:
-
-```
-rootPath/www/{clientName}/{platform}/updates/
-  1.0.0.exe    (Windows)
-  1.0.1.exe
-  1.0.0.apk    (Android)
-  1.0.1.apk
-```
-
-| Method | Returns | Description |
-|--------|---------|------|
-| `getLastVersion(platform)` | `Promise<{ version: string; downloadPath: string } \| undefined>` | Returns the latest version and download path for the platform. Returns `undefined` if no update files exist |
-
-Return value example:
-
-```typescript
-{
-  version: "1.0.1",
-  downloadPath: "/my-app/android/updates/1.0.1.apk",
-}
-```
-
-Use `AutoUpdateServiceType` to share method signatures with the client:
-
-```typescript
-import type { AutoUpdateServiceType } from "@simplysm/service-server";
-// AutoUpdateServiceType = ServiceMethods<typeof AutoUpdateService>
-```