@tuturuuu/utils 0.0.2 → 0.6.0

package/src/__tests__/time-helper.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest';
+import { parseTimeFromTimetz } from '../time-helper';
+
+describe('Time Helper', () => {
+  describe('parseTimeFromTimetz', () => {
+    it('parses valid timetz format', () => {
+      expect(parseTimeFromTimetz('09:00:00+00')).toBe(9);
+    });
+
+    it('parses midnight as 24', () => {
+      expect(parseTimeFromTimetz('00:00:00+00')).toBe(24);
+    });
+
+    it('parses single digit hour', () => {
+      expect(parseTimeFromTimetz('5:00:00+00')).toBe(5);
+    });
+
+    it('parses hour 23', () => {
+      expect(parseTimeFromTimetz('23:00:00+00')).toBe(23);
+    });
+
+    it('parses hour 12', () => {
+      expect(parseTimeFromTimetz('12:00:00+00')).toBe(12);
+    });
+
+    it('parses hour 1', () => {
+      expect(parseTimeFromTimetz('01:00:00+00')).toBe(1);
+    });
+
+    it('handles different timezone offsets', () => {
+      expect(parseTimeFromTimetz('15:30:00+05:30')).toBe(15);
+    });
+
+    it('handles negative timezone offset', () => {
+      expect(parseTimeFromTimetz('08:00:00-08')).toBe(8);
+    });
+
+    it('returns undefined for undefined input', () => {
+      expect(parseTimeFromTimetz(undefined)).toBeUndefined();
+    });
+
+    it('returns undefined for empty string', () => {
+      expect(parseTimeFromTimetz('')).toBeUndefined();
+    });
+
+    it('returns undefined for invalid format without colon', () => {
+      expect(parseTimeFromTimetz('invalid')).toBeUndefined();
+    });
+
+    it('returns undefined for invalid hour (24)', () => {
+      expect(parseTimeFromTimetz('24:00:00+00')).toBeUndefined();
+    });
+
+    it('returns undefined for negative hour', () => {
+      expect(parseTimeFromTimetz('-1:00:00+00')).toBeUndefined();
+    });
+
+    it('returns undefined for non-numeric hour', () => {
+      expect(parseTimeFromTimetz('abc:00:00+00')).toBeUndefined();
+    });
+
+    it('handles time without timezone', () => {
+      expect(parseTimeFromTimetz('14:30:00')).toBe(14);
+    });
+
+    it('handles just hour:minute format', () => {
+      expect(parseTimeFromTimetz('10:30')).toBe(10);
+    });
+  });
+});

package/src/__tests__/time-tracker-period.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import {
+  formatTimeTrackerDateRange,
+  getTimeTrackerPeriodBounds,
+} from '../time-tracker-period';
+
+describe('time-tracker-period', () => {
+  it('builds ISO week boundaries in UTC', () => {
+    const date = new Date('2024-02-07T10:30:00.000Z');
+    const { startOfPeriod, endOfPeriod } = getTimeTrackerPeriodBounds(
+      date,
+      'week',
+      'UTC'
+    );
+
+    expect(startOfPeriod.toISOString()).toBe('2024-02-05T00:00:00.000Z');
+    expect(endOfPeriod.toISOString()).toBe('2024-02-11T23:59:59.999Z');
+  });
+
+  it('formats a week range with a consistent locale', () => {
+    const start = new Date('2024-02-05T00:00:00.000Z');
+    const end = new Date('2024-02-11T23:59:59.999Z');
+    const expected = `${start.toLocaleDateString('en-US', {
+      month: 'short',
+      day: 'numeric',
+    })} - ${end.toLocaleDateString('en-US', {
+      month: 'short',
+      day: 'numeric',
+      year: 'numeric',
+    })}`;
+
+    expect(
+      formatTimeTrackerDateRange(start, end, 'week', {
+        locale: 'en-US',
+        referenceDate: new Date('2023-01-01T00:00:00.000Z'),
+      })
+    ).toBe(expected);
+  });
+
+  it('formats a day range without a year in the same year', () => {
+    const start = new Date('2024-03-12T09:00:00.000Z');
+    const expected = start.toLocaleDateString('en-US', {
+      weekday: 'long',
+      month: 'long',
+      day: 'numeric',
+    });
+
+    expect(
+      formatTimeTrackerDateRange(start, start, 'day', {
+        locale: 'en-US',
+        referenceDate: new Date('2024-01-01T00:00:00.000Z'),
+      })
+    ).toBe(expected);
+  });
+});

