akanjs 0.0.1 → 2.0.0-beta.0

package/service/predefinedAdaptor/index.ts

@@ -0,0 +1,13 @@
+export * from "./cache.adaptor";
+export * from "./compress.adaptor";
+export * from "./database.adaptor";
+export * from "./logging.adaptor";
+export * from "./queue.adaptor";
+export * from "./role.adaptor";
+export * from "./schedule.adaptor";
+export * from "./solidCache.adaptor";
+export * from "./solidPubsub.adaptor";
+export * from "./solidQueue.adaptor";
+export * from "./solidSqlite";
+export * from "./storage.adaptor";
+export * from "./websocket.adaptor";

package/service/predefinedAdaptor/logging.adaptor.ts

@@ -0,0 +1,36 @@
+import { Logger } from "akanjs/common";
+import { adapt } from "../adapt";
+
+export interface LoggingAdaptor {
+  trace(name: string, msg: string, context?: string): void;
+  verbose(name: string, msg: string, context?: string): void;
+  debug(name: string, msg: string, context?: string): void;
+  log(name: string, msg: string, context?: string): void;
+  info(name: string, msg: string, context?: string): void;
+  warn(name: string, msg: string, context?: string): void;
+  error(name: string, msg: string, context?: string): void;
+}
+
+export class ConsoleLogger extends adapt("consoleLogger", () => ({})) implements LoggingAdaptor {
+  trace(name: string, msg: string, context?: string): void {
+    Logger.trace(msg, context, name);
+  }
+  verbose(name: string, msg: string, context?: string): void {
+    Logger.verbose(msg, context, name);
+  }
+  debug(name: string, msg: string, context?: string): void {
+    Logger.debug(msg, context, name);
+  }
+  log(name: string, msg: string, context?: string): void {
+    Logger.log(msg, context, name);
+  }
+  info(name: string, msg: string, context?: string): void {
+    Logger.info(msg, context, name);
+  }
+  warn(name: string, msg: string, context?: string): void {
+    Logger.warn(msg, context, name);
+  }
+  error(name: string, msg: string, context?: string): void {
+    Logger.error(msg, context, name);
+  }
+}

package/service/predefinedAdaptor/queue.adaptor.ts

@@ -0,0 +1,42 @@
+import { type BaseEnv, getEnv } from "akanjs/base";
+import { type ConnectionOptions, type Job, type JobsOptions, Queue, Worker } from "bullmq";
+import { adapt } from "../adapt";
+import type { AkanJob, AkanJobOptions, AkanWorker } from "../ipcTypes";
+import { RedisCache } from "./cache.adaptor";
+
+export interface QueueAdaptor {
+  registerProcessWorker(key: string, handler: (job: AkanJob) => Promise<void>): AkanWorker;
+  registerProcessQueue(key: string, args: unknown[], jobOptions?: AkanJobOptions): Promise<AkanJob>;
+}
+
+export class BullQueue
+  extends adapt("bullQueue", ({ plug, env }) => ({
+    redis: plug(RedisCache, (redisCache) => redisCache.getClient()),
+    queue: plug(
+      RedisCache,
+      (redisCache) =>
+        new Queue(`queue-${getEnv().repoName}-${getEnv().appName}-${getEnv().environment}-${getEnv().operationMode}`, {
+          connection: redisCache.getClient() as ConnectionOptions,
+          defaultJobOptions: { removeOnComplete: true, removeOnFail: true },
+        }),
+    ),
+    prefix: env((env: BaseEnv) => `queue-${env.repoName}-${env.appName}-${env.environment}-${env.operationMode}`),
+  }))
+  implements QueueAdaptor
+{
+  override async onInit(): Promise<void> {
+  }
+  getQueue(): Queue {
+    return this.queue;
+  }
+  registerProcessWorker(key: string, handler: (job: AkanJob) => Promise<void>): Worker {
+    const worker = new Worker(`${this.prefix}:${key}`, handler as (job: Job) => Promise<void>, {
+      connection: this.redis as ConnectionOptions,
+    });
+    return worker;
+  }
+  async registerProcessQueue(key: string, args: unknown[], jobOptions?: AkanJobOptions): Promise<AkanJob> {
+    const job = await this.queue.add(`${this.prefix}:${key}`, args, jobOptions as JobsOptions | undefined);
+    return job as unknown as AkanJob;
+  }
+}

