@geenius/tools 0.1.0 → 0.3.0

package/packages/errors/solidjs/src/components/ErrorDisplay.tsx

@@ -1,179 +0,0 @@
-// @geenius-tools/errors-solidjs — src/components/ErrorDisplay.tsx
-// SolidJS error display component
-
-import { Component, Show, For } from 'solid-js'
-import { extractAppError, extractRequestId, normalizeErrorMessage } from '../utils/extractAppError'
-import { formatValidationErrors } from '../utils/formatError'
-import type { AppErrorPayload, ErrorDisplayVariant } from '../types'
-import { getErrorMessages } from '../config'
-
-export interface ErrorDisplayProps {
-    error: unknown
-    onRetry?: () => void
-    variant?: ErrorDisplayVariant
-    compact?: boolean
-    showRequestId?: boolean
-}
-
-export const ErrorDisplay: Component<ErrorDisplayProps> = (props) => {
-    const appError = () => extractAppError(props.error)
-    const requestId = () => extractRequestId(props.error)
-    const messages = () => getErrorMessages()
-
-    return (
-        <Show
-            when={appError()}
-            fallback={
-                <div style={{
-                    "border-radius": "8px",
-                    border: "1px solid var(--border, #e5e7eb)",
-                    "background-color": "var(--panel, #fff)",
-                    padding: props.compact ? "16px" : "24px",
-                }}>
-                    <div style={{ display: "flex", "align-items": "center", gap: "12px" }}>
-                        <div style={{ flex: "1" }}>
-                            <h3 style={{ "font-size": "14px", "font-weight": "600", margin: "0 0 4px" }}>Error</h3>
-                            <p style={{ "font-size": "14px", color: "var(--muted-foreground, #6b7280)", margin: "0" }}>
-                                {normalizeErrorMessage(props.error)}
-                            </p>
-                        </div>
-                        <Show when={props.onRetry}>
-                            <button
-                                onClick={props.onRetry}
-                                style={{
-                                    padding: "6px 12px",
-                                    "border-radius": "6px",
-                                    border: "1px solid var(--border, #e5e7eb)",
-                                    "background-color": "transparent",
-                                    cursor: "pointer",
-                                    "font-size": "13px",
-                                }}
-                            >
-                                Retry
-                            </button>
-                        </Show>
-                    </div>
-                </div>
-            }
-        >
-            {(err) => (
-                <div style={{
-                    "border-radius": "8px",
-                    border: "1px solid var(--border, #e5e7eb)",
-                    "background-color": "var(--panel, #fff)",
-                    padding: props.compact ? "16px" : "24px",
-                    display: "flex",
-                    "flex-direction": "column",
-                    gap: "16px",
-                }}>
-                    <div style={{ display: "flex", "align-items": "flex-start", gap: "16px" }}>
-                        <div style={{ flex: "1", "min-width": "0" }}>
-                            <h3 style={{
-                                "font-size": props.compact ? "14px" : "16px",
-                                "font-weight": "600",
-                                color: "var(--foreground, #111)",
-                                margin: "0 0 4px",
-                            }}>
-                                {messages().titles[err().code]}
-                            </h3>
-                            <p style={{
-                                "font-size": props.compact ? "13px" : "14px",
-                                color: "var(--muted-foreground, #6b7280)",
-                                margin: "0",
-                            }}>
-                                {err().message ?? messages().messages[err().code]}
-                            </p>
-                        </div>
-                    </div>
-
-                    <Show when={err().validationErrors && err().validationErrors!.length > 0}>
-                        <ValidationErrorList errors={err().validationErrors!} />
-                    </Show>
-
-                    <Show when={props.showRequestId && requestId()}>
-                        <p style={{
-                            "font-size": "12px",
-                            "font-family": "monospace",
-                            color: "var(--muted-foreground, #6b7280)",
-                            margin: "0",
-                        }}>
-                            Request ID: {requestId()}
-                        </p>
-                    </Show>
-
-                    <div style={{ display: "flex", gap: "8px" }}>
-                        <Show when={props.onRetry}>
-                            <button
-                                onClick={props.onRetry}
-                                style={{
-                                    padding: "6px 12px",
-                                    "border-radius": "6px",
-                                    border: "1px solid var(--border, #e5e7eb)",
-                                    "background-color": "transparent",
-                                    cursor: "pointer",
-                                    "font-size": "13px",
-                                    "font-weight": "500",
-                                }}
-                            >
-                                Retry
-                            </button>
-                        </Show>
-                        <Show when={!props.onRetry}>
-                            <p style={{
-                                "font-size": "13px",
-                                color: "var(--muted-foreground, #6b7280)",
-                                margin: "0",
-                            }}>
-                                {messages().actions[err().code]}
-                            </p>
-                        </Show>
-                    </div>
-                </div>
-            )}
-        </Show>
-    )
-}
-
-// Internal component for validation error list
-import type { ValidationError } from '../types'
-
-const ValidationErrorList: Component<{ errors: ValidationError[] }> = (props) => {
-    const grouped = () => formatValidationErrors(props.errors)
-
-    return (
-        <div style={{ display: "flex", "flex-direction": "column", gap: "8px" }}>
-            <For each={Object.entries(grouped())}>
-                {([field, messages]) => (
-                    <div style={{
-                        display: "flex",
-                        "align-items": "flex-start",
-                        gap: "8px",
-                        padding: "12px",
-                        "border-radius": "8px",
-                        "background-color": "rgba(234, 179, 8, 0.05)",
-                        border: "1px solid rgba(234, 179, 8, 0.2)",
-                    }}>
-                        <div style={{ flex: "1" }}>
-                            <p style={{
-                                "font-size": "14px",
-                                "font-weight": "500",
-                                "text-transform": "capitalize",
-                                color: "#854d0e",
-                                margin: "0",
-                            }}>
-                                {field}
-                            </p>
-                            <For each={messages}>
-                                {(msg) => (
-                                    <p style={{ "font-size": "14px", color: "#a16207", margin: "0" }}>
-                                        {msg}
-                                    </p>
-                                )}
-                            </For>
-                        </div>
-                    </div>
-                )}
-            </For>
-        </div>
-    )
-}

