create-lego-one 2.0.9 → 2.0.12

package/template/host/src/kernel/auth/hooks.ts

@@ -0,0 +1,174 @@
+import { useCallback, useEffect, useState } from 'react';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { usePocketBase } from '../providers';
+import { AuthService } from './service';
+import type { LoginCredentials, RegisterData, User } from './types';
+import { useGlobalKernelState } from '../shared-state';
+
+/**
+ * Get auth service instance
+ */
+function useAuthService(): AuthService | null {
+  const pb = usePocketBase();
+  if (!pb) return null;
+  return new AuthService(pb);
+}
+
+/**
+ * Main auth hook - provides auth state and actions
+ */
+export function useAuth() {
+  const pb = usePocketBase();
+  const queryClient = useQueryClient();
+  const { setUser, setToken, clearAuth, setIsLoading } = useGlobalKernelState();
+  const [authService, setAuthService] = useState<AuthService | null>(null);
+
+  // Initialize auth service
+  useEffect(() => {
+    if (pb) {
+      setAuthService(new AuthService(pb));
+
+      // Restore session from PocketBase auth store
+      if (pb.authStore.isValid && pb.authStore.model) {
+        setUser({
+          id: pb.authStore.model.id,
+          email: pb.authStore.model.email,
+          name: pb.authStore.model.name || pb.authStore.model.email,
+          avatar: pb.authStore.model.avatar,
+          role: pb.authStore.model.role,
+          organizationId: pb.authStore.model.organizationId,
+        });
+        setToken(pb.authStore.token);
+      }
+
+      setIsLoading(false);
+    }
+  }, [pb, setUser, setToken, setIsLoading]);
+
+  // Listen to auth state changes
+  useEffect(() => {
+    if (!pb) return;
+
+    const unsubscribe = pb.authStore.onChange((token, model) => {
+      if (model && token) {
+        setUser({
+          id: model.id,
+          email: model.email,
+          name: model.name || model.email,
+          avatar: model.avatar,
+          role: model.role,
+          organizationId: model.organizationId,
+        });
+        setToken(token);
+      } else {
+        clearAuth();
+      }
+    });
+
+    return unsubscribe;
+  }, [pb, setUser, setToken, clearAuth]);
+
+  const loginMutation = useMutation({
+    mutationFn: async (credentials: LoginCredentials) => {
+      if (!authService) throw new Error('Auth service not initialized');
+      return authService.login(credentials);
+    },
+    onSuccess: (data) => {
+      setUser(data.user);
+      setToken(data.token);
+      queryClient.invalidateQueries({ queryKey: ['auth', 'user'] });
+    },
+  });
+
+  const registerMutation = useMutation({
+    mutationFn: async (data: { registerData: RegisterData; organizationId?: string }) => {
+      if (!authService) throw new Error('Auth service not initialized');
+      return authService.register(data.registerData, data.organizationId);
+    },
+    onSuccess: (data) => {
+      setUser(data.user);
+      setToken(data.token);
+      queryClient.invalidateQueries({ queryKey: ['auth', 'user'] });
+    },
+  });
+
+  const logoutMutation = useMutation({
+    mutationFn: async () => {
+      if (!authService) throw new Error('Auth service not initialized');
+      return authService.logout();
+    },
+    onSuccess: () => {
+      clearAuth();
+      queryClient.clear();
+    },
+  });
+
+  const login = useCallback(
+    (credentials: LoginCredentials) => {
+      return loginMutation.mutateAsync(credentials);
+    },
+    [loginMutation]
+  );
+
+  const register = useCallback(
+    (registerData: RegisterData, organizationId?: string) => {
+      return registerMutation.mutateAsync({ registerData: registerData, organizationId });
+    },
+    [registerMutation]
+  );
+
+  const logout = useCallback(() => {
+    return logoutMutation.mutateAsync();
+  }, [logoutMutation]);
+
+  return {
+    user: authService?.getCurrentUser() || null,
+    isAuthenticated: !!pb?.authStore.isValid,
+    isLoading: loginMutation.isPending || registerMutation.isPending || logoutMutation.isPending,
+    login,
+    register,
+    logout,
+    error: loginMutation.error || registerMutation.error || logoutMutation.error,
+  };
+}
+
+/**
+ * Get current user data
+ */
+export function useCurrentUser() {
+  const { user, isAuthenticated } = useAuth();
+
+  const { data: currentUser, isLoading } = useQuery({
+    queryKey: ['auth', 'user'],
+    queryFn: () => Promise.resolve(user),
+    enabled: isAuthenticated,
+    staleTime: Infinity,
+  });
+
+  return {
+    user: currentUser,
+    isLoading,
+    isAuthenticated,
+  };
+}
+
+/**
+ * Require authentication - redirect if not logged in
+ */
+export function useRequireAuth() {
+  const { isAuthenticated, isLoading, user } = useAuth();
+  const [shouldRedirect, setShouldRedirect] = useState(false);
+
+  useEffect(() => {
+    if (!isLoading && !isAuthenticated) {
+      setShouldRedirect(true);
+    }
+  }, [isLoading, isAuthenticated]);
+
+  return {
+    user,
+    isAuthenticated,
+    isLoading,
+    shouldRedirect,
+  };
+}

