create-fluxstack 1.19.0 → 1.20.1

package/LLMD/resources/routes-eden.md

@@ -1,254 +1,254 @@
-# Routes with Eden Treaty
-
-**Version:** 1.11.0 | **Updated:** 2025-02-08
-
-## Quick Facts
-
-- Routes use Elysia with `t.Object()` validation schemas
-- **Response schemas are REQUIRED** for Eden Treaty type inference
-- Frontend gets automatic type inference via Eden Treaty
-- Route grouping uses `prefix` option
-- Validation happens automatically via schemas
-
-## Route Definition Pattern
-
-```typescript
-import { Elysia, t } from 'elysia'
-
-export const usersRoutes = new Elysia({ prefix: '/users', tags: ['Users'] })
-  .get('/', async () => {
-    // Handler logic
-    return { success: true, users: [], count: 0 }
-  }, {
-    detail: {
-      summary: 'Get All Users',
-      description: 'Retrieves a list of all registered users',
-      tags: ['Users', 'CRUD']
-    },
-    response: t.Object({
-      success: t.Boolean(),
-      users: t.Array(UserSchema),
-      count: t.Number()
-    })
-  })
-```
-
-## Schema Definition
-
-Define schemas at the top of route files:
-
-```typescript
-const UserSchema = t.Object({
-  id: t.Number(),
-  name: t.String(),
-  email: t.String()
-}, {
-  description: 'User object'
-})
-
-const CreateUserRequestSchema = t.Object({
-  name: t.String({ minLength: 2, description: 'User name (minimum 2 characters)' }),
-  email: t.String({ format: 'email', description: 'Valid email address' })
-}, {
-  description: 'Request body for creating a new user'
-})
-```
-
-## Response Schema (REQUIRED!)
-
-**Every route MUST define a response schema** for Eden Treaty type inference:
-
-```typescript
-.get('/users', async () => {
-  return { success: true, users: [] }
-}, {
-  response: t.Object({
-    success: t.Boolean(),
-    users: t.Array(UserSchema)
-  })
-})
-```
-
-Without response schema, frontend loses type inference.
-
-## Multiple Status Code Responses
-
-```typescript
-.post('/', async ({ body, set }) => {
-  // Validation error
-  if (!body.name) {
-    set.status = 400
-    return { success: false, error: 'Name required' }
-  }
-  
-  // Success
-  set.status = 201
-  return { success: true, user: newUser }
-}, {
-  body: CreateUserRequestSchema,
-  response: {
-    201: t.Object({
-      success: t.Literal(true),
-      user: UserSchema
-    }),
-    400: t.Object({
-      success: t.Literal(false),
-      error: t.String()
-    })
-  }
-})
-```
-
-## Route Parameters
-
-```typescript
-.get('/:id', async ({ params }) => {
-  const id = Number(params.id)
-  return { success: true, user: foundUser }
-}, {
-  params: t.Object({
-    id: t.String({ description: 'User ID' })
-  }),
-  response: {
-    200: GetUserResponseSchema,
-    404: ErrorResponseSchema
-  }
-})
-```
-
-## Request Body Validation
-
-```typescript
-.post('/', async ({ body }) => {
-  // body is automatically validated against schema
-  const user = await createUser(body)
-  return { success: true, user }
-}, {
-  body: t.Object({
-    name: t.String({ minLength: 2 }),
-    email: t.String({ format: 'email' })
-  }),
-  response: CreateUserResponseSchema
-})
-```
-
-## Route Grouping
-
-```typescript
-// Main API routes with prefix
-export const apiRoutes = new Elysia({ prefix: "/api" })
-  .get("/health", () => ({ status: "ok" }), {
-    response: t.Object({ status: t.String() })
-  })
-  // Register sub-routes
-  .use(usersRoutes)
-  .use(postsRoutes)
-```
-
-## Frontend Usage (Eden Treaty)
-
-Once routes are defined with response schemas, frontend gets automatic type inference:
-
-```typescript
-import { api } from '@/lib/eden-api'
-
-// GET request - types inferred from response schema
-const { data, error } = await api.users.get()
-// data: { success: boolean, users: User[], count: number } | undefined
-// error: Error | undefined
-
-// POST request - body type inferred from body schema
-const { data, error } = await api.users.post({
-  name: 'John Doe',
-  email: 'john@example.com'
-})
-// TypeScript validates body matches CreateUserRequestSchema
-
-// Path parameters
-const { data } = await api.users({ id: '123' }).get()
-
-// Query parameters
-const { data } = await api.users.get({ 
-  query: { page: 1, limit: 10 } 
-})
-```
-
-## Type Flow Diagram
-
-```
-Backend Route Definition
-  ↓
-t.Object() Schema (response)
-  ↓
-Eden Treaty Type Inference
-  ↓
-Frontend api.users.get()
-  ↓
-Typed { data, error }
-```
-
-## Common Validation Types
-
-```typescript
-// String validations
-t.String({ minLength: 2, maxLength: 100 })
-t.String({ format: 'email' })
-t.String({ pattern: '^[a-z]+$' })
-
-// Number validations
-t.Number({ minimum: 0, maximum: 100 })
-t.Integer()
-
-// Arrays
-t.Array(t.String())
-t.Array(UserSchema, { minItems: 1 })
-
-// Optional fields
-t.Optional(t.String())
-
-// Unions (multiple types)
-t.Union([
-  t.Object({ success: t.Literal(true), data: t.Any() }),
-  t.Object({ success: t.Literal(false), error: t.String() })
-])
-
-// Enums
-t.Union([t.Literal('active'), t.Literal('inactive')])
-```
-
-## OpenAPI Documentation
-
-The `detail` object generates OpenAPI/Swagger documentation:
-
-```typescript
-.get('/users', handler, {
-  detail: {
-    summary: 'Get All Users',
-    description: 'Retrieves a list of all registered users',
-    tags: ['Users', 'CRUD']
-  },
-  response: ResponseSchema
-})
-```
-
-Access Swagger UI at `/swagger` when server is running.
-
-## Critical Rules
-
-**ALWAYS:**
-- Define response schema for every route
-- Use `t.Object()` for validation
-- Set `set.status` for non-200 responses
-- Define schemas at file top for reusability
-
-**NEVER:**
-- Omit response schema (breaks type inference)
-- Use plain objects without `t.Object()`
-- Forget to validate user input
-- Mix route logic with business logic (use controllers)
-
-## Related
-
-- [Controllers & Services](./controllers.md)
-- [Type Safety Patterns](../patterns/type-safety.md)
-- [Anti-Patterns](../patterns/anti-patterns.md)
+# Routes with Eden Treaty
+
+**Version:** 1.19.0 | **Updated:** 2026-04-14
+
+## Quick Facts
+
+- Routes use Elysia with `t.Object()` validation schemas
+- **Response schemas are REQUIRED** for Eden Treaty type inference
+- Frontend gets automatic type inference via Eden Treaty
+- Route grouping uses `prefix` option
+- Validation happens automatically via schemas
+
+## Route Definition Pattern
+
+```typescript
+import { Elysia, t } from 'elysia'
+
+export const usersRoutes = new Elysia({ prefix: '/users', tags: ['Users'] })
+  .get('/', async () => {
+    // Handler logic
+    return { success: true, users: [], count: 0 }
+  }, {
+    detail: {
+      summary: 'Get All Users',
+      description: 'Retrieves a list of all registered users',
+      tags: ['Users', 'CRUD']
+    },
+    response: t.Object({
+      success: t.Boolean(),
+      users: t.Array(UserSchema),
+      count: t.Number()
+    })
+  })
+```
+
+## Schema Definition
+
+Define schemas at the top of route files:
+
+```typescript
+const UserSchema = t.Object({
+  id: t.Number(),
+  name: t.String(),
+  email: t.String()
+}, {
+  description: 'User object'
+})
+
+const CreateUserRequestSchema = t.Object({
+  name: t.String({ minLength: 2, description: 'User name (minimum 2 characters)' }),
+  email: t.String({ format: 'email', description: 'Valid email address' })
+}, {
+  description: 'Request body for creating a new user'
+})
+```
+
+## Response Schema (REQUIRED!)
+
+**Every route MUST define a response schema** for Eden Treaty type inference:
+
+```typescript
+.get('/users', async () => {
+  return { success: true, users: [] }
+}, {
+  response: t.Object({
+    success: t.Boolean(),
+    users: t.Array(UserSchema)
+  })
+})
+```
+
+Without response schema, frontend loses type inference.
+
+## Multiple Status Code Responses
+
+```typescript
+.post('/', async ({ body, set }) => {
+  // Validation error
+  if (!body.name) {
+    set.status = 400
+    return { success: false, error: 'Name required' }
+  }
+  
+  // Success
+  set.status = 201
+  return { success: true, user: newUser }
+}, {
+  body: CreateUserRequestSchema,
+  response: {
+    201: t.Object({
+      success: t.Literal(true),
+      user: UserSchema
+    }),
+    400: t.Object({
+      success: t.Literal(false),
+      error: t.String()
+    })
+  }
+})
+```
+
+## Route Parameters
+
+```typescript
+.get('/:id', async ({ params }) => {
+  const id = Number(params.id)
+  return { success: true, user: foundUser }
+}, {
+  params: t.Object({
+    id: t.String({ description: 'User ID' })
+  }),
+  response: {
+    200: GetUserResponseSchema,
+    404: ErrorResponseSchema
+  }
+})
+```
+
+## Request Body Validation
+
+```typescript
+.post('/', async ({ body }) => {
+  // body is automatically validated against schema
+  const user = await createUser(body)
+  return { success: true, user }
+}, {
+  body: t.Object({
+    name: t.String({ minLength: 2 }),
+    email: t.String({ format: 'email' })
+  }),
+  response: CreateUserResponseSchema
+})
+```
+
+## Route Grouping
+
+```typescript
+// Main API routes with prefix
+export const apiRoutes = new Elysia({ prefix: "/api" })
+  .get("/health", () => ({ status: "ok" }), {
+    response: t.Object({ status: t.String() })
+  })
+  // Register sub-routes
+  .use(usersRoutes)
+  .use(postsRoutes)
+```
+
+## Frontend Usage (Eden Treaty)
+
+Once routes are defined with response schemas, frontend gets automatic type inference:
+
+```typescript
+import { api } from '@/lib/eden-api'
+
+// GET request - types inferred from response schema
+const { data, error } = await api.users.get()
+// data: { success: boolean, users: User[], count: number } | undefined
+// error: Error | undefined
+
+// POST request - body type inferred from body schema
+const { data, error } = await api.users.post({
+  name: 'John Doe',
+  email: 'john@example.com'
+})
+// TypeScript validates body matches CreateUserRequestSchema
+
+// Path parameters
+const { data } = await api.users({ id: '123' }).get()
+
+// Query parameters
+const { data } = await api.users.get({ 
+  query: { page: 1, limit: 10 } 
+})
+```
+
+## Type Flow Diagram
+
+```
+Backend Route Definition
+  ↓
+t.Object() Schema (response)
+  ↓
+Eden Treaty Type Inference
+  ↓
+Frontend api.users.get()
+  ↓
+Typed { data, error }
+```
+
+## Common Validation Types
+
+```typescript
+// String validations
+t.String({ minLength: 2, maxLength: 100 })
+t.String({ format: 'email' })
+t.String({ pattern: '^[a-z]+$' })
+
+// Number validations
+t.Number({ minimum: 0, maximum: 100 })
+t.Integer()
+
+// Arrays
+t.Array(t.String())
+t.Array(UserSchema, { minItems: 1 })
+
+// Optional fields
+t.Optional(t.String())
+
+// Unions (multiple types)
+t.Union([
+  t.Object({ success: t.Literal(true), data: t.Any() }),
+  t.Object({ success: t.Literal(false), error: t.String() })
+])
+
+// Enums
+t.Union([t.Literal('active'), t.Literal('inactive')])
+```
+
+## OpenAPI Documentation
+
+The `detail` object generates OpenAPI/Swagger documentation:
+
+```typescript
+.get('/users', handler, {
+  detail: {
+    summary: 'Get All Users',
+    description: 'Retrieves a list of all registered users',
+    tags: ['Users', 'CRUD']
+  },
+  response: ResponseSchema
+})
+```
+
+Access Swagger UI at `/swagger` when server is running.
+
+## Critical Rules
+
+**ALWAYS:**
+- Define response schema for every route
+- Use `t.Object()` for validation
+- Set `set.status` for non-200 responses
+- Define schemas at file top for reusability
+
+**NEVER:**
+- Omit response schema (breaks type inference)
+- Use plain objects without `t.Object()`
+- Forget to validate user input
+- Mix route logic with business logic (use controllers)
+
+## Related
+
+- [Controllers & Services](./controllers.md)
+- [Type Safety Patterns](../patterns/type-safety.md)
+- [Anti-Patterns](../patterns/anti-patterns.md)

