@lego-box/shell 1.0.5 → 1.0.7

package/src/piral/api.ts

@@ -0,0 +1,39 @@
+import type { PiralPlugin } from 'piral';
+import PocketBase from 'pocketbase';
+import type { PiletPocketBaseApi } from '../types';
+
+export interface PocketBaseConfig {
+  url: string;
+}
+
+export interface PocketBasePluginOptions {
+  /** PocketBase server URL (used to create a new instance if pb is not provided). */
+  url?: string;
+  /** Existing PocketBase instance (e.g. shared with auth plugin). */
+  pb?: PocketBase;
+}
+
+/**
+ * Creates a Piral plugin that exposes a single PocketBase instance to all pilets.
+ * Pilets use app.pocketbase for data and app.test.getTesting() for connectivity checks.
+ * Pass an existing pb instance to share it with the auth plugin.
+ */
+export function createPocketBasePlugin(
+  config: PocketBaseConfig | PocketBasePluginOptions
+): PiralPlugin<PiletPocketBaseApi> {
+  const pb =
+    'pb' in config && config.pb
+      ? config.pb
+      : new PocketBase((config as PocketBaseConfig).url);
+
+  // When creating our own pb we don't call loadFromCookie; default store uses localStorage.
+  // When pb is passed from shell, the shell owns the instance and does not load from cookie.
+
+  return () => (_api: unknown, _target: unknown) => ({
+    pocketbase: pb,
+    test: {
+      getTesting: () =>
+        'Hello from PocketBase plugin! This validates the wrapper is working.',
+    },
+  });
+}

package/src/piral/auth-casl.ts

@@ -0,0 +1,56 @@
+import * as React from 'react';
+import type { PiralPlugin } from 'piral';
+import type { PiletAuthObject, PiletCaslApi } from '../types';
+import { getRoleName, getPermissions, can } from '../auth/auth-store';
+import { ProtectedPage } from '../components/ProtectedPage';
+
+/**
+ * Creates a Piral plugin that exposes auth, casl, and registerProtectedPage to pilets.
+ * Pilets use app.auth.getId(), app.auth.getRole(), app.auth.can(), app.casl.can(), etc.
+ * Use registerProtectedPage for route-level permission guards (same as core ProtectedPage).
+ *
+ * Requires: auth plugin (for getUser, login, logout) and AbilityProvider (for CASL data).
+ */
+export function createAuthCaslPlugin(): PiralPlugin<{
+  auth: PiletAuthObject;
+  casl: PiletCaslApi;
+  registerProtectedPage: (
+    route: string,
+    Component: React.ComponentType,
+    options: { action: string; subject: string }
+  ) => void;
+}> {
+  return () => (api) => ({
+    auth: {
+      getId: () => api.getUserId?.() ?? null,
+      getEmail: () => api.getUser?.()?.email ?? null,
+      getRole: () => getRoleName(),
+      getPermissions: () => getPermissions(),
+      can: (action: string, subject: string) => can(action, subject),
+      getUser: () => api.getUser?.(),
+      isAuthenticated: () => api.isAuthenticated?.() ?? false,
+      login: (email: string, password: string) =>
+        api.login?.(email, password) ?? Promise.reject(new Error('Login not available')),
+      logout: () => {
+        if (typeof api.logout === 'function') api.logout();
+      },
+    },
+    casl: {
+      can: (action: string, subject: string) => can(action, subject),
+    },
+    registerProtectedPage(
+      route: string,
+      Component: React.ComponentType,
+      options: { action: string; subject: string }
+    ) {
+      const { action, subject } = options;
+      const Wrapped = () =>
+        React.createElement(
+          ProtectedPage,
+          { action, subject },
+          React.createElement(Component, null)
+        );
+      api.registerPage(route, Wrapped);
+    },
+  });
+}

package/src/piral/menu.ts

