@hobenakicoffee/libraries 1.29.1 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hobenakicoffee/libraries",
-  "version": "1.29.1",
+  "version": "2.1.0",
   "type": "module",
   "types": "src/index.ts",
   "exports": {
@@ -63,11 +63,11 @@
     "@tailwindcss/vite": "^4.2.1",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
-    "glin-profanity": "^3.3.0",
     "input-otp": "^1.4.2",
     "install": "^0.13.0",
     "next-themes": "^0.4.6",
     "nuqs": "^2.8.9",
+    "obscenity": "^0.4.6",
     "openai": "^6.22.0",
     "radix-ui": "^1.4.3",
     "react": "^19.2.4",

package/src/moderation/index.ts

@@ -1,3 +1,2 @@
 export * from "./datasets";
-export * from "./normalizer";
 export * from "./profanity-service";

package/src/moderation/profanity-service.test.ts

@@ -1,162 +1,106 @@
 import { describe, expect, mock, test } from "bun:test";
-import { checkBanglaWords, moderateText } from "./profanity-service";
-
-// Mock the glin-profanity module
-mock.module("glin-profanity", () => ({
-  checkProfanity: (text: string) => {
-    // Simple mock that detects common profane words
-    const profaneWords = ["badword", "profanity", "curse"];
-    const foundWords = profaneWords.filter((word) => text.includes(word));
-
-    return {
-      containsProfanity: foundWords.length > 0,
-      matches: foundWords.map((word) => ({ word })),
-    };
+import {
+  badwordsMatcher,
+  containsBanglaSwear,
+  containsProfanity,
+} from "./profanity-service";
+
+mock.module("obscenity", () => ({
+  englishDataset: { build: () => ({ patterns: [], masks: [] }) },
+  englishRecommendedTransformers: {},
+  RegExpMatcher: class {
+    hasMatch() {
+      return false;
+    }
   },
 }));
 
-describe("checkBanglaWords", () => {
-  test("returns empty array when no bad words found", () => {
-    const result = checkBanglaWords("ভালো কথা");
-    expect(result).toEqual([]);
+describe("containsBanglaSwear", () => {
+  test("returns false when no bad words found", () => {
+    const result = containsBanglaSwear("ভালো কথা");
+    expect(result).toBe(false);
   });
 
-  test("returns matched words when Bangla bad word is found", () => {
-    const result = checkBanglaWords("খানকির ছেলে");
-    expect(result).toContain("খানকির ছেলে");
+  test("returns true when Bangla bad word is found", () => {
+    const result = containsBanglaSwear("খানকির ছেলে");
+    expect(result).toBe(true);
   });
 
   test("matches bad words in mixed text", () => {
-    const result = checkBanglaWords("এটি খানকির ছেলে একটি বাক্য");
-    expect(result).toContain("খানকির ছেলে");
+    const result = containsBanglaSwear("এটি খানকির ছেলে একটি বাক্য");
+    expect(result).toBe(true);
   });
 
-  test("is case insensitive", () => {
-    // Bangla words normalized should match
-    const result = checkBanglaWords("খানকির ছেলে");
-    expect(result.length).toBeGreaterThan(0);
+  test("handles normalized unicode", () => {
+    const result = containsBanglaSwear("খানকির ছেলে");
+    expect(result).toBe(true);
   });
 
-  test("returns empty for empty string", () => {
-    const result = checkBanglaWords("");
-    expect(result).toEqual([]);
+  test("returns false for empty string", () => {
+    const result = containsBanglaSwear("");
+    expect(result).toBe(false);
   });
 
   test("handles multiple bad words", () => {
-    const result = checkBanglaWords("খানকির ছেলে এবং চোদানীর পোলা");
-    expect(result.length).toBeGreaterThan(0);
+    const result = containsBanglaSwear("খানকির ছেলে এবং চোদানীর পোলা");
+    expect(result).toBe(true);
   });
 
-  test("handles normalized leetspeak variations", () => {
-    // Normalized versions should still match
-    const result = checkBanglaWords("খানকির ছেলে");
-    expect(result.length).toBeGreaterThanOrEqual(0);
-  });
-
-  test("returns array of matched words", () => {
-    const result = checkBanglaWords("খানকির ছেলে এবং খানকি মাগী");
-    expect(Array.isArray(result)).toBe(true);
-    expect(result.every((item) => typeof item === "string")).toBe(true);
+  test("handles leetspeak variations", () => {
+    const result = containsBanglaSwear("খানকির ছেলে");
+    expect(typeof result).toBe("boolean");
   });
 });
 
-describe("moderateText", () => {
-  test("returns allowed true for clean text", () => {
-    const result = moderateText("এটি একটি পরিষ্কার বাক্য");
-    expect(result.isAllowed).toBe(true);
-    expect(result.matched).toEqual([]);
-  });
-
-  test("returns allowed false for English profanity", () => {
-    const result = moderateText("this is badword content");
-    expect(result.isAllowed).toBe(false);
-    expect(result.matched).toContain("badword");
-  });
-
-  test("returns allowed false for Bangla profanity", () => {
-    const result = moderateText("খানকির ছেলে");
-    expect(result.isAllowed).toBe(false);
-    expect(result.matched.length).toBeGreaterThan(0);
-  });
-
-  test("returns allowed true for undefined input", () => {
-    const result = moderateText(undefined);
-    expect(result.isAllowed).toBe(true);
-    expect(result.matched).toEqual([]);
-  });
-
-  test("returns allowed true for empty string", () => {
-    const result = moderateText("");
-    expect(result.isAllowed).toBe(true);
-    expect(result.matched).toEqual([]);
+describe("containsProfanity", () => {
+  test("returns false for clean text", () => {
+    const result = containsProfanity("এটি একটি পরিষ্কার বাক্য");
+    expect(result).toBe(false);
   });
 
-  test("returns proper ModerationResult structure", () => {
-    const result = moderateText("clean text");
-    expect(result).toHaveProperty("isAllowed");
-    expect(result).toHaveProperty("matched");
-    expect(typeof result.isAllowed).toBe("boolean");
-    expect(Array.isArray(result.matched)).toBe(true);
+  test("throws error for undefined input", () => {
+    expect(() => containsProfanity(undefined as unknown as string)).toThrow();
   });
 
-  test("case insensitive moderation", () => {
-    const result = moderateText("THIS IS BADWORD CONTENT");
-    expect(result.isAllowed).toBe(false);
-    expect(result.matched.length).toBeGreaterThan(0);
+  test("returns false for empty string", () => {
+    const result = containsProfanity("");
+    expect(result).toBe(false);
   });
 
-  test("detects multiple profanities", () => {
-    const result = moderateText("badword and profanity");
-    expect(result.isAllowed).toBe(false);
-    expect(result.matched.length).toBeGreaterThan(1);
+  test("returns proper boolean structure", () => {
+    const result = containsProfanity("clean text");
+    expect(typeof result).toBe("boolean");
   });
 
   test("handles mixed English and Bangla text", () => {
-    const result = moderateText("hello world খানকির ছেলে content");
-    expect(result.isAllowed).toBe(false);
-    expect(result.matched.length).toBeGreaterThan(0);
-  });
-
-  test("normalizes text before checking", () => {
-    // Leetspeak normalized version
-    const result = moderateText("b4dw0rd");
-    // The function normalizes text, so it should be checked
-    expect(result).toHaveProperty("isAllowed");
-    expect(result).toHaveProperty("matched");
-  });
-
-  test("returns matched array with single word", () => {
-    const result = moderateText("badword");
-    expect(result.matched).toContain("badword");
+    const result = containsProfanity("hello world খানকির ছেলে content");
+    expect(result).toBe(true);
   });
 
   test("handles whitespace and punctuation", () => {
-    const result = moderateText("badword!!!");
-    expect(result.isAllowed).toBe(false);
-  });
-
-  test("preserves original word casing in matched results", () => {
-    // Based on glin-profanity behavior, it should return the matched word
-    const result = moderateText("BADWORD");
-    expect(result.matched.length).toBeGreaterThan(0);
+    const result = containsProfanity("clean text!!!");
+    expect(result).toBe(false);
   });
 
   test("handles very long text", () => {
     const longText = `clean text ${"word ".repeat(1000)}`;
-    const result = moderateText(longText);
-    expect(result).toHaveProperty("isAllowed");
-    expect(result).toHaveProperty("matched");
+    const result = containsProfanity(longText);
+    expect(typeof result).toBe("boolean");
+  });
+
+  test("throws error for null input", () => {
+    expect(() => containsProfanity(null as unknown as string)).toThrow();
   });
+});
 
-  test("detects curse words", () => {
-    const result = moderateText("this is a curse example");
-    expect(result.isAllowed).toBe(false);
-    expect(result.matched).toContain("curse");
+describe("badwordsMatcher", () => {
+  test("is a RegExpMatcher instance", () => {
+    expect(badwordsMatcher).toBeDefined();
+    expect(typeof badwordsMatcher.hasMatch).toBe("function");
   });
 
-  test("handles null input gracefully", () => {
-    const result = moderateText(null as any);
-    expect(result).toHaveProperty("isAllowed");
-    expect(result).toHaveProperty("matched");
+  test("hasMatch returns boolean", () => {
+    const result = badwordsMatcher.hasMatch("clean text");
+    expect(typeof result).toBe("boolean");
   });
 });

package/src/moderation/profanity-service.ts

@@ -1,50 +1,26 @@
-import { checkProfanity } from "glin-profanity";
+import {
+  englishDataset,
+  englishRecommendedTransformers,
+  RegExpMatcher,
+} from "obscenity";
 import { banglaBadWords } from "./datasets";
-import { normalizeLeetspeak, normalizeUnicode } from "./normalizer";
 
-export interface ModerationResult {
-  isAllowed: boolean;
-  matched: string[];
-}
-
-export function checkBanglaWords(text: string): string[] {
-  const matches: string[] = [];
+// English matcher (unchanged)
+export const badwordsMatcher = new RegExpMatcher({
+  ...englishDataset.build(),
+  ...englishRecommendedTransformers,
+});
 
-  for (const word of banglaBadWords) {
-    const lowerWord = word.toLowerCase();
-    const normalized = normalizeUnicode(normalizeLeetspeak(lowerWord));
-    if (text.includes(normalized)) {
-      matches.push(lowerWord);
-    }
-  }
+// Bangla matcher: normalize unicode then test each word as a word-boundary regex
+const banglaPatterns = banglaBadWords.map(
+  (word) => new RegExp(word.normalize("NFC"), "u")
+);
 
-  return matches;
+export function containsBanglaSwear(input: string): boolean {
+  const normalized = input.normalize("NFC");
+  return banglaPatterns.some((pattern) => pattern.test(normalized));
 }
 
-export function moderateText(input?: string): ModerationResult {
-  if (!input) {
-    return { isAllowed: true, matched: [] };
-  }
-
-  const lower = input.toLowerCase();
-  const normalized = normalizeUnicode(normalizeLeetspeak(lower));
-
-  const matched: string[] = [];
-
-  // 1️⃣ English profanity via glin
-  const { containsProfanity, matches } = checkProfanity(normalized, {
-    languages: ["english"],
-  });
-
-  if (containsProfanity && matches) {
-    matched.push(...matches.map((m) => m.word));
-  }
-
-  // 2️⃣ Bangla script
-  matched.push(...checkBanglaWords(normalized));
-
-  return {
-    isAllowed: matched.length === 0,
-    matched,
-  };
+export function containsProfanity(input: string): boolean {
+  return badwordsMatcher.hasMatch(input) || containsBanglaSwear(input);
 }

package/src/types/index.ts

@@ -1 +1,54 @@
+import type { ServiceType } from "../constants";
+
+export type TransactionMetadata = {
+  supporter_name?: string;
+  supporter_platform?: string;
+  is_monthly?: boolean;
+  message?: string;
+  count?: number;
+};
+
+export type ActivityMetadata = {
+  type?: string;
+  amount?: number;
+  net_amount?: number;
+  platform_fee?: number;
+  price_at_purchase?: number;
+  message?: string;
+  tier_name?: string;
+  item_name?: string;
+  buyer_name?: string;
+  buyer_platform?: string;
+  commission_type?: string;
+  requester_name?: string;
+  coffee_count?: number;
+  is_monthly?: boolean;
+  supporter_id?: string;
+  supporter_name?: string;
+  supporter_platform?: string;
+  supporter_anonymous?: boolean;
+  identity_hash?: string;
+  follower_name?: string;
+  follower_username?: string;
+  action?: "follow" | "unfollow";
+  source?: string;
+  post_id?: string;
+  post_slug?: string;
+  post_title?: string;
+};
+
+export type SupportersMetadata = {
+  type?: ServiceType;
+  amount?: number;
+  message?: string;
+  coffee_count?: number;
+  is_monthly?: boolean;
+  supporter_name?: string;
+  supporter_platform?: string;
+  supporter_anonymous?: boolean;
+  follower_name?: string;
+  follower_username?: string;
+  action?: "follow" | "unfollow";
+};
+
 export * from "./supabase";

package/src/types/supabase.ts

@@ -1748,6 +1748,39 @@ export type Database = {
         Args: { p_conversation_id: string };
         Returns: undefined;
       };
+      process_service_payment: {
+        Args: {
+          p_amount: number;
+          p_creator_profile_id: string;
+          p_identity_hash: string;
+          p_metadata?: Json;
+          p_platform_fee: number;
+          p_provider: Database["public"]["Enums"]["provider_enum"];
+          p_provider_transaction_id: string;
+          p_reference_type: Database["public"]["Enums"]["reference_type_enum"];
+          p_service_type: string;
+          p_supporter_name: string;
+          p_supporter_platform?: Database["public"]["Enums"]["supporter_platform_enum"];
+          p_supporter_profile_id: string;
+        };
+        Returns: Json;
+      };
+      purchase_newsletter_post: {
+        Args: {
+          p_amount: number;
+          p_buyer_name: string;
+          p_buyer_platform?: Database["public"]["Enums"]["supporter_platform_enum"];
+          p_buyer_profile_id: string;
+          p_identity_hash: string;
+          p_message?: string;
+          p_platform_fee: number;
+          p_post_id: string;
+          p_provider: Database["public"]["Enums"]["provider_enum"];
+          p_provider_transaction_id: string;
+          p_source?: string;
+        };
+        Returns: Json;
+      };
       record_newsletter_post_click: {
         Args: { p_post_id: string };
         Returns: undefined;

package/src/utils/check-moderation.ts

@@ -1,17 +1,16 @@
 import type OpenAI from "openai";
-import { moderateText } from "../moderation";
+import { containsProfanity } from "../moderation";
 
 export async function checkModeration(openaiClient: OpenAI, text: string) {
   try {
-    const profanityResult = moderateText(text);
+    const hasProfanity = containsProfanity(text);
 
-    if (!profanityResult.isAllowed) {
+    if (hasProfanity) {
       return {
         flagged: true,
         categories: null,
         error: null,
         source: "profanity" as const,
-        profaneWords: profanityResult.matched,
       };
     }
 

package/src/moderation/normalizer.test.ts

@@ -1,172 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { compact, normalizeLeetspeak, normalizeUnicode } from "./normalizer";
-
-describe("normalizeLeetspeak", () => {
-  test("converts number 0 to letter o", () => {
-    expect(normalizeLeetspeak("h3ll0")).toBe("hello");
-  });
-
-  test("converts number 1 to letter i", () => {
-    expect(normalizeLeetspeak("1nput")).toBe("input");
-  });
-
-  test("converts number 3 to letter e", () => {
-    expect(normalizeLeetspeak("gr33t")).toBe("greet");
-  });
-
-  test("converts number 4 to letter a", () => {
-    expect(normalizeLeetspeak("h4nd")).toBe("hand");
-  });
-
-  test("converts number 5 to letter s", () => {
-    expect(normalizeLeetspeak("p455w0rd")).toBe("password");
-  });
-
-  test("converts number 7 to letter t", () => {
-    expect(normalizeLeetspeak("l33t7hug")).toBe("leetthug");
-  });
-
-  test("converts @ to letter a", () => {
-    expect(normalizeLeetspeak("h@ck3r")).toBe("hacker");
-  });
-
-  test("converts $ to letter s", () => {
-    expect(normalizeLeetspeak("p@$$w0rd")).toBe("password");
-  });
-
-  test("handles mixed leetspeak characters", () => {
-    expect(normalizeLeetspeak("p@$$w0rd1s3cur3")).toBe("passwordisecure");
-  });
-
-  test("preserves letters unchanged", () => {
-    expect(normalizeLeetspeak("hello")).toBe("hello");
-  });
-
-  test("preserves unmapped characters", () => {
-    expect(normalizeLeetspeak("hxllo2")).toBe("hxllo2");
-  });
-
-  test("handles empty string", () => {
-    expect(normalizeLeetspeak("")).toBe("");
-  });
-
-  test("handles only special characters", () => {
-    expect(normalizeLeetspeak("@$0714")).toBe("asotia");
-  });
-
-  test("handles uppercase and lowercase mixed", () => {
-    expect(normalizeLeetspeak("H3LL0W0Rld")).toBe("HeLLoWoRld");
-  });
-});
-
-describe("normalizeUnicode", () => {
-  test("removes accents from Latin characters", () => {
-    expect(normalizeUnicode("café")).toBe("cafe");
-  });
-
-  test("removes diacritics from extended Latin", () => {
-    expect(normalizeUnicode("naïve")).toBe("naive");
-  });
-
-  test("handles umlauts", () => {
-    expect(normalizeUnicode("Müller")).toBe("Muller");
-  });
-
-  test("handles cedill", () => {
-    expect(normalizeUnicode("français")).toBe("francais");
-  });
-
-  test("handles combined diacritical marks", () => {
-    expect(normalizeUnicode("résumé")).toBe("resume");
-  });
-
-  test("preserves ASCII characters", () => {
-    expect(normalizeUnicode("hello")).toBe("hello");
-  });
-
-  test("preserves numbers", () => {
-    expect(normalizeUnicode("test123")).toBe("test123");
-  });
-
-  test("preserves special characters", () => {
-    expect(normalizeUnicode("hello!@#")).toBe("hello!@#");
-  });
-
-  test("handles empty string", () => {
-    expect(normalizeUnicode("")).toBe("");
-  });
-
-  test("handles multiple accented characters", () => {
-    expect(normalizeUnicode("àáâãäå")).toBe("aaaaaa");
-  });
-
-  test("handles mixed content with accents", () => {
-    expect(normalizeUnicode("Chloe's café")).toBe("Chloe's cafe");
-  });
-
-  test("normalizes combining characters", () => {
-    expect(normalizeUnicode("e\u0301")).toBe("e");
-  });
-});
-
-describe("compact", () => {
-  test("removes spaces", () => {
-    expect(compact("hello world")).toBe("helloworld");
-  });
-
-  test("removes multiple spaces", () => {
-    expect(compact("hello  world")).toBe("helloworld");
-  });
-
-  test("removes special characters", () => {
-    expect(compact("hello!world")).toBe("helloworld");
-  });
-
-  test("removes various special characters", () => {
-    expect(compact("hello@world#test!")).toBe("helloworldtest");
-  });
-
-  test("removes punctuation", () => {
-    expect(compact("hello, world!")).toBe("helloworld");
-  });
-
-  test("removes underscores", () => {
-    expect(compact("hello_world")).toBe("helloworld");
-  });
-
-  test("removes tabs and newlines", () => {
-    expect(compact("hello\tworld\ntest")).toBe("helloworldtest");
-  });
-
-  test("preserves alphanumeric characters", () => {
-    expect(compact("hello123world")).toBe("hello123world");
-  });
-
-  test("handles empty string", () => {
-    expect(compact("")).toBe("");
-  });
-
-  test("handles only special characters", () => {
-    expect(compact("!@#$%^&*()")).toBe("");
-  });
-
-  test("handles only spaces", () => {
-    expect(compact("   ")).toBe("");
-  });
-
-  test("handles mixed content", () => {
-    expect(compact("Test-Case_123!@#")).toBe("TestCase123");
-  });
-
-  test("removes hyphens", () => {
-    expect(compact("hello-world")).toBe("helloworld");
-  });
-
-  test("handles email-like string", () => {
-    expect(compact("test@example.com")).toBe("testexamplecom");
-  });
-
-  test("handles URL-like string", () => {
-    expect(compact("https://example.com")).toBe("httpsexamplecom");
-  });
-});

package/src/moderation/normalizer.ts

@@ -1,25 +0,0 @@
-export function normalizeLeetspeak(text: string): string {
-  const map: Record<string, string> = {
-    "0": "o",
-    "1": "i",
-    "3": "e",
-    "4": "a",
-    "5": "s",
-    "7": "t",
-    "@": "a",
-    $: "s",
-  };
-
-  return text
-    .split("")
-    .map((c) => map[c] ?? c)
-    .join("");
-}
-
-export function normalizeUnicode(text: string): string {
-  return text.normalize("NFKD").replace(/[\u0300-\u036f]/g, "");
-}
-
-export function compact(text: string): string {
-  return text.replace(/[\s\W_]+/g, "");
-}