@twasik4/pocket-service 1.0.3 → 1.0.4

package/tests/express-types.spec.ts

@@ -0,0 +1,232 @@
+/// <reference types="vitest/globals" />
+import type { Request } from "express";
+import z from "zod";
+import {
+  createAuthResolver,
+  createMetaRouterWithAuth,
+  defaultHeaderAuthResolver,
+} from "../src/workers/express-types";
+
+function createMockResponse() {
+  return {
+    statusCode: 200,
+    body: undefined as unknown,
+    status(code: number) {
+      this.statusCode = code;
+      return this;
+    },
+    json(payload: unknown) {
+      this.body = payload;
+      return this;
+    },
+  };
+}
+
+describe("express-types", () => {
+  it("reads user from x-user-meta header when valid JSON is provided", () => {
+    const req = {
+      headers: {
+        "x-user-meta": JSON.stringify({ userId: "user-1", role: "admin" }),
+      },
+    } as unknown as Request;
+
+    expect(defaultHeaderAuthResolver(req)).toEqual({
+      userId: "user-1",
+      role: "admin",
+    });
+  });
+
+  it("returns null when x-user-meta is invalid JSON", () => {
+    const req = {
+      headers: {
+        "x-user-id": "user-1",
+        "x-user-meta": "{invalid-json",
+      },
+    } as unknown as Request;
+
+    expect(defaultHeaderAuthResolver(req)).toBeNull();
+  });
+
+  it("falls back to x-user-id header when x-user-meta is not set", () => {
+    const req = {
+      headers: { "x-user-id": "user-2" },
+    } as unknown as Request;
+
+    expect(defaultHeaderAuthResolver(req)).toEqual({ userId: "user-2" });
+  });
+
+  it("uses auth strategies in order and then fallback resolver", async () => {
+    const authResolver = createAuthResolver(
+      [
+        {
+          name: "first",
+          canHandle: async () => false,
+          authenticate: async () => ({ userId: "ignored" }),
+        },
+        {
+          name: "second",
+          authenticate: async () => null,
+        },
+      ],
+      {
+        fallbackResolver: async () => ({ userId: "fallback" }),
+      },
+    );
+
+    await expect(
+      authResolver({ headers: {} } as unknown as Request, {
+        method: "GET",
+        fullPath: "/",
+        requireAuth: true,
+      }),
+    ).resolves.toEqual({ userId: "fallback" });
+  });
+
+  it("returns route metadata from createMetaRouterWithAuth", () => {
+    const { routes, addRoute } = createMetaRouterWithAuth();
+
+    addRoute(
+      {
+        method: "POST",
+        fullPath: "/items/:id",
+        requireAuth: true,
+        bodyValidator: z.object({ name: z.string() }),
+        paramsValidator: z.object({ id: z.string() }),
+        meta: { description: "Create item" },
+      },
+      (_req, res) => {
+        res.status(200).json({ ok: true });
+      },
+    );
+
+    expect(routes).toHaveLength(1);
+    expect(routes[0]).toMatchObject({
+      method: "POST",
+      fullPath: "/items/:id",
+      requireAuth: true,
+      meta: { description: "Create item" },
+    });
+  });
+
+  it("returns 401 for protected route when auth resolver returns null", async () => {
+    const { router, addRoute } = createMetaRouterWithAuth({
+      authResolver: async () => null,
+    });
+
+    addRoute(
+      {
+        method: "POST",
+        fullPath: "/secure",
+        requireAuth: true,
+        bodyValidator: z.object({ name: z.string() }),
+      },
+      (_req, res) => {
+        res.status(200).json({ ok: true });
+      },
+    );
+
+    const layer = (router as any).stack.find(
+      (l: any) => l.route?.path === "/secure",
+    );
+    const authMiddleware = layer.route.stack[0].handle;
+
+    const req = { headers: {}, body: { name: "a" } } as unknown as Request;
+    const res = createMockResponse();
+    const next = vi.fn();
+
+    await authMiddleware(req, res, next);
+
+    expect(next).not.toHaveBeenCalled();
+    expect(res.statusCode).toBe(401);
+    expect(res.body).toEqual({ isSuccess: false, message: "Unauthorized" });
+  });
+
+  it("parses JSON body string when object schema is used", () => {
+    const { router, addRoute } = createMetaRouterWithAuth();
+
+    addRoute(
+      {
+        method: "POST",
+        fullPath: "/body",
+        bodyValidator: z.object({ count: z.number() }),
+      },
+      (_req, res) => {
+        res.status(200).json({ ok: true });
+      },
+    );
+
+    const layer = (router as any).stack.find(
+      (l: any) => l.route?.path === "/body",
+    );
+    const bodyMiddleware = layer.route.stack[0].handle;
+
+    const req = { body: '{"count":1}' } as Request;
+    const res = createMockResponse();
+    const next = vi.fn();
+
+    bodyMiddleware(req, res as any, next);
+
+    expect(next).toHaveBeenCalledOnce();
+    expect(req.body).toEqual({ count: 1 });
+  });
+
+  it("returns 400 for invalid JSON body string", () => {
+    const { router, addRoute } = createMetaRouterWithAuth();
+
+    addRoute(
+      {
+        method: "POST",
+        fullPath: "/invalid-body",
+        bodyValidator: z.object({ count: z.number() }),
+      },
+      (_req, res) => {
+        res.status(200).json({ ok: true });
+      },
+    );
+
+    const layer = (router as any).stack.find(
+      (l: any) => l.route?.path === "/invalid-body",
+    );
+    const bodyMiddleware = layer.route.stack[0].handle;
+
+    const req = { body: "{bad" } as Request;
+    const res = createMockResponse();
+    const next = vi.fn();
+
+    bodyMiddleware(req, res as any, next);
+
+    expect(next).not.toHaveBeenCalled();
+    expect(res.statusCode).toBe(400);
+    expect((res.body as any).message).toBe("Invalid JSON in request body");
+  });
+
+  it("returns 400 when params validation fails", () => {
+    const { router, addRoute } = createMetaRouterWithAuth();
+
+    addRoute(
+      {
+        method: "GET",
+        fullPath: "/items/:id",
+        paramsValidator: z.object({ id: z.uuid() }),
+      },
+      (_req, res) => {
+        res.status(200).json({ ok: true });
+      },
+    );
+
+    const layer = (router as any).stack.find(
+      (l: any) => l.route?.path === "/items/:id",
+    );
+    const paramsMiddleware = layer.route.stack[0].handle;
+
+    const req = { params: { id: "not-a-uuid" } } as unknown as Request;
+    const res = createMockResponse();
+    const next = vi.fn();
+
+    paramsMiddleware(req, res as any, next);
+
+    expect(next).not.toHaveBeenCalled();
+    expect(res.statusCode).toBe(400);
+    expect((res.body as any).message).toBe("Invalid URL parameters");
+  });
+});

