@bash-app/bash-common 30.247.0 → 30.254.0

package/src/utils/__tests__/addressUtils.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  addressHasEnoughDataForGeolocation,
+  addressValuesToDatabaseAddressString,
+  databaseAddressStringToAddressValues,
+  formatLocalityForCardDisplay,
+  databaseAddressStringToOneLineString,
+  databaseAddressStringToDisplayString,
+  addressToDisplayString,
+  extractAddressComponents,
+} from "../addressUtils.js";
+
+describe("addressUtils", () => {
+  describe("addressHasEnoughDataForGeolocation", () => {
+    test("returns true when place, city, and state are set", () => {
+      expect(
+        addressHasEnoughDataForGeolocation({
+          place: "Madison Square Garden",
+          city: "New York",
+          state: "NY",
+        } as any)
+      ).toBe(true);
+    });
+
+    test("returns true when street, city, and state are set", () => {
+      expect(
+        addressHasEnoughDataForGeolocation({
+          street: "4 Pennsylvania Plaza",
+          city: "New York",
+          state: "NY",
+        } as any)
+      ).toBe(true);
+    });
+
+    test("returns false when city or state is missing", () => {
+      expect(
+        addressHasEnoughDataForGeolocation({ place: "Venue", city: "NYC", state: "" } as any)
+      ).toBe(false);
+    });
+  });
+
+  describe("addressValuesToDatabaseAddressString", () => {
+    test("joins fields with pipe delimiter", () => {
+      expect(
+        addressValuesToDatabaseAddressString({
+          place: "The Loft",
+          street: "123 Main St",
+          city: "Brooklyn",
+          state: "NY",
+          zipCode: "11201",
+          country: "USA",
+        })
+      ).toBe("The Loft|123 Main St|Brooklyn|NY|11201|USA");
+    });
+  });
+
+  describe("databaseAddressStringToAddressValues", () => {
+    test("parses pipe-delimited strings", () => {
+      expect(databaseAddressStringToAddressValues("Venue|1 Ave|NYC|NY|10001|USA")).toEqual({
+        place: "Venue",
+        street: "1 Ave",
+        city: "NYC",
+        state: "NY",
+        zipCode: "10001",
+        country: "USA",
+      });
+    });
+
+    test("parses legacy bullet-delimited 5-part strings", () => {
+      expect(
+        databaseAddressStringToAddressValues("123 Main St • Brooklyn • NY • 11201 • USA")
+      ).toEqual({
+        place: "",
+        street: "123 Main St",
+        city: "Brooklyn",
+        state: "NY",
+        zipCode: "11201",
+        country: "USA",
+      });
+    });
+
+    test("treats undelimited string as place-only", () => {
+      expect(databaseAddressStringToAddressValues("Central Park")).toEqual({
+        place: "Central Park",
+        street: "",
+        city: "",
+        state: "",
+        zipCode: "",
+        country: "",
+      });
+    });
+
+    test("returns empty address for null/undefined", () => {
+      expect(databaseAddressStringToAddressValues(null)).toEqual({
+        place: "",
+        street: "",
+        city: "",
+        state: "",
+        zipCode: "",
+        country: "",
+      });
+    });
+  });
+
+  describe("formatLocalityForCardDisplay", () => {
+    test("joins city, state, and country", () => {
+      expect(formatLocalityForCardDisplay("Brooklyn", "NY", "USA")).toBe("Brooklyn, NY, USA");
+    });
+
+    test("skips empty parts", () => {
+      expect(formatLocalityForCardDisplay("Austin", null, "USA")).toBe("Austin, USA");
+    });
+  });
+
+  describe("databaseAddressStringToOneLineString", () => {
+    test("formats full pipe-delimited address", () => {
+      const db = addressValuesToDatabaseAddressString({
+        place: "Rooftop Bar",
+        street: "99 King St",
+        city: "Seattle",
+        state: "WA",
+        zipCode: "98101",
+        country: "USA",
+      });
+      expect(databaseAddressStringToOneLineString(db)).toBe(
+        "Rooftop Bar, 99 King St, Seattle, WA 98101"
+      );
+    });
+
+    test("returns place-only for undelimited strings", () => {
+      expect(databaseAddressStringToOneLineString("Secret Warehouse")).toBe("Secret Warehouse");
+    });
+  });
+
+  describe("addressToDisplayString", () => {
+    test("builds comma-separated line with zip", () => {
+      expect(
+        addressToDisplayString({
+          place: "Studio",
+          street: "5th Ave",
+          city: "NYC",
+          state: "NY",
+          zipCode: "10003",
+          country: "USA",
+        })
+      ).toBe("Studio, 5th Ave, NYC, NY 10003");
+    });
+  });
+
+  describe("extractAddressComponents", () => {
+    test("maps Google place components to IAddress", () => {
+      expect(
+        extractAddressComponents({
+          place_id: "place-123",
+          name: "Bash HQ",
+          address_components: [
+            { types: ["street_number"], long_name: "100", short_name: "100" },
+            { types: ["route"], long_name: "Broadway", short_name: "Broadway" },
+            { types: ["locality"], long_name: "New York", short_name: "New York" },
+            { types: ["administrative_area_level_1"], long_name: "New York", short_name: "NY" },
+            { types: ["postal_code"], long_name: "10005", short_name: "10005" },
+            { types: ["country"], long_name: "United States", short_name: "US" },
+          ],
+        })
+      ).toEqual({
+        googlePlaceId: "place-123",
+        place: "Bash HQ",
+        street: "100 Broadway",
+        city: "New York",
+        state: "NY",
+        zipCode: "10005",
+        country: "United States",
+      });
+    });
+  });
+});

