@bgord/bun 0.7.0 → 0.8.1

package/src/{healthcheck.ts → healthcheck.service.ts}

@@ -1,24 +1,19 @@
 import * as tools from "@bgord/tools";
 import { createFactory } from "hono/factory";
 
-import { BuildInfoRepository } from "./build-info-repository";
-import { MemoryConsumption } from "./memory-consumption";
-import {
-  AbstractPrerequisite,
-  BasePrerequisiteConfig,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-} from "./prerequisites";
-import { Uptime, UptimeResultType } from "./uptime";
+import { BuildInfoRepository } from "./build-info-repository.service";
+import { MemoryConsumption } from "./memory-consumption.service";
+import * as prereqs from "./prerequisites.service";
+import { Uptime, UptimeResultType } from "./uptime.service";
 
 const handler = createFactory();
 
 type HealthcheckResultType = {
-  ok: PrerequisiteStatusEnum;
+  ok: prereqs.PrerequisiteStatusEnum;
   version: tools.BuildVersionType;
   details: {
-    label: PrerequisiteLabelType;
-    status: PrerequisiteStatusEnum;
+    label: prereqs.PrerequisiteLabelType;
+    status: prereqs.PrerequisiteStatusEnum;
   }[];
   uptime: UptimeResultType;
   memory: {
@@ -28,7 +23,7 @@ type HealthcheckResultType = {
 } & tools.StopwatchResultType;
 
 export class Healthcheck {
-  static build = (prerequisites: AbstractPrerequisite<BasePrerequisiteConfig>[]) =>
+  static build = (prerequisites: prereqs.AbstractPrerequisite<prereqs.BasePrerequisiteConfig>[]) =>
     handler.createHandlers(async (c) => {
       const stopwatch = new tools.Stopwatch();
 
@@ -41,11 +36,11 @@ export class Healthcheck {
         details.push({ label: prerequisite.label, status });
       }
 
-      const ok = details.every((result) => result.status !== PrerequisiteStatusEnum.failure)
-        ? PrerequisiteStatusEnum.success
-        : PrerequisiteStatusEnum.failure;
+      const ok = details.every((result) => result.status !== prereqs.PrerequisiteStatusEnum.failure)
+        ? prereqs.PrerequisiteStatusEnum.success
+        : prereqs.PrerequisiteStatusEnum.failure;
 
-      const code = ok === PrerequisiteStatusEnum.success ? 200 : 424;
+      const code = ok === prereqs.PrerequisiteStatusEnum.success ? 200 : 424;
 
       const result: HealthcheckResultType = {
         ok,

package/src/{http-logger.ts → http-logger.middleware.ts}

@@ -2,10 +2,10 @@ import { getConnInfo } from "hono/bun";
 import { createMiddleware } from "hono/factory";
 import _ from "lodash";
 
-import { CacheHitEnum } from "./cache-resolver";
-import { CacheResponse } from "./cache-response";
-import { CorrelationIdType } from "./correlation-id";
-import { Logger } from "./logger";
+import { CacheHitEnum } from "./cache-resolver.service";
+import { CacheResponse } from "./cache-response.middleware";
+import type { CorrelationIdType } from "./correlation-id.vo";
+import { Logger } from "./logger.service";
 
 export class HttpLogger {
   private static simplify(response: unknown) {

package/src/{i18n.ts → i18n.service.ts}

@@ -1,20 +1,24 @@
 import path from "node:path";
 import * as tools from "@bgord/tools";
 
-import { Path, PathType } from "./path";
+import { Path, PathType } from "./path.vo";
 
 export type TranslationsKeyType = string;
+
 export type TranslationsValueType = string;
+
 export type TranslationsType = Record<TranslationsKeyType, TranslationsValueType>;
 
 export type TranslationPlaceholderType = string;
+
 export type TranslationPlaceholderValueType = string | number;
+
 export type TranslationVariableType = Record<TranslationPlaceholderType, TranslationPlaceholderValueType>;
 
 export type I18nConfigType = {
+  supportedLanguages: Record<string, tools.LanguageType>;
   translationsPath?: PathType;
   defaultLanguage?: tools.LanguageType;
-  supportedLanguages: Record<string, tools.LanguageType>;
 };
 
 export class I18n {

package/src/image-compressor.service.ts

@@ -0,0 +1,26 @@
+import sharp from "sharp";
+import { z } from "zod/v4";
+
+import type { PathType } from "../src/path.vo";
+
+export const ImageCompressionQuality = z.number().int().min(1).max(100).default(85);
+
+type ImageCompressionQualityType = z.infer<typeof ImageCompressionQuality>;
+
+export type ImageCompressorConfigType = {
+  input: PathType;
+  output: PathType;
+  quality?: ImageCompressionQualityType;
+};
+
+export class ImageCompressor {
+  static async compress(config: ImageCompressorConfigType): Promise<sharp.OutputInfo> {
+    const quality = config.quality ?? 85;
+
+    const image = sharp(config.input);
+    const metadata = await image.metadata();
+    const format = metadata.format as keyof sharp.FormatEnum;
+
+    return image.toFormat(format, { quality }).toFile(config.output);
+  }
+}

package/src/image-exif.service.ts

@@ -0,0 +1,38 @@
+import path from "node:path";
+import * as tools from "@bgord/tools";
+import mime from "mime-types";
+import sharp from "sharp";
+
+import type { PathType } from "./path.vo";
+
+export type ImageExifOutputType = {
+  width: tools.WidthType;
+  height: tools.HeightType;
+  name: path.ParsedPath["base"];
+  mimeType: tools.MimeRawType;
+};
+
+export type ImageExifClearConfigType = {
+  input: PathType;
+  output: PathType;
+};
+
+export class ImageEXIF {
+  static async read(input: PathType): Promise<ImageExifOutputType> {
+    const image = sharp(input);
+    const metadata = await image.metadata();
+
+    const name = path.parse(input).base;
+
+    return {
+      width: tools.Width.parse(metadata.width),
+      height: tools.Height.parse(metadata.height),
+      name,
+      mimeType: String(mime.contentType(String(metadata.format))),
+    };
+  }
+
+  static async clear(config: ImageExifClearConfigType): Promise<sharp.OutputInfo> {
+    return sharp(config.input).rotate().toFile(config.output);
+  }
+}

package/src/index.ts

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

package/src/{jobs.ts → jobs.service.ts}

@@ -1,11 +1,12 @@
 import * as tools from "@bgord/tools";
 import { Cron } from "croner";
 
-import { CorrelationId } from "./correlation-id";
-import { Logger } from "./logger";
-import { NewUUID } from "./new-uuid";
+import { CorrelationId } from "./correlation-id.vo";
+import { Logger } from "./logger.service";
+import { NewUUID } from "./new-uuid.service";
 
 export type JobNameType = string;
+
 export type MultipleJobsType = Record<JobNameType, Cron>;
 
 export enum UTC_DAY_OF_THE_WEEK {

package/src/{logger.ts → logger.service.ts}

@@ -2,9 +2,9 @@ import * as tools from "@bgord/tools";
 import * as winston from "winston";
 import { z } from "zod/v4";
 
-import { CorrelationIdType } from "./correlation-id";
+import { CorrelationIdType } from "./correlation-id.vo";
 import { NodeEnvironmentEnum } from "./node-env.vo";
-import { PathType } from "./path";
+import { PathType } from "./path.vo";
 
 export enum LogLevelEnum {
   /** @public */
@@ -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 → mailer.service.ts}

@@ -1,19 +1,23 @@
 import nodemailer, { SendMailOptions } from "nodemailer";
 import { z } from "zod/v4";
 
-import { Path } from "./path";
-import { Port } from "./port";
+import { Path } from "./path.vo";
+import { Port } from "./port.vo";
 
 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 = {
@@ -26,18 +30,23 @@ 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 {

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.service.ts

@@ -0,0 +1,259 @@
+import { z } from "zod/v4";
+
+import { ImageEXIF } from "./image-exif.service";
+import { Path, PathType } from "./path.vo";
+import { UrlWithoutTrailingSlashType } from "./url-wo-trailing-slash.vo";
+
+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 → passwords.vo.ts}

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

package/src/{path.ts → path.vo.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 → port.vo.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>;