@bgord/bun 1.5.4 → 1.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.5.4",
+  "version": "1.5.8",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -28,7 +28,7 @@
     "@types/nodemailer": "7.0.4",
     "@types/yazl": "3.3.0",
     "cspell": "9.4.0",
-    "knip": "5.74.0",
+    "knip": "5.75.1",
     "lefthook": "2.0.12",
     "lockfile-lint": "4.14.1",
     "only-allow": "1.2.2",
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@axiomhq/winston": "1.3.1",
-    "@bgord/tools": "1.2.2",
+    "@bgord/tools": "1.2.3",
     "@hono/ua-blocker": "0.1.22",
     "better-auth": "1.4.7",
     "croner": "9.1.0",

package/readme.md

@@ -74,6 +74,7 @@ src/
 ├── encryption-noop.adapter.ts
 ├── encryption.port.ts
 ├── environment-loader-encrypted.adapter.ts
+├── environment-loader-process-safe.adapter.ts
 ├── environment-loader-process.adapter.ts
 ├── environment-loader.port.ts
 ├── etag-extractor.middleware.ts
@@ -207,6 +208,7 @@ src/
 │   ├── directory.ts
 │   ├── dns.ts
 │   ├── external-api.ts
+│   ├── file.ts
 │   ├── jobs.ts
 │   ├── log-file.ts
 │   ├── mailer.ts

package/src/environment-loader-process-safe.adapter.ts

@@ -0,0 +1,26 @@
+import type { z } from "zod/v4";
+import type { NodeEnvironmentEnum } from "../src/node-env.vo";
+import type { EnvironmentLoaderPort, EnvironmentResultType } from "./environment-loader.port";
+
+export class EnvironmentLoaderProcessSafeAdapter<Schema extends z.ZodObject<any>>
+  implements EnvironmentLoaderPort<Schema>
+{
+  private cached: Readonly<EnvironmentResultType<Schema>> | null = null;
+
+  constructor(
+    private readonly config: { type: NodeEnvironmentEnum; Schema: Schema },
+    private env: NodeJS.ProcessEnv,
+  ) {}
+
+  async load() {
+    if (this.cached) return this.cached;
+
+    const result = this.config.Schema.parse(this.env);
+
+    for (const key of Object.keys(result)) delete process.env[key];
+
+    this.cached = Object.freeze({ ...result, type: this.config.type });
+
+    return this.cached;
+  }
+}

package/src/environment-loader-process.adapter.ts

@@ -1,26 +1,16 @@
 import type { z } from "zod/v4";
 import type { NodeEnvironmentEnum } from "../src/node-env.vo";
-import type { EnvironmentLoaderPort, EnvironmentResultType } from "./environment-loader.port";
+import type { EnvironmentLoaderPort } from "./environment-loader.port";
 
 export class EnvironmentLoaderProcessAdapter<Schema extends z.ZodObject<any>>
   implements EnvironmentLoaderPort<Schema>
 {
-  private cached: Readonly<EnvironmentResultType<Schema>> | null = null;
-
   constructor(
     private readonly config: { type: NodeEnvironmentEnum; Schema: Schema },
     private env: NodeJS.ProcessEnv,
   ) {}
 
   async load() {
-    if (this.cached) return this.cached;
-
-    const result = this.config.Schema.parse(this.env);
-
-    for (const key of Object.keys(result)) delete process.env[key];
-
-    this.cached = Object.freeze({ ...result, type: this.config.type });
-
-    return this.cached;
+    return Object.freeze({ ...this.config.Schema.parse(this.env), type: this.config.type });
   }
 }

package/src/index.ts

@@ -48,6 +48,7 @@ export * from "./encryption-noop.adapter";
 export * from "./environment-loader.port";
 export * from "./environment-loader-encrypted.adapter";
 export * from "./environment-loader-process.adapter";
+export * from "./environment-loader-process-safe.adapter";
 export * from "./etag-extractor.middleware";
 export * from "./event.types";
 export * from "./event-bus-like.types";

package/src/prerequisites/directory.ts

@@ -1,28 +1,29 @@
-import { constants } from "node:fs";
-import fsp from "node:fs/promises";
+import { access, constants, stat } from "node:fs/promises";
 import * as tools from "@bgord/tools";
 import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 