@@ -0,0 +1,102 @@
+import * as React from 'react';
+import type { PiralPlugin } from 'piral';
+import type { PiletMenuItem, PiletMenuApi } from '../types';
+
+// Module-level store for menu items
+let menuItems: PiletMenuItem[] = [];
+const listeners = new Set<() => void>();
+
+// Notify all subscribers of changes
+function notifyListeners() {
+  listeners.forEach((listener) => listener());
+}
+
+/**
+ * Get current menu items
+ */
+export function getPiletMenus(): PiletMenuItem[] {
+  return menuItems;
+}
+
+/**
+ * Subscribe to menu changes
+ * Returns unsubscribe function
+ */
+export function subscribeToMenus(callback: () => void): () => void {
+  listeners.add(callback);
+  return () => listeners.delete(callback);
+}
+
+/**
+ * Creates a Piral plugin that exposes menu registration API to all pilets.
+ * Pilets use app.registerMenu() to add sidebar menu items and app.unregisterMenu() to remove them.
+ *
+ * Example usage in pilet:
+ * ```tsx
+ * export function setup(context: PiletContext) {
+ *   // Register a single menu item
+ *   context.registerSidebarMenu({
+ *     id: 'my-feature',
+ *     label: 'My Feature',
+ *     href: '/my-feature',
+ *     icon: <Icon />
+ *   });
+ *
+ *   // Register a menu with children
+ *   context.registerSidebarMenu({
+ *     id: 'parent-menu',
+ *     label: 'Parent Menu',
+ *     icon: <Icon />,
+ *     children: [
+ *       { id: 'child-1', label: 'Child 1', href: '/child-1' },
+ *       { id: 'child-2', label: 'Child 2', href: '/child-2' }
+ *     ]
+ *   });
+ *
+ *   // Unregister when no longer needed
+ *   context.unregisterSidebarMenu('my-feature');
+ * }
+ * ```
+ */
+export function createMenuPlugin(): PiralPlugin<PiletMenuApi> {
+  return () => {
+    return {
+      registerSidebarMenu(menuItem: PiletMenuItem) {
+        // Check if menu already exists
+        const existingIndex = menuItems.findIndex((m) => m.id === menuItem.id);
+
+        if (existingIndex >= 0) {
+          // Update existing menu
+          menuItems = [...menuItems];
+          menuItems[existingIndex] = menuItem;
+        } else {
+          // Add new menu
+          menuItems = [...menuItems, menuItem];
+        }
+
+        notifyListeners();
+        console.log('[MenuPlugin] Registered menu:', menuItem.id);
+      },
+
+      unregisterSidebarMenu(id: string) {
+        menuItems = menuItems.filter((m) => m.id !== id);
+        notifyListeners();
+        console.log('[MenuPlugin] Unregistered menu:', id);
+      },
+    };
+  };
+}
+
+/**
+ * Hook to get pilet menus with subscription
+ * This ensures the component re-renders when menus change
+ */
+export function usePiletMenus(): PiletMenuItem[] {
+  const [, forceUpdate] = React.useReducer((x) => x + 1, 0);
+
+  React.useEffect(() => {
+    return subscribeToMenus(forceUpdate);
+  }, []);
+
+  return menuItems;
+}

package/src/piral/piral.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://schemas.piral.io/piral/v1",
+  "plugins": []
+}

package/src/services/telemetry.ts

@@ -0,0 +1,84 @@
+/**
+ * Telemetry Service
+ *
+ * Handles tracking of user activities.
+ * Integrates with PocketBase for data storage.
+ */
+
+import PocketBase from 'pocketbase';
+
+/** Generate a unique session ID */
+export function generateSessionId(): string {
+  return `session_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+
+/**
+ * Start a user session (track session start in PocketBase if collection exists)
+ */
+export async function startUserSession(
+  pocketbase: PocketBase,
+  userId: string,
+  sessionId: string,
+  meta?: { userAgent?: string }
+): Promise<void> {
+  try {
+    await pocketbase.collection('user_sessions').create({
+      user_id: userId,
+      session_id: sessionId,
+      started_at: new Date().toISOString(),
+      user_agent: meta?.userAgent,
+    });
+  } catch {
+    // Collection may not exist yet - ignore
+  }
+}
+
+/**
+ * End a user session (update session end time in PocketBase if collection exists)
+ */
+export async function endUserSession(
+  pocketbase: PocketBase,
+  sessionId: string
+): Promise<void> {
+  try {
+    const records = await pocketbase.collection('user_sessions').getList(1, 1, {
+      filter: `session_id="${sessionId}"`,
+    });
+    if (records.items.length > 0) {
+      await pocketbase.collection('user_sessions').update(records.items[0].id, {
+        ended_at: new Date().toISOString(),
+      });
+    }
+  } catch {
+    // Collection may not exist yet - ignore
+  }
+}
+
+/**
+ * Track a user login event
+ */
+export async function trackUserLogin(
+  pocketbase: PocketBase,
+  data: {
+    userId?: string;
+    emailAttempted?: string;
+    success: boolean;
+    failureReason?: string;
+    ipAddress?: string;
+    userAgent?: string;
+  }
+): Promise<void> {
+  try {
+    await pocketbase.collection('user_logins').create({
+      user_id: data.userId,
+      email_attempted: data.emailAttempted,
+      timestamp: new Date().toISOString(),
+      success: data.success,
+      failure_reason: data.failureReason,
+      ip_address: data.ipAddress,
+      user_agent: data.userAgent,
+    });
+  } catch (error) {
+    console.error('[Telemetry] Failed to track login:', error);
+  }
+}