package/service/predefinedAdaptor/role.adaptor.ts

@@ -0,0 +1,18 @@
+import { type AdaptorCls, adapt } from "../adapt";
+import type { CacheAdaptor } from "./cache.adaptor";
+import type { CompressAdaptor } from "./compress.adaptor";
+import type { DatabaseAdaptor } from "./database.adaptor";
+import type { LoggingAdaptor } from "./logging.adaptor";
+import type { QueueAdaptor } from "./queue.adaptor";
+import type { ScheduleAdaptor } from "./schedule.adaptor";
+import type { StorageAdaptor } from "./storage.adaptor";
+import type { WebsocketAdaptor } from "./websocket.adaptor";
+
+export const DatabaseAdaptorRole = adapt("databaseAdaptorRole") as AdaptorCls<DatabaseAdaptor>;
+export const CacheAdaptorRole = adapt("cacheAdaptorRole") as AdaptorCls<CacheAdaptor>;
+export const StorageAdaptorRole = adapt("storageAdaptorRole") as AdaptorCls<StorageAdaptor>;
+export const QueueAdaptorRole = adapt("queueAdaptorRole") as AdaptorCls<QueueAdaptor>;
+export const ScheduleAdaptorRole = adapt("scheduleAdaptorRole") as AdaptorCls<ScheduleAdaptor>;
+export const LoggingAdaptorRole = adapt("loggingAdaptorRole") as AdaptorCls<LoggingAdaptor>;
+export const WebsocketAdaptorRole = adapt("websocketAdaptorRole") as AdaptorCls<WebsocketAdaptor>;
+export const CompressAdaptorRole = adapt("compressAdaptorRole") as AdaptorCls<CompressAdaptor>;

package/service/predefinedAdaptor/schedule.adaptor.ts

