typescript

export async function retry<T>(fn: () => Promise<T>, opts: { attempts: number; baseMs: number; maxMs: number }) {
  let lastError: unknown;
  for (let i = 0; i < opts.attempts; i++) {
    try {
      return await fn();
    } catch (e) {

export function limit(concurrency: number) {
  let active = 0;
  const queue: Array<() => void> = [];

  const next = () => {
    active -= 1;

import axios, { AxiosError } from 'axios'
import { v4 as uuidv4 } from 'uuid'

const api = axios.create({
  baseURL: import.meta.env.VITE_API_URL || 'http://localhost:3000/api/v1',
  timeout: 15000,

import { create } from 'zustand'
import { persist } from 'zustand/middleware'

interface FilterState {
  search: string
  category: string | null

import crypto from 'node:crypto';
import jwt from 'jsonwebtoken';

export function signAccessToken(payload: object) {
  return jwt.sign(payload, process.env.JWT_SECRET!, { expiresIn: '15m' });
}

import React from 'react';

type Props = { children: React.ReactNode; fallback?: React.ReactNode };

export class ErrorBoundary extends React.Component<Props, { hasError: boolean }> {
  state = { hasError: false };

import compression from 'compression';
import type { Express } from 'express';

export function applyCompression(app: Express) {
  app.use(
    compression({

import { Navigate, useLocation } from 'react-router-dom'
import { useAuth } from '@/contexts/AuthContext'

interface ProtectedRouteProps {
  children: React.ReactNode
}

import type { NextFunction, Request, Response } from 'express';
import crypto from 'node:crypto';
import pino from 'pino';

const baseLogger = pino({
  level: process.env.LOG_LEVEL ?? 'info',

export function toFieldErrors(err: any): Record<string, string> {
  if (err?.error !== 'VALIDATION_ERROR' || !Array.isArray(err.issues)) return {};
  return Object.fromEntries(err.issues.map((i: any) => [String(i.path ?? 'unknown'), String(i.message ?? 'Invalid')])) as Record<
    string,
    string
  >;

import cron from 'node-cron';
import { withAdvisoryLock } from '../db/advisory-lock';

export function startCron() {
  cron.schedule('0 * * * *', async () => {
    await withAdvisoryLock('cron:hourly-rollup', async () => {

CREATE TABLE IF NOT EXISTS outbox_events (
  id BIGSERIAL PRIMARY KEY,
  event_name TEXT NOT NULL,
  dedupe_key TEXT NOT NULL UNIQUE,
  payload JSONB NOT NULL,
  status TEXT NOT NULL DEFAULT 'pending',