package/src/utils/__tests__/apiUtils.test.ts

@@ -0,0 +1,219 @@
+/**
+ * Tests for shared contact/user helpers and environment detection.
+ */
+
+import { describe, expect, test, beforeEach, afterEach } from "@jest/globals";
+import {
+  getUserName,
+  getUserImage,
+  isContactAndNotUser,
+  getContactOrUserEmail,
+  getUserIdAndNotContactId,
+  getBashEventDetailUrlParamsFromBashEvent,
+  isProduction,
+} from "../apiUtils.js";
+
+describe("apiUtils", () => {
+  describe("isContactAndNotUser", () => {
+    test("returns true when contactOwnerId is set", () => {
+      expect(isContactAndNotUser({ contactOwnerId: "owner-1", fullName: "Jane" })).toBe(true);
+    });
+
+    test("returns false for user-shaped objects", () => {
+      expect(isContactAndNotUser({ id: "user-1", email: "jane@example.com" })).toBe(false);
+    });
+  });
+
+  describe("getUserName", () => {
+    test("returns empty string for undefined", () => {
+      expect(getUserName(undefined)).toBe("");
+    });
+
+    test("returns contact fullName when present", () => {
+      expect(
+        getUserName({ contactOwnerId: "owner-1", fullName: "Jane Contact", contactEmail: "j@x.com" })
+      ).toBe("Jane Contact");
+    });
+
+    test("falls back to contactEmail for contacts without fullName", () => {
+      expect(getUserName({ contactOwnerId: "owner-1", contactEmail: "j@x.com" })).toBe("j@x.com");
+    });
+
+    test("combines givenName and familyName for users", () => {
+      expect(getUserName({ givenName: "Jane", familyName: "Doe", email: "j@x.com" })).toBe("Jane Doe");
+    });
+
+    test("falls back to email when name parts missing", () => {
+      expect(getUserName({ email: "solo@example.com" })).toBe("solo@example.com");
+    });
+  });
+
+  describe("getUserImage", () => {
+    const noProfilePicture = "/noProfilePicture.svg";
+
+    test("returns empty string for undefined", () => {
+      expect(getUserImage(undefined)).toBe("");
+    });
+
+    test("returns placeholder for contacts", () => {
+      expect(getUserImage({ contactOwnerId: "owner-1", fullName: "Jane" })).toBe(noProfilePicture);
+    });
+
+    test("returns uploaded image when only upload exists", () => {
+      expect(getUserImage({ uploadedImage: "https://cdn.example/upload.jpg" })).toBe(
+        "https://cdn.example/upload.jpg"
+      );
+    });
+
+    test("returns google image when only google image exists", () => {
+      expect(getUserImage({ image: "https://lh3.google.com/photo.jpg" })).toBe(
+        "https://lh3.google.com/photo.jpg"
+      );
+    });
+
+    test("treats whitespace-only image URLs as missing", () => {
+      expect(getUserImage({ uploadedImage: "   ", image: "https://google.com/p.jpg" })).toBe(
+        "https://google.com/p.jpg"
+      );
+    });
+
+    test("prefers most recently updated image when both exist", () => {
+      const older = new Date("2024-01-01");
+      const newer = new Date("2024-06-01");
+      expect(
+        getUserImage({
+          uploadedImage: "https://cdn.example/upload.jpg",
+          uploadedImageUpdatedAt: newer,
+          image: "https://lh3.google.com/photo.jpg",
+          imageUpdatedAt: older,
+        })
+      ).toBe("https://cdn.example/upload.jpg");
+      expect(
+        getUserImage({
+          uploadedImage: "https://cdn.example/upload.jpg",
+          uploadedImageUpdatedAt: older,
+          image: "https://lh3.google.com/photo.jpg",
+          imageUpdatedAt: newer,
+        })
+      ).toBe("https://lh3.google.com/photo.jpg");
+    });
+
+    test("falls back to uploadedImage when both exist without timestamps", () => {
+      expect(
+        getUserImage({
+          uploadedImage: "https://cdn.example/upload.jpg",
+          image: "https://lh3.google.com/photo.jpg",
+        })
+      ).toBe("https://cdn.example/upload.jpg");
+    });
+
+    test("returns placeholder when user has no images", () => {
+      expect(getUserImage({ email: "j@x.com" })).toBe(noProfilePicture);
+    });
+  });
+
+  describe("getContactOrUserEmail", () => {
+    test("returns contactEmail for contacts", () => {
+      expect(getContactOrUserEmail({ contactOwnerId: "o1", contactEmail: "c@x.com" })).toBe("c@x.com");
+    });
+
+    test("returns email for users", () => {
+      expect(getContactOrUserEmail({ id: "u1", email: "u@x.com" })).toBe("u@x.com");
+    });
+  });
+
+  describe("getUserIdAndNotContactId", () => {
+    test("returns null for contacts", () => {
+      expect(getUserIdAndNotContactId({ contactOwnerId: "o1" })).toBeNull();
+    });
+
+    test("returns user id for users", () => {
+      expect(getUserIdAndNotContactId({ id: "user-42" })).toBe("user-42");
+    });
+  });
+
+  describe("getBashEventDetailUrlParamsFromBashEvent", () => {
+    test("returns empty string for undefined event", () => {
+      expect(getBashEventDetailUrlParamsFromBashEvent(undefined)).toBe("");
+    });
+
+    test("returns empty string when title/desc/cover are absent", () => {
+      expect(
+        getBashEventDetailUrlParamsFromBashEvent({
+          title: "",
+          description: null,
+          coverPhoto: null,
+        } as any)
+      ).toBe("");
+    });
+
+    test("truncates long descriptions before building params", () => {
+      const longDesc = "abcdefghijklmnop";
+      const result = getBashEventDetailUrlParamsFromBashEvent(
+        { title: "Party", description: longDesc, coverPhoto: null } as any,
+        "cover.jpg"
+      );
+      expect(result).toBe("");
+    });
+  });
+
+  describe("isProduction", () => {
+    const envKeys = ["NODE_ENV", "ENVIRONMENT", "BASH_ENV"] as const;
+    const saved: Partial<Record<(typeof envKeys)[number], string | undefined>> = {};
+
+    beforeEach(() => {
+      for (const key of envKeys) {
+        saved[key] = process.env[key];
+      }
+    });
+
+    afterEach(() => {
+      for (const key of envKeys) {
+        if (saved[key] === undefined) {
+          delete process.env[key];
+        } else {
+          process.env[key] = saved[key];
+        }
+      }
+    });
+
+    test("returns false when ENVIRONMENT contains qa", () => {
+      process.env.NODE_ENV = "production";
+      process.env.ENVIRONMENT = "qa-staging";
+      expect(isProduction()).toBe(false);
+    });
+
+    test("returns false when BASH_ENV contains qa", () => {
+      process.env.NODE_ENV = "production";
+      process.env.BASH_ENV = "QA";
+      expect(isProduction()).toBe(false);
+    });
+
+    test("returns true only when NODE_ENV is production and env is explicitly production", () => {
+      process.env.NODE_ENV = "production";
+      process.env.ENVIRONMENT = "production";
+      delete process.env.BASH_ENV;
+      expect(isProduction()).toBe(true);
+    });
+
+    test("returns true when BASH_ENV is production", () => {
+      process.env.NODE_ENV = "production";
+      delete process.env.ENVIRONMENT;
+      process.env.BASH_ENV = "production";
+      expect(isProduction()).toBe(true);
+    });
+
+    test("returns false in development even with production env vars", () => {
+      process.env.NODE_ENV = "development";
+      process.env.ENVIRONMENT = "production";
+      expect(isProduction()).toBe(false);
+    });
+
+    test("returns false when NODE_ENV is production but env vars are unset", () => {
+      process.env.NODE_ENV = "production";
+      delete process.env.ENVIRONMENT;
+      delete process.env.BASH_ENV;
+      expect(isProduction()).toBe(false);
+    });
+  });
+});