@@ -0,0 +1,188 @@
+import { Cron } from "croner";
+import { adapt } from "../adapt";
+import { CacheAdaptorRole } from "./role.adaptor";
+
+export interface ScheduleAdaptor {
+  getCron(key: string): Cron | undefined;
+  registerCron(key: string, cronStr: string, callback: () => Promise<void>, option?: { lock?: boolean }): Cron;
+  unregisterCron(key: string): void;
+  getInterval(key: string): NodeJS.Timeout | undefined;
+  registerInterval(
+    key: string,
+    scheduleTime: number,
+    callback: () => Promise<void>,
+    option?: { lock?: boolean },
+  ): NodeJS.Timeout;
+  unregisterInterval(key: string): void;
+  getTimeout(key: string): NodeJS.Timeout | undefined;
+  registerTimeout(
+    key: string,
+    timeout: number,
+    callback: () => Promise<void>,
+    option?: { lock?: boolean },
+  ): NodeJS.Timeout;
+  unregisterTimeout(key: string): void;
+  getInit(key: string): (() => Promise<void>) | undefined;
+  registerInit(key: string, callback: () => Promise<void>): void;
+  unregisterInit(key: string): void;
+  _runInit(): Promise<void>;
+  getDestroy(key: string): (() => Promise<void>) | undefined;
+  registerDestroy(key: string, callback: () => Promise<void>): void;
+  unregisterDestroy(key: string): void;
+  _runDestroy(): Promise<void>;
+}
+
+export class Scheduler
+  extends adapt("scheduler", ({ plug }) => ({
+    cache: plug(CacheAdaptorRole),
+  }))
+  implements ScheduleAdaptor
+{
+  readonly lockMap = new Map<string, boolean>();
+  readonly cronMap = new Map<string, Cron>();
+  readonly intervalMap = new Map<string, NodeJS.Timeout>();
+  readonly timeoutMap = new Map<string, NodeJS.Timeout>();
+  readonly initMap = new Map<string, () => Promise<void>>();
+  readonly destroyMap = new Map<string, () => Promise<void>>();
+  getCron(key: string) {
+    return this.cronMap.get(key);
+  }
+  registerCron(key: string, cronStr: string, callback: () => Promise<void>, { lock = true }: { lock?: boolean } = {}) {
+    const cron = new Cron(cronStr, async () => {
+      if (this.lockMap.get(key) && lock) {
+        this.logger.warn(`Schedule ${key} is locked, skipped`);
+        return;
+      }
+      try {
+        this.lockMap.set(key, true);
+        const now = Date.now();
+        this.logger.debug(`Schedule ${key} started`);
+        await callback();
+        this.logger.debug(`Schedule ${key} finished ${Date.now() - now}ms`);
+      } catch (e) {
+        this.logger.error(`Schedule ${key} error: ${e}`);
+      } finally {
+        this.lockMap.delete(key);
+      }
+    });
+    this.cronMap.set(key, cron);
+    return cron;
+  }
+  unregisterCron(key: string) {
+    const cron = this.cronMap.get(key);
+    if (cron) cron.stop();
+    this.cronMap.delete(key);
+    this.lockMap.delete(key);
+  }
+  getInterval(key: string) {
+    return this.intervalMap.get(key);
+  }
+  registerInterval(
+    key: string,
+    scheduleTime: number,
+    callback: () => Promise<void>,
+    { lock = true }: { lock?: boolean } = {},
+  ) {
+    const interval = setInterval(async () => {
+      if (this.lockMap.get(key) && lock) {
+        this.logger.warn(`Schedule interval ${key} is locked, skipped`);
+        return;
+      }
+      try {
+        this.lockMap.set(key, true);
+        const now = Date.now();
+        this.logger.debug(`Schedule interval ${key} started`);
+        await callback();
+        this.logger.debug(`Schedule interval ${key} finished ${Date.now() - now}ms`);
+      } catch (e) {
+        this.logger.error(`Schedule interval ${key} error: ${e}`);
+      } finally {
+        this.lockMap.delete(key);
+      }
+    }, scheduleTime);
+    this.intervalMap.set(key, interval);
+    return interval;
+  }
+  unregisterInterval(key: string) {
+    const interval = this.intervalMap.get(key);
+    if (interval) clearInterval(interval);
+    this.intervalMap.delete(key);
+    this.lockMap.delete(key);
+  }
+  getTimeout(key: string) {
+    return this.timeoutMap.get(key);
+  }
+  registerTimeout(key: string, scheduleTime: number, callback: () => Promise<void>) {
+    const timeout = setTimeout(async () => {
+      try {
+        const now = Date.now();
+        this.logger.debug(`Schedule timeout ${key} started`);
+        await callback();
+        this.logger.debug(`Schedule timeout ${key} finished ${Date.now() - now}ms`);
+      } catch (e) {
+        this.logger.error(`Schedule timeout ${key} error: ${e}`);
+      }
+    }, scheduleTime);
+    this.timeoutMap.set(key, timeout);
+    return timeout;
+  }
+  unregisterTimeout(key: string) {
+    const timeout = this.timeoutMap.get(key);
+    if (timeout) clearTimeout(timeout);
+    this.timeoutMap.delete(key);
+    this.lockMap.delete(key);
+  }
+  getInit(key: string) {
+    return this.initMap.get(key);
+  }
+  registerInit(key: string, callback: () => Promise<void>) {
+    this.initMap.set(key, async () => {
+      try {
+        const now = Date.now();
+        this.logger.debug(`Schedule init ${key} started`);
+        await callback();
+        this.logger.debug(`Schedule init ${key} finished ${Date.now() - now}ms`);
+      } catch (e) {
+        this.logger.error(`Schedule init ${key} error: ${e}`);
+      }
+    });
+  }
+  unregisterInit(key: string) {
+    this.initMap.delete(key);
+  }
+  async _runInit() {
+    await Promise.all([...this.initMap.values()].map((callback) => callback()));
+  }
+  getDestroy(key: string) {
+    return this.destroyMap.get(key);
+  }
+  registerDestroy(key: string, callback: () => Promise<void>) {
+    this.destroyMap.set(key, async () => {
+      try {
+        const now = Date.now();
+        this.logger.debug(`Schedule destroy ${key} started`);
+        await callback();
+        this.logger.debug(`Schedule destroy ${key} finished ${Date.now() - now}ms`);
+      } catch (e) {
+        this.logger.error(`Schedule destroy ${key} error: ${e}`);
+      }
+    });
+  }
+  unregisterDestroy(key: string) {
+    this.destroyMap.delete(key);
+  }
+  async _runDestroy() {
+    await Promise.all([...this.destroyMap.values()].map((callback) => callback()));
+  }
+  override async onDestroy() {
+    for (const cron of this.cronMap.values()) cron.stop();
+    for (const interval of this.intervalMap.values()) clearInterval(interval);
+    for (const timeout of this.timeoutMap.values()) clearTimeout(timeout);
+    this.cronMap.clear();
+    this.intervalMap.clear();
+    this.timeoutMap.clear();
+    this.initMap.clear();
+    this.destroyMap.clear();
+    this.lockMap.clear();
+  }
+}

