@akanjs/test 0.0.30 → 0.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/test",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -11,13 +11,60 @@
     "directory": "pkgs/@akanjs/base"
   },
   "dependencies": {
+    "@apollo/server": "^4.11.2",
+    "@inquirer/prompts": "^7.2.1",
+    "@nestjs/apollo": "^12.2.2",
+    "@nestjs/bull": "^10.2.3",
+    "@nestjs/common": "^10.4.15",
+    "@nestjs/core": "^10.4.15",
+    "@nestjs/graphql": "^12.2.2",
+    "@nestjs/mongoose": "^10.1.0",
+    "@nestjs/passport": "^10.0.3",
+    "@nestjs/platform-express": "^10.4.15",
+    "@nestjs/platform-socket.io": "^10.4.15",
+    "@nestjs/schedule": "^4.1.2",
+    "@nestjs/websockets": "^10.4.15",
+    "@socket.io/redis-adapter": "^8.3.0",
     "@urql/core": "^5.1.0",
+    "apple-signin": "^1.0.9",
+    "body-parser": "^1.20.3",
+    "bull": "^4.16.5",
     "chance": "^1.1.12",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "cookie-parser": "^1.4.7",
+    "dataloader": "^2.2.3",
     "dayjs": "^1.11.13",
+    "dotenv": "^16.4.7",
+    "express": "^4.21.2",
+    "graphql": "^16.10.0",
+    "graphql-type-json": "^0.3.2",
+    "graphql-upload": "^12.0.0",
+    "iap": "^1.1.1",
+    "immer": "^10.1.1",
+    "jsonwebtoken": "^9.0.2",
+    "lodash": "^4.17.21",
+    "meilisearch": "^0.47.0",
     "mongoose": "^8.9.3",
+    "next": "^15.3.0",
+    "passport": "^0.7.0",
+    "passport-apple": "^2.0.2",
+    "passport-facebook": "^3.0.0",
+    "passport-github": "^1.1.0",
+    "passport-google-oauth20": "^2.0.0",
+    "passport-kakao": "^1.0.1",
+    "passport-naver": "^1.0.6",
+    "picocolors": "^1.1.1",
     "pluralize": "^8.0.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "redis": "^4.7.0",
     "reflect-metadata": "^0.2.2",
-    "tunnel-ssh": "^5.2.0"
+    "rxjs": "^7.8.1",
+    "socket.io": "^4.8.1",
+    "socket.io-client": "^4.8.1",
+    "tunnel-ssh": "^5.2.0",
+    "ua-parser-js": "^1.0.40"
   },
   "main": "./index.js"
 }

package/src/jest.config.base.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from "@jest/types";
+export declare const withBase: (name: string) => Config.InitialOptions;

package/src/jest.config.base.js

