@geenius/tools 0.1.0 → 0.3.0

package/packages/errors/react/src/types.ts

@@ -1,102 +0,0 @@
-// @geenius-tools/errors-react — src/types.ts
-// Self-contained error types (no Convex path imports)
-
-/**
- * Application error codes
- */
-export type AppErrorCode =
-    | 'UNAUTHENTICATED'
-    | 'FORBIDDEN'
-    | 'NOT_FOUND'
-    | 'BAD_REQUEST'
-    | 'CONFLICT'
-    | 'INTERNAL'
-    | 'VALIDATION_ERROR'
-    | 'RATE_LIMITED'
-    | 'FEATURE_DISABLED'
-
-/**
- * Validation error for a single field
- */
-export interface ValidationError {
-    field: string
-    message: string
-}
-
-/**
- * Full error payload structure (matches ConvexError.data shape)
- */
-export interface AppErrorPayload {
-    code: AppErrorCode
-    message: string
-    details?: Record<string, unknown>
-    validationErrors?: ValidationError[]
-    _metadata?: {
-        requestId?: string
-        functionName?: string
-        timestamp?: string
-        userId?: string
-        [key: string]: unknown
-    }
-}
-
-/**
- * Display variants for error components
- */
-export type ErrorDisplayVariant = 'page' | 'card' | 'inline' | 'toast'
-
-/**
- * Error analytics filter options
- */
-export type ErrorAnalyticsFilters = {
-    errorCode?: string
-    functionName?: string
-    timeRange?: { start: Date; end: Date }
-    bucketType?: 'hourly' | 'daily'
-    showMuted?: boolean
-}
-
-/**
- * Error trend data point
- */
-export type ErrorTrend = {
-    timeBucket: string
-    errorCode: string
-    functionName: string
-    count: number
-    uniqueUsers: number
-    firstOccurrence: string
-    lastOccurrence: string
-}
-
-/**
- * Error analytics entry (from Convex)
- */
-export type ErrorAnalyticsEntry = {
-    _id: string
-    _creationTime: number
-    timeBucket: string
-    bucketType: 'hourly' | 'daily'
-    errorCode: AppErrorCode
-    functionName: string
-    count: number
-    uniqueUsers: string[]
-    firstOccurrence: string
-    lastOccurrence: string
-    muted?: boolean
-}
-
-/**
- * Muted error entry
- */
-export type ErrorMute = {
-    _id: string
-    _creationTime: number
-    errorCode: string
-    functionName: string // "*" = all functions
-    muted: boolean
-    mutedAt?: string
-    mutedBy?: string
-    muteReason?: string
-    createdAt: string
-}

package/packages/errors/react/src/utils/errorMessages.ts

@@ -1,35 +0,0 @@
-// @geenius-tools/errors-react — src/utils/errorMessages.ts
-
-import type { AppErrorCode } from '../types'
-import { getErrorMessages } from '../config'
-
-/**
- * Get localized error title by error code
- *
- * @example
- * const title = getErrorTitle('FORBIDDEN') // "Access Denied"
- */
-export function getErrorTitle(code: AppErrorCode): string {
-    return getErrorMessages().titles[code] || 'Error'
-}
-
-/**
- * Get fallback error message by error code
- */
-export function getFallbackMessage(code: AppErrorCode): string {
-    return getErrorMessages().messages[code]
-}
-
-/**
- * Get detailed user-friendly error description
- */
-export function getErrorDescription(code: AppErrorCode): string {
-    return getErrorMessages().descriptions[code] || 'An unexpected error occurred.'
-}
-
-/**
- * Get suggested action for error code
- */
-export function getErrorAction(code: AppErrorCode): string {
-    return getErrorMessages().actions[code] || 'Try again or contact support.'
-}

package/packages/errors/react/src/utils/errorPolicy.ts