package/packages/errors/solidjs/src/config.ts

@@ -1,98 +0,0 @@
-// @geenius-tools/errors-solidjs — src/config.ts
-// Pluggable configuration (same API as errors-react)
-
-import type { AppErrorCode } from './types'
-
-export interface ToastFn {
-    (message: string): void
-    error: (message: string, options?: { id?: string }) => void
-    success: (message: string, options?: { id?: string }) => void
-    loading: (message: string, options?: { id?: string }) => string | number
-}
-
-export interface ErrorHandlerConfig {
-    toast?: ToastFn
-    logInDev?: boolean
-}
-
-let _errorHandlerConfig: ErrorHandlerConfig = { logInDev: true }
-
-export function configureErrorHandler(config: ErrorHandlerConfig): void {
-    _errorHandlerConfig = { ..._errorHandlerConfig, ...config }
-}
-
-export function getErrorHandlerConfig(): ErrorHandlerConfig {
-    return _errorHandlerConfig
-}
-
-export interface ErrorMessageSet {
-    messages: Record<AppErrorCode, string>
-    titles: Record<AppErrorCode, string>
-    descriptions: Record<AppErrorCode, string>
-    actions: Record<AppErrorCode, string>
-    validation: Record<string, string>
-}
-
-export const ERROR_MESSAGES_EN: ErrorMessageSet = {
-    messages: {
-        UNAUTHENTICATED: 'Authentication required. Please sign in.',
-        FORBIDDEN: 'Access denied. You do not have permission for this action.',
-        NOT_FOUND: 'The requested resource was not found.',
-        BAD_REQUEST: 'Invalid request. Please check your input.',
-        CONFLICT: 'A conflict occurred with existing data.',
-        INTERNAL: 'An internal error occurred. Please try again later.',
-        VALIDATION_ERROR: 'Some fields are invalid. Please check and try again.',
-        RATE_LIMITED: 'Too many requests. Please try again later.',
-        FEATURE_DISABLED: 'This feature is currently disabled.',
-    },
-    titles: {
-        UNAUTHENTICATED: 'Not Authenticated',
-        FORBIDDEN: 'Access Denied',
-        NOT_FOUND: 'Not Found',
-        BAD_REQUEST: 'Invalid Request',
-        CONFLICT: 'Conflict',
-        INTERNAL: 'Internal Error',
-        VALIDATION_ERROR: 'Validation Error',
-        RATE_LIMITED: 'Too Many Requests',
-        FEATURE_DISABLED: 'Feature Disabled',
-    },
-    descriptions: {
-        UNAUTHENTICATED: 'Please sign in to continue. Your session may have expired.',
-        FORBIDDEN: 'You do not have permission for this action. Contact an administrator if you believe this is an error.',
-        NOT_FOUND: 'The requested resource was not found. It may have been deleted or moved.',
-        BAD_REQUEST: 'Invalid request. Please check your input and try again.',
-        CONFLICT: 'This action could not be completed due to a conflict with existing data.',
-        INTERNAL: 'An internal error occurred. Our team has been notified. Please try again later.',
-        VALIDATION_ERROR: 'Some of your inputs are invalid. Please check the highlighted fields and try again.',
-        RATE_LIMITED: 'You have sent too many requests in a short time. Please wait a moment and try again.',
-        FEATURE_DISABLED: 'This feature is currently disabled. Please try again later or contact support.',
-    },
-    actions: {
-        UNAUTHENTICATED: 'Please sign in again.',
-        FORBIDDEN: 'Contact an administrator if you need access.',
-        NOT_FOUND: 'Go back to the home page or use search.',
-        BAD_REQUEST: 'Check your input and try again.',
-        CONFLICT: 'Refresh the page and try again.',
-        INTERNAL: 'Try again in a few minutes.',
-        VALIDATION_ERROR: 'Fix the highlighted fields.',
-        RATE_LIMITED: 'Wait a moment and try again.',
-        FEATURE_DISABLED: 'Try again later or contact support.',
-    },
-    validation: {
-        required: 'This field is required.',
-        minLength: 'Must be at least {min} characters.',
-        maxLength: 'Must be at most {max} characters.',
-        email: 'Please enter a valid email address.',
-        url: 'Please enter a valid URL.',
-    },
-}
-
-let _currentMessages: ErrorMessageSet = ERROR_MESSAGES_EN
-
-export function configureErrorMessages(messages: ErrorMessageSet): void {
-    _currentMessages = messages
-}
-
-export function getErrorMessages(): ErrorMessageSet {
-    return _currentMessages
-}