package/service/predefinedAdaptor/solidCache.adaptor.ts

@@ -0,0 +1,143 @@
+import type { Database } from "bun:sqlite";
+import type { Dayjs } from "akanjs/base";
+import { adapt } from "../adapt";
+import type { CacheAdaptor } from "./cache.adaptor";
+import {
+  decodeSolidValue,
+  encodeSolidValue,
+  getSolidConfig,
+  openSolidDatabase,
+  type SolidConfig,
+  type SolidEnv,
+  type SolidValueType,
+  toEpochMs,
+} from "./solidSqlite";
+
+type CacheRow = { value: string | Buffer | null; valueType: SolidValueType; expiresAt: number | null };
+
+export class SolidCache
+  extends adapt("solidCache", ({ env }) => ({
+    config: env((env: SolidEnv) => getSolidConfig(env)),
+  }))
+  implements CacheAdaptor
+{
+  #db!: Database;
+  #cleanupTimer: Timer | null = null;
+
+  override async onInit() {
+    this.#db = await openSolidDatabase(this.config as Required<SolidConfig>);
+    this.#db.run(
+      `CREATE TABLE IF NOT EXISTS "_akan_solid_cache" (
+        "topic" TEXT NOT NULL,
+        "key" TEXT NOT NULL,
+        "value" BLOB NOT NULL,
+        "valueType" TEXT NOT NULL,
+        "expiresAt" INTEGER,
+        "createdAt" INTEGER NOT NULL,
+        "updatedAt" INTEGER NOT NULL,
+        PRIMARY KEY ("topic", "key")
+      )`,
+    );
+    this.#db.run(
+      `CREATE TABLE IF NOT EXISTS "_akan_solid_cache_hash" (
+        "topic" TEXT NOT NULL,
+        "key" TEXT NOT NULL,
+        "subKey" TEXT NOT NULL,
+        "value" BLOB NOT NULL,
+        "valueType" TEXT NOT NULL,
+        "expiresAt" INTEGER,
+        "createdAt" INTEGER NOT NULL,
+        "updatedAt" INTEGER NOT NULL,
+        PRIMARY KEY ("topic", "key", "subKey")
+      )`,
+    );
+    this.#cleanupTimer = setInterval(() => this.#cleanup(), this.config.cleanupIntervalMs);
+    this.#cleanup();
+  }
+
+  override async onDestroy() {
+    if (this.#cleanupTimer) clearInterval(this.#cleanupTimer);
+    this.#db?.run("PRAGMA wal_checkpoint(TRUNCATE)");
+    this.#db?.close();
+  }
+
+  async set(topic: string, key: string, value: string | number | Buffer, option: { expireAt?: Dayjs } = {}) {
+    const encoded = encodeSolidValue(value);
+    const now = Date.now();
+    this.#db
+      .query(
+        `INSERT INTO "_akan_solid_cache" ("topic", "key", "value", "valueType", "expiresAt", "createdAt", "updatedAt")
+         VALUES (?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT("topic", "key") DO UPDATE SET
+          "value" = excluded."value",
+          "valueType" = excluded."valueType",
+          "expiresAt" = excluded."expiresAt",
+          "updatedAt" = excluded."updatedAt"`,
+      )
+      .run(topic, key, encoded.value, encoded.type, toEpochMs(option.expireAt), now, now);
+  }
+
+  async get<T extends string | number | Buffer>(topic: string, key: string): Promise<T | undefined> {
+    const row = this.#db
+      .query(`SELECT "value", "valueType", "expiresAt" FROM "_akan_solid_cache" WHERE "topic" = ? AND "key" = ?`)
+      .get(topic, key) as CacheRow | null;
+    if (!row) return undefined;
+    if (row.expiresAt !== null && row.expiresAt <= Date.now()) {
+      await this.delete(topic, key);
+      return undefined;
+    }
+    return decodeSolidValue<T>(row.valueType, row.value);
+  }
+
+  async delete(topic: string, key: string) {
+    this.#db.query(`DELETE FROM "_akan_solid_cache" WHERE "topic" = ? AND "key" = ?`).run(topic, key);
+  }
+
+  async hset(
+    topic: string,
+    key: string,
+    subKey: string,
+    value: string | number | Buffer,
+    option: { expireAt?: Dayjs } = {},
+  ) {
+    const encoded = encodeSolidValue(value);
+    const now = Date.now();
+    this.#db
+      .query(
+        `INSERT INTO "_akan_solid_cache_hash" ("topic", "key", "subKey", "value", "valueType", "expiresAt", "createdAt", "updatedAt")
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT("topic", "key", "subKey") DO UPDATE SET
+          "value" = excluded."value",
+          "valueType" = excluded."valueType",
+          "expiresAt" = excluded."expiresAt",
+          "updatedAt" = excluded."updatedAt"`,
+      )
+      .run(topic, key, subKey, encoded.value, encoded.type, toEpochMs(option.expireAt), now, now);
+  }
+
+  async hget<T extends string | number | Buffer>(topic: string, key: string, subKey: string): Promise<T | undefined> {
+    const row = this.#db
+      .query(
+        `SELECT "value", "valueType", "expiresAt" FROM "_akan_solid_cache_hash" WHERE "topic" = ? AND "key" = ? AND "subKey" = ?`,
+      )
+      .get(topic, key, subKey) as CacheRow | null;
+    if (!row) return undefined;
+    if (row.expiresAt !== null && row.expiresAt <= Date.now()) {
+      await this.hdelete(topic, key, subKey);
+      return undefined;
+    }
+    return decodeSolidValue<T>(row.valueType, row.value);
+  }
+
+  async hdelete(topic: string, key: string, subKey: string): Promise<void> {
+    this.#db
+      .query(`DELETE FROM "_akan_solid_cache_hash" WHERE "topic" = ? AND "key" = ? AND "subKey" = ?`)
+      .run(topic, key, subKey);
+  }
+
+  #cleanup() {
+    const now = Date.now();
+    this.#db.query(`DELETE FROM "_akan_solid_cache" WHERE "expiresAt" IS NOT NULL AND "expiresAt" <= ?`).run(now);
+    this.#db.query(`DELETE FROM "_akan_solid_cache_hash" WHERE "expiresAt" IS NOT NULL AND "expiresAt" <= ?`).run(now);
+  }
+}

