@bgord/bun 0.6.0 → 0.8.0

package/src/index.ts

@@ -1,35 +1,54 @@
 export * from "./api-key-shield";
 export * from "./api-version";
 export * from "./auth-shield";
+export * from "./basic-auth";
 export * from "./build-info-repository";
 export * from "./cache-resolver";
 export * from "./cache-response";
 export * from "./cache-static-files";
 export * from "./context";
 export * from "./correlation-id";
+export * from "./decorators";
 export * from "./download-file";
+export * from "./encryption";
+export * from "./env-validator";
 export * from "./etag-extractor";
+export * from "./event";
+export * from "./event-handler";
+export * from "./event-logger";
+export * from "./file-location";
 export * from "./file-uploader";
 export * from "./graceful-shutdown";
+export * from "./gzip";
+export * from "./hcaptcha-shield";
 export * from "./healthcheck";
 export * from "./http-logger";
 export * from "./i18n";
+export * from "./image-compressor";
+export * from "./image-exif";
 export * from "./jobs";
 export * from "./logger";
 export * from "./mailer";
 export * from "./memory-consumption";
 export * from "./new-uuid";
 export * from "./node-env.vo";
+export * from "./open-graph";
 export * from "./passwords";
 export * from "./path";
+export * from "./policy.service";
 export * from "./port";
 export * from "./prerequisites";
 export * from "./prerequisites/index";
 export * from "./rate-limit-shield";
+export * from "./recaptcha-shield";
 export * from "./session-id";
 export * from "./setup";
+export * from "./simulated-error";
+export * from "./sitemap";
+export * from "./slower";
 export * from "./time-zone-offset";
 export * from "./uptime";
+export * from "./url-wo-trailing-slash";
 export * from "./username";
 export * from "./uuid";
 export * from "./weak-etag-extractor";

package/src/jobs.ts

@@ -6,6 +6,7 @@ import { Logger } from "./logger";
 import { NewUUID } from "./new-uuid";
 
 export type JobNameType = string;
