@tuturuuu/utils 0.7.0 → 0.8.0

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.12.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.12.0'; // x-release-please-version
 
 export type PlatformBuildMetadataInput = {
   builtAt?: string | null;

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,