package/src/__tests__/timezone.test.ts

@@ -0,0 +1,117 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import {
+  AUTO_TIMEZONE,
+  getBrowserTimezone,
+  getTimezoneOffset,
+  isValidTimezone,
+  resolveAutoTimezone,
+} from '../timezone';
+
+describe('timezone utilities', () => {
+  describe('isValidTimezone', () => {
+    it('should return true for valid IANA timezone identifiers', () => {
+      // Test commonly supported timezones
+      expect(isValidTimezone('America/New_York')).toBe(true);
+      expect(isValidTimezone('Europe/London')).toBe(true);
+      expect(isValidTimezone('UTC')).toBe(true);
+      // Note: Some test environments may not support all IANA timezones
+      // through the Intl.DateTimeFormat fallback
+    });
+
+    it('should return false for invalid timezone strings', () => {
+      expect(isValidTimezone('Invalid/Timezone')).toBe(false);
+      expect(isValidTimezone('')).toBe(false);
+      expect(isValidTimezone('random-string')).toBe(false);
+      // Note: PST/EST may be accepted by some Node.js versions as legacy abbreviations
+      // but they're not proper IANA identifiers - behavior may vary by environment
+    });
+
+    it('should return false for null, undefined, or non-string values', () => {
+      expect(isValidTimezone(null as unknown as string)).toBe(false);
+      expect(isValidTimezone(undefined as unknown as string)).toBe(false);
+      expect(isValidTimezone(123 as unknown as string)).toBe(false);
+    });
+  });
+
+  describe('getBrowserTimezone', () => {
+    it('should return a valid timezone string', () => {
+      const tz = getBrowserTimezone();
+      expect(typeof tz).toBe('string');
+      expect(tz.length).toBeGreaterThan(0);
+      // Should be a valid timezone
+      expect(isValidTimezone(tz)).toBe(true);
+    });
+
+    it('should fallback to UTC when Intl is unavailable', () => {
+      const originalIntl = globalThis.Intl;
+      // @ts-expect-error - Intentionally removing Intl for testing
+      globalThis.Intl = undefined;
+
+      const tz = getBrowserTimezone();
+      expect(tz).toBe('UTC');
+
+      globalThis.Intl = originalIntl;
+    });
+  });
+
+  describe('resolveAutoTimezone', () => {
+    let mockBrowserTimezone: string;
+
+    beforeEach(() => {
+      // Store the actual browser timezone
+      mockBrowserTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    });
+
+    it('should resolve "auto" to browser timezone', () => {
+      const result = resolveAutoTimezone('auto');
+      expect(result).toBe(mockBrowserTimezone);
+    });
+
+    it('should resolve AUTO_TIMEZONE constant to browser timezone', () => {
+      const result = resolveAutoTimezone(AUTO_TIMEZONE);
+      expect(result).toBe(mockBrowserTimezone);
+    });
+
+    it('should return valid timezone as-is', () => {
+      expect(resolveAutoTimezone('America/New_York')).toBe('America/New_York');
+      expect(resolveAutoTimezone('UTC')).toBe('UTC');
+      expect(resolveAutoTimezone('Europe/London')).toBe('Europe/London');
+    });
+
+    it('should fallback to UTC for invalid timezone', () => {
+      expect(resolveAutoTimezone('Invalid/Timezone')).toBe('UTC');
+      expect(resolveAutoTimezone('random-string')).toBe('UTC');
+    });
+
+    it('should fallback to UTC for null or undefined', () => {
+      expect(resolveAutoTimezone(null)).toBe('UTC');
+      expect(resolveAutoTimezone(undefined)).toBe('UTC');
+    });
+  });
+
+  describe('getTimezoneOffset', () => {
+    it('should return correct offset for known timezones', () => {
+      // Note: These tests may fail during DST transitions
+      // We test format rather than exact values since offsets change with DST
+      const utcOffset = getTimezoneOffset('UTC');
+      expect(utcOffset).toBe('+00:00');
+
+      const hoChiMinhOffset = getTimezoneOffset('Asia/Ho_Chi_Minh');
+      expect(hoChiMinhOffset).toBe('+07:00');
+
+      const tokyoOffset = getTimezoneOffset('Asia/Tokyo');
+      expect(tokyoOffset).toBe('+09:00');
+    });
+
+    it('should return offset in correct format', () => {
+      const offset = getTimezoneOffset('America/New_York');
+      // Should match format +HH:MM or -HH:MM
+      expect(offset).toMatch(/^[+-]\d{2}:\d{2}$/);
+    });
+
+    it('should fallback to +00:00 for invalid timezone', () => {
+      const offset = getTimezoneOffset('Invalid/Timezone');
+      expect(offset).toBe('+00:00');
+    });
+  });
+});