package/packages/errors/solidjs/src/hooks/createErrorHandler.ts

@@ -1,107 +0,0 @@
-// @geenius-tools/errors-solidjs — src/hooks/createErrorHandler.ts
-// SolidJS signal-based error handling primitives
-
-import { createSignal } from 'solid-js'
-import { handleAppError, shouldRetryError, getRetryDelay } from '../utils/errorPolicy'
-import { extractAppError } from '../utils/extractAppError'
-
-/**
- * Create an error handler for SolidJS
- *
- * @example
- * const { handleError } = createErrorHandler()
- * try { await mutation(...) } catch (e) { handleError(e) }
- */
-export function createErrorHandler() {
-    const handleError = (error: unknown) => {
-        handleAppError(error)
-    }
-
-    return { handleError }
-}
-
-/**
- * Create async error handler with loading/error signals
- *
- * @example
- * const { execute, loading, error, hasError } = createAsyncError()
- *
- * const handleClick = async () => {
- *   await execute(async () => {
- *     await someAsyncOperation()
- *   })
- * }
- */
-export function createAsyncError() {
-    const [loading, setLoading] = createSignal(false)
-    const [error, setError] = createSignal<Error | null>(null)
-
-    const execute = async <T>(fn: () => Promise<T>): Promise<T | undefined> => {
-        setLoading(true)
-        setError(null)
-
-        try {
-            const result = await fn()
-            setLoading(false)
-            return result
-        } catch (err) {
-            setError(err instanceof Error ? err : new Error(String(err)))
-            setLoading(false)
-            return undefined
-        }
-    }
-
-    const resetError = () => setError(null)
-
-    return {
-        execute,
-        loading,
-        error,
-        hasError: () => error() !== null,
-        resetError,
-    }
-}
-
-/**
- * Create error boundary state management
- *
- * @example
- * const { error, hasError, setError, resetError } = createErrorBoundary()
- */
-export function createErrorBoundary() {
-    const [error, setErrorState] = createSignal<Error | null>(null)
-
-    const setError = (err: Error | null) => setErrorState(err)
-    const resetError = () => setErrorState(null)
-
-    return {
-        error,
-        hasError: () => error() !== null,
-        setError,
-        resetError,
-    }
-}
-
-/**
- * Create error retry configuration
- */
-export function createErrorRetry(maxRetries = 3) {
-    return {
-        retry: (failureCount: number, error: unknown) => {
-            if (failureCount >= maxRetries) return false
-            return shouldRetryError(error)
-        },
-        retryDelay: (attemptIndex: number, error: unknown) => {
-            return getRetryDelay(error, attemptIndex + 1)
-        },
-    }
-}
-
-/**
- * Create error info accessor
- */
-export function createErrorInfo() {
-    return {
-        getErrorInfo: (error: unknown) => extractAppError(error),
-    }
-}