@@ -1,139 +0,0 @@
-// @geenius-tools/errors-react — src/utils/errorPolicy.ts
-
-import { extractAppError, extractRequestId } from './extractAppError'
-import { getErrorHandlerConfig } from '../config'
-import { getErrorMessages } from '../config'
-
-/**
- * Global error handling policy
- *
- * Uses the configured toast function (set via configureErrorHandler).
- * If no toast is configured, errors are logged to console.
- *
- * @example
- * // In your app setup:
- * import toast from 'react-hot-toast'
- * configureErrorHandler({ toast })
- *
- * // Then in router/query client:
- * queryClient: new QueryClient({
- *   defaultOptions: { mutations: { onError: handleAppError } },
- * })
- */
-export function handleAppError(error: unknown): void {
-    const appError = extractAppError(error)
-    const requestId = extractRequestId(error)
-    const config = getErrorHandlerConfig()
-    const messages = getErrorMessages().messages
-
-    const showError = (msg: string) => {
-        if (config.toast) {
-            config.toast.error(msg)
-        } else {
-            console.error('[errors-react]', msg)
-        }
-    }
-
-    // If not an app error, show generic error
-    if (!appError) {
-        const msg = requestId
-            ? `An unexpected error occurred. Request ID: ${requestId}`
-            : 'An unexpected error occurred.'
-        showError(msg)
-        return
-    }
-
-    const message = appError.message ?? messages[appError.code]
-
-    switch (appError.code) {
-        case 'UNAUTHENTICATED':
-            // Don't show toast — auth provider handles redirect
-            break
-
-        case 'FORBIDDEN':
-        case 'NOT_FOUND':
-        case 'BAD_REQUEST':
-        case 'CONFLICT':
-            showError(message)
-            break
-
-        case 'INTERNAL': {
-            const internalMsg = requestId
-                ? `${message} Request ID: ${requestId}`
-                : message
-            showError(internalMsg)
-            break
-        }
-
-        case 'VALIDATION_ERROR':
-            // Don't show toast — handled by ValidationErrors component
-            break
-
-        case 'RATE_LIMITED':
-        case 'FEATURE_DISABLED':
-            showError(message)
-            break
-
-        default: {
-            const defaultMsg = requestId
-                ? `${message} Request ID: ${requestId}`
-                : message
-            showError(defaultMsg)
-        }
-    }
-}
-
-/**
- * Silent error handler (no toast)
- */
-export function handleAppErrorSilent(error: unknown) {
-    return extractAppError(error)
-}
-
-/**
- * Check if error should be retried
- */
-export function shouldRetryError(error: unknown): boolean {
-    const appError = extractAppError(error)
-
-    if (!appError) {
-        // Unknown errors can be retried (might be network)
-        return true
-    }
-
-    switch (appError.code) {
-        case 'RATE_LIMITED':
-        case 'INTERNAL':
-            return true
-        case 'UNAUTHENTICATED':
-        case 'FORBIDDEN':
-        case 'NOT_FOUND':
-        case 'BAD_REQUEST':
-        case 'VALIDATION_ERROR':
-        case 'CONFLICT':
-        case 'FEATURE_DISABLED':
-            return false
-        default:
-            return false
-    }
-}
-
-/**
- * Get retry delay for error (in milliseconds)
- */
-export function getRetryDelay(error: unknown, attemptNumber: number): number {
-    const appError = extractAppError(error)
-
-    if (!appError) {
-        return Math.min(1000 * Math.pow(2, attemptNumber - 1), 30000)
-    }
-
-    switch (appError.code) {
-        case 'RATE_LIMITED':
-            return Math.min(1000 * Math.pow(2, attemptNumber - 1), 60000)
-        case 'INTERNAL':
-            return 2000
-        default:
-            return 0
-    }
-}

package/packages/errors/react/src/utils/extractAppError.ts