package/app/client/.live-stubs/LiveAdminPanel.js

@@ -0,0 +1,15 @@
+export class LiveAdminPanel {
+  static componentName = 'LiveAdminPanel'
+  static defaultState = {
+    users: [
+      { id: '1', name: 'Alice', role: 'admin', createdAt: Date.now() },
+      { id: '2', name: 'Bob', role: 'user', createdAt: Date.now() },
+      { id: '3', name: 'Carol', role: 'moderator', createdAt: Date.now() },
+    ],
+    audit: [],
+    currentUser: null,
+    currentRoles: [],
+    isAdmin: false,
+  }
+  static publicActions = ['getAuthInfo', 'init', 'listUsers', 'addUser', 'deleteUser', 'clearAudit']
+}

package/app/client/.live-stubs/LiveCounter.js

@@ -0,0 +1,9 @@
+export class LiveCounter {
+  static componentName = 'LiveCounter'
+  static defaultState = {
+    count: 0,
+    lastUpdatedBy: null,
+    connectedUsers: 0
+  }
+  static publicActions = ['increment', 'decrement', 'reset']
+}

package/app/client/.live-stubs/LiveForm.js

@@ -0,0 +1,11 @@
+export class LiveForm {
+  static componentName = 'LiveForm'
+  static defaultState = {
+    name: '',
+    email: '',
+    message: '',
+    submitted: false,
+    submittedAt: null
+  }
+  static publicActions = ['submit', 'reset', 'validate', 'setValue']
+}