package/template/host/src/kernel/auth/index.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './schemas';
+export * from './service';
+export * from './hooks';
+export * from './ProtectedRoute';

package/template/host/src/kernel/auth/schemas.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+
+export const loginSchema = z.object({
+  email: z.string().email('Invalid email address'),
+  password: z.string().min(8, 'Password must be at least 8 characters'),
+});
+
+export type LoginFormData = z.infer<typeof loginSchema>;
+
+export const registerSchema = z
+  .object({
+    email: z.string().email('Invalid email address'),
+    password: z
+      .string()
+      .min(8, 'Password must be at least 8 characters')
+      .regex(/[A-Z]/, 'Password must contain at least one uppercase letter')
+      .regex(/[a-z]/, 'Password must contain at least one lowercase letter')
+      .regex(/[0-9]/, 'Password must contain at least one number'),
+    passwordConfirm: z.string(),
+    name: z.string().min(2, 'Name must be at least 2 characters'),
+  })
+  .refine((data) => data.password === data.passwordConfirm, {
+    message: 'Passwords do not match',
+    path: ['passwordConfirm'],
+  });
+
+export type RegisterFormData = z.infer<typeof registerSchema>;

package/template/host/src/kernel/auth/service.ts

@@ -0,0 +1,197 @@
+import PocketBase from 'pocketbase';
+import type { LoginCredentials, RegisterData, User, AuthResponse, AuthError } from './types';
+
+// Map PocketBase auth record to our User type
+function mapAuthRecordToUser(record: any): User {
+  return {
+    id: record.id,
+    email: record.email,
+    name: record.name || record.email,
+    avatar: record.avatar,
+    role: record.role,
+    organizationId: record.organizationId,
+  };
+}
+
+export class AuthService {
+  constructor(private pb: PocketBase) {}
+
+  /**
+   * Login with email and password
+   */
+  async login(credentials: LoginCredentials): Promise<AuthResponse> {
+    try {
+      const authData = await this.pb.collection('users').authWithPassword(
+        credentials.email,
+        credentials.password
+      );
+
+      return {
+        token: authData.token,
+        user: mapAuthRecordToUser(authData.record),
+      };
+    } catch (error: any) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Register new user (admin only in our system)
+   */
+  async register(data: RegisterData, organizationId?: string): Promise<AuthResponse> {
+    try {
+      const record = await this.pb.collection('users').create({
+        email: data.email,
+        password: data.password,
+        passwordConfirm: data.passwordConfirm,
+        name: data.name,
+        organizationId,
+        role: 'member', // Default role
+      });
+
+      // Auto-login after registration
+      const authData = await this.pb.collection('users').authWithPassword(
+        data.email,
+        data.password
+      );
+
+      return {
+        token: authData.token,
+        user: mapAuthRecordToUser(authData.record),
+      };
+    } catch (error: any) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Logout current user
+   */
+  async logout(): Promise<void> {
+    this.pb.authStore.clear();
+    localStorage.removeItem('pocketbase_auth');
+  }
+
+  /**
+   * Get current authenticated user
+   */
+  getCurrentUser(): User | null {
+    if (!this.pb.authStore.isValid) return null;
+
+    const model = this.pb.authStore.model;
+    if (!model) return null;
+
+    return mapAuthRecordToUser(model);
+  }
+
+  /**
+   * Get current auth token
+   */
+  getToken(): string | null {
+    return this.pb.authStore.token;
+  }
+
+  /**
+   * Refresh auth token
+   */
+  async refreshToken(): Promise<string> {
+    try {
+      // PocketBase handles token refresh automatically
+      // This is a no-op but kept for interface consistency
+      return this.pb.authStore.token;
+    } catch (error: any) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Update user profile
+   */
+  async updateProfile(userId: string, data: Partial<User>): Promise<User> {
+    try {
+      const record = await this.pb.collection('users').update(userId, {
+        name: data.name,
+        avatar: data.avatar,
+      });
+
+      return mapAuthRecordToUser(record);
+    } catch (error: any) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Change password
+   */
+  async changePassword(oldPassword: string, newPassword: string): Promise<void> {
+    try {
+      const model = this.pb.authStore.model as any;
+      await this.pb.collection('users').update(model?.id, {
+        oldPassword,
+        password: newPassword,
+        passwordConfirm: newPassword,
+      });
+    } catch (error: any) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Request password reset
+   */
+  async requestPasswordReset(email: string): Promise<void> {
+    try {
+      await this.pb.collection('users').requestPasswordReset(email);
+    } catch (error: any) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Confirm password reset
+   */
+  async confirmPasswordReset(token: string, password: string): Promise<void> {
+    try {
+      await this.pb.collection('users').confirmPasswordReset(token, password, password);
+    } catch (error: any) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Handle PocketBase errors
+   */
+  private handleError(error: any): AuthError {
+    // PocketBase error format
+    if (error?.data?.message) {
+      return {
+        message: error.data.message,
+        code: error.status,
+      };
+    }
+
+    if (error?.message) {
+      return {
+        message: error.message,
+      };
+    }
+
+    return {
+      message: 'An unexpected error occurred',
+    };
+  }
+
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated(): boolean {
+    return this.pb.authStore.isValid;
+  }
+
+  /**
+   * Listen to auth state changes
+   */
+  onAuthChange(callback: (token: string, record: any | null) => void): () => void {
+    return this.pb.authStore.onChange(callback);
+  }
+}

package/template/host/src/kernel/auth/types.ts

@@ -0,0 +1,36 @@
+export interface LoginCredentials {
+  email: string;
+  password: string;
+}
+
+export interface RegisterData {
+  email: string;
+  password: string;
+  passwordConfirm: string;
+  name: string;
+}
+
+export interface User {
+  id: string;
+  email: string;
+  name: string;
+  avatar?: string;
+  role?: string;
+  organizationId?: string;
+}
+
+export interface AuthResponse {
+  token: string;
+  user: User;
+}
+
+export interface AuthError {
+  message: string;
+  code?: number;
+}
+
+export interface SessionData {
+  token: string;
+  user: User;
+  organizationId?: string;
+}

package/template/host/src/kernel/channels/ChannelBus.ts

@@ -0,0 +1,181 @@
+import Garfish from 'garfish';
+import type {
+  ChannelName,
+  ChannelMessage,
+  ChannelSubscriber,
+  ChannelAPI,
+} from './types';
+
+/**
+ * ChannelBus - Singleton service for inter-plugin communication using Garfish channels
+ */
+class ChannelBus implements ChannelAPI {
+  private garfishInstance: typeof Garfish | null = null;
+  private subscribers: Map<ChannelName, Set<ChannelSubscriber>> = new Map();
+  private initialized = false;
+
+  /**
+   * Initialize the channel bus with Garfish instance
+   */
+  initialize(garfish: typeof Garfish): void {
+    if (this.initialized) {
+      console.warn('[ChannelBus] Already initialized');
+      return;
+    }
+
+    this.garfishInstance = garfish;
+    this.initialized = true;
+
+    console.log('[ChannelBus] Initialized');
+  }
+
+  /**
+   * Publish a message to a channel
+   */
+  publish<T extends ChannelMessage>(message: T): void {
+    if (!this.initialized || !this.garfishInstance) {
+      console.warn('[ChannelBus] Not initialized, cannot publish message');
+      return;
+    }
+
+    const { channel, data } = message;
+
+    // Add metadata
+    const enrichedData = {
+      ...data,
+      id: data.id || this.generateId(),
+      timestamp: data.timestamp || Date.now(),
+      source: data.source || 'host',
+    };
+
+    // Publish via Garfish channel
+    try {
+      this.garfishInstance.channel.emit(channel, enrichedData);
+    } catch (error) {
+      console.error('[ChannelBus] Failed to publish message:', error);
+    }
+
+    // Also notify local subscribers (in same app context)
+    const channelSubscribers = this.subscribers.get(channel);
+    if (channelSubscribers) {
+      channelSubscribers.forEach((callback) => {
+        try {
+          callback({ channel, data: enrichedData } as T);
+        } catch (error) {
+          console.error('[ChannelBus] Subscriber callback error:', error);
+        }
+      });
+    }
+  }
+
+  /**
+   * Subscribe to a channel
+   * Returns unsubscribe function
+   */
+  subscribe<T extends ChannelMessage>(
+    channel: ChannelName,
+    callback: ChannelSubscriber<T>
+  ): () => void {
+    if (!this.initialized || !this.garfishInstance) {
+      console.warn('[ChannelBus] Not initialized, subscription may not work');
+    }
+
+    // Add to local subscribers
+    if (!this.subscribers.has(channel)) {
+      this.subscribers.set(channel, new Set());
+    }
+    this.subscribers.get(channel)!.add(callback as ChannelSubscriber);
+
+    // Also subscribe to Garfish channel for cross-app communication
+    if (this.garfishInstance) {
+      try {
+        this.garfishInstance.channel.on(channel, callback as any);
+      } catch (error) {
+        console.error('[ChannelBus] Failed to subscribe to Garfish channel:', error);
+      }
+    }
+
+    console.log(`[ChannelBus] Subscribed to channel: ${channel}`);
+
+    // Return unsubscribe function
+    return () => this.unsubscribe(channel, callback as ChannelSubscriber);
+  }
+
+  /**
+   * Unsubscribe from a channel
+   */
+  unsubscribe(channel: ChannelName, callback: ChannelSubscriber): void {
+    // Remove from local subscribers
+    const channelSubscribers = this.subscribers.get(channel);
+    if (channelSubscribers) {
+      channelSubscribers.delete(callback);
+    }
+
+    // Also unsubscribe from Garfish channel
+    if (this.garfishInstance) {
+      try {
+        this.garfishInstance.channel.off(channel, callback as any);
+      } catch (error) {
+        console.error('[ChannelBus] Failed to unsubscribe from Garfish channel:', error);
+      }
+    }
+
+    console.log(`[ChannelBus] Unsubscribed from channel: ${channel}`);
+  }
+
+  /**
+   * Unsubscribe all from a channel
+   */
+  unsubscribeAll(channel: ChannelName): void {
+    const channelSubscribers = this.subscribers.get(channel);
+    if (channelSubscribers) {
+      channelSubscribers.forEach((callback) => {
+        if (this.garfishInstance) {
+          this.garfishInstance.channel.off(channel, callback as any);
+        }
+      });
+      channelSubscribers.clear();
+    }
+  }
+
+  /**
+   * Clear all subscribers
+   */
+  clear(): void {
+    this.subscribers.forEach((_, channel) => {
+      this.unsubscribeAll(channel);
+    });
+    this.subscribers.clear();
+  }
+
+  /**
+   * Generate unique ID for events
+   */
+  private generateId(): string {
+    return `evt_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  /**
+   * Get list of active channels
+   */
+  getActiveChannels(): ChannelName[] {
+    return Array.from(this.subscribers.keys());
+  }
+
+  /**
+   * Get subscriber count for a channel
+   */
+  getSubscriberCount(channel: ChannelName): number {
+    return this.subscribers.get(channel)?.size || 0;
+  }
+}
+
+// Export singleton instance
+export const channelBus = new ChannelBus();
+
+/**
+ * Initialize channel bus (call from host bootstrap)
+ */
+export function initializeChannelBus(garfish: typeof Garfish): void {
+  channelBus.initialize(garfish);
+}

package/template/host/src/kernel/channels/ChannelProvider.tsx

@@ -0,0 +1,57 @@
+import { useEffect } from 'react';
+import { ToastIntegration } from './integrations/ToastIntegration';
+import { useGlobalKernelState } from '../shared-state';
+import { useAuth } from '../auth/hooks';
+import { usePublish } from './hooks';
+import { ChannelName } from './types';
+
+/**
+ * ChannelProvider - Sets up all channel integrations
+ *
+ * This component:
+ * 1. Renders the ToastIntegration component
+ * 2. Publishes auth changes when authentication state changes
+ * 3. Publishes organization changes when organization changes
+ */
+export function ChannelProvider() {
+  const { user, isAuthenticated } = useAuth();
+  const { organization } = useGlobalKernelState();
+  const publish = usePublish();
+
+  // Publish auth changes
+  useEffect(() => {
+    publish({
+      channel: ChannelName.AUTH_CHANGE,
+      data: {
+        isAuthenticated,
+        userId: user?.id,
+        organizationId: organization?.id,
+        id: `auth_${Date.now()}`,
+        timestamp: Date.now(),
+        source: 'host',
+      },
+    });
+  }, [isAuthenticated, user?.id, organization?.id, publish]);
+
+  // Publish organization changes
+  useEffect(() => {
+    if (organization) {
+      publish({
+        channel: ChannelName.ORGANIZATION_CHANGE,
+        data: {
+          organizationId: organization.id,
+          organizationName: organization.name,
+          id: `org_${Date.now()}`,
+          timestamp: Date.now(),
+          source: 'host',
+        },
+      });
+    }
+  }, [organization, publish]);
+
+  return (
+    <>
+      <ToastIntegration />
+    </>
+  );
+}

package/template/host/src/kernel/channels/events.ts

@@ -0,0 +1,27 @@
+/**
+ * Event constants for type-safe event publishing
+ */
+export const Events = {
+  TOAST: {
+    SUCCESS: (title: string, description?: string) => ({
+      type: 'success' as const,
+      title,
+      description,
+    }),
+    ERROR: (title: string, description?: string) => ({
+      type: 'error' as const,
+      title,
+      description,
+    }),
+    INFO: (title: string, description?: string) => ({
+      type: 'info' as const,
+      title,
+      description,
+    }),
+    WARNING: (title: string, description?: string) => ({
+      type: 'warning' as const,
+      title,
+      description,
+    }),
+  },
+} as const;