+export type PrerequisiteDirectoryPermissionsType = { read?: boolean; write?: boolean; execute?: boolean };
+
 export class PrerequisiteDirectory implements prereqs.Prerequisite {
   readonly kind = "directory";
   readonly label: prereqs.PrerequisiteLabelType;
   readonly enabled?: boolean = true;
 
   private readonly directory: tools.DirectoryPathAbsoluteType | tools.DirectoryPathRelativeType;
-  private readonly access?: { write?: boolean; execute?: boolean };
+  private readonly permissions: PrerequisiteDirectoryPermissionsType;
 
   constructor(
     config: prereqs.PrerequisiteConfigType & {
       directory: tools.DirectoryPathAbsoluteType | tools.DirectoryPathRelativeType;
-      access?: { write?: boolean; execute?: boolean };
+      permissions?: PrerequisiteDirectoryPermissionsType;
     },
   ) {
     this.label = config.label;
     this.enabled = config.enabled === undefined ? true : config.enabled;
 
     this.directory = config.directory;
-    this.access = config.access;
+    this.permissions = config.permissions ?? {};
   }
 
   async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
@@ -30,17 +31,40 @@ export class PrerequisiteDirectory implements prereqs.Prerequisite {
 
     if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
-    const write = this.access?.write ?? false;
-    const execute = this.access?.execute ?? false;
+    try {
+      const stats = await stat(this.directory);
 
-    const flags = constants.R_OK | (write ? constants.W_OK : 0) | (execute ? constants.X_OK : 0);
+      if (!stats.isDirectory()) {
+        return prereqs.Verification.failure(stopwatch.stop(), { message: "Not a directory" });
+      }
+    } catch {
+      return prereqs.Verification.failure(stopwatch.stop(), { message: "Directory does not exist" });
+    }
 
-    try {
-      await fsp.access(this.directory, flags);
+    if (this.permissions.read) {
+      try {
+        await access(this.directory, constants.R_OK);
+      } catch {
+        return prereqs.Verification.failure(stopwatch.stop(), { message: "Directory is not readable" });
+      }
+    }
+
+    if (this.permissions.write) {
+      try {
+        await access(this.directory, constants.W_OK);
+      } catch {
+        return prereqs.Verification.failure(stopwatch.stop(), { message: "Directory is not writable" });
+      }
+    }
 
-      return prereqs.Verification.success(stopwatch.stop());
-    } catch (error) {
-      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
+    if (this.permissions.execute) {
+      try {
+        await access(this.directory, constants.X_OK);
+      } catch {
+        return prereqs.Verification.failure(stopwatch.stop(), { message: "Directory is not executable" });
+      }
     }
+
+    return prereqs.Verification.success(stopwatch.stop());
   }
 }

package/src/prerequisites/file.ts

@@ -0,0 +1,69 @@
+import { access, constants } from "node:fs/promises";
+import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
+import * as prereqs from "../prerequisites.service";
+
+export type PrerequisiteFilePermissionsType = { read?: boolean; write?: boolean; execute?: boolean };
+
+export class PrerequisiteFile implements prereqs.Prerequisite {
+  readonly kind = "file";
+  readonly label: prereqs.PrerequisiteLabelType;
+  readonly enabled?: boolean = true;
+
+  private readonly file: tools.FilePathAbsolute | tools.FilePathRelative;
+  private readonly permissions: PrerequisiteFilePermissionsType;
+
+  constructor(
+    config: prereqs.PrerequisiteConfigType & {
+      file: tools.FilePathAbsolute | tools.FilePathRelative;
+      permissions?: PrerequisiteFilePermissionsType;
+    },
+  ) {
+    this.label = config.label;
+    this.enabled = config.enabled === undefined ? true : config.enabled;
+
+    this.file = config.file;
+    this.permissions = config.permissions ?? {};
+  }
+
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
+
+    try {
+      const path = this.file.get();
+
+      const exists = await Bun.file(path).exists();
+      if (!exists) return prereqs.Verification.failure(stopwatch.stop(), { message: "File does not exist" });
+
+      if (this.permissions.read) {
+        try {
+          await access(path, constants.R_OK);
+        } catch {
+          return prereqs.Verification.failure(stopwatch.stop(), { message: "File is not readable" });
+        }
+      }
+
+      if (this.permissions.write) {
+        try {
+          await access(path, constants.W_OK);
+        } catch {
+          return prereqs.Verification.failure(stopwatch.stop(), { message: "File is not writable" });
+        }
+      }
+
+      if (this.permissions.execute) {
+        try {
+          await access(path, constants.X_OK);
+        } catch {
+          return prereqs.Verification.failure(stopwatch.stop(), { message: "File is not executable" });
+        }
+      }
+
+      return prereqs.Verification.success(stopwatch.stop());
+    } catch (error) {
+      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
+    }
+  }
+}

package/src/prerequisites/index.ts

@@ -5,6 +5,7 @@ export * from "./dependency-vulnerabilities";
 export * from "./directory";
 export * from "./dns";
 export * from "./external-api";
+export * from "./file";
 export * from "./jobs";
 export * from "./log-file";
 export * from "./mailer";

package/src/prerequisites/log-file.ts

@@ -2,6 +2,7 @@ import * as tools from "@bgord/tools";
 import type { ClockPort } from "../clock.port";
 import type { LoggerPort } from "../logger.port";
 import * as prereqs from "../prerequisites.service";
+import { PrerequisiteFile } from "./file";
 
 type Dependencies = { Logger: LoggerPort };
 
@@ -27,10 +28,13 @@ export class PrerequisiteLogFile implements prereqs.Prerequisite {
       const path = this.deps.Logger.getFilePath();
       if (!path) return prereqs.Verification.undetermined(stopwatch.stop());
 
-      const result = await Bun.file(path.get()).exists();
+      const file = new PrerequisiteFile({
+        label: this.label,
+        file: path,
+        permissions: { read: true, write: true },
+      });
 
-      if (result) return prereqs.Verification.success(stopwatch.stop());
-      return prereqs.Verification.failure(stopwatch.stop(), { message: `Missing file: ${path.get()}` });
+      return file.verify(clock);
     } catch (error) {
       return prereqs.Verification.failure(stopwatch.stop(), error as Error);
     }