package/src/utils/__tests__/arrayUtils.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from "@jest/globals";
+import { asyncFilter } from "../arrayUtils.js";
+
+describe("asyncFilter", () => {
+  test("keeps items where async predicate resolves true", async () => {
+    const nums = [1, 2, 3, 4];
+    const result = await asyncFilter(nums, async (n) => n % 2 === 0);
+    expect(result).toEqual([2, 4]);
+  });
+
+  test("returns empty array when no items match", async () => {
+    const result = await asyncFilter([1, 3, 5], async () => false);
+    expect(result).toEqual([]);
+  });
+
+  test("returns empty array for empty input", async () => {
+    const result = await asyncFilter([], async () => true);
+    expect(result).toEqual([]);
+  });
+
+  test("preserves order of matching items", async () => {
+    const items = ["a", "b", "c", "d"];
+    const result = await asyncFilter(items, async (v) => v !== "b");
+    expect(result).toEqual(["a", "c", "d"]);
+  });
+});

package/src/utils/__tests__/blogUtils.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, test } from "@jest/globals";
+import { DEFAULT_BLOG_IMAGE } from "../../definitions.js";
+import {
+  calculateReadingTime,
+  formatPublishDate,
+  generateBlogDetailUrl,
+  generateExcerpt,
+  generateMetaDescription,
+  generateMetaTitle,
+  getBlogDetailUrl,
+  getBlogImageUrl,
+  highlightSearchTerms,
+  parseBlogUrlParams,
+  processTags,
+  validateBlogContent,
+} from "../blogUtils.js";
+
+describe("blogUtils", () => {
+  describe("URL helpers", () => {
+    test("generateBlogDetailUrl with slug", () => {
+      expect(generateBlogDetailUrl("abc123", "my-post")).toBe("/blog/abc123-my-post");
+    });
+
+    test("generateBlogDetailUrl without slug", () => {
+      expect(generateBlogDetailUrl("abc123")).toBe("/blog/abc123");
+    });
+
+    test("getBlogDetailUrl prefers explicit slug", () => {
+      expect(getBlogDetailUrl("id1", "saved-slug", "Ignored Title")).toBe(
+        "/blog/id1-saved-slug"
+      );
+    });
+
+    test("getBlogDetailUrl generates slug from title when slug missing", () => {
+      expect(getBlogDetailUrl("id1", undefined, "Hello World Party")).toBe(
+        "/blog/id1-hello-world-party"
+      );
+    });
+
+    test("getBlogDetailUrl falls back to id-only URL", () => {
+      expect(getBlogDetailUrl("id1")).toBe("/blog/id1");
+    });
+
+    test("parseBlogUrlParams handles id-only param", () => {
+      expect(parseBlogUrlParams("abc123")).toEqual({ id: "abc123" });
+    });
+
+    test("parseBlogUrlParams splits id-slug at first hyphen", () => {
+      expect(parseBlogUrlParams("abc123-my-cool-post")).toEqual({
+        id: "abc123",
+        slug: "my-cool-post",
+      });
+    });
+
+    test("parseBlogUrlParams returns null for empty input", () => {
+      expect(parseBlogUrlParams("")).toBeNull();
+    });
+  });
+
+  describe("content processing", () => {
+    test("generateExcerpt strips HTML tags", () => {
+      expect(generateExcerpt("<p>Hello <strong>world</strong></p>")).toBe("Hello world");
+    });
+
+    test("generateExcerpt truncates at word boundary with ellipsis", () => {
+      const long = "word ".repeat(50);
+      const excerpt = generateExcerpt(long, 20);
+      expect(excerpt.endsWith("...")).toBe(true);
+      expect(excerpt.length).toBeLessThanOrEqual(23);
+    });
+
+    test("calculateReadingTime rounds up by word count", () => {
+      const words = Array.from({ length: 401 }, (_, i) => `w${i}`).join(" ");
+      expect(calculateReadingTime(words)).toBe(3);
+    });
+
+    test("getBlogImageUrl uses default when missing", () => {
+      expect(getBlogImageUrl(null)).toBe(DEFAULT_BLOG_IMAGE);
+      expect(getBlogImageUrl("https://cdn.example/img.jpg")).toBe(
+        "https://cdn.example/img.jpg"
+      );
+    });
+  });
+
+  describe("SEO helpers", () => {
+    test("generateMetaTitle appends site name", () => {
+      expect(generateMetaTitle("My Post")).toBe("My Post | Bash");
+      expect(generateMetaTitle("My Post", "Custom")).toBe("My Post | Custom");
+    });
+
+    test("generateMetaDescription uses excerpt or fallback", () => {
+      const content = "x".repeat(200);
+      expect(generateMetaDescription(content, "Title")).toContain("...");
+      expect(generateMetaDescription("", "Title")).toContain("Title");
+    });
+  });
+
+  describe("validateBlogContent", () => {
+    test("accepts valid title and content", () => {
+      expect(
+        validateBlogContent("Good title", "x".repeat(100))
+      ).toEqual({ isValid: true, errors: [] });
+    });
+
+    test("collects validation errors", () => {
+      const result = validateBlogContent("", "short");
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toContain("Title is required");
+      expect(result.errors).toContain("Content must be at least 100 characters");
+    });
+  });
+
+  describe("processTags", () => {
+    test("splits, trims, lowercases, and caps at 10 tags", () => {
+      const tags = processTags(" Jazz, ROCK , ,Blues, " + "tag,".repeat(15));
+      expect(tags[0]).toBe("jazz");
+      expect(tags[1]).toBe("rock");
+      expect(tags.length).toBeLessThanOrEqual(10);
+    });
+
+    test("returns empty array for blank input", () => {
+      expect(processTags("")).toEqual([]);
+    });
+  });
+
+  describe("highlightSearchTerms", () => {
+    test("wraps matches in mark tags case-insensitively", () => {
+      expect(highlightSearchTerms("Hello Bash world", "bash")).toBe(
+        "Hello <mark>Bash</mark> world"
+      );
+    });
+
+    test("returns text unchanged when search term empty", () => {
+      expect(highlightSearchTerms("Hello", "")).toBe("Hello");
+    });
+  });
+
+  describe("formatPublishDate", () => {
+    test("formats Date and ISO string consistently", () => {
+      const date = new Date("2024-06-15T12:00:00Z");
+      expect(formatPublishDate(date)).toMatch(/June/);
+      expect(formatPublishDate("2024-06-15T12:00:00Z")).toMatch(/2024/);
+    });
+  });
+});