package/packages/errors/solidjs/src/index.ts

@@ -1,61 +0,0 @@
-// @geenius-tools/errors-solidjs — src/index.ts
-
-// ===== Types =====
-export type {
-    AppErrorCode,
-    AppErrorPayload,
-    ValidationError,
-    ErrorDisplayVariant,
-} from './types'
-
-// ===== Config =====
-export {
-    configureErrorHandler,
-    configureErrorMessages,
-    getErrorHandlerConfig,
-    getErrorMessages,
-    ERROR_MESSAGES_EN,
-} from './config'
-export type {
-    ToastFn,
-    ErrorHandlerConfig,
-    ErrorMessageSet,
-} from './config'
-
-// ===== Utils =====
-export {
-    extractAppError,
-    extractRequestId,
-    extractFunctionName,
-    getErrorDetails,
-    normalizeErrorMessage,
-} from './utils/extractAppError'
-
-export {
-    handleAppError,
-    handleAppErrorSilent,
-    shouldRetryError,
-    getRetryDelay,
-} from './utils/errorPolicy'
-
-export {
-    formatValidationErrors,
-    formatValidationErrorsAsString,
-    getFieldError,
-    getFieldErrors,
-    truncateMessage,
-    formatErrorCode,
-} from './utils/formatError'
-
-// ===== Components =====
-export { ErrorDisplay } from './components/ErrorDisplay'
-export type { ErrorDisplayProps } from './components/ErrorDisplay'
-
-// ===== Hooks (SolidJS signals) =====
-export {
-    createErrorHandler,
-    createAsyncError,
-    createErrorBoundary,
-    createErrorRetry,
-    createErrorInfo,
-} from './hooks/createErrorHandler'

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

@@ -1,34 +0,0 @@
-// @geenius-tools/errors-solidjs — src/types.ts
-// Self-contained error types (same as errors-react, no framework deps)
-
-export type AppErrorCode =
-    | 'UNAUTHENTICATED'
-    | 'FORBIDDEN'
-    | 'NOT_FOUND'
-    | 'BAD_REQUEST'
-    | 'CONFLICT'
-    | 'INTERNAL'
-    | 'VALIDATION_ERROR'
-    | 'RATE_LIMITED'
-    | 'FEATURE_DISABLED'
-
-export interface ValidationError {
-    field: string
-    message: string
-}
-
-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
-    }
-}
-
-export type ErrorDisplayVariant = 'page' | 'card' | 'inline' | 'toast'

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

