@bgord/bun 0.30.0 → 1.0.0

package/src/encryption.service.ts

@@ -1,45 +0,0 @@
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
-import { pipeline } from "node:stream/promises";
-import * as util from "node:util";
-import { z } from "zod/v4";
-
-export const EncryptionIV = z
-  .string()
-  .min(1)
-  .transform((value) => Buffer.from(value.split(",").map(Number)));
-export type EncryptionIVType = z.infer<typeof EncryptionIV>;
-
-export const EncryptionSecret = z.string().length(64);
-export type EncryptionSecretType = z.infer<typeof EncryptionSecret>;
-
-export type EncryptionConfig = { secret: EncryptionSecretType; iv: EncryptionIVType };
-export type EncryptionOperationConfig = { input: fs.PathLike; output: fs.PathLike };
-
-const scrypt = util.promisify(crypto.scrypt);
-
-export class Encryption {
-  private readonly algorithm = "aes-192-cbc";
-
-  constructor(private readonly config: EncryptionConfig) {}
-
-  async createEncrypt() {
-    const key = (await scrypt(this.config.secret, "salt", 24)) as Buffer;
-    return crypto.createCipheriv(this.algorithm, key, this.config.iv);
-  }
-
-  async createDecrypt() {
-    const key = (await scrypt(this.config.secret, "salt", 24)) as Buffer;
-    return crypto.createDecipheriv(this.algorithm, key, this.config.iv);
-  }
-
-  async encrypt(config: EncryptionOperationConfig) {
-    const encrypt = await this.createEncrypt();
-    return pipeline(fs.createReadStream(config.input), encrypt, fs.createWriteStream(config.output));
-  }
-
-  async decrypt(config: EncryptionOperationConfig) {
-    const decrypt = await this.createDecrypt();
-    return pipeline(fs.createReadStream(config.input), decrypt, fs.createWriteStream(config.output));
-  }
-}

package/src/gzip.service.ts

@@ -1,23 +0,0 @@
-import { createReadStream, createWriteStream, type PathLike } from "node:fs";
-import { pipeline } from "node:stream/promises";
-import { createGunzip, createGzip } from "node:zlib";
-
-type GzipCompressConfigType = { input: PathLike; output: PathLike };
-
-export class Gzip {
-  static createCompress() {
-    return createGzip();
-  }
-
-  static createDecompress() {
-    return createGunzip();
-  }
-
-  static async compress(config: GzipCompressConfigType) {
-    return pipeline(createReadStream(config.input), createGzip(), createWriteStream(config.output));
-  }
-
-  static async uncompress(config: GzipCompressConfigType) {
-    return pipeline(createReadStream(config.input), createGunzip(), createWriteStream(config.output));
-  }
-}

package/src/open-graph.service.ts

@@ -1,242 +0,0 @@
-import { z } from "zod/v4";
-// import { ImageEXIF } from "./image-exif.service";
-// import type { 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: string) {
-    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 {
-  // TODO: use image port
-  // static async generate(config: { path: string; BASE_URL: UrlWithoutTrailingSlashType }) {
-  //   const exif = await ImageEXIF.read(config.path);
-  //   return new OpenGraphImage({
-  //     url: new OpenGraph.image.url(`${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/sitemap.service.ts

@@ -1,91 +0,0 @@
-import { z } from "zod/v4";
-import type { UrlWithoutTrailingSlashType } from "./url-wo-trailing-slash.vo";
-
-export const SitemapLoc = z.string().min(1);
-export type SitemapLocType = z.infer<typeof SitemapLoc>;
-
-export const SitemapLastmod = z
-  .string()
-  .refine(
-    (value) => {
-      const [year, month, day] = value.split("-");
-
-      return (
-        Number.isInteger(Number(year)) && Number.isInteger(Number(month)) && Number.isInteger(Number(day))
-      );
-    },
-    { message: "sitemap.lastmod.invalid" },
-  )
-  .optional();
-export type SitemapLastmodType = z.infer<typeof SitemapLastmod>;
-
-export const SitemapChangefreq = z
-  .union([
-    z.literal("always"),
-    z.literal("hourly"),
-    z.literal("daily"),
-    z.literal("weekly"),
-    z.literal("monthly"),
-    z.literal("yearly"),
-    z.literal("never"),
-  ])
-  .optional();
-export type SitemapChangefreqType = z.infer<typeof SitemapChangefreq>;
-
-export const SitemapPriority = z.number().min(0).max(1).default(0.5);
-export type SitemapPriorityType = z.infer<typeof SitemapPriority>;
-
-export const SitemapEntry = z.object({
-  loc: SitemapLoc,
-  lastmod: SitemapLastmod,
-  changefreq: SitemapChangefreq,
-  priority: SitemapPriority,
-});
-export type SitemapEntryType = z.infer<typeof SitemapEntry>;
-
-export type SitemapConfigType = {
-  path?: string;
-  entries: SitemapEntryType[];
-  BASE_URL: UrlWithoutTrailingSlashType;
-};
-
-export class Sitemap {
-  static DEFAULT_PATH = "static/sitemap.xml";
-
-  static generate(config: SitemapConfigType) {
-    let sitemap = `<?xml version="1.0" encoding="UTF-8"?>\n`;
-    sitemap += `<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n`;
-
-    for (const entry of config.entries) {
-      {
-        let output = "<url>\n";
-        output += `\t<loc>${config.BASE_URL}${entry.loc}</loc>\n`;
-
-        if (entry.lastmod) {
-          output += `\t<lastmod>${entry.lastmod}</lastmod>\n`;
-        }
-
-        if (entry.changefreq) {
-          output += `\t<changefreq>${entry.changefreq}</changefreq>\n`;
-        }
-
-        output += `\t<priority>${entry.priority}</priority>\n`;
-
-        output += "</url>\n";
-
-        sitemap += output;
-      }
-    }
-
-    sitemap += "</urlset>";
-
-    return sitemap;
-  }
-
-  static async save(config: SitemapConfigType) {
-    const output = config.path ?? Sitemap.DEFAULT_PATH;
-    const content = Sitemap.generate(config);
-
-    return Bun.file(output).write(content);
-  }
-}

package/src/url-wo-trailing-slash.vo.ts

@@ -1,9 +0,0 @@
-import { z } from "zod/v4";
-
-export const UrlWithoutTrailingSlash = z
-  .url()
-  .trim()
-  .min(1)
-  .refine((value) => !value.endsWith("/"), { message: "url_cannot_end_with_trailing_slash" })
-  .brand("UrlWithoutTrailingSlash");
-export type UrlWithoutTrailingSlashType = z.infer<typeof UrlWithoutTrailingSlash>;