package/src/__tests__/upstash-rest.test.ts

@@ -0,0 +1,77 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+  fromEnv: vi.fn(),
+}));
+
+vi.mock('@upstash/redis', () => ({
+  Redis: {
+    fromEnv: mocks.fromEnv,
+  },
+}));
+
+describe('upstash-rest', () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    mocks.fromEnv.mockReset();
+  });
+
+  it('returns null when Upstash REST env vars are missing', async () => {
+    const { getUpstashRestRedisClient, hasUpstashRestEnv } = await import(
+      '../upstash-rest.js'
+    );
+
+    expect(hasUpstashRestEnv()).toBe(false);
+    await expect(getUpstashRestRedisClient()).resolves.toBeNull();
+    expect(mocks.fromEnv).not.toHaveBeenCalled();
+  });
+
+  it('builds the Redis client from Upstash REST env vars', async () => {
+    vi.stubEnv('UPSTASH_REDIS_REST_URL', 'https://redis.test');
+    vi.stubEnv('UPSTASH_REDIS_REST_TOKEN', 'token');
+    const client = {
+      del: vi.fn(),
+      eval: vi.fn(),
+      evalsha: vi.fn(),
+      expire: vi.fn(),
+      get: vi.fn(),
+      incr: vi.fn(),
+      set: vi.fn(),
+      ttl: vi.fn(),
+    };
+    mocks.fromEnv.mockReturnValue(client);
+
+    const {
+      getUpstashRatelimitRedisClient,
+      getUpstashRestRedisClient,
+      hasUpstashRestEnv,
+    } = await import('../upstash-rest.js');
+
+    expect(hasUpstashRestEnv()).toBe(true);
+
+    const restClient = await getUpstashRestRedisClient();
+    const ratelimitClient = await getUpstashRatelimitRedisClient();
+
+    expect(restClient).not.toBeNull();
+    expect(ratelimitClient).not.toBeNull();
+
+    await restClient?.get('rest-key');
+    await restClient?.set('rest-key', 'value', { ex: 60 });
+    await ratelimitClient?.get('ratelimit-key');
+    await ratelimitClient?.set('ratelimit-key', 'value');
+    await ratelimitClient?.eval('return 1', ['k'], ['v']);
+    await ratelimitClient?.evalsha('sha', ['k'], ['v']);
+
+    expect(client.get).toHaveBeenCalledWith('rest-key');
+    expect(client.set).toHaveBeenCalledWith('rest-key', 'value', { ex: 60 });
+    expect(client.get).toHaveBeenCalledWith('ratelimit-key');
+    expect(client.set).toHaveBeenCalledWith(
+      'ratelimit-key',
+      'value',
+      undefined
+    );
+    expect(client.eval).toHaveBeenCalledWith('return 1', ['k'], ['v']);
+    expect(client.evalsha).toHaveBeenCalledWith('sha', ['k'], ['v']);
+    expect(mocks.fromEnv).toHaveBeenCalledTimes(2);
+  });
+});

