@tuturuuu/utils 0.7.0 → 0.9.0

package/src/money.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest';
+import {
+  formatMoneyFromMinor,
+  getAmountStep,
+  getCurrencyFractionDigits,
+  getMinorUnitFactor,
+  majorToMinor,
+  minorToMajor,
+  normalizeAmount,
+} from './money';
+
+describe('currency precision', () => {
+  it('knows fraction digits per currency', () => {
+    expect(getCurrencyFractionDigits('USD')).toBe(2);
+    expect(getCurrencyFractionDigits('EUR')).toBe(2);
+    expect(getCurrencyFractionDigits('JPY')).toBe(0);
+    expect(getCurrencyFractionDigits('VND')).toBe(0);
+  });
+
+  it('falls back to 2 digits for unknown currencies', () => {
+    expect(getCurrencyFractionDigits('XYZ')).toBe(2);
+  });
+
+  it('derives the minor-unit factor', () => {
+    expect(getMinorUnitFactor('USD')).toBe(100);
+    expect(getMinorUnitFactor('JPY')).toBe(1);
+    expect(getMinorUnitFactor('VND')).toBe(1);
+  });
+});
+
+describe('major <-> minor conversion', () => {
+  it('converts dollars to cents', () => {
+    expect(majorToMinor(100, 'USD')).toBe(10000);
+    expect(majorToMinor(9.99, 'USD')).toBe(999);
+  });
+
+  it('treats zero-decimal currencies 1:1', () => {
+    expect(majorToMinor(500, 'JPY')).toBe(500);
+    expect(majorToMinor(25000, 'VND')).toBe(25000);
+  });
+
+  it('round-trips cleanly', () => {
+    expect(minorToMajor(10000, 'USD')).toBe(100);
+    expect(minorToMajor(999, 'USD')).toBe(9.99);
+    expect(minorToMajor(500, 'JPY')).toBe(500);
+  });
+
+  it('rounds rather than truncating fractional minor units', () => {
+    expect(majorToMinor(1.005, 'USD')).toBe(101);
+  });
+
+  it('handles non-finite input defensively', () => {
+    expect(majorToMinor(Number.NaN, 'USD')).toBe(0);
+    expect(minorToMajor(Number.POSITIVE_INFINITY, 'USD')).toBe(0);
+  });
+});
+
+describe('normalizeAmount & getAmountStep', () => {
+  it('normalizes to currency precision', () => {
+    expect(normalizeAmount(9.999, 'USD')).toBe(10);
+    expect(normalizeAmount(9.994, 'USD')).toBe(9.99);
+    expect(normalizeAmount(500.7, 'JPY')).toBe(501);
+  });
+
+  it('returns the right input step', () => {
+    expect(getAmountStep('USD')).toBe('0.01');
+    expect(getAmountStep('JPY')).toBe('1');
+    expect(getAmountStep('VND')).toBe('1');
+  });
+});
+
+describe('formatMoneyFromMinor', () => {
+  it('formats USD cents as dollars', () => {
+    // Non-breaking space / symbol placement varies by ICU; assert the digits.
+    expect(formatMoneyFromMinor(10000, 'USD', 'en-US')).toContain('100.00');
+    expect(formatMoneyFromMinor(999, 'USD', 'en-US')).toContain('9.99');
+  });
+
+  it('formats zero-decimal currencies without scaling', () => {
+    expect(formatMoneyFromMinor(500, 'JPY', 'ja-JP')).toContain('500');
+  });
+});

package/src/money.ts

