@bgord/bun 1.5.6 → 1.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.5.6",
+  "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

@@ -208,6 +208,7 @@ src/
 │   ├── directory.ts
 │   ├── dns.ts
 │   ├── external-api.ts
+│   ├── file.ts
 │   ├── jobs.ts
 │   ├── log-file.ts
 │   ├── mailer.ts

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);
     }