create-fluxstack 1.20.0 → 1.21.0

package/core/client/state/createStore.ts

@@ -3,44 +3,44 @@
  * Core FluxStack state management utilities
  */
 
-import { create } from 'zustand'
-import { persist, createJSONStorage } from 'zustand/middleware'
-
-export interface StoreOptions<T> {
-  name?: string
-  persist?: boolean
-  storage?: 'localStorage' | 'sessionStorage'
-  version?: number
-  migrate?: (persistedState: unknown, version: number) => T
-}
-
-/**
- * Create a Zustand store with FluxStack conventions
- */
-export function createFluxStore<T>(
-  storeFactory: (set: (partial: Partial<T> | ((state: T) => Partial<T>)) => void, get: () => T) => T,
-  options: StoreOptions<T> = {}
-) {
-  const { name, persist: shouldPersist = false, storage = 'localStorage', version = 1, migrate } = options
-
-  if (shouldPersist && name) {
-    return create<T>()(
-      persist(
-        storeFactory,
-        {
-          name,
-          storage: createJSONStorage(() => 
-            storage === 'localStorage' ? localStorage : sessionStorage
-          ),
-          version,
-          migrate: migrate as ((persistedState: unknown, version: number) => T) | undefined,
-          onRehydrateStorage: () => (state) => {
-            console.log('FluxStack: Store rehydrated', name, state)
-          }
-        }
-      )
-    )
-  }
+import { create } from 'zustand'
+import { persist, createJSONStorage } from 'zustand/middleware'
+
+export interface StoreOptions<T> {
+  name?: string
+  persist?: boolean
+  storage?: 'localStorage' | 'sessionStorage'
+  version?: number
+  migrate?: (persistedState: unknown, version: number) => T
+}
+
+/**
+ * Create a Zustand store with FluxStack conventions
+ */
+export function createFluxStore<T>(
+  storeFactory: (set: (partial: Partial<T> | ((state: T) => Partial<T>)) => void, get: () => T) => T,
+  options: StoreOptions<T> = {}
+) {
+  const { name, persist: shouldPersist = false, storage = 'localStorage', version = 1, migrate } = options
+
+  if (shouldPersist && name) {
+    return create<T>()(
+      persist(
+        storeFactory,
+        {
+          name,
+          storage: createJSONStorage(() => 
+            storage === 'localStorage' ? localStorage : sessionStorage
+          ),
+          version,
+          migrate: migrate as ((persistedState: unknown, version: number) => T) | undefined,
+          onRehydrateStorage: () => (state) => {
+            console.log('FluxStack: Store rehydrated', name, state)
+          }
+        }
+      )
+    )
+  }
 
   return create<T>()(storeFactory)
 }
@@ -65,27 +65,27 @@ export interface BaseUserStore {
   logout: () => void
   updateProfile: (data: Partial<BaseUser>) => Promise<void>
   clearError: () => void
-  setLoading: (loading: boolean) => void
-}
-
-/**
- * Create user store with FluxStack conventions
- */
-export function createUserStore(options: StoreOptions<BaseUserStore> = {}) {
-  return createFluxStore<BaseUserStore>(
-    (set, get) => ({
-      currentUser: null,
-      isAuthenticated: false,
+  setLoading: (loading: boolean) => void
+}
+
+/**
+ * Create user store with FluxStack conventions
+ */
+export function createUserStore(options: StoreOptions<BaseUserStore> = {}) {
+  return createFluxStore<BaseUserStore>(
+    (set, get) => ({
+      currentUser: null,
+      isAuthenticated: false,
       isLoading: false,
       error: null,
 
-      login: async (credentials) => {
-        set({ isLoading: true, error: null })
-        try {
-          const response = await fetch('/api/auth/login', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(credentials)
+      login: async (credentials) => {
+        set({ isLoading: true, error: null })
+        try {
+          const response = await fetch('/api/auth/login', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(credentials)
           })
 
           if (!response.ok) {
@@ -108,13 +108,13 @@ export function createUserStore(options: StoreOptions<BaseUserStore> = {}) {
         }
       },
 
-      register: async (data) => {
-        set({ isLoading: true, error: null })
-        try {
-          const response = await fetch('/api/auth/register', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(data)
+      register: async (data) => {
+        set({ isLoading: true, error: null })
+        try {
+          const response = await fetch('/api/auth/register', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(data)
           })
 
           if (!response.ok) {
@@ -135,14 +135,14 @@ export function createUserStore(options: StoreOptions<BaseUserStore> = {}) {
           })
           throw error
         }
-      },
-
-      logout: () => {
-        // Call logout API
-        fetch('/api/auth/logout', { method: 'POST' }).catch(console.error)
-        
-        set({ 
-          currentUser: null, 
+      },
+
+      logout: () => {
+        // Call logout API
+        fetch('/api/auth/logout', { method: 'POST' }).catch(console.error)
+        
+        set({ 
+          currentUser: null, 
           isAuthenticated: false, 
           error: null 
         })
@@ -151,15 +151,15 @@ export function createUserStore(options: StoreOptions<BaseUserStore> = {}) {
       updateProfile: async (data) => {
         const { currentUser } = get()
         if (!currentUser) {
-          throw new Error('No user logged in')
-        }
-
-        set({ isLoading: true, error: null })
-        try {
-          const response = await fetch('/api/user/profile', {
-            method: 'PUT',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(data)
+          throw new Error('No user logged in')
+        }
+
+        set({ isLoading: true, error: null })
+        try {
+          const response = await fetch('/api/user/profile', {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(data)
           })
 
           if (!response.ok) {
@@ -183,11 +183,11 @@ export function createUserStore(options: StoreOptions<BaseUserStore> = {}) {
 
       clearError: () => set({ error: null }),
       setLoading: (loading) => set({ isLoading: loading })
-    }),
-    {
-      name: 'user-store',
-      persist: true,
-      ...options
-    }
-  )
-}
+    }),
+    {
+      name: 'user-store',
+      persist: true,
+      ...options
+    }
+  )
+}

package/core/client/state/index.ts

@@ -8,8 +8,8 @@ export {
   createUserStore 
 } from './createStore'
 
-export type { 
-  StoreOptions, 
-  BaseUser, 
-  BaseUserStore 
-} from './createStore'
+export type { 
+  StoreOptions, 
+  BaseUser, 
+  BaseUserStore 
+} from './createStore'

package/core/server/live/auto-generated-components.ts

@@ -1,6 +1,6 @@
 // Auto-generated Live Components Registration
 // Generated by @fluxstack/live — DO NOT EDIT MANUALLY
-// Generated at: 2026-03-21T23:18:32.007Z
+// Generated at: 2026-04-15T23:06:28.948Z
 
 import { LiveAdminPanel } from "@app/server/live/LiveAdminPanel"
 import { LiveCounter } from "@app/server/live/LiveCounter"
@@ -10,7 +10,6 @@ import { LivePingPong } from "@app/server/live/LivePingPong"
 import { LiveProtectedChat } from "@app/server/live/LiveProtectedChat"
 import { LiveRoomChat } from "@app/server/live/LiveRoomChat"
 import { LiveSharedCounter } from "@app/server/live/LiveSharedCounter"
-import { LiveUpload } from "@app/server/live/LiveUpload"
 
 // Component classes array for LiveServer({ components }) option
 export const liveComponentClasses = [
@@ -22,5 +21,4 @@ export const liveComponentClasses = [
   LiveProtectedChat,
   LiveRoomChat,
   LiveSharedCounter,
-  LiveUpload,
 ]

package/core/utils/version.ts

@@ -3,4 +3,4 @@
  * Single source of truth for version number
  * Auto-synced with package.json
  */
-export const FLUXSTACK_VERSION = '1.18.1'
+export const FLUXSTACK_VERSION = '1.21.0'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-fluxstack",
-  "version": "1.20.0",
+  "version": "1.21.0",
   "description": "⚡ Revolutionary full-stack TypeScript framework with Declarative Config System, Elysia + React + Bun",
   "keywords": [
     "framework",

package/tsconfig.json

@@ -44,9 +44,10 @@
   },
   "exclude": [
     "examples/**/*",
-    "**/*.test.ts",
-    "**/__tests__/**/*",
-    "run-env-tests.ts",
-    "plugins/**/scripts/**/*"
-  ]
-}
+    "**/*.test.ts",
+    "**/__tests__/**/*",
+    "dist/**/*",
+    "run-env-tests.ts",
+    "plugins/**/scripts/**/*"
+  ]
+}

package/app/client/src/components/LiveUploadWidget.tsx

@@ -1,200 +0,0 @@
-import { useEffect, useMemo, useState } from 'react'
-import { useLiveChunkedUpload } from '@/core/client'
-import type { LiveChunkedUploadOptions } from '@/core/client'
-import type { FileUploadCompleteResponse } from '@core/types/types'
-import { LiveUpload } from '@server/live/LiveUpload'
-
-// Derive the state type from the actual LiveUpload component to avoid duplication
-type LiveUploadState = typeof LiveUpload.defaultState
-
-// Minimal interface for any Live.use() proxy compatible with LiveUpload
-interface LiveUploadProxy {
-  $componentId: string | null
-  $connected: boolean
-  $state: LiveUploadState
-  $error?: string | null
-  startUpload: (payload: { fileName: string; fileSize: number; fileType: string }) => Promise<any>
-  updateProgress: (payload: { progress: number; bytesUploaded: number; totalBytes: number }) => Promise<any>
-  completeUpload: (payload: { fileUrl: string }) => Promise<any>
-  failUpload: (payload: { error: string }) => Promise<any>
-  reset: () => Promise<any>
-}
-
-export interface LiveUploadWidgetProps {
-  live: LiveUploadProxy
-  title?: string
-  description?: string
-  allowPreview?: boolean
-  options?: LiveChunkedUploadOptions
-  onComplete?: (response: FileUploadCompleteResponse) => void
-}
-
-export function LiveUploadWidget({
-  live,
-  title = 'Upload em Chunks',
-  description = 'Envio via WebSocket com Live Components e reatividade server-side.',
-  allowPreview = true,
-  options,
-  onComplete
-}: LiveUploadWidgetProps) {
-  // live is expected to be a LiveUpload-compatible component
-  const [selectedFile, setSelectedFile] = useState<File | null>(null)
-  const [localError, setLocalError] = useState<string | null>(null)
-  const [previewUrl, setPreviewUrl] = useState<string | null>(null)
-
-  const mergedOptions = useMemo<LiveChunkedUploadOptions>(() => {
-    return {
-      allowedTypes: [],
-      maxFileSize: 500 * 1024 * 1024,
-      adaptiveChunking: true,
-      fileUrlResolver: (fileUrl) => fileUrl.startsWith('/uploads/') ? `/api${fileUrl}` : fileUrl,
-      onComplete,
-      ...options
-    }
-  }, [options, onComplete])
-
-  const {
-    uploading,
-    bytesUploaded,
-    totalBytes,
-    uploadFile,
-    cancelUpload,
-    reset
-  } = useLiveChunkedUpload(live, mergedOptions)
-
-  const canUpload = live.$connected && !!live.$componentId && !uploading
-
-  const handleSelectFile = (e: React.ChangeEvent<HTMLInputElement>) => {
-    const file = e.target.files?.[0] ?? null
-    setSelectedFile(file)
-    setLocalError(null)
-
-    if (previewUrl) {
-      URL.revokeObjectURL(previewUrl)
-      setPreviewUrl(null)
-    }
-
-    if (allowPreview && file && file.type.startsWith('image/')) {
-      setPreviewUrl(URL.createObjectURL(file))
-    }
-  }
-
-  useEffect(() => {
-    return () => {
-      if (previewUrl) {
-        URL.revokeObjectURL(previewUrl)
-      }
-    }
-  }, [previewUrl])
-
-  const handleStartUpload = async () => {
-    if (!selectedFile) {
-      setLocalError('Selecione um arquivo primeiro.')
-      return
-    }
-
-    if (!live.$connected || !live.$componentId) {
-      setLocalError('WebSocket ainda nao conectou. Tente novamente em alguns segundos.')
-      return
-    }
-
-    setLocalError(null)
-    await uploadFile(selectedFile)
-  }
-
-  const handleReset = async () => {
-    setSelectedFile(null)
-    setLocalError(null)
-    if (previewUrl) {
-      URL.revokeObjectURL(previewUrl)
-      setPreviewUrl(null)
-    }
-    await reset()
-  }
-
-  const resolvedUrl = live.$state.fileUrl
-
-  return (
-    <div className="bg-white/5 backdrop-blur-sm border border-white/10 rounded-2xl p-8 max-w-xl w-full mx-auto">
-      <h2 className="text-2xl font-bold text-white mb-2 text-center">
-        {title}
-      </h2>
-
-      <p className="text-gray-400 text-sm text-center mb-6">
-        {description}
-      </p>
-
-      <div className="space-y-4">
-        <input
-          type="file"
-          onChange={handleSelectFile}
-          className="w-full text-sm text-gray-300 file:mr-4 file:py-2 file:px-4 file:rounded-lg file:border-0 file:bg-white/10 file:text-white hover:file:bg-white/20"
-          disabled={!live.$connected || uploading}
-        />
-
-        <div className="flex gap-3">
-          <button
-            onClick={handleStartUpload}
-            disabled={!canUpload || !selectedFile}
-            className="flex-1 px-4 py-2 rounded-lg bg-emerald-500/20 border border-emerald-500/30 text-emerald-300 hover:bg-emerald-500/30 transition-all disabled:opacity-50"
-          >
-            Iniciar Upload
-          </button>
-          <button
-            onClick={cancelUpload}
-            disabled={!uploading}
-            className="px-4 py-2 rounded-lg bg-red-500/20 border border-red-500/30 text-red-300 hover:bg-red-500/30 transition-all disabled:opacity-50"
-          >
-            Cancelar
-          </button>
-          <button
-            onClick={handleReset}
-            className="px-4 py-2 rounded-lg bg-white/10 border border-white/20 text-white hover:bg-white/20 transition-all"
-          >
-            Reset
-          </button>
-        </div>
-
-        {(localError || live.$state.error || live.$error) && (
-          <div className="text-sm text-red-300 bg-red-500/10 border border-red-500/30 rounded-lg px-3 py-2">
-            {localError || live.$state.error || live.$error}
-          </div>
-        )}
-
-        <div className="bg-black/40 border border-white/10 rounded-xl p-4">
-          <div className="flex justify-between text-xs text-gray-400 mb-2">
-            <span>Status: {live.$state.status}</span>
-            <span>{Math.round(live.$state.progress)}%</span>
-          </div>
-          <div className="w-full h-3 bg-white/10 rounded-full overflow-hidden">
-            <div
-              className="h-full bg-theme-gradient transition-all"
-              style={{ width: `${live.$state.progress}%` }}
-            />
-          </div>
-          <div className="flex justify-between text-xs text-gray-500 mt-2">
-            <span>{live.$state.fileName || 'Nenhum arquivo selecionado'}</span>
-            <span>{bytesUploaded > 0 ? `${Math.round(bytesUploaded / 1024)} KB` : ''}{totalBytes > 0 ? ` / ${Math.round(totalBytes / 1024)} KB` : ''}</span>
-          </div>
-        </div>
-
-        {previewUrl && (
-          <div className="bg-white/5 border border-white/10 rounded-xl p-4">
-            <div className="text-xs text-gray-400 mb-2">Preview</div>
-            <img
-              src={previewUrl}
-              alt="Preview"
-              className="max-h-48 w-full object-contain rounded-lg border border-white/10"
-            />
-          </div>
-        )}
-
-        {resolvedUrl && live.$state.status === 'complete' && (
-          <div className="bg-emerald-500/10 border border-emerald-500/30 rounded-xl p-4 text-sm text-emerald-200">
-            Upload concluido: <a className="underline" href={resolvedUrl} target="_blank" rel="noopener noreferrer">abrir arquivo</a>
-          </div>
-        )}
-      </div>
-    </div>
-  )
-}

package/app/client/src/live/UploadDemo.tsx

@@ -1,21 +0,0 @@
-import { useState } from 'react'
-import { LiveUploadWidget } from '../components/LiveUploadWidget'
-import { useLiveUpload } from '@/core/client'
-
-export function UploadDemo() {
-  const [lastUrl, setLastUrl] = useState<string | null>(null)
-  const { live } = useLiveUpload({
-    onComplete: (response) => setLastUrl(response.fileUrl || null)
-  })
-
-  return (
-    <div className="flex flex-col gap-4 max-w-xl w-full mx-auto">
-      <LiveUploadWidget live={live} />
-      {lastUrl && (
-        <div className="text-xs text-gray-500 text-center">
-          Ultimo arquivo: {lastUrl}
-        </div>
-      )}
-    </div>
-  )
-}

package/app/server/live/LiveUpload.ts

@@ -1,96 +0,0 @@
-// LiveUpload - Estado de upload chunked + sincronização UI
-
-import { LiveComponent } from '@core/types/types'
-
-// Componente Cliente (Ctrl+Click para navegar)
-import type { UploadDemo as _Client } from '@client/src/live/UploadDemo'
-
-export class LiveUpload extends LiveComponent<typeof LiveUpload.defaultState> {
-  static componentName = 'LiveUpload'
-  static publicActions = ['startUpload', 'updateProgress', 'completeUpload', 'failUpload', 'reset'] as const
-  static defaultState = {
-    status: 'idle' as 'idle' | 'uploading' | 'complete' | 'error',
-    progress: 0,
-    fileName: '',
-    fileSize: 0,
-    fileType: '',
-    fileUrl: '',
-    bytesUploaded: 0,
-    totalBytes: 0,
-    error: null as string | null
-  }
-
-  async startUpload(payload: { fileName: string; fileSize: number; fileType: string }) {
-    const fileName = payload.fileName
-
-    // Validate filename length
-    if (!fileName || fileName.length > 255) {
-      throw new Error('Invalid file name: must be 1-255 characters')
-    }
-
-    // Block path traversal, null bytes, and control characters
-    if (/[\x00-\x1f]/.test(fileName) || fileName.includes('..') || fileName.includes('/') || fileName.includes('\\')) {
-      throw new Error('Invalid file name: contains forbidden characters')
-    }
-
-    // Block Windows reserved names
-    const baseName = fileName.split('.')[0].toUpperCase()
-    const reserved = ['CON', 'PRN', 'AUX', 'NUL', 'COM1', 'COM2', 'COM3', 'COM4', 'LPT1', 'LPT2', 'LPT3']
-    if (reserved.includes(baseName)) {
-      throw new Error('Invalid file name: reserved name')
-    }
-
-    // All file types allowed - no extension blocking
-    // Security note: Configure allowed extensions per your application needs
-
-    this.setState({
-      status: 'uploading',
-      progress: 0,
-      fileName: payload.fileName,
-      fileSize: payload.fileSize,
-      fileType: payload.fileType,
-      fileUrl: '',
-      bytesUploaded: 0,
-      totalBytes: payload.fileSize,
-      error: null
-    })
-
-    return { success: true }
-  }
-
-  async updateProgress(payload: { progress: number; bytesUploaded: number; totalBytes: number }) {
-    const progress = Math.max(0, Math.min(100, payload.progress))
-    this.setState({
-      progress,
-      bytesUploaded: payload.bytesUploaded,
-      totalBytes: payload.totalBytes
-    })
-
-    return { success: true, progress }
-  }
-
-  async completeUpload(payload: { fileUrl: string }) {
-    this.setState({
-      status: 'complete',
-      progress: 100,
-      fileUrl: payload.fileUrl,
-      error: null
-    })
-
-    return { success: true }
-  }
-
-  async failUpload(payload: { error: string }) {
-    this.setState({
-      status: 'error',
-      error: payload.error || 'Upload failed'
-    })
-
-    return { success: true }
-  }
-
-  async reset() {
-    this.setState({ ...LiveUpload.defaultState })
-    return { success: true }
-  }
-}

package/core/client/hooks/useLiveUpload.ts

@@ -1,70 +0,0 @@
-import { useMemo } from 'react'
-import { Live, useLiveChunkedUpload } from '@fluxstack/live-react'
-import type { LiveChunkedUploadOptions } from '@fluxstack/live-react'
-import type { FileUploadCompleteResponse } from '@fluxstack/live'
-import { LiveUpload } from '@server/live/LiveUpload'
-
-export interface UseLiveUploadOptions {
-  live?: {
-    room?: string
-    userId?: string
-    autoMount?: boolean
-    debug?: boolean
-  }
-  upload?: LiveChunkedUploadOptions
-  onProgress?: (progress: number, bytesUploaded: number, totalBytes: number) => void
-  onComplete?: (response: FileUploadCompleteResponse) => void
-  onError?: (error: string) => void
-}
-
-export function useLiveUpload(options: UseLiveUploadOptions = {}) {
-  const { live: liveOptions, upload: uploadOptions, onProgress, onComplete, onError } = options
-
-  const live = Live.use(LiveUpload, {
-    initialState: LiveUpload.defaultState,
-    ...liveOptions
-  })
-
-  const mergedUploadOptions = useMemo<LiveChunkedUploadOptions>(() => {
-    return {
-      allowedTypes: [],
-      maxFileSize: 500 * 1024 * 1024,
-      adaptiveChunking: true,
-      fileUrlResolver: (fileUrl) => fileUrl.startsWith('/uploads/') ? `/api${fileUrl}` : fileUrl,
-      onProgress,
-      onComplete,
-      onError,
-      ...uploadOptions
-    }
-  }, [onProgress, onComplete, onError, uploadOptions])
-
-  const upload = useLiveChunkedUpload(live, mergedUploadOptions)
-
-  const startUpload = useMemo(() => {
-    return async (file: File) => {
-      if (!live.$connected || !live.$componentId) {
-        const msg = 'WebSocket nao conectado. Tente novamente.'
-        onError?.(msg)
-        await live.failUpload({ error: msg })
-        return
-      }
-      await upload.uploadFile(file)
-    }
-  }, [live, upload, onError])
-
-  return {
-    live,
-    state: live.$state,
-    status: live.$state.status,
-    connected: live.$connected,
-    componentId: live.$componentId,
-    uploading: upload.uploading,
-    progress: upload.progress,
-    bytesUploaded: upload.bytesUploaded,
-    totalBytes: upload.totalBytes,
-    error: live.$state.error,
-    startUpload,
-    cancelUpload: upload.cancelUpload,
-    reset: upload.reset
-  }
-}