@@ -0,0 +1,120 @@
+/**
+ * Centralized money/minor-unit helpers.
+ *
+ * Money is modeled as integer **minor units** (the currency's smallest unit:
+ * cents for USD/EUR, but whole units for zero-decimal currencies like JPY/VND,
+ * and thousandths for three-decimal currencies like BHD). This matches how
+ * payment processors (e.g. Polar/Stripe) represent amounts and avoids floating
+ * point drift on money.
+ *
+ * Use {@link majorToMinor} when persisting a user-entered amount, and
+ * {@link minorToMajor} / {@link formatMoneyFromMinor} when reading a stored
+ * amount back for display. The conversion factor is currency-aware, so never
+ * hard-code `* 100` / `/ 100`.
+ */
+
+import { getCurrencyLocale } from './currencies';
+import { formatCurrency } from './format';
+
+const DEFAULT_FRACTION_DIGITS = 2;
+
+// Intl construction is comparatively expensive; cache per currency code.
+const fractionDigitsCache = new Map<string, number>();
+
+/**
+ * Round a scaled value to the nearest integer while neutralizing binary
+ * floating-point error (e.g. `1.005 * 100` is `100.4999…`, which must round to
+ * `101`, not `100`). Trimming to 4 extra decimals before rounding removes the
+ * noise without affecting legitimate values.
+ */
+function roundScaled(value: number): number {
+  return Math.round(Number(value.toFixed(4)));
+}
+
+/**
+ * Number of decimal places a currency uses (USD → 2, JPY/VND → 0, BHD → 3).
+ * Falls back to 2 for unknown/invalid currency codes.
+ */
+export function getCurrencyFractionDigits(currency = 'USD'): number {
+  const code = currency.toUpperCase();
+  const cached = fractionDigitsCache.get(code);
+  if (cached !== undefined) return cached;
+
+  let digits = DEFAULT_FRACTION_DIGITS;
+  try {
+    digits =
+      new Intl.NumberFormat(getCurrencyLocale(code), {
+        style: 'currency',
+        currency: code,
+      }).resolvedOptions().maximumFractionDigits ?? DEFAULT_FRACTION_DIGITS;
+  } catch {
+    digits = DEFAULT_FRACTION_DIGITS;
+  }
+
+  fractionDigitsCache.set(code, digits);
+  return digits;
+}
+
+/**
+ * Multiplier between a currency's major and minor units
+ * (USD → 100, JPY/VND → 1, BHD → 1000).
+ */
+export function getMinorUnitFactor(currency = 'USD'): number {
+  return 10 ** getCurrencyFractionDigits(currency);
+}
+
+/**
+ * Convert a major-unit amount (e.g. dollars `100`, or `9.99`) into integer
+ * minor units (e.g. `10000`, `999`) for storage / sending to a payment API.
+ */
+export function majorToMinor(major: number, currency = 'USD'): number {
+  if (!Number.isFinite(major)) return 0;
+  return roundScaled(major * getMinorUnitFactor(currency));
+}
+
+/**
+ * Convert integer minor units (e.g. `10000`) back into a major-unit amount
+ * (e.g. `100`) for display or for ledgers that store major units.
+ */
+export function minorToMajor(minor: number, currency = 'USD'): number {
+  if (!Number.isFinite(minor)) return 0;
+  return minor / getMinorUnitFactor(currency);
+}
+
+/**
+ * Round a major-unit amount to the currency's precision (drops sub-minor-unit
+ * noise from user input before it is converted/stored).
+ */
+export function normalizeAmount(major: number, currency = 'USD'): number {
+  if (!Number.isFinite(major)) return 0;
+  const factor = getMinorUnitFactor(currency);
+  return roundScaled(major * factor) / factor;
+}
+
+/**
+ * The numeric step a major-unit price input should use for the currency
+ * ('1' for zero-decimal currencies, '0.01' for two-decimal, etc.).
+ */
+export function getAmountStep(currency = 'USD'): string {
+  const fractionDigits = getCurrencyFractionDigits(currency);
+  if (fractionDigits <= 0) return '1';
+  return (1 / 10 ** fractionDigits).toFixed(fractionDigits);
+}
+
+/**
+ * Format an amount stored in minor units as a localized currency string.
+ * This is the canonical display path for minor-unit-stored money.
+ */
+export function formatMoneyFromMinor(
+  minorAmount: number,
+  currency = 'USD',
+  locale?: string,
+  options?: Partial<Intl.NumberFormatOptions>
+): string {
+  return formatCurrency(
+    minorToMajor(minorAmount, currency),
+    currency,
+    locale,
+    options
+  );
+}

package/src/next-config.test.ts

@@ -23,6 +23,19 @@ describe('createTuturuuuNextConfig', () => {
     expect(config.typescript?.ignoreBuildErrors).toBe(true);
   });
 
+  it('does not expose loopback hosts to the shared image optimizer allowlist', () => {
+    const config = createTuturuuuNextConfig();
+
+    expect(config.images?.remotePatterns).not.toContainEqual({
+      protocol: 'http',
+      hostname: 'localhost',
+    });
+    expect(config.images?.remotePatterns).not.toContainEqual({
+      protocol: 'http',
+      hostname: '127.0.0.1',
+    });
+  });
+
   it('allows the exact worktree-prefixed Portless host for Next dev assets', () => {
     const originalPortlessUrl = process.env.PORTLESS_URL;
 

package/src/next-config.ts

@@ -19,14 +19,6 @@ type NextImageRemotePattern = NonNullable<
 >[number];
 
 export const TUTURUUU_NEXT_IMAGE_REMOTE_PATTERNS = [
-  {
-    protocol: 'http',
-    hostname: 'localhost',
-  },
-  {
-    protocol: 'http',
-    hostname: '127.0.0.1',
-  },
   {
     protocol: 'https',
     hostname: '**.supabase.co',

package/src/platform-release.test.ts

@@ -7,7 +7,7 @@ import {
 
 describe('platform release metadata', () => {
   it('uses the centralized shared browser app version', () => {
-    expect(TUTURUUU_PLATFORM_VERSION).toBe('0.11.0'); // x-release-please-version
+    expect(TUTURUUU_PLATFORM_VERSION).toBe('0.13.0'); // x-release-please-version
   });
 
   it('normalizes generated metadata and derives a short hash', () => {

package/src/platform-release.ts

@@ -1,6 +1,6 @@
 import { PLATFORM_BUILD_METADATA } from './generated/platform-build-metadata';
 
-export const TUTURUUU_PLATFORM_VERSION = '0.11.0'; // x-release-please-version
+export const TUTURUUU_PLATFORM_VERSION = '0.13.0'; // x-release-please-version
 
 export type PlatformBuildMetadataInput = {
   builtAt?: string | null;

package/src/portless.ts

@@ -15,6 +15,7 @@ export const TUTURUUU_PORTLESS_APP_ORIGINS = {
   finance: `https://finance.${TUTURUUU_PORTLESS_ROOT_HOST}`,
   hive: `https://hive.${TUTURUUU_PORTLESS_ROOT_HOST}`,
   'hive-realtime': `https://realtime.hive.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  infra: `https://infra.${TUTURUUU_PORTLESS_ROOT_HOST}`,
   inventory: `https://inventory.${TUTURUUU_PORTLESS_ROOT_HOST}`,
   learn: `https://learn.${TUTURUUU_PORTLESS_ROOT_HOST}`,
   mail: `https://mail.${TUTURUUU_PORTLESS_ROOT_HOST}`,
@@ -27,6 +28,7 @@ export const TUTURUUU_PORTLESS_APP_ORIGINS = {
   rewise: `https://rewise.${TUTURUUU_PORTLESS_ROOT_HOST}`,
   shortener: `https://shortener.${TUTURUUU_PORTLESS_ROOT_HOST}`,
   storefront: `https://storefront.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  'tanstack-web': `https://tanstack.${TUTURUUU_PORTLESS_ROOT_HOST}`,
   tasks: `https://tasks.${TUTURUUU_PORTLESS_ROOT_HOST}`,
   teach: `https://teach.${TUTURUUU_PORTLESS_ROOT_HOST}`,
   track: `https://track.${TUTURUUU_PORTLESS_ROOT_HOST}`,

package/src/task-helper/task-operations.ts

@@ -165,6 +165,9 @@ export async function invalidateTaskCaches(
     promises.push(
       queryClient.invalidateQueries({ queryKey: ['task_lists', boardId] })
     );
+    promises.push(
+      queryClient.invalidateQueries({ queryKey: ['kanban-deadline-tasks'] })
+    );
   }
 
   promises.push(

package/src/upstash-rest.ts

@@ -2,7 +2,7 @@ import type { Redis } from '@upstash/redis';
 
 export type UpstashRestRedisClient = Pick<
   Redis,
-  'decr' | 'del' | 'expire' | 'get' | 'incr' | 'set' | 'ttl'
+  'decr' | 'del' | 'expire' | 'get' | 'incr' | 'mget' | 'scan' | 'set' | 'ttl'
 >;
 export type UpstashRatelimitRedisClient = Pick<
   Redis,
@@ -30,6 +30,8 @@ export async function getUpstashRestRedisClient(): Promise<UpstashRestRedisClien
     expire: (key, seconds) => client.expire(key, seconds),
     get: <T = unknown>(key: string) => client.get<T>(key),
     incr: (key) => client.incr(key),
+    mget: (...args) => client.mget(...args),
+    scan: client.scan.bind(client),
     set: (key, value, options) => client.set(key, value, options),
     ttl: (key) => client.ttl(key),
   };

package/src/workspace-helper.ts

@@ -12,6 +12,7 @@ import type {
 } from '@tuturuuu/types';
 import type { WorkspaceSecret } from '@tuturuuu/types/primitives/WorkspaceSecret';
 import type { NextRequest } from 'next/server';
+import { cache } from 'react';
 import {
   PERSONAL_WORKSPACE_SLUG,
   ROOT_WORKSPACE_ID,
@@ -703,7 +704,33 @@ async function resolveWorkspaceIdForPermissions({
   return workspace.id;
 }
 
-export async function getPermissions({
+/**
+ * Resolve the caller's workspace permissions.
+ *
+ * The common Server Component flow (`getPermissions({ wsId })`, no explicit
+ * `user`/`request`) is memoized per request via React `cache()` keyed on the
+ * primitive `wsId`, so multiple callers in the same render tree (e.g. a layout
+ * and its page) share a single permission lookup instead of each running ~3
+ * queries. Flows that pass an explicit `user` or `request` bypass the cache to
+ * avoid any cross-request contamination.
+ */
+export async function getPermissions(args: {
+  user?: AuthenticatedWorkspacePrincipal | null;
+  wsId: string;
+  request?: Request;
+}): Promise<PermissionsResult | null> {
+  if (!args.user && !args.request) {
+    return getPermissionsByWsId(args.wsId);
+  }
+  return getPermissionsImpl(args);
+}
+
+const getPermissionsByWsId = cache(
+  async (wsId: string): Promise<PermissionsResult | null> =>
+    getPermissionsImpl({ wsId })
+);
+
+async function getPermissionsImpl({
   user,
   wsId,
   request,