+
 export type MultipleJobsType = Record<JobNameType, Cron>;
 
 export enum UTC_DAY_OF_THE_WEEK {

package/src/logger.ts

@@ -18,11 +18,17 @@ export enum LogLevelEnum {
 export const LogLevel = z.enum(LogLevelEnum);
 
 type LogTimestampType = number;
+
 type LogAppType = string;
+
 type LogEnvironmentType = NodeEnvironmentEnum;
+
 type LogMessageType = string;
+
 type LogOperationType = string;
+
 type LogMetadataType = Record<string, any>;
+
 type LogCorrelationIdType = CorrelationIdType;
 
 const levels: Record<LogLevelEnum, number> = {

package/src/mailer.ts

@@ -1,18 +1,23 @@
 import nodemailer, { SendMailOptions } from "nodemailer";
 import { z } from "zod/v4";
 
+import { Path } from "./path";
 import { Port } from "./port";
 
 export const SmtpHost = z.string().trim().min(1);
+
 export type SmtpHostType = z.infer<typeof SmtpHost>;
 
 export const SmtpPort = Port;
+
 export type SmtpPortType = z.infer<typeof SmtpPort>;
 
 export const SmtpUser = z.string().trim().min(1);
+
 export type SmtpUserType = z.infer<typeof SmtpUser>;
 
 export const SmtpPass = z.string().trim().min(1);
+
 export type SmtpPassType = z.infer<typeof SmtpPass>;
 
 type MailerConfigType = {
@@ -24,6 +29,26 @@ type MailerConfigType = {
 
 type MailerSendOptionsType = SendMailOptions;
 
+export const EmailSubject = z.string().min(1).max(128);
+
+export type EmailSubjectType = z.infer<typeof EmailSubject>;
+
+export const EmailContentHtml = z.string().min(1).max(10_000);
+
+export type EmailContentHtmlType = z.infer<typeof EmailContentHtml>;
+
+export const EmailFrom = z.email();
+
+export type EmailFromType = z.infer<typeof EmailFrom>;
+
+export const EmailTo = z.email();
+
+export type EmailToType = z.infer<typeof EmailTo>;
+
+export const EmailAttachment = z.object({ filename: Path, path: Path });
+
+export type EmailAttachmentType = z.infer<typeof EmailAttachment>;
+
 export class Mailer {
   private readonly transport: nodemailer.Transporter;
 

package/src/node-env.vo.ts

@@ -6,4 +6,5 @@ export enum NodeEnvironmentEnum {
   staging = "staging",
   production = "production",
 }
+
 export const NodeEnvironment = z.enum(NodeEnvironmentEnum);

package/src/open-graph.ts

@@ -0,0 +1,259 @@
+import { z } from "zod/v4";
+
+import { ImageEXIF } from "./image-exif";
+import { Path, PathType } from "./path";
+import { UrlWithoutTrailingSlashType } from "./url-wo-trailing-slash";
+
+export const OpenGraphTitleValue = z.string().min(1);
+
+export type OpenGraphTitleValueType = z.infer<typeof OpenGraphTitleValue>;
+
+export const OpenGraphDescriptionValue = z.string().min(1);
+
+export type OpenGraphDescriptionValueType = z.infer<typeof OpenGraphDescriptionValue>;
+
+export const OpenGraphUrlValue = z.string().min(1);
+
+export type OpenGraphUrlValueType = z.infer<typeof OpenGraphUrlValue>;
+
+export const OpenGraphTypeValue = z.union([z.literal("website"), z.literal("article")]);
+
+export type OpenGraphTypeValueType = z.infer<typeof OpenGraphTypeValue>;
+
+export const OpenGraphImageUrlValue = z.url();
+
+export type OpenGraphImageUrlValueType = z.infer<typeof OpenGraphImageUrlValue>;
+
+export const OpenGraphImageTypeValue = z.string().min(1);
+
+export type OpenGraphImageTypeValueType = z.infer<typeof OpenGraphImageTypeValue>;
+
+export const OpenGraphImageWidthValue = z
+  .number()
+  .int()
+  .positive()
+  .refine((value) => value === 1200, {
+    message: "open.graph.image.width.invalid",
+  });
+
+export type OpenGraphImageWidthValueType = z.infer<typeof OpenGraphImageWidthValue>;
+
+export const OpenGraphImageHeightValue = z
+  .number()
+  .int()
+  .positive()
+  .refine((value) => value === 630, {
+    message: "open.graph.image.height.invalid",
+  });
+
+export type OpenGraphImageHeightValueType = z.infer<typeof OpenGraphImageHeightValue>;
+
+class OpenGraphTitle {
+  private readonly value: OpenGraphTitleValueType;
+
+  constructor(value: OpenGraphTitleValueType) {
+    this.value = OpenGraphTitleValue.parse(value);
+  }
+
+  toMetatag(): string {
+    return `<meta property="og:title" content="${this.value}" />`;
+  }
+
+  toMeta(): string {
+    return `${this.toMetatag()}\n\t`;
+  }
+}
+
+class OpenGraphDescription {
+  private readonly value: OpenGraphDescriptionValueType;
+
+  constructor(value: OpenGraphDescriptionValueType) {
+    this.value = OpenGraphDescriptionValue.parse(value);
+  }
+
+  toMetatag(): string {
+    return `<meta property="og:description" content="${this.value}" />`;
+  }
+
+  toMeta(): string {
+    return `${this.toMetatag()}\n\t`;
+  }
+}
+
+class OpenGraphUrl {
+  private readonly value: OpenGraphUrlValueType;
+
+  constructor(value: OpenGraphUrlValueType) {
+    this.value = OpenGraphUrlValue.parse(value);
+  }
+
+  toMetatag(): string {
+    return `<meta property="og:url" content="${this.value}" />`;
+  }
+
+  toMeta(): string {
+    return `${this.toMetatag()}\n\t`;
+  }
+}
+
+class OpenGraphType {
+  private readonly value: OpenGraphTypeValueType;
+
+  constructor(value: OpenGraphTypeValueType) {
+    this.value = OpenGraphTypeValue.parse(value);
+  }
+
+  toMetatag(): string {
+    return `<meta property="og:type" content="${this.value}" />`;
+  }
+
+  toMeta(): string {
+    return `${this.toMetatag()}\n\t`;
+  }
+}
+
+class OpenGraphImageUrl {
+  private readonly value: OpenGraphImageUrlValueType;
+
+  constructor(path: PathType) {
+    this.value = OpenGraphImageUrlValue.parse(path);
+  }
+
+  toMetatag(): string {
+    return `<meta property="og:image" content="${this.value}" />`;
+  }
+
+  toMeta(): string {
+    return `${this.toMetatag()}\n\t`;
+  }
+}
+
+class OpenGraphImageType {
+  private readonly value: OpenGraphImageTypeValueType;
+
+  constructor(value: OpenGraphImageTypeValueType) {
+    this.value = OpenGraphImageTypeValue.parse(value);
+  }
+
+  toMetatag(): string {
+    return `<meta property="og:image:type" content="${this.value}" />`;
+  }
+
+  toMeta(): string {
+    return `${this.toMetatag()}\n\t`;
+  }
+}
+
+class OpenGraphImageWidth {
+  private readonly value: OpenGraphImageWidthValueType;
+
+  constructor(value: OpenGraphImageWidthValueType) {
+    this.value = OpenGraphImageWidthValue.parse(value);
+  }
+
+  toMetatag(): string {
+    return `<meta property="og:image:width" content="${this.value}" />`;
+  }
+
+  toMeta(): string {
+    return `${this.toMetatag()}\n\t`;
+  }
+}
+
+class OpenGraphImageHeight {
+  private readonly value: OpenGraphImageHeightValueType;
+
+  constructor(value: OpenGraphImageHeightValueType) {
+    this.value = OpenGraphImageHeightValue.parse(value);
+  }
+
+  toMetatag(): string {
+    return `<meta property="og:image:height" content="${this.value}" />`;
+  }
+
+  toMeta(): string {
+    return `${this.toMetatag()}\n\t`;
+  }
+}
+
+export type OpenGraphImageConfigType = {
+  url: OpenGraphImageUrl;
+  width: OpenGraphImageWidth;
+  height: OpenGraphImageHeight;
+  type: OpenGraphImageType;
+};
+
+export class OpenGraphImage {
+  private readonly value: OpenGraphImageConfigType;
+
+  constructor(value: OpenGraphImageConfigType) {
+    this.value = value;
+  }
+
+  toString() {
+    let output = "";
+
+    output += this.value.url.toMeta();
+    output += this.value.width.toMeta();
+    output += this.value.height.toMeta();
+    output += this.value.type.toMeta();
+
+    return output;
+  }
+}
+
+class OpenGraphImageGenerator {
+  static async generate(config: {
+    path: PathType;
+    BASE_URL: UrlWithoutTrailingSlashType;
+  }) {
+    const exif = await ImageEXIF.read(config.path);
+
+    return new OpenGraphImage({
+      url: new OpenGraph.image.url(Path.parse(`${config.BASE_URL}/${exif.name}`)),
+      type: new OpenGraph.image.type(exif.mimeType),
+      width: new OpenGraph.image.width(exif.width),
+      height: new OpenGraph.image.height(exif.height),
+    });
+  }
+}
+
+type OpenGraphConfigType = {
+  title: OpenGraphTitle;
+  description: OpenGraphDescription;
+  url: OpenGraphUrl;
+  type: OpenGraphType;
+  image?: OpenGraphImage;
+};
+
+class OpenGraphGenerator {
+  static toString(config: OpenGraphConfigType) {
+    let output = "";
+
+    output += config.title.toMeta();
+    output += config.description.toMeta();
+    output += config.url.toMeta();
+    output += config.type.toMeta();
+
+    if (config.image) {
+      output += config.image.toString();
+    }
+
+    return output;
+  }
+}
+
+export const OpenGraph = {
+  generator: OpenGraphGenerator,
+  title: OpenGraphTitle,
+  description: OpenGraphDescription,
+  url: OpenGraphUrl,
+  type: OpenGraphType,
+  image: {
+    generator: OpenGraphImageGenerator,
+    url: OpenGraphImageUrl,
+    width: OpenGraphImageWidth,
+    height: OpenGraphImageHeight,
+    type: OpenGraphImageType,
+  },
+};

package/src/passwords.ts

@@ -1,6 +1,7 @@
 import { z } from "zod/v4";
 
 export type PasswordType = string;
+
 type HashedPasswordType = string;
 
 export class Password {

package/src/path.ts

@@ -1,4 +1,5 @@
 import { z } from "zod/v4";
 
 export const Path = z.string().min(1);
+
 export type PathType = z.infer<typeof Path>;

package/src/policy.service.ts

@@ -0,0 +1,25 @@
+import type { Constructor } from "@bgord/tools";
+
+type BasePolicyConfig = Record<string, unknown>;
+
+export abstract class Policy<T extends BasePolicyConfig> {
+  abstract fails(config: T): Promise<boolean> | boolean;
+
+  abstract error: Constructor<Error>;
+
+  abstract message: string;
+
+  throw() {
+    throw new this.error();
+  }
+
+  async perform(config: T) {
+    if (await this.fails(config)) {
+      this.throw();
+    }
+  }
+
+  async passes(config: T) {
+    return !(await this.fails(config));
+  }
+}

package/src/port.ts

@@ -1,4 +1,5 @@
 import { z } from "zod/v4";
 
 export const Port = z.coerce.number().min(0).max(99999);
+
 export type PortType = z.infer<typeof Port>;

package/src/prerequisites/binary.ts

@@ -1,35 +1,31 @@
 import bun from "bun";
 import { z } from "zod/v4";
 
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import * as prereqs from "../prerequisites";
 
 const PrerequisiteBinaryValue = z
   .string()
   .min(1)
   .max(64)
   .refine((value) => !value.includes(" "));
+
 type PrerequisiteBinaryValueType = z.infer<typeof PrerequisiteBinaryValue>;
 
 type PrerequisiteBinaryConfigType = {
   binary: PrerequisiteBinaryValueType;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisiteBinary extends AbstractPrerequisite<PrerequisiteBinaryConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.binary;
+export class PrerequisiteBinary extends prereqs.AbstractPrerequisite<PrerequisiteBinaryConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.binary;
 
   constructor(readonly config: PrerequisiteBinaryConfigType) {
     super(config);
   }
 
   async verify() {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     try {
       const binary = PrerequisiteBinaryValue.parse(this.config.binary);

package/src/prerequisites/bun.ts

@@ -1,27 +1,24 @@
 import * as tools from "@bgord/tools";
 
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import * as prereqs from "../prerequisites";
 
 type PrerequisiteBunConfigType = {
   version: tools.PackageVersion;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
   current: string;
 };
 
-export class PrerequisiteBun extends AbstractPrerequisite<PrerequisiteBunConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.bun;
+export class PrerequisiteBun extends prereqs.AbstractPrerequisite<PrerequisiteBunConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.bun;
 
   constructor(readonly config: PrerequisiteBunConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
+
     const current = tools.PackageVersion.fromString(this.config.current);
 
     if (current.isGreaterThanOrEqual(this.config.version)) {

package/src/prerequisites/dependency-vulnerabilities.ts

@@ -0,0 +1,54 @@
+import bun from "bun";
+
+import {
+  AbstractPrerequisite,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+  PrerequisiteStrategyEnum,
+} from "../prerequisites";
+
+type PrerequisiteDependencyVulnerabilityConfigType = {
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+};
+
+type BunAuditOutput = {
+  [packageName: string]: {
+    severity: "low" | "moderate" | "high" | "critical";
+  }[];
+};
+
+export class PrerequisiteDependencyVulnerabilities extends AbstractPrerequisite<PrerequisiteDependencyVulnerabilityConfigType> {
+  readonly strategy = PrerequisiteStrategyEnum.dependencyVulnerabilities;
+
+  constructor(readonly config: PrerequisiteDependencyVulnerabilityConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<PrerequisiteStatusEnum> {
+    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+
+    try {
+      const result = await bun.$`bun audit --json`;
+
+      if (result.exitCode !== 0) return this.reject();
+
+      const audit = JSON.parse(result.stdout.toString()) as BunAuditOutput;
+
+      const criticalVulnerabilitiesCount = Object.values(audit).filter((name) =>
+        name.some((vulnerability) => vulnerability.severity === "critical"),
+      ).length;
+
+      const highVulnerabilitiesCount = Object.values(audit).filter((name) =>
+        name.some((vulnerability) => vulnerability.severity === "high"),
+      ).length;
+
+      if (criticalVulnerabilitiesCount > 0 || highVulnerabilitiesCount > 0) {
+        return this.reject();
+      }
+      return this.pass();
+    } catch (error) {
+      return this.reject();
+    }
+  }
+}

package/src/prerequisites/external-api.ts

@@ -0,0 +1,27 @@
+import * as prereqs from "../prerequisites";
+
+type PrerequisiteExternalApiConnectivityConfigType = {
+  label: prereqs.PrerequisiteLabelType;
+  enabled?: boolean;
+  request: () => Promise<Response>;
+};
+
+export class PrerequisiteExternalApi extends prereqs.AbstractPrerequisite<PrerequisiteExternalApiConnectivityConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.externalApi;
+
+  constructor(readonly config: PrerequisiteExternalApiConnectivityConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
+
+    try {
+      const result = await this.config.request();
+
+      return result.ok ? this.pass() : this.reject();
+    } catch (error) {
+      return this.reject();
+    }
+  }
+}

package/src/prerequisites/index.ts

@@ -1,5 +1,7 @@
 export * from "./binary";
 export * from "./bun";
+export * from "./dependency-vulnerabilities";
+export * from "./external-api";
 export * from "./jobs";
 export * from "./log-file";
 export * from "./mailer";

package/src/prerequisites/jobs.ts

@@ -1,27 +1,21 @@
 import { Jobs, MultipleJobsType } from "../jobs";
-
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import * as prereqs from "../prerequisites";
 
 type PrerequisiteJobsConfigType = {
   jobs: MultipleJobsType;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisiteJobs extends AbstractPrerequisite<PrerequisiteJobsConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.jobs;
+export class PrerequisiteJobs extends prereqs.AbstractPrerequisite<PrerequisiteJobsConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.jobs;
 
   constructor(readonly config: PrerequisiteJobsConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     return Jobs.areAllRunning(this.config.jobs) ? this.pass() : this.reject();
   }

package/src/prerequisites/log-file.ts

@@ -1,26 +1,21 @@
 import { Logger } from "../logger";
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import * as prereqs from "../prerequisites";
 
 type PrerequisiteLogFileConfigType = {
   logger: Logger;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisiteLogFile extends AbstractPrerequisite<PrerequisiteLogFileConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.logFile;
+export class PrerequisiteLogFile extends prereqs.AbstractPrerequisite<PrerequisiteLogFileConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.logFile;
 
   constructor(readonly config: PrerequisiteLogFileConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     try {
       const path = this.config.logger.getProductionLogFilePath();