@twasik4/pocket-service 1.0.4 → 1.1.0

package/tests/mongo-advanced.spec.ts

@@ -1,172 +0,0 @@
-/// <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

@@ -1,141 +0,0 @@
-/// <reference types="vitest/globals" />
-import z from "zod";
-import {
-  defineMongoCollection,
-  MongoCollectionDefinition,
-} from "../src/workers/db/mongo/mongo";
-import { MongoMemoryServer } from "mongodb-memory-server";
-import { Service } from "../src/workers/service";
-
-describe("MongoDB Dependency", () => {
-  let service: Service<{
-    testCollection: MongoCollectionDefinition<
-      {
-        name: string;
-      },
-      {}
-    >;
-  }>;
-  let mongoServer: MongoMemoryServer;
-
-  beforeAll(async () => {
-    mongoServer = await MongoMemoryServer.create();
-    const uri = mongoServer.getUri();
-    service = new Service()
-      .withName("admin-service")
-      .withPort(4120)
-      .withRedis("redis://localhost:6379")
-      .withMongo({
-        dbName: "test",
-        uri,
-        collections: {
-          testCollection: defineMongoCollection({
-            schema: z.object({
-              name: z.string(),
-            }),
-          }),
-        },
-      })
-      .build();
-  });
-
-  afterEach(async () => {
-    await service.db.testCollection.delete({});
-  });
-
-  afterAll(async () => {
-    await mongoServer.stop();
-  });
-
-  it("Should contain the custom collection", () => {
-    expect(service.db).toHaveProperty("testCollection");
-  });
-
-  it("Should not contain undefined collection", () => {
-    expect(() => service.db).not.toHaveProperty("undefinedCollection");
-  });
-
-  it("Should be initialized", () => {
-    expect(() => service.mongo).not.toThrow();
-  });
-
-  it("Should return an empty array when getting from an empty collection", async () => {
-    const res = await service.db.testCollection.get();
-    expect(res).toEqual([]);
-  });
-
-  it("Should insert and retrieve documents correctly", async () => {
-    await service.db.testCollection.insert({ name: "test" });
-    const res = await service.db.testCollection.get({});
-    expect(res.length).toBe(1);
-    expect(res[0].name).toEqual("test");
-  });
-
-  it("Should delete documents correctly", async () => {
-    await service.db.testCollection.insert({ name: "toDelete" });
-    await service.db.testCollection.delete({ name: "toDelete" });
-    const res = await service.db.testCollection.get({ name: "toDelete" });
-    expect(res).toEqual([]);
-  });
-
-  it("Should update documents correctly", async () => {
-    await service.db.testCollection.insert({ name: "toUpdate" });
-    await service.db.testCollection.updateOne(
-      { name: "toUpdate" },
-      { name: "updated" },
-    );
-    const res = await service.db.testCollection.get({ name: "updated" });
-    expect(res.length).toBe(1);
-    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,36 +0,0 @@
-/// <reference types="vitest/globals" />
-import { Service } from "../src/workers/service";
-
-describe("Redis Dependency", () => {
-  let service: Service<{}>;
-
-  beforeAll(async () => {
-    service = new Service()
-      .withName("admin-service")
-      .withPort(3103)
-      .withRedis("redis://localhost:6379")
-      .build();
-  });
-
-  it("Should not throw an error when accessing redis", () => {
-    expect(() => service.redis).not.toThrow();
-  });
-
-  it.skip("Should automatically register the service to redis", async () => {
-    const value = await service.redis.get("services:registry:admin-service");
-    expect(value).toBeDefined();
-    const parsedValue = JSON.parse(value!);
-    expect(parsedValue.name).equal("admin-service");
-    expect(parsedValue.streamKey).equal("admin:events");
-    expect(parsedValue.url).equal("http://admin-service:3103");
-    expect(parsedValue.dependencies).toEqual([]);
-    expect(parsedValue.routes).toBeInstanceOf(Array);
-    expect(
-      parsedValue.routes.some(
-        (s: any) => s.method === "GET" && s.path === "/health",
-      ),
-    ).toBeTruthy();
-    expect(parsedValue.routes.length).toBeGreaterThan(0);
-    expect(parsedValue.lastHeartbeat).toBeDefined();
-  });
-});

package/tests/service.spec.ts

@@ -1,82 +0,0 @@
-/// <reference types="vitest/globals" />
-import z from "zod";
-import { defineMongoCollection } from "../src/workers/db/mongo/mongo";
-import { MongoMemoryServer } from "mongodb-memory-server";
-import { Service } from "../src/workers/service";
-import { CustomDependencies } from "../src/workers/types";
-
-describe("Service Class", () => {
-  it("Should be able to be initialized", async () => {
-    const service = new Service()
-      .withName("admin-service")
-      .withPort(3000)
-      .build();
-    expect(service.simpleName).toBe("admin");
-    expect(() => service.log.info("Service initialized")).not.toThrow();
-  });
-
-  it("Should throw error if accessing uninitialized dependencies", async () => {
-    const service = new Service().withName("admin-service").build();
-    expect(() => service.redis).toThrow("Redis module has not been added.");
-    expect(() => service.clickhouse).toThrow(
-      "Clickhouse module has not been added.",
-    );
-  });
-
-  it("Should initialize Redis dependency", async () => {
-    const service = new Service()
-      .withName("admin-service")
-      .withRedis("redis://localhost:6379")
-      .build();
-    expect(() => service.redis).not.toThrow();
-  });
-
-  it("Should initialize MongoDB dependency", async () => {
-    const mongoServer = await MongoMemoryServer.create();
-    const uri = mongoServer.getUri();
-    const service = new Service()
-      .withName("admin-service")
-      .withPort(4120)
-      .withRedis("redis://localhost:6379")
-      .withMongo({
-        dbName: "test",
-        uri,
-        collections: {
-          testCollection: defineMongoCollection({
-            schema: z.object({
-              name: z.string(),
-            }),
-          }),
-        },
-      })
-      .build();
-
-    expect(() => service.mongo).not.toThrow();
-    await mongoServer.stop();
-  });
-
-  it("Should allow custom dependencies", async () => {
-    const service = new Service()
-      .withName("admin-service")
-      .withPort(4120)
-      .withModules([
-        {
-          name: "doSomething",
-          init: async (log) => {
-            log.info("Initializing custom dependency");
-            return true;
-          },
-        },
-      ])
-      .withRedis("redis://localhost:6379")
-      .build();
-    expect(service["dependencies"].has("customDependencies")).toBe(true);
-    const customDeps = service["dependencies"].get(
-      "customDependencies",
-    ) as CustomDependencies;
-    expect(customDeps).toBeDefined();
-    expect(customDeps[0].name).toBe("doSomething");
-    expect(await customDeps[0].init(service.log)).toBe(true);
-    expect(customDeps[0].shutdown).toBeUndefined();
-  });
-});

package/tests/utils.spec.ts

@@ -1,30 +0,0 @@
-/// <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,
-    });
-  });
-});

package/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist",
-    "declaration": true,
-    "declarationMap": true,
-    "emitDeclarationOnly": false
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist"]
-}

package/tsup.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from "tsup";
-
-export default defineConfig({
-  entry: ["src/index.ts", "src/worker-thread.ts"],
-  format: ["esm"],
-  dts: true,
-  sourcemap: true,
-  clean: true,
-  minify: true,
-  outDir: "dist",
-});

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    globals: true,
-    include: ["tests/**/*.spec.ts"],
-  },
-});