@bgord/bun 0.5.0 → 0.6.0

package/src/prerequisites/log-file.ts

@@ -0,0 +1,35 @@
+import { Logger } from "../logger";
+import {
+  AbstractPrerequisite,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+  PrerequisiteStrategyEnum,
+} from "../prerequisites";
+
+type PrerequisiteLogFileConfigType = {
+  logger: Logger;
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+};
+
+export class PrerequisiteLogFile extends AbstractPrerequisite<PrerequisiteLogFileConfigType> {
+  readonly strategy = PrerequisiteStrategyEnum.logFile;
+
+  constructor(readonly config: PrerequisiteLogFileConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<PrerequisiteStatusEnum> {
+    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+
+    try {
+      const path = this.config.logger.getProductionLogFilePath();
+
+      const result = await Bun.file(path).exists();
+
+      return result ? this.pass() : this.reject();
+    } catch (error) {
+      return this.reject();
+    }
+  }
+}

package/src/prerequisites/mailer.ts

@@ -0,0 +1,32 @@
+import { Mailer } from "../mailer";
+import {
+  AbstractPrerequisite,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+  PrerequisiteStrategyEnum,
+} from "../prerequisites";
+
+type PrerequisiteMailerConfigType = {
+  mailer: Mailer;
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+};
+
+export class PrerequisiteMailer extends AbstractPrerequisite<PrerequisiteMailerConfigType> {
+  readonly strategy = PrerequisiteStrategyEnum.mailer;
+
+  constructor(readonly config: PrerequisiteMailerConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<PrerequisiteStatusEnum> {
+    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+
+    try {
+      await this.config.mailer.verify();
+      return this.pass();
+    } catch (error) {
+      return this.reject();
+    }
+  }
+}

package/src/prerequisites/memory.ts

@@ -0,0 +1,34 @@
+import * as tools from "@bgord/tools";
+import { MemoryConsumption } from "../memory-consumption";
+
+import {
+  AbstractPrerequisite,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+  PrerequisiteStrategyEnum,
+} from "../prerequisites";
+
+type PrerequisiteMemoryConfigType = {
+  maximum: tools.Size;
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+};
+
+export class PrerequisiteMemory extends AbstractPrerequisite<PrerequisiteMemoryConfigType> {
+  readonly strategy = PrerequisiteStrategyEnum.memory;
+
+  constructor(readonly config: PrerequisiteMemoryConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<PrerequisiteStatusEnum> {
+    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+
+    const memoryConsumption = MemoryConsumption.get();
+
+    if (memoryConsumption.isGreaterThan(this.config.maximum)) {
+      return this.reject();
+    }
+    return this.pass();
+  }
+}

package/src/prerequisites/node.ts

@@ -0,0 +1,36 @@
+import * as tools from "@bgord/tools";
+import bun from "bun";
+
+import {
+  AbstractPrerequisite,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+  PrerequisiteStrategyEnum,
+} from "../prerequisites";
+
+type PrerequisiteNodeConfigType = {
+  version: tools.PackageVersion;
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+};
+
+export class PrerequisiteNode extends AbstractPrerequisite<PrerequisiteNodeConfigType> {
+  readonly strategy = PrerequisiteStrategyEnum.node;
+
+  constructor(readonly config: PrerequisiteNodeConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<PrerequisiteStatusEnum> {
+    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+
+    const { stdout } = await bun.$`node -v`;
+    const version = stdout.toString().trim();
+    const current = tools.PackageVersion.fromStringWithV(version);
+
+    if (current.isGreaterThanOrEqual(this.config.version)) {
+      return this.pass();
+    }
+    return this.reject();
+  }
+}

package/src/prerequisites/outside-connectivity.ts

@@ -0,0 +1,31 @@
+import {
+  AbstractPrerequisite,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+  PrerequisiteStrategyEnum,
+} from "../prerequisites";
+
+type PrerequisiteOutsideConnectivityConfigType = {
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+};
+
+export class PrerequisiteOutsideConnectivity extends AbstractPrerequisite<PrerequisiteOutsideConnectivityConfigType> {
+  readonly strategy = PrerequisiteStrategyEnum.outsideConnectivity;
+
+  constructor(readonly config: PrerequisiteOutsideConnectivityConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<PrerequisiteStatusEnum> {
+    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+
+    try {
+      const result = await fetch("https://google.com");
+
+      return result.ok ? this.pass() : this.reject();
+    } catch (error) {
+      return this.reject();
+    }
+  }
+}

package/src/prerequisites/path.ts

@@ -0,0 +1,41 @@
+import { constants } from "node:fs";
+import fsp from "node:fs/promises";
+
+import {
+  AbstractPrerequisite,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+  PrerequisiteStrategyEnum,
+} from "../prerequisites";
+
+type PrerequisitePathConfigType = {
+  path: string;
+  access?: { write?: boolean; execute?: boolean };
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+};
+
+export class PrerequisitePath extends AbstractPrerequisite<PrerequisitePathConfigType> {
+  readonly strategy = PrerequisiteStrategyEnum.path;
+
+  constructor(readonly config: PrerequisitePathConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<PrerequisiteStatusEnum> {
+    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+
+    const write = this.config.access?.write ?? false;
+    const execute = this.config.access?.execute ?? false;
+
+    const flags = constants.R_OK | (write ? constants.W_OK : 0) | (execute ? constants.X_OK : 0);
+
+    try {
+      await fsp.access(this.config.path, flags);
+
+      return this.pass();
+    } catch (error) {
+      return this.reject();
+    }
+  }
+}

package/src/prerequisites/port.ts

@@ -0,0 +1,44 @@
+import net from "node:net";
+
+import type { PortType } from "../port";
+
+import {
+  AbstractPrerequisite,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+  PrerequisiteStrategyEnum,
+} from "../prerequisites";
+
+type PrerequisitePortConfigType = {
+  port: PortType;
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+};
+
+export class PrerequisitePort extends AbstractPrerequisite<PrerequisitePortConfigType> {
+  readonly strategy = PrerequisiteStrategyEnum.port;
+
+  constructor(readonly config: PrerequisitePortConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<PrerequisiteStatusEnum> {
+    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+
+    return new Promise((resolve) => {
+      const server = net.createServer();
+
+      server.listen(this.config.port, () =>
+        server.close(() => {
+          this.pass();
+          return resolve(PrerequisiteStatusEnum.success);
+        }),
+      );
+
+      server.on("error", () => {
+        this.reject();
+        return resolve(PrerequisiteStatusEnum.failure);
+      });
+    });
+  }
+}

package/src/prerequisites/ram.ts

@@ -0,0 +1,35 @@
+import os from "node:os";
+import * as tools from "@bgord/tools";
+
+import {
+  AbstractPrerequisite,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+  PrerequisiteStrategyEnum,
+} from "../prerequisites";
+
+type PrerequisiteRAMConfigType = {
+  minimum: tools.Size;
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+};
+
+export class PrerequisiteRAM extends AbstractPrerequisite<PrerequisiteRAMConfigType> {
+  readonly strategy = PrerequisiteStrategyEnum.RAM;
+
+  constructor(readonly config: PrerequisiteRAMConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<PrerequisiteStatusEnum> {
+    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+
+    const freeRAM = new tools.Size({
+      unit: tools.SizeUnit.b,
+      value: os.freemem(),
+    });
+
+    if (freeRAM.isGreaterThan(this.config.minimum)) return this.pass();
+    return this.reject();
+  }
+}

package/src/prerequisites/self.ts

@@ -0,0 +1,24 @@
+import {
+  AbstractPrerequisite,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+  PrerequisiteStrategyEnum,
+} from "../prerequisites";
+
+type PrerequisiteSelfConfigType = {
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+};
+
+export class PrerequisiteSelf extends AbstractPrerequisite<PrerequisiteSelfConfigType> {
+  readonly strategy = PrerequisiteStrategyEnum.self;
+
+  constructor(readonly config: PrerequisiteSelfConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<PrerequisiteStatusEnum> {
+    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+    return this.pass();
+  }
+}

package/src/prerequisites/space.ts

@@ -0,0 +1,39 @@
+import path from "node:path";
+import * as tools from "@bgord/tools";
+import checkDiskSpace from "check-disk-space";
+
+import {
+  AbstractPrerequisite,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+  PrerequisiteStrategyEnum,
+} from "../prerequisites";
+
+type PrerequisiteSpaceConfigType = {
+  minimum: tools.Size;
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+};
+
+export class PrerequisiteSpace extends AbstractPrerequisite<PrerequisiteSpaceConfigType> {
+  readonly strategy = PrerequisiteStrategyEnum.space;
+
+  constructor(readonly config: PrerequisiteSpaceConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<PrerequisiteStatusEnum> {
+    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+
+    const fsRoot = path.sep;
+    const bytes = await checkDiskSpace(fsRoot);
+
+    const freeDiskSpace = new tools.Size({
+      unit: tools.SizeUnit.b,
+      value: bytes.free,
+    });
+
+    if (freeDiskSpace.isGreaterThan(this.config.minimum)) return this.pass();
+    return this.reject();
+  }
+}

package/src/prerequisites/ssl-certificate-expiry.ts

@@ -0,0 +1,37 @@
+import sslChecker from "ssl-checker";
+
+import {
+  AbstractPrerequisite,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+  PrerequisiteStrategyEnum,
+} from "../prerequisites";
+
+type PrerequisiteSSLCertificateExpiryConfigType = {
+  host: string;
+  validDaysMinimum: number;
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+};
+
+export class PrerequisiteSSLCertificateExpiry extends AbstractPrerequisite<PrerequisiteSSLCertificateExpiryConfigType> {
+  readonly strategy = PrerequisiteStrategyEnum.sslCertificateExpiry;
+
+  constructor(readonly config: PrerequisiteSSLCertificateExpiryConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<PrerequisiteStatusEnum> {
+    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+
+    try {
+      const result = await sslChecker(this.config.host);
+
+      if (!result.valid) return PrerequisiteStatusEnum.failure;
+
+      return result.daysRemaining <= this.config.validDaysMinimum ? this.reject() : this.pass();
+    } catch (error) {
+      return this.reject();
+    }
+  }
+}

package/src/prerequisites/timezone-utc.ts

@@ -0,0 +1,34 @@
+import * as tools from "@bgord/tools";
+import { z } from "zod/v4";
+
+import {
+  AbstractPrerequisite,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+  PrerequisiteStrategyEnum,
+} from "../prerequisites";
+
+type PrerequisiteTimezoneUtcConfigType = {
+  timezone: tools.TimezoneType;
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+};
+
+export class PrerequisiteTimezoneUTC extends AbstractPrerequisite<PrerequisiteTimezoneUtcConfigType> {
+  readonly strategy = PrerequisiteStrategyEnum.timezoneUTC;
+
+  constructor(readonly config: PrerequisiteTimezoneUtcConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<PrerequisiteStatusEnum> {
+    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+
+    try {
+      z.literal("UTC").parse(this.config.timezone);
+      return this.pass();
+    } catch (error) {
+      return this.reject();
+    }
+  }
+}

package/src/prerequisites/translations.ts

@@ -0,0 +1,92 @@
+import { constants } from "node:fs";
+import fsp from "node:fs/promises";
+import * as tools from "@bgord/tools";
+
+import { I18n, I18nConfigType, TranslationsKeyType } from "../i18n";
+import {
+  AbstractPrerequisite,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+  PrerequisiteStrategyEnum,
+} from "../prerequisites";
+
+type PrerequisiteTranslationsConfigType = {
+  translationsPath?: typeof I18n.DEFAULT_TRANSLATIONS_PATH;
+  supportedLanguages: I18nConfigType["supportedLanguages"];
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+};
+
+type PrerequisiteTranslationsProblemType = {
+  translationKey: TranslationsKeyType;
+  existsInLanguage: tools.LanguageType;
+  missingInLanguage: tools.LanguageType;
+};
+
+export class PrerequisiteTranslations extends AbstractPrerequisite<PrerequisiteTranslationsConfigType> {
+  readonly strategy = PrerequisiteStrategyEnum.translations;
+
+  constructor(readonly config: PrerequisiteTranslationsConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<PrerequisiteStatusEnum> {
+    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+
+    const translationsPath = this.config.translationsPath ?? I18n.DEFAULT_TRANSLATIONS_PATH;
+
+    try {
+      await fsp.access(translationsPath, constants.R_OK);
+
+      for (const language in this.config.supportedLanguages) {
+        await fsp.access(new I18n().getTranslationPathForLanguage(language), constants.R_OK);
+      }
+    } catch (error) {
+      return this.reject();
+    }
+
+    const supportedLanguages = Object.keys(this.config.supportedLanguages);
+
+    if (supportedLanguages.length === 1) return this.pass();
+
+    const languageToTranslationKeys: Record<tools.LanguageType, TranslationsKeyType[]> = {};
+
+    const problems: PrerequisiteTranslationsProblemType[] = [];
+
+    for (const language of supportedLanguages) {
+      const translations = await new I18n().getTranslations(language);
+      const translationKeys = Object.keys(translations);
+
+      languageToTranslationKeys[language] = translationKeys;
+    }
+
+    for (const currentLanguage in languageToTranslationKeys) {
+      const translationKeys = languageToTranslationKeys[currentLanguage] ?? [];
+
+      for (const translationKey of translationKeys) {
+        for (const supportedLanguage of supportedLanguages) {
+          if (supportedLanguage === currentLanguage) continue;
+
+          const translationKeyExists = languageToTranslationKeys[supportedLanguage]?.some(
+            (key) => translationKey === key,
+          );
+
+          if (!translationKeyExists) {
+            problems.push({
+              translationKey,
+              existsInLanguage: currentLanguage,
+              missingInLanguage: supportedLanguage,
+            });
+          }
+        }
+      }
+    }
+
+    if (problems.length === 0) return this.pass();
+
+    // biome-ignore lint: lint/suspicious/noConsoleLog
+    console.log(problems);
+
+    return this.reject();
+  }
+}

package/src/prerequisites.ts

@@ -0,0 +1,105 @@
+export type PrerequisiteLabelType = string;
+
+export enum PrerequisiteStrategyEnum {
+  binary = "binary",
+  mailer = "mailer",
+  self = "self",
+  timezoneUTC = "timezoneUTC",
+  path = "path",
+  node = "node",
+  bun = "bun",
+  RAM = "RAM",
+  space = "space",
+  translations = "translations",
+  port = "port",
+  jobs = "jobs",
+  memory = "memory",
+  outsideConnectivity = "outsideConnectivity",
+  sslCertificateExpiry = "sslCertificateExpiry",
+  logFile = "logFile",
+  /** @public */
+  custom = "custom",
+}
+
+export enum PrerequisiteStatusEnum {
+  success = "success",
+  failure = "failure",
+  undetermined = "undetermined",
+}
+
+export type BasePrerequisiteConfig = {
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+} & Record<string, unknown>;
+
+export abstract class AbstractPrerequisite<T extends BasePrerequisiteConfig> {
+  readonly label: PrerequisiteLabelType;
+  readonly enabled: boolean = true;
+  abstract readonly strategy: PrerequisiteStrategyEnum;
+  abstract readonly config: T;
+
+  status: PrerequisiteStatusEnum = PrerequisiteStatusEnum.undetermined;
+
+  constructor(config: T) {
+    this.label = config.label;
+    this.enabled = config.enabled ?? true;
+  }
+
+  abstract verify(): Promise<PrerequisiteStatusEnum>;
+
+  protected pass(): PrerequisiteStatusEnum.success {
+    this.status = PrerequisiteStatusEnum.success;
+    return PrerequisiteStatusEnum.success;
+  }
+
+  protected reject(): PrerequisiteStatusEnum.failure {
+    this.status = PrerequisiteStatusEnum.failure;
+    return PrerequisiteStatusEnum.failure;
+  }
+
+  report() {
+    if (this.status === PrerequisiteStatusEnum.success) {
+      // biome-ignore lint: lint/suspicious/noConsoleLog
+      console.log(`[x] ${this.config.label} verified correctly with ${this.strategy} strategy`);
+    }
+
+    if (this.status === PrerequisiteStatusEnum.failure) {
+      // biome-ignore lint: lint/suspicious/noConsoleLog
+      console.log(`[-] ${this.config.label} not verified correctly with ${this.strategy} strategy`);
+    }
+
+    if (this.status === PrerequisiteStatusEnum.undetermined) {
+      // biome-ignore lint: lint/suspicious/noConsoleLog
+      console.log(`[?] ${this.config.label} not enabled with ${this.strategy} strategy`);
+    }
+  }
+}
+
+export class Prerequisites {
+  static async check(prerequisites: AbstractPrerequisite<BasePrerequisiteConfig>[]) {
+    try {
+      const failedPrerequisiteLabels: PrerequisiteLabelType[] = [];
+
+      for (const prerequisite of prerequisites) {
+        await prerequisite.verify();
+        prerequisite.report();
+
+        if (prerequisite.status === PrerequisiteStatusEnum.failure) {
+          failedPrerequisiteLabels.push(prerequisite.label);
+        }
+      }
+
+      if (failedPrerequisiteLabels.length > 0) {
+        const failedPrerequisiteLabelsFormatted = failedPrerequisiteLabels.join(", ");
+
+        // biome-ignore lint: lint/suspicious/noConsoleLog
+        console.log(`Prerequisites failed: ${failedPrerequisiteLabelsFormatted}, quitting...`);
+
+        process.exit(1);
+      }
+    } catch (error) {
+      // biome-ignore lint: lint/suspicious/noConsoleLog
+      console.log("Prerequisites error", String(error));
+    }
+  }
+}

package/src/rate-limit-shield.ts

@@ -1,15 +1,15 @@
-import * as bg from "@bgord/node";
+import * as tools from "@bgord/tools";
 import { createMiddleware } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
 
-type RateLimitShieldOptionsType = { ms: bg.Schema.TimestampType };
+type RateLimitShieldOptionsType = { ms: tools.TimestampType };
 
 export const TooManyRequestsError = new HTTPException(429, {
   message: "app.too_many_requests",
 });
 
 export const rateLimitShield = (options: RateLimitShieldOptionsType) => {
-  const rateLimiter = new bg.RateLimiter(options);
+  const rateLimiter = new tools.RateLimiter(options);
 
   return createMiddleware(async (_c, next) => {
     const currentTimestampMs = Date.now();

package/src/session-id.ts

@@ -0,0 +1,13 @@
+import { Lucia } from "lucia";
+
+export class SessionId {
+  private value: string | null;
+
+  constructor(cookie: string | undefined, lucia: Lucia) {
+    this.value = lucia.readSessionCookie(cookie ?? "");
+  }
+
+  get(): SessionId["value"] {
+    return this.value;
+  }
+}