package/app/client/.live-stubs/LiveLocalCounter.js

@@ -0,0 +1,8 @@
+export class LiveLocalCounter {
+  static componentName = 'LiveLocalCounter'
+  static defaultState = {
+    count: 0,
+    clicks: 0
+  }
+  static publicActions = ['increment', 'decrement', 'reset']
+}

package/app/client/.live-stubs/LivePingPong.js

@@ -0,0 +1,10 @@
+export class LivePingPong {
+  static componentName = 'LivePingPong'
+  static defaultState = {
+    username: '',
+    onlineCount: 0,
+    totalPings: 0,
+    lastPingBy: null,
+  }
+  static publicActions = ['ping']
+}

package/app/client/.live-stubs/LiveRoomChat.js

@@ -0,0 +1,11 @@
+export class LiveRoomChat {
+  static componentName = 'LiveRoomChat'
+  static defaultState = {
+    username: '',
+    activeRoom: null,
+    rooms: [],
+    messages: {},
+    customRooms: []
+  }
+  static publicActions = ['createRoom', 'joinRoom', 'leaveRoom', 'switchRoom', 'sendMessage', 'setUsername']
+}

package/app/client/.live-stubs/LiveSharedCounter.js

@@ -0,0 +1,10 @@
+export class LiveSharedCounter {
+  static componentName = 'LiveSharedCounter'
+  static defaultState = {
+    username: '',
+    count: 0,
+    lastUpdatedBy: null,
+    onlineCount: 0
+  }
+  static publicActions = ['increment', 'decrement', 'reset']
+}

package/app/client/.live-stubs/LiveUpload.js

@@ -0,0 +1,15 @@
+export class LiveUpload {
+  static componentName = 'LiveUpload'
+  static defaultState = {
+    status: 'idle',
+    progress: 0,
+    fileName: '',
+    fileSize: 0,
+    fileType: '',
+    fileUrl: '',
+    bytesUploaded: 0,
+    totalBytes: 0,
+    error: null
+  }
+  static publicActions = ['startUpload', 'updateProgress', 'completeUpload', 'failUpload', 'reset']
+}

package/app/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-04-11T19:00:17.642Z
+// Generated at: 2026-04-12T17:15:28.136Z
 
 import { LiveAdminPanel } from "./LiveAdminPanel"
 import { LiveCounter } from "./LiveCounter"

package/core/utils/version.ts

@@ -1,6 +1,6 @@
-/**
- * FluxStack Framework Version
- * Single source of truth for version number
- * Auto-synced with package.json
- */
-export const FLUXSTACK_VERSION = '1.19.0'
+/**
+ * FluxStack Framework Version
+ * Single source of truth for version number
+ * Auto-synced with package.json
+ */
+export const FLUXSTACK_VERSION = '1.20.1'