@@ -1,56 +0,0 @@
-// @geenius-tools/errors-solidjs — src/utils/errorPolicy.ts
-
-import { extractAppError, extractRequestId } from './extractAppError'
-import { getErrorHandlerConfig, getErrorMessages } from '../config'
-
-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-solidjs]', msg)
-        }
-    }
-
-    if (!appError) {
-        showError(requestId ? `An unexpected error occurred. Request ID: ${requestId}` : 'An unexpected error occurred.')
-        return
-    }
-
-    const message = appError.message ?? messages[appError.code]
-
-    switch (appError.code) {
-        case 'UNAUTHENTICATED':
-        case 'VALIDATION_ERROR':
-            break
-        case 'INTERNAL': {
-            showError(requestId ? `${message} Request ID: ${requestId}` : message)
-            break
-        }
-        default:
-            showError(message)
-    }
-}
-
-export function handleAppErrorSilent(error: unknown) {
-    return extractAppError(error)
-}
-
-export function shouldRetryError(error: unknown): boolean {
-    const appError = extractAppError(error)
-    if (!appError) return true
-    return appError.code === 'RATE_LIMITED' || appError.code === 'INTERNAL'
-}
-
-export function getRetryDelay(error: unknown, attemptNumber: number): number {
-    const appError = extractAppError(error)
-    if (!appError) return Math.min(1000 * Math.pow(2, attemptNumber - 1), 30000)
-    if (appError.code === 'RATE_LIMITED') return Math.min(1000 * Math.pow(2, attemptNumber - 1), 60000)
-    if (appError.code === 'INTERNAL') return 2000
-    return 0
-}

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

@@ -1,94 +0,0 @@
-// @geenius-tools/errors-solidjs — src/utils/extractAppError.ts
-// Same pure logic as errors-react (no framework dependency)
-
-import type { AppErrorPayload, AppErrorCode } from '../types'
-
-const VALID_CODES: AppErrorCode[] = [
-    'UNAUTHENTICATED', 'FORBIDDEN', 'NOT_FOUND', 'BAD_REQUEST',
-    'CONFLICT', 'INTERNAL', 'VALIDATION_ERROR', 'RATE_LIMITED', 'FEATURE_DISABLED',
-]
-
-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)
-}
-
-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)
-}
-
-export function extractAppError(error: unknown): AppErrorPayload | null {
-    if (error && typeof error === 'object' && 'data' in error) {
-        const data = (error as { data: unknown }).data
-        if (isAppErrorPayload(data)) return data as AppErrorPayload
-    }
-    if (isAppErrorPayload(error)) return error as AppErrorPayload
-    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
-}
-
-export function extractRequestId(error: unknown): string | undefined {
-    if (error && typeof error === 'object') {
-        const err = error as Record<string, unknown>
-        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
-            }
-        }
-        if (err._metadata && typeof err._metadata === 'object') {
-            const meta = err._metadata as Record<string, unknown>
-            if (typeof meta.requestId === 'string') return meta.requestId
-        }
-    }
-    const message = normalizeErrorMessage(error)
-    const match = message.match(/Request ID:\s*([^\]\s]+)/i)
-    return match?.[1]
-}
-
-export function extractFunctionName(error: unknown): string | undefined {
-    if (error && typeof error === 'object') {
-        const err = error as Record<string, unknown>
-        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
-            }
-        }
-        if (err._metadata && typeof err._metadata === 'object') {
-            const meta = err._metadata as Record<string, unknown>
-            if (typeof meta.functionName === 'string') return meta.functionName
-        }
-    }
-    const message = normalizeErrorMessage(error)
-    const match = message.match(/\[CONVEX [QM]\(([^)]+)\)\]/i)
-    return match?.[1]
-}
-
-export function getErrorDetails(error: unknown) {
-    return {
-        appError: extractAppError(error),
-        requestId: extractRequestId(error),
-        functionName: extractFunctionName(error),
-        message: normalizeErrorMessage(error),
-        raw: error,
-    }
-}

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

@@ -1,33 +0,0 @@
-// @geenius-tools/errors-solidjs — src/utils/formatError.ts
-
-import type { ValidationError } from '../types'
-
-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
-}
-
-export function formatValidationErrorsAsString(errors: ValidationError[]): string {
-    return errors.map((e) => `${e.field}: ${e.message}`).join('\n')
-}
-
-export function getFieldError(errors: ValidationError[], field: string): string | undefined {
-    return errors.find((e) => e.field === field)?.message
-}
-
-export function getFieldErrors(errors: ValidationError[], field: string): string[] {
-    return errors.filter((e) => e.field === field).map((e) => e.message)
-}
-
-export function truncateMessage(message: string, maxLength = 200): string {
-    if (message.length <= maxLength) return message
-    return message.slice(0, maxLength - 3) + '...'
-}
-
-export function formatErrorCode(code: string): string {
-    return code.split('_').map((word) => word.charAt(0) + word.slice(1).toLowerCase()).join(' ')
-}