package/service/predefinedAdaptor/solidPubsub.adaptor.ts

@@ -0,0 +1,98 @@
+import type { BaseEnv, Cls } from "akanjs/base";
+import { adapt } from "../adapt";
+import { sendAkanIpc } from "../ipcTypes";
+import type { WebsocketAdaptor, WsRedisEventHandler, WsSocketData } from "./websocket.adaptor";
+
+const getSocketId = (ws: Bun.ServerWebSocket<unknown>, serverId: string) => {
+  const data = ws.data as WsSocketData;
+  if (!data.socketId) data.socketId = `${serverId}-${Bun.randomUUIDv7()}`;
+  return data.socketId;
+};
+
+export class SolidPubSub
+  extends adapt("solidPubsub", ({ env }) => ({
+    serverId: env(
+      ({ appName, environment, operationMode }: BaseEnv) =>
+        `${appName}-${environment}-${operationMode}-${process.env.AKAN_REPLICA_IDX ?? "0"}-${process.pid}`,
+    ),
+  }))
+  implements WebsocketAdaptor
+{
+  readonly #endpointMap = new Map<string, { returnRef: Cls; arrDepth: number }>();
+  readonly #socketRooms = new Map<string, Set<string>>();
+  #eventHandler: WsRedisEventHandler | null = null;
+  readonly #messageHandler = (message: unknown) => {
+    if (!message || typeof message !== "object") return;
+    const data = message as { type?: string; roomId?: string; data?: unknown; origin?: string };
+    if (data.type === "pubsub.deliver" && data.roomId && data.origin !== this.serverId) {
+      this.#eventHandler?.(data.roomId, data.data);
+      return;
+    }
+    if (data.type === "pubsub.snapshot.request") {
+      sendAkanIpc({
+        type: "pubsub.snapshot",
+        rooms: [...new Set([...this.#socketRooms.values()].flatMap((rooms) => [...rooms]))],
+        pid: process.pid,
+      });
+    }
+  };
+
+  override async onInit() {
+    process.on("message", this.#messageHandler);
+  }
+
+  override async onDestroy() {
+    process.off("message", this.#messageHandler);
+    this.#eventHandler = null;
+    this.#socketRooms.clear();
+  }
+
+  publish(roomId: string, data: unknown): void {
+    sendAkanIpc({ type: "pubsub.publish", roomId, data: data as object | object[], origin: this.serverId });
+  }
+
+  setEventHandler(handler: WsRedisEventHandler): void {
+    this.#eventHandler = handler;
+  }
+
+  clearEventHandler(): void {
+    this.#eventHandler = null;
+  }
+
+  registerEndpoint(key: string, returnRef: Cls, arrDepth: number): void {
+    this.#endpointMap.set(key, { returnRef, arrDepth });
+  }
+
+  async joinRoom(ws: Bun.ServerWebSocket<unknown>, room: string): Promise<void> {
+    const socketId = getSocketId(ws, this.serverId);
+    const rooms = this.#socketRooms.get(socketId) ?? new Set<string>();
+    rooms.add(room);
+    this.#socketRooms.set(socketId, rooms);
+    sendAkanIpc({ type: "pubsub.subscribe", roomId: room, socketId, pid: process.pid });
+  }
+
+  async leaveRoom(ws: Bun.ServerWebSocket<unknown>, room: string): Promise<void> {
+    const socketId = getSocketId(ws, this.serverId);
+    const rooms = this.#socketRooms.get(socketId);
+    rooms?.delete(room);
+    if (!rooms || rooms.size === 0) this.#socketRooms.delete(socketId);
+    sendAkanIpc({ type: "pubsub.unsubscribe", roomId: room, socketId, pid: process.pid });
+  }
+
+  async leaveAllRooms(ws: Bun.ServerWebSocket<unknown>): Promise<void> {
+    const socketId = getSocketId(ws, this.serverId);
+    const rooms = this.#socketRooms.get(socketId);
+    if (rooms) {
+      for (const room of rooms) sendAkanIpc({ type: "pubsub.unsubscribe", roomId: room, socketId, pid: process.pid });
+    }
+    this.#socketRooms.delete(socketId);
+  }
+
+  async registerSocket(ws: Bun.ServerWebSocket<unknown>): Promise<void> {
+    getSocketId(ws, this.serverId);
+  }
+
+  async unregisterSocket(ws: Bun.ServerWebSocket<unknown>): Promise<void> {
+    await this.leaveAllRooms(ws);
+  }
+}