@@ -1,174 +0,0 @@
-// @geenius-tools/errors-react — src/utils/extractAppError.ts
-
-import type { AppErrorPayload, AppErrorCode } from '../types'
-
-const VALID_CODES: AppErrorCode[] = [
-    'UNAUTHENTICATED',
-    'FORBIDDEN',
-    'NOT_FOUND',
-    'BAD_REQUEST',
-    'CONFLICT',
-    'INTERNAL',
-    'VALIDATION_ERROR',
-    'RATE_LIMITED',
-    'FEATURE_DISABLED',
-]
-
-/**
- * Type guard to check if an object is an AppErrorPayload
- */
-function isAppErrorPayload(x: unknown): x is AppErrorPayload {
-    if (!x || typeof x !== 'object') return false
-    const obj = x as Record<string, unknown>
-    if (typeof obj.code !== 'string') return false
-    return VALID_CODES.includes(obj.code as AppErrorCode)
-}
-
-/**
- * Normalize error message from various error formats
- */
-export function normalizeErrorMessage(error: unknown): string {
-    if (typeof error === 'string') return error
-    if (error instanceof Error) return error.message || error.toString()
-    if (error && typeof error === 'object' && 'message' in error) {
-        const msg = (error as { message?: unknown }).message
-        if (typeof msg === 'string') return msg
-    }
-    return String(error)
-}
-
-/**
- * Extract AppErrorPayload from ConvexError or other error types
- *
- * @param error - The error to extract from (ConvexError, Error, or unknown)
- * @returns AppErrorPayload if found, null otherwise
- *
- * @example
- * try {
- *   await mutation(...)
- * } catch (error) {
- *   const appError = extractAppError(error)
- *   if (appError) {
- *     console.log(appError.code, appError.message)
- *   }
- * }
- */
-export function extractAppError(error: unknown): AppErrorPayload | null {
-    // Strategy 1: Check ConvexError.data (new backend format)
-    if (error && typeof error === 'object' && 'data' in error) {
-        const data = (error as { data: unknown }).data
-        if (isAppErrorPayload(data)) {
-            return data as AppErrorPayload
-        }
-    }
-
-    // Strategy 2: Check if error itself is AppErrorPayload
-    if (isAppErrorPayload(error)) {
-        return error as AppErrorPayload
-    }
-
-    // Strategy 3: Check error._metadata for backend format
-    if (error && typeof error === 'object' && '_metadata' in error) {
-        const meta = (error as { _metadata: unknown })._metadata
-        if (meta && typeof meta === 'object' && 'code' in meta) {
-            const code = (meta as { code: unknown }).code
-            if (typeof code === 'string' && isAppErrorPayload({ code })) {
-                return error as AppErrorPayload
-            }
-        }
-    }
-
-    return null
-}
-
-/**
- * Extract request ID from error (from metadata or Convex debug message)
- */
-export function extractRequestId(error: unknown): string | undefined {
-    if (error && typeof error === 'object') {
-        const err = error as Record<string, unknown>
-
-        // ConvexError.data._metadata.requestId
-        if (err.data && typeof err.data === 'object') {
-            const data = err.data as Record<string, unknown>
-            if (data._metadata && typeof data._metadata === 'object') {
-                const meta = data._metadata as Record<string, unknown>
-                if (typeof meta.requestId === 'string') {
-                    return meta.requestId
-                }
-            }
-        }
-
-        // Direct _metadata.requestId
-        if (err._metadata && typeof err._metadata === 'object') {
-            const meta = err._metadata as Record<string, unknown>
-            if (typeof meta.requestId === 'string') {
-                return meta.requestId
-            }
-        }
-    }
-
-    // Parse from Convex debug message format
-    const message = normalizeErrorMessage(error)
-    const requestIdMatch = message.match(/Request ID:\s*([^\]\s]+)/i)
-    if (requestIdMatch?.[1]) {
-        return requestIdMatch[1]
-    }
-
-    return undefined
-}
-
-/**
- * Extract function name from error (from metadata or Convex debug message)
- */
-export function extractFunctionName(error: unknown): string | undefined {
-    if (error && typeof error === 'object') {
-        const err = error as Record<string, unknown>
-
-        // ConvexError.data._metadata.functionName
-        if (err.data && typeof err.data === 'object') {
-            const data = err.data as Record<string, unknown>
-            if (data._metadata && typeof data._metadata === 'object') {
-                const meta = data._metadata as Record<string, unknown>
-                if (typeof meta.functionName === 'string') {
-                    return meta.functionName
-                }
-            }
-        }
-
-        // Direct _metadata.functionName
-        if (err._metadata && typeof err._metadata === 'object') {
-            const meta = err._metadata as Record<string, unknown>
-            if (typeof meta.functionName === 'string') {
-                return meta.functionName
-            }
-        }
-    }
-
-    // Parse from Convex debug message format
-    const message = normalizeErrorMessage(error)
-    const operationMatch = message.match(/\[CONVEX [QM]\(([^)]+)\)\]/i)
-    if (operationMatch?.[1]) {
-        return operationMatch[1]
-    }
-
-    return undefined
-}
-
-/**
- * Get detailed error information for debugging
- */
-export function getErrorDetails(error: unknown) {
-    const appError = extractAppError(error)
-    const requestId = extractRequestId(error)
-    const functionName = extractFunctionName(error)
-    const message = normalizeErrorMessage(error)
-
-    return {
-        appError,
-        requestId,
-        functionName,
-        message,
-        raw: error,
-    }
-}

package/packages/errors/react/src/utils/formatError.ts