package/src/__tests__/uuid-helper.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import { generateRandomUUID, generateUUID } from '../uuid-helper';
+
+describe('UUID Helper', () => {
+  describe('generateUUID', () => {
+    it('generates consistent UUID for same inputs', () => {
+      const uuid1 = generateUUID('test-id-1');
+      const uuid2 = generateUUID('test-id-1');
+      expect(uuid1).toBe(uuid2);
+    });
+
+    it('generates different UUIDs for different inputs', () => {
+      const uuid1 = generateUUID('test-id-1');
+      const uuid2 = generateUUID('test-id-2');
+      expect(uuid1).not.toBe(uuid2);
+    });
+
+    it('generates valid UUID format', () => {
+      const uuid = generateUUID('test-id');
+      const uuidRegex =
+        /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+      expect(uuid).toMatch(uuidRegex);
+    });
+
+    it('handles multiple UUIDs concatenated', () => {
+      const uuid1 = generateUUID('id1', 'id2');
+      const uuid2 = generateUUID('id1', 'id2');
+      expect(uuid1).toBe(uuid2);
+    });
+
+    it('generates different UUID when order changes', () => {
+      const uuid1 = generateUUID('id1', 'id2');
+      const uuid2 = generateUUID('id2', 'id1');
+      expect(uuid1).not.toBe(uuid2);
+    });
+
+    it('handles empty string input', () => {
+      const uuid = generateUUID('');
+      expect(uuid).toBeDefined();
+      expect(typeof uuid).toBe('string');
+    });
+
+    it('handles single UUID input', () => {
+      const uuid = generateUUID('single-id');
+      const uuidRegex =
+        /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+      expect(uuid).toMatch(uuidRegex);
+    });
+
+    it('handles multiple inputs', () => {
+      const uuid = generateUUID('a', 'b', 'c', 'd');
+      expect(uuid).toBeDefined();
+    });
+  });
+
+  describe('generateRandomUUID', () => {
+    it('generates valid UUIDv4 format', () => {
+      const uuid = generateRandomUUID();
+      const uuidRegex =
+        /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+      expect(uuid).toMatch(uuidRegex);
+    });
+
+    it('generates different UUIDs on each call', () => {
+      const uuid1 = generateRandomUUID();
+      const uuid2 = generateRandomUUID();
+      expect(uuid1).not.toBe(uuid2);
+    });
+
+    it('generates unique UUIDs across multiple calls', () => {
+      const uuids = new Set<string>();
+      for (let i = 0; i < 100; i++) {
+        uuids.add(generateRandomUUID());
+      }
+      expect(uuids.size).toBe(100);
+    });
+  });
+
+  describe('Zod uuid parsing', () => {
+    it('accept full 0s', () => {
+      const result = z.uuid().safeParse('00000000-0000-0000-0000-000000000000');
+      expect(result.success).toBe(true);
+    });
+
+    it('accept full Fs', () => {
+      const result = z.uuid().safeParse('ffffffff-ffff-ffff-ffff-ffffffffffff');
+      expect(result.success).toBe(true);
+    });
+
+    it('reject full 0s with ending 1', () => {
+      const result = z.uuid().safeParse('00000000-0000-0000-0000-000000000001');
+      expect(result.success).toBe(false);
+    });
+
+    it('accept version 4 UUID', () => {
+      const result = z.uuid().safeParse('01234567-89ab-4cde-8f01-234567890abc');
+      expect(result.success).toBe(true);
+    });
+
+    it('reject invalid UUID format', () => {
+      const result = z.uuid().safeParse('invalid-uuid-format');
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('Zod guid parsing', () => {
+    it('accept full 0s', () => {
+      const result = z.guid().safeParse('00000000-0000-0000-0000-000000000000');
+      expect(result.success).toBe(true);
+    });
+
+    it('accept full Fs', () => {
+      const result = z.guid().safeParse('ffffffff-ffff-ffff-ffff-ffffffffffff');
+      expect(result.success).toBe(true);
+    });
+
+    it('accept full 0s with ending 1', () => {
+      const result = z.guid().safeParse('00000000-0000-0000-0000-000000000001');
+      expect(result.success).toBe(true);
+    });
+
+    it('accept version 4 GUID', () => {
+      const result = z.guid().safeParse('01234567-89ab-4cde-8f01-234567890abc');
+      expect(result.success).toBe(true);
+    });
+
+    it('reject invalid GUID format', () => {
+      const result = z.guid().safeParse('invalid-guid-format');
+      expect(result.success).toBe(false);
+    });
+  });
+});