package/tests/mongo-advanced.spec.ts

@@ -0,0 +1,172 @@
+/// <reference types="vitest/globals" />
+import { MongoMemoryServer } from "mongodb-memory-server";
+import { ObjectId } from "mongodb";
+import z from "zod";
+import {
+  createMongo,
+  defineMongoCollection,
+  type MongoCollectionsConfig,
+} from "../src/workers/db/mongo/mongo";
+
+describe("Mongo abstraction advanced behaviors", () => {
+  let mongoServer: MongoMemoryServer;
+
+  beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+  });
+
+  afterAll(async () => {
+    await mongoServer.stop();
+  });
+
+  it("supports soft delete filtering and deletedBy attribution", async () => {
+    const mongo = createMongo(
+      "soft_delete_db",
+      {
+        users: defineMongoCollection({
+          schema: z.object({
+            name: z.string(),
+            deletedAt: z.date().optional(),
+            deletedBy: z.string().optional(),
+          }),
+        }),
+      },
+      { uri: mongoServer.getUri() },
+    );
+
+    await mongo.connect();
+
+    await mongo.users.insert({ name: "Ada" });
+    await mongo.users.delete({ name: "Ada" });
+
+    await mongo.users.insert({ name: "Grace" });
+    await mongo.users.delete({ name: "Grace" }, "admin-user");
+
+    const visible = await mongo.users.get({ name: "Ada" });
+    const rawAda = await mongo.db.collection("users").findOne({ name: "Ada" });
+    const rawGrace = await mongo.db.collection("users").findOne({
+      name: "Grace",
+    });
+
+    expect(visible).toEqual([]);
+    expect(rawAda?.deletedAt).toBeInstanceOf(Date);
+    expect(rawAda?.deletedBy).toBe("system");
+    expect(rawGrace?.deletedBy).toBe("admin-user");
+
+    await mongo.disconnect();
+  });
+
+  it("tracks revisions and updates updatedAt/revision on updateOne", async () => {
+    const config = {
+      records: {
+        ...defineMongoCollection({
+          schema: z.object({
+            key: z.string(),
+            value: z.string(),
+            revision: z.number().default(0),
+            updatedAt: z.date().optional(),
+          }),
+        }),
+        trackRevisions: true,
+      },
+    } satisfies MongoCollectionsConfig;
+
+    const mongo = createMongo("revisions_db", config, {
+      uri: mongoServer.getUri(),
+    });
+
+    await mongo.connect();
+
+    await mongo.records.insert({
+      key: "k1",
+      value: "v1",
+      revision: 0,
+      updatedAt: new Date("2020-01-01T00:00:00.000Z"),
+    });
+
+    await mongo.records.updateOne({ key: "k1" }, { value: "v2" });
+
+    const current = await mongo.records.getOne({ key: "k1" });
+    const revisions = await mongo.records.getRevisions({ key: "k1" });
+    const mostRecent = await mongo.records.getMostRecentRevision();
+
+    expect(current?.value).toBe("v2");
+    expect(current?.revision).toBe(1);
+    expect(current?.updatedAt).toBeInstanceOf(Date);
+    expect(revisions.length).toBeGreaterThanOrEqual(2);
+    expect(mostRecent?.value).toBe("v2");
+
+    await mongo.disconnect();
+  });
+
+  it("creates configured indexes during setup", async () => {
+    const mongo = createMongo(
+      "index_setup_db",
+      {
+        users: defineMongoCollection({
+          schema: z.object({
+            email: z.string(),
+            createdAt: z.date(),
+          }),
+          indexes: [
+            { key: { email: 1 }, unique: true, name: "users_email_unique" },
+            { key: { createdAt: 1 }, name: "users_created_at" },
+          ],
+        }),
+      },
+      { uri: mongoServer.getUri() },
+    );
+
+    await mongo.connect();
+
+    const indexes = await mongo.db.collection("users").indexes();
+
+    expect(indexes.some((idx) => idx.name === "users_email_unique")).toBe(true);
+    expect(indexes.some((idx) => idx.name === "users_created_at")).toBe(true);
+
+    await mongo.disconnect();
+  });
+
+  it("fails when enabling timeSeries on an existing non-time-series collection", async () => {
+    const dbName = `timeseries_mismatch_${new ObjectId().toHexString()}`;
+
+    const initial = createMongo(
+      dbName,
+      {
+        metrics: defineMongoCollection({
+          schema: z.object({
+            timestamp: z.date(),
+            value: z.number(),
+          }),
+        }),
+      },
+      { uri: mongoServer.getUri() },
+    );
+
+    await initial.connect();
+    await initial.db.createCollection("legacy_metrics");
+    await initial.disconnect();
+
+    const withTimeSeries = createMongo(
+      dbName,
+      {
+        legacy_metrics: defineMongoCollection({
+          schema: z.object({
+            timestamp: z.date(),
+            value: z.number(),
+          }),
+          timeSeries: {
+            timeField: "timestamp",
+          },
+        }),
+      },
+      { uri: mongoServer.getUri() },
+    );
+
+    await expect(withTimeSeries.connect()).rejects.toThrow(
+      "already exists and is not a time-series collection",
+    );
+
+    await withTimeSeries.disconnect();
+  });
+});

package/tests/mongo.spec.ts

@@ -89,4 +89,53 @@ describe("MongoDB Dependency", () => {
     expect(res[0].name).toEqual("updated");
     console.log("Updated document:", res[0]);
   });
+
+  it("Should support creating and using time-series collections", async () => {
+    const tsService = new Service()
+      .withName("admin-service")
+      .withPort(4121)
+      .withRedis("redis://localhost:6379")
+      .withMongo({
+        dbName: "test_timeseries",
+        uri: mongoServer.getUri(),
+        collections: {
+          metrics: defineMongoCollection({
+            schema: z.object({
+              timestamp: z.date(),
+              host: z.string(),
+              value: z.number(),
+            }),
+            timeSeries: {
+              timeField: "timestamp",
+              metaField: "host",
+              granularity: "seconds",
+            },
+          }),
+        },
+      })
+      .build();
+
+    await tsService.mongo.connect();
+
+    const collectionInfo = await tsService.mongo.db
+      .listCollections({ name: "metrics" }, { nameOnly: false })
+      .next();
+
+    expect(
+      collectionInfo?.type === "timeseries" ||
+        Boolean((collectionInfo?.options as any)?.timeseries),
+    ).toBe(true);
+
+    await tsService.db.metrics.insert({
+      timestamp: new Date(),
+      host: "app-1",
+      value: 42,
+    });
+    const values = await tsService.db.metrics.get({ host: "app-1" });
+
+    expect(values.length).toBe(1);
+    expect(values[0].value).toBe(42);
+
+    await tsService.mongo.disconnect();
+  });
 });

package/tests/redis.spec.ts

@@ -1,7 +1,7 @@
 /// <reference types="vitest/globals" />
 import { Service } from "../src/workers/service";
 
-describe.only("Redis Dependency", () => {
+describe("Redis Dependency", () => {
   let service: Service<{}>;
 
   beforeAll(async () => {

package/tests/utils.spec.ts

@@ -0,0 +1,30 @@
+/// <reference types="vitest/globals" />
+import {
+  generateRandomHexString,
+  getUseableDatesFromMs,
+} from "../src/workers/utils";
+
+describe("Utils", () => {
+  it("generates a hex string of the requested length", () => {
+    const value = generateRandomHexString(16);
+    expect(value).toHaveLength(16);
+    expect(value).toMatch(/^[0-9a-f]+$/);
+  });
+
+  it("throws when requested length is odd", () => {
+    expect(() => generateRandomHexString(3)).toThrow(
+      "Length must be an even number",
+    );
+  });
+
+  it("converts milliseconds to day/hour/minute/second parts", () => {
+    const ms =
+      2 * 24 * 60 * 60 * 1000 + 3 * 60 * 60 * 1000 + 4 * 60 * 1000 + 5 * 1000;
+    expect(getUseableDatesFromMs(ms)).toEqual({
+      days: 2,
+      hours: 3,
+      minutes: 4,
+      seconds: 5,
+    });
+  });
+});