@@ -1,112 +0,0 @@
-// @geenius-tools/errors-react — src/utils/formatError.ts
-
-import type { ValidationError } from '../types'
-
-/**
- * Format validation errors for display
- *
- * @param errors - Array of validation errors
- * @returns Formatted error messages grouped by field
- */
-export function formatValidationErrors(
-    errors: ValidationError[],
-): Record<string, string[]> {
-    const grouped: Record<string, string[]> = {}
-    for (const error of errors) {
-        if (!grouped[error.field]) {
-            grouped[error.field] = []
-        }
-        grouped[error.field].push(error.message)
-    }
-    return grouped
-}
-
-/**
- * Format validation errors as a single string
- */
-export function formatValidationErrorsAsString(
-    errors: ValidationError[],
-): string {
-    return errors.map((e) => `${e.field}: ${e.message}`).join('\n')
-}
-
-/**
- * Get first validation error for a specific field
- */
-export function getFieldError(
-    errors: ValidationError[],
-    field: string,
-): string | undefined {
-    const fieldError = errors.find((e) => e.field === field)
-    return fieldError?.message
-}
-
-/**
- * Get all validation errors for a specific field
- */
-export function getFieldErrors(
-    errors: ValidationError[],
-    field: string,
-): string[] {
-    return errors.filter((e) => e.field === field).map((e) => e.message)
-}
-
-/**
- * Format timestamp to readable format
- */
-export function formatTimestamp(timestamp: string, locale = 'en-US'): string {
-    try {
-        const date = new Date(timestamp)
-        return date.toLocaleString(locale, {
-            year: 'numeric',
-            month: '2-digit',
-            day: '2-digit',
-            hour: '2-digit',
-            minute: '2-digit',
-        })
-    } catch {
-        return timestamp
-    }
-}
-
-/**
- * Format relative time
- */
-export function formatRelativeTime(timestamp: string): string {
-    try {
-        const date = new Date(timestamp)
-        const now = new Date()
-        const diffMs = now.getTime() - date.getTime()
-        const diffSec = Math.floor(diffMs / 1000)
-        const diffMin = Math.floor(diffSec / 60)
-        const diffHour = Math.floor(diffMin / 60)
-        const diffDay = Math.floor(diffHour / 24)
-
-        if (diffSec < 60) return 'just now'
-        if (diffMin < 60) return `${diffMin} minute${diffMin !== 1 ? 's' : ''} ago`
-        if (diffHour < 24) return `${diffHour} hour${diffHour !== 1 ? 's' : ''} ago`
-        if (diffDay < 7) return `${diffDay} day${diffDay !== 1 ? 's' : ''} ago`
-
-        return formatTimestamp(timestamp)
-    } catch {
-        return timestamp
-    }
-}
-
-/**
- * Truncate long error messages
- */
-export function truncateMessage(message: string, maxLength = 200): string {
-    if (message.length <= maxLength) return message
-    return message.slice(0, maxLength - 3) + '...'
-}
-
-/**
- * Format error code for display (convert to title case)
- */
-export function formatErrorCode(code: string): string {
-    return code
-        .split('_')
-        .map((word) => word.charAt(0) + word.slice(1).toLowerCase())
-        .join(' ')
-}

package/packages/errors/react/tsconfig.json

@@ -1,25 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "jsx": "react-jsx",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationDir": "./dist",
-    "outDir": "./dist",
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true
-  },
-  "include": [
-    "src"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
-}

package/packages/errors/react/tsup.config.ts

@@ -1,24 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig({
-    entry: {
-        index: 'src/index.ts',
-        analytics: 'src/analytics.ts',
-    },
-    format: ['esm'],
-    dts: true,
-    clean: true,
-    outDir: 'dist',
-    sourcemap: true,
-    external: [
-        'react',
-        'react-dom',
-        'lucide-react',
-        '@geenius-ui/react',
-        '@tanstack/react-router',
-        '@tanstack/react-query',
-        'convex',
-        'convex/react',
-        'convex/server',
-    ],
-})

package/packages/errors/solidjs/package.json

@@ -1,46 +0,0 @@
-{
-  "name": "@geenius-tools/errors-solidjs",
-  "version": "0.1.0",
-  "private": false,
-  "description": "SolidJS error handling UI \u2014 boundaries, displays, hooks & utilities",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit"
-  },
-  "devDependencies": {
-    "solid-js": "^1.9.0",
-    "tsup": "^8.5.1",
-    "typescript": "~5.9.3"
-  },
-  "peerDependencies": {
-    "solid-js": "^1.8.0 || ^1.9.0"
-  },
-  "peerDependenciesMeta": {
-    "lucide-solid": {
-      "optional": true
-    }
-  },
-  "author": "Antigravity HQ",
-  "license": "MIT",
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}