@@ -0,0 +1,56 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jest_config_base_exports = {};
+__export(jest_config_base_exports, {
+  withBase: () => withBase
+});
+module.exports = __toCommonJS(jest_config_base_exports);
+var import_dotenv = require("dotenv");
+const withBase = (name) => {
+  (0, import_dotenv.config)();
+  process.env.NEXT_PUBLIC_ENV = "testing";
+  process.env.NEXT_PUBLIC_OPERATION_MODE = "local";
+  process.env.NEXT_PUBLIC_APP_NAME = name;
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+  const akanjsPrefix = process.env.USE_AKANJS_PKGS === "true" ? "../../pkgs/" : "";
+  return {
+    displayName: name,
+    resolver: "@nx/jest/plugins/resolver",
+    globalSetup: `${akanjsPrefix}@akanjs/test/src/jest.globalSetup.ts`,
+    setupFilesAfterEnv: [`${akanjsPrefix}@akanjs/test/src/jest.setupFilesAfterEnv.ts`],
+    globalTeardown: `${akanjsPrefix}@akanjs/test/src/jest.globalTeardown.ts`,
+    testMatch: ["**/?(*.)+(test).ts?(x)"],
+    testPathIgnorePatterns: ["/node_modules/", "/app/"],
+    maxWorkers: 1,
+    transform: {
+      "signal\\.(test)\\.ts$": ["ts-jest", { tsconfig: "<rootDir>/tsconfig.spec.json" }],
+      "^.+\\.(ts|js|html)$": ["ts-jest", { tsconfig: "<rootDir>/tsconfig.spec.json" }]
+    },
+    moduleFileExtensions: ["ts", "tsx", "js", "jsx"],
+    coverageDirectory: `../../coverage/libs/${name}`,
+    coverageReporters: ["html"],
+    testEnvironment: "node",
+    testEnvironmentOptions: {
+      customExportConditions: ["node", "require", "default"]
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withBase
+});

package/src/jest.config.base.ts

@@ -0,0 +1,32 @@
+import type { Config } from "@jest/types";
+import { config } from "dotenv";
+
+export const withBase = (name: string): Config.InitialOptions => {
+  config();
+  process.env.NEXT_PUBLIC_ENV = "testing";
+  process.env.NEXT_PUBLIC_OPERATION_MODE = "local";
+  process.env.NEXT_PUBLIC_APP_NAME = name;
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+  const akanjsPrefix = process.env.USE_AKANJS_PKGS === "true" ? "../../pkgs/" : "";
+  return {
+    displayName: name,
+    resolver: "@nx/jest/plugins/resolver",
+    globalSetup: `${akanjsPrefix}@akanjs/test/src/jest.globalSetup.ts`,
+    setupFilesAfterEnv: [`${akanjsPrefix}@akanjs/test/src/jest.setupFilesAfterEnv.ts`],
+    globalTeardown: `${akanjsPrefix}@akanjs/test/src/jest.globalTeardown.ts`,
+    testMatch: ["**/?(*.)+(test).ts?(x)"],
+    testPathIgnorePatterns: ["/node_modules/", "/app/"],
+    maxWorkers: 1,
+    transform: {
+      "signal\\.(test)\\.ts$": ["ts-jest", { tsconfig: "<rootDir>/tsconfig.spec.json" }],
+      "^.+\\.(ts|js|html)$": ["ts-jest", { tsconfig: "<rootDir>/tsconfig.spec.json" }],
+    },
+    moduleFileExtensions: ["ts", "tsx", "js", "jsx"],
+    coverageDirectory: `../../coverage/libs/${name}`,
+    coverageReporters: ["html"],
+    testEnvironment: "node",
+    testEnvironmentOptions: {
+      customExportConditions: ["node", "require", "default"],
+    },
+  };
+};

package/src/jest.globalSetup.d.ts

@@ -0,0 +1,4 @@
+import "tsconfig-paths/register";
+import type { Config } from "@jest/types";
+declare const setup: (globalConfig: Config.InitialOptions, projectConfig: any) => Promise<void>;
+export default setup;

package/src/jest.globalSetup.js

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jest_globalSetup_exports = {};
+__export(jest_globalSetup_exports, {
+  default: () => jest_globalSetup_default
+});
+module.exports = __toCommonJS(jest_globalSetup_exports);
+var import_register = require("tsconfig-paths/register");
+var import_jest = require("./jest.testServer");
+const setup = async (globalConfig, projectConfig) => {
+  const { env } = require(`${globalConfig.rootDir}/env/env.server.testing`);
+  const { fetch, registerModules } = require(`${globalConfig.rootDir}/server`);
+  const maxWorkers = globalConfig.maxWorkers;
+  if (!maxWorkers)
+    throw new Error("maxWorkers is not defined");
+  const testServers = new Array(maxWorkers).fill(0).map((_, idx) => new import_jest.TestServer(registerModules, env, idx + 1));
+  await Promise.all(testServers.map((server) => server.init()));
+  global.__TEST_SERVERS__ = testServers;
+  global.fetch = fetch;
+  global.env = env;
+  global.registerModules = registerModules;
+};
+var jest_globalSetup_default = setup;

package/src/jest.globalSetup.ts

@@ -0,0 +1,26 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+
+import "tsconfig-paths/register";
+
+import type { BackendEnv } from "@akanjs/base";
+import type { Config } from "@jest/types";
+
+import { TestServer } from "./jest.testServer";
+
+const setup = async (globalConfig: Config.InitialOptions, projectConfig) => {
+  const { env } = require(`${globalConfig.rootDir}/env/env.server.testing`);
+  const { fetch, registerModules } = require(`${globalConfig.rootDir}/server`);
+  const maxWorkers = globalConfig.maxWorkers;
+  if (!maxWorkers) throw new Error("maxWorkers is not defined");
+  const testServers = new Array(maxWorkers)
+    .fill(0)
+    .map((_, idx) => new TestServer(registerModules as (options: any) => any[], env as BackendEnv, idx + 1));
+  await Promise.all(testServers.map((server) => server.init()));
+  global.__TEST_SERVERS__ = testServers;
+  global.fetch = fetch;
+  global.env = env;
+  global.registerModules = registerModules;
+};
+
+export default setup;

package/src/jest.globalTeardown.d.ts

@@ -0,0 +1,3 @@
+import "tsconfig-paths/register";
+declare const teardown: (globalConfig: any, projectConfig: any) => Promise<void>;
+export default teardown;

package/src/jest.globalTeardown.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jest_globalTeardown_exports = {};
+__export(jest_globalTeardown_exports, {
+  default: () => jest_globalTeardown_default
+});
+module.exports = __toCommonJS(jest_globalTeardown_exports);
+var import_register = require("tsconfig-paths/register");
+const teardown = async (globalConfig, projectConfig) => {
+  const testServers = global.__TEST_SERVERS__;
+  if (!testServers)
+    throw new Error("Test servers are not defined");
+  await Promise.all(testServers.map((server) => server.terminate()));
+};
+var jest_globalTeardown_default = teardown;

package/src/jest.globalTeardown.ts

@@ -0,0 +1,12 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import "tsconfig-paths/register";
+
+import { TestServer } from "./jest.testServer";
+
+const teardown = async (globalConfig, projectConfig) => {
+  const testServers: TestServer[] | undefined = global.__TEST_SERVERS__;
+  if (!testServers) throw new Error("Test servers are not defined");
+  await Promise.all(testServers.map((server) => server.terminate()));
+};
+
+export default teardown;

package/src/jest.setupFilesAfterEnv.d.ts

@@ -0,0 +1 @@
+export {};

package/src/jest.setupFilesAfterEnv.js

@@ -0,0 +1,10 @@
+var import_jest = require("./jest.testServer");
+const { env, fetch } = global;
+jest.setTimeout(3e4);
+global.beforeAll(async () => {
+  import_jest.TestServer.initClient(env);
+  await fetch.cleanup();
+});
+global.afterAll(async () => {
+  await fetch.client.terminate();
+});

package/src/jest.setupFilesAfterEnv.ts

@@ -0,0 +1,17 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import type { BackendEnv } from "@akanjs/base";
+
+import { TestServer } from "./jest.testServer";
+
+const { env, fetch } = global as any;
+jest.setTimeout(30000);
+global.beforeAll(async () => {
+  TestServer.initClient(env as BackendEnv);
+  await fetch.cleanup();
+});
+
+global.afterAll(async () => {
+  await fetch.client.terminate();
+});

package/src/jest.testServer.d.ts

@@ -0,0 +1,11 @@
+import { type BackendEnv } from "@akanjs/base";
+export declare class TestServer {
+    #private;
+    workerId: number;
+    static initClient(env: BackendEnv, workerId?: number): void;
+    constructor(registerModules: (options: any) => any[], env: BackendEnv, workerId?: number);
+    init(): Promise<void>;
+    startMongo(): Promise<string>;
+    cleanup(): Promise<void>;
+    terminate(): Promise<void>;
+}

package/src/jest.testServer.js

@@ -0,0 +1,139 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jest_testServer_exports = {};
+__export(jest_testServer_exports, {
+  TestServer: () => TestServer
+});
+module.exports = __toCommonJS(jest_testServer_exports);
+var import_common = require("@akanjs/common");
+var import_server = require("@akanjs/server");
+var import_signal = require("@akanjs/signal");
+var import_mongodb_memory_server = require("mongodb-memory-server");
+var import_mongoose = __toESM(require("mongoose"));
+var import_redis_memory_server = require("redis-memory-server");
+const MAX_RETRY = 5;
+const TEST_LISTEN_PORT_BASE = 38080;
+const TEST_MONGODB_PORT_BASE = 38081;
+const TEST_REDIS_PORT_BASE = 38082;
+const MIN_ACTIVATION_TIME = 0;
+const MAX_ACTIVATION_TIME = 3e4;
+class TestServer {
+  #logger = new import_common.Logger("TestServer");
+  #mongod;
+  #redis;
+  #registerModules;
+  #env;
+  workerId;
+  #startAt = Date.now();
+  #app;
+  #portOffset = 0;
+  static initClient(env, workerId = parseInt(process.env.JEST_WORKER_ID ?? "0")) {
+    if (workerId === 0)
+      throw new Error("TestClient should not be used in main thread");
+    const portOffset = workerId * 1e3 + env.appCode * 10;
+    const port = TEST_LISTEN_PORT_BASE + portOffset;
+    const endpoint = `http://localhost:${port}/backend/graphql`;
+    import_signal.client.init({ uri: endpoint });
+  }
+  constructor(registerModules, env, workerId) {
+    this.workerId = workerId ?? parseInt(process.env.JEST_WORKER_ID ?? "0");
+    if (this.workerId === 0)
+      throw new Error("TestServer should not be used in main thread");
+    this.#portOffset = this.workerId * 1e3 + env.appCode * 10;
+    this.#mongod = new import_mongodb_memory_server.MongoMemoryServer({ instance: { port: TEST_MONGODB_PORT_BASE + this.#portOffset } });
+    this.#redis = new import_redis_memory_server.RedisMemoryServer({ instance: { port: TEST_REDIS_PORT_BASE + this.#portOffset } });
+    this.#env = { ...env };
+    this.#registerModules = registerModules;
+  }
+  async init() {
+    for (let i = 0; i < MAX_RETRY; i++) {
+      try {
+        const watchdog = setTimeout(() => {
+          throw new Error("TestServer Init Timeout");
+        }, MAX_ACTIVATION_TIME);
+        await this.#init();
+        clearTimeout(watchdog);
+        return;
+      } catch (e) {
+        this.#logger.error(e);
+        await this.terminate();
+      }
+    }
+  }
+  async #init() {
+    const now = Date.now();
+    this.#logger.log(`Test System #${this.workerId} Initializing...`);
+    const port = TEST_LISTEN_PORT_BASE + this.#portOffset;
+    const [mongoUri, redisHost, redisPort] = await Promise.all([
+      this.startMongo(),
+      this.#redis.getHost(),
+      this.#redis.getPort()
+    ]);
+    this.#env.port = port;
+    this.#env.mongoUri = mongoUri;
+    this.#env.redisUri = `redis://${redisHost}:${redisPort}`;
+    this.#env.meiliUri = "http://localhost:7700/search";
+    this.#env.onCleanup = async () => {
+      await this.cleanup();
+    };
+    this.#app = await (0, import_server.createNestApp)({ registerModules: this.#registerModules, env: this.#env });
+    this.#logger.log(`Test System #${this.workerId} Initialized, Mongo: ${mongoUri}, Redis: ${redisHost}:${redisPort}`);
+    this.#startAt = Date.now();
+    this.#logger.log(`Test System #${this.workerId} Activation Time: ${this.#startAt - now}ms`);
+  }
+  async startMongo() {
+    await this.#mongod.start();
+    return this.#mongod.getUri();
+  }
+  async cleanup() {
+    const now = Date.now();
+    this.#logger.log("Mongo Memory Database Cleaning up...");
+    if (this.#mongod.state === "running") {
+      await this.#mongod.stop();
+      await this.#mongod.start(true);
+    }
+    this.#logger.log(`Mongo Memory Database Cleaned up in ${Date.now() - now}ms`);
+  }
+  async terminate() {
+    const now = Date.now();
+    const elapsed = now - this.#startAt;
+    await (0, import_common.sleep)(50);
+    import_signal.client.io?.socket.close();
+    await this.#app.close();
+    if (elapsed < MIN_ACTIVATION_TIME) {
+      this.#logger.log(`waiting for ${MIN_ACTIVATION_TIME - elapsed}`);
+      await (0, import_common.sleep)(MIN_ACTIVATION_TIME - elapsed);
+    }
+    await Promise.all([import_mongoose.default.disconnect(), this.#mongod.stop(), this.#redis.stop()]);
+    this.#logger.log(`System Terminated in ${Date.now() - now}ms`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TestServer
+});

package/src/jest.testServer.ts

@@ -0,0 +1,104 @@
+import { type BackendEnv } from "@akanjs/base";
+import { Logger, sleep } from "@akanjs/common";
+import { type BackendApp, createNestApp } from "@akanjs/server";
+import { client } from "@akanjs/signal";
+import { MongoMemoryServer } from "mongodb-memory-server";
+import mongoose from "mongoose";
+import { RedisMemoryServer } from "redis-memory-server";
+
+const MAX_RETRY = 5;
+const TEST_LISTEN_PORT_BASE = 38080;
+const TEST_MONGODB_PORT_BASE = 38081;
+const TEST_REDIS_PORT_BASE = 38082;
+const MIN_ACTIVATION_TIME = 0;
+const MAX_ACTIVATION_TIME = 30000;
+
+export class TestServer {
+  readonly #logger = new Logger("TestServer");
+  readonly #mongod: MongoMemoryServer;
+  readonly #redis: RedisMemoryServer;
+  readonly #registerModules: (options: any) => any[];
+  readonly #env: BackendEnv;
+  workerId: number;
+  #startAt = Date.now();
+  #app: BackendApp;
+  #portOffset = 0;
+  static initClient(env: BackendEnv, workerId = parseInt(process.env.JEST_WORKER_ID ?? "0")) {
+    if (workerId === 0) throw new Error("TestClient should not be used in main thread");
+    const portOffset = workerId * 1000 + env.appCode * 10;
+    const port = TEST_LISTEN_PORT_BASE + portOffset;
+    const endpoint = `http://localhost:${port}/backend/graphql`;
+    client.init({ uri: endpoint });
+  }
+  constructor(registerModules: (options: any) => any[], env: BackendEnv, workerId?: number) {
+    this.workerId = workerId ?? parseInt(process.env.JEST_WORKER_ID ?? "0");
+    if (this.workerId === 0) throw new Error("TestServer should not be used in main thread");
+    this.#portOffset = this.workerId * 1000 + env.appCode * 10;
+    this.#mongod = new MongoMemoryServer({ instance: { port: TEST_MONGODB_PORT_BASE + this.#portOffset } });
+    this.#redis = new RedisMemoryServer({ instance: { port: TEST_REDIS_PORT_BASE + this.#portOffset } });
+    this.#env = { ...env };
+    this.#registerModules = registerModules;
+  }
+  async init() {
+    for (let i = 0; i < MAX_RETRY; i++) {
+      try {
+        const watchdog = setTimeout(() => {
+          throw new Error("TestServer Init Timeout");
+        }, MAX_ACTIVATION_TIME);
+        await this.#init();
+        clearTimeout(watchdog);
+        return;
+      } catch (e) {
+        this.#logger.error(e as string);
+        await this.terminate();
+      }
+    }
+  }
+  async #init() {
+    const now = Date.now();
+    this.#logger.log(`Test System #${this.workerId} Initializing...`);
+    const port = TEST_LISTEN_PORT_BASE + this.#portOffset;
+    const [mongoUri, redisHost, redisPort] = await Promise.all([
+      this.startMongo(),
+      this.#redis.getHost(),
+      this.#redis.getPort(),
+    ]);
+    this.#env.port = port;
+    this.#env.mongoUri = mongoUri;
+    this.#env.redisUri = `redis://${redisHost}:${redisPort}`;
+    this.#env.meiliUri = "http://localhost:7700/search";
+    this.#env.onCleanup = async () => {
+      await this.cleanup();
+    };
+    this.#app = await createNestApp({ registerModules: this.#registerModules, env: this.#env });
+    this.#logger.log(`Test System #${this.workerId} Initialized, Mongo: ${mongoUri}, Redis: ${redisHost}:${redisPort}`);
+    this.#startAt = Date.now();
+    this.#logger.log(`Test System #${this.workerId} Activation Time: ${this.#startAt - now}ms`);
+  }
+  async startMongo() {
+    await this.#mongod.start();
+    return this.#mongod.getUri();
+  }
+  async cleanup() {
+    const now = Date.now();
+    this.#logger.log("Mongo Memory Database Cleaning up...");
+    if (this.#mongod.state === "running") {
+      await this.#mongod.stop();
+      await this.#mongod.start(true);
+    }
+    this.#logger.log(`Mongo Memory Database Cleaned up in ${Date.now() - now}ms`);
+  }
+  async terminate() {
+    const now = Date.now();
+    const elapsed = now - this.#startAt;
+    await sleep(50); // cooldown
+    client.io?.socket.close();
+    await this.#app.close();
+    if (elapsed < MIN_ACTIVATION_TIME) {
+      this.#logger.log(`waiting for ${MIN_ACTIVATION_TIME - elapsed}`);
+      await sleep(MIN_ACTIVATION_TIME - elapsed);
+    }
+    await Promise.all([mongoose.disconnect(), this.#mongod.stop(), this.#redis.stop()]);
+    this.#logger.log(`System Terminated in ${Date.now() - now}ms`);
+  }
+}

package/src/playwright.config.base.d.ts

@@ -0,0 +1,9 @@
+import { type PlaywrightTestConfig } from "@playwright/test";
+/**
+ * Read environment variables from file.
+ * https://github.com/motdotla/dotenv
+ */
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+export declare const withBase: (filename: string, config?: PlaywrightTestConfig) => PlaywrightTestConfig<{}, {}>;

package/src/playwright.config.base.js

@@ -0,0 +1,80 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var playwright_config_base_exports = {};
+__export(playwright_config_base_exports, {
+  withBase: () => withBase
+});
+module.exports = __toCommonJS(playwright_config_base_exports);
+var import_devkit = require("@nx/devkit");
+var import_preset = require("@nx/playwright/preset");
+var import_test = require("@playwright/test");
+const baseURL = process.env.BASE_URL ?? "http://127.0.0.1:4200";
+const projectName = process.env.NX_TASK_TARGET_PROJECT ?? "unknown";
+const withBase = (filename, config = {}) => (0, import_test.defineConfig)({
+  ...(0, import_preset.nxE2EPreset)(filename, { testDir: "./app" }),
+  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+  use: {
+    baseURL,
+    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+    trace: "on-first-retry"
+  },
+  /* Run your local dev server before starting the tests */
+  webServer: {
+    command: `nx serve ${projectName}`,
+    url: "http://127.0.0.1:4200",
+    reuseExistingServer: !process.env.CI,
+    cwd: import_devkit.workspaceRoot
+  },
+  projects: [
+    {
+      name: "chromium",
+      use: { ...import_test.devices["Desktop Chrome"] }
+    },
+    {
+      name: "firefox",
+      use: { ...import_test.devices["Desktop Firefox"] }
+    },
+    {
+      name: "webkit",
+      use: { ...import_test.devices["Desktop Safari"] }
+    }
+    // Uncomment for mobile browsers support
+    /* {
+      name: 'Mobile Chrome',
+      use: { ...devices['Pixel 5'] },
+    },
+    {
+      name: 'Mobile Safari',
+      use: { ...devices['iPhone 12'] },
+    }, */
+    // Uncomment for branded browsers
+    /* {
+      name: 'Microsoft Edge',
+      use: { ...devices['Desktop Edge'], channel: 'msedge' },
+    },
+    {
+      name: 'Google Chrome',
+      use: { ...devices['Desktop Chrome'], channel: 'chrome' },
+    } */
+  ],
+  ...config
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withBase
+});

package/src/playwright.config.base.ts

@@ -0,0 +1,71 @@
+import { workspaceRoot } from "@nx/devkit";
+import { nxE2EPreset } from "@nx/playwright/preset";
+import { defineConfig, devices, type PlaywrightTestConfig } from "@playwright/test";
+
+// For CI, you may want to set BASE_URL to the deployed application.
+const baseURL = process.env.BASE_URL ?? "http://127.0.0.1:4200";
+const projectName = process.env.NX_TASK_TARGET_PROJECT ?? "unknown";
+
+/**
+ * Read environment variables from file.
+ * https://github.com/motdotla/dotenv
+ */
+// require('dotenv').config();
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+export const withBase = (filename: string, config: PlaywrightTestConfig = {}) =>
+  defineConfig({
+    ...nxE2EPreset(filename, { testDir: "./app" }),
+    /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+    use: {
+      baseURL,
+      /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+      trace: "on-first-retry",
+    },
+    /* Run your local dev server before starting the tests */
+    webServer: {
+      command: `nx serve ${projectName}`,
+      url: "http://127.0.0.1:4200",
+      reuseExistingServer: !process.env.CI,
+      cwd: workspaceRoot,
+    },
+    projects: [
+      {
+        name: "chromium",
+        use: { ...devices["Desktop Chrome"] },
+      },
+
+      {
+        name: "firefox",
+        use: { ...devices["Desktop Firefox"] },
+      },
+
+      {
+        name: "webkit",
+        use: { ...devices["Desktop Safari"] },
+      },
+
+      // Uncomment for mobile browsers support
+      /* {
+      name: 'Mobile Chrome',
+      use: { ...devices['Pixel 5'] },
+    },
+    {
+      name: 'Mobile Safari',
+      use: { ...devices['iPhone 12'] },
+    }, */
+
+      // Uncomment for branded browsers
+      /* {
+      name: 'Microsoft Edge',
+      use: { ...devices['Desktop Edge'], channel: 'msedge' },
+    },
+    {
+      name: 'Google Chrome',
+      use: { ...devices['Desktop Chrome'], channel: 'chrome' },
+    } */
+    ],
+    ...config,
+  });

package/src/playwright.pageAgent.d.ts

@@ -0,0 +1,13 @@
+import { type Page } from "@playwright/test";
+import { test } from "@playwright/test";
+export { expect } from "@playwright/test";
+export { test };
+export declare class PageAgent {
+    #private;
+    readonly page: Page;
+    constructor(page: Page);
+    goto(path: string): Promise<void>;
+    waitForPathChange(path?: string): Promise<unknown>;
+    wait(ms?: number): Promise<void>;
+    url(): string;
+}

package/src/playwright.pageAgent.js

@@ -0,0 +1,67 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var playwright_pageAgent_exports = {};
+__export(playwright_pageAgent_exports, {
+  PageAgent: () => PageAgent,
+  expect: () => import_test3.expect,
+  test: () => import_test2.test
+});
+module.exports = __toCommonJS(playwright_pageAgent_exports);
+var import_test2 = require("@playwright/test");
+var import_test3 = require("@playwright/test");
+class PageAgent {
+  page;
+  #defaultWaitMs = 500;
+  #isInitialized = false;
+  constructor(page) {
+    this.page = page;
+  }
+  async goto(path) {
+    await Promise.all([this.page.goto(path), this.waitForPathChange(path)]);
+    if (!this.#isInitialized) {
+      this.#isInitialized = true;
+    }
+  }
+  async waitForPathChange(path) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Timeout waiting for pathChange message"));
+      }, 3e4);
+      this.page.on("console", (msg) => {
+        if (msg.type() === "log" && msg.text().startsWith(`%cpathChange-finished:${path ?? ""}`)) {
+          clearInterval(timeout);
+          setTimeout(() => {
+            resolve(true);
+          }, this.#defaultWaitMs);
+        }
+      });
+    });
+  }
+  async wait(ms = this.#defaultWaitMs) {
+    await this.page.waitForTimeout(ms);
+  }
+  url() {
+    return "/" + this.page.url().split("/").slice(4).join("/");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PageAgent,
+  expect,
+  test
+});

package/src/playwright.pageAgent.ts

@@ -0,0 +1,42 @@
+import { type Page } from "@playwright/test";
+import { test } from "@playwright/test";
+
+export { expect } from "@playwright/test";
+export { test };
+
+export class PageAgent {
+  readonly page: Page;
+  readonly #defaultWaitMs = 500;
+  #isInitialized = false;
+  constructor(page: Page) {
+    this.page = page;
+  }
+  async goto(path: string) {
+    await Promise.all([this.page.goto(path), this.waitForPathChange(path)]);
+    if (!this.#isInitialized) {
+      // await this.page.waitForEvent("websocket");
+      this.#isInitialized = true;
+    }
+  }
+  async waitForPathChange(path?: string) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Timeout waiting for pathChange message"));
+      }, 30000);
+      this.page.on("console", (msg) => {
+        if (msg.type() === "log" && msg.text().startsWith(`%cpathChange-finished:${path ?? ""}`)) {
+          clearInterval(timeout);
+          setTimeout(() => {
+            resolve(true);
+          }, this.#defaultWaitMs);
+        }
+      });
+    });
+  }
+  async wait(ms = this.#defaultWaitMs) {
+    await this.page.waitForTimeout(ms);
+  }
+  url() {
+    return "/" + this.page.url().split("/").slice(4).join("/");
+  }
+}