@qwickapps/server 1.7.0 → 1.7.2

package/src/plugins/usage/usage-plugin.ts

@@ -17,6 +17,8 @@ import type {
   UsageStatus,
   UsageSummary,
 } from './types.js';
+import { hasPostgres, getPostgres } from '../postgres-plugin.js';
+import { postgresUsageStore } from './stores/index.js';
 
 // Import subscription helpers if available
 let getFeatureLimitFn: ((userId: string, featureCode: string) => Promise<number | null>) | null = null;
@@ -44,15 +46,18 @@ function getTomorrowMidnight(): Date {
 }
 
 /**
- * Create the Usage plugin
+ * Create the Usage plugin with smart defaults
+ *
+ * Config is optional - plugin will use defaults and get dependencies from registry.
+ * Gracefully handles missing dependencies with clear log messages.
  */
-export function createUsagePlugin(config: UsagePluginConfig): Plugin {
-  const debug = config.debug || false;
-  const apiPrefix = config.api?.prefix || '/'; // Framework adds /usage prefix automatically
-
-  function log(message: string, data?: Record<string, unknown>) {
-    if (debug) {
-      console.log(`[UsagePlugin] ${message}`, data || '');
+export function createUsagePlugin(config: Partial<UsagePluginConfig> = {}): Plugin {
+  function log(message: string, data?: Record<string, unknown>, isError = false) {
+    const prefix = '[UsagePlugin]';
+    if (isError) {
+      console.error(`${prefix} ${message}`, data || '');
+    } else if (config.debug) {
+      console.log(`${prefix} ${message}`, data || '');
     }
   }
 
@@ -62,15 +67,48 @@ export function createUsagePlugin(config: UsagePluginConfig): Plugin {
     version: '1.0.0',
 
     async onStart(_pluginConfig: PluginConfig, registry: PluginRegistry): Promise<void> {
+      const logger = registry.getLogger('usage');
+
+      // Check for postgres in registry
+      if (!hasPostgres()) {
+        logger.warn('No Database! Usage plugin disabled.');
+        registry.registerHealthCheck({
+          name: 'usage-store',
+          type: 'custom',
+          check: async () => ({
+            healthy: false,
+            details: {
+              error: 'PostgreSQL not available',
+              state: 'disabled',
+            },
+          }),
+        });
+        return;
+      }
+
+      // Smart defaults - get dependencies from registry
+      const store = config.store ?? postgresUsageStore({
+        pool: () => getPostgres().getPool(),
+        autoCreateTables: true,
+      });
+
+      const debug = config.debug ?? false;
+      const apiPrefix = config.api?.prefix ?? '/'; // Framework adds /usage prefix automatically
+      const apiEnabled = config.api?.enabled ?? true;
+      const dailyRetentionDays = config.cleanup?.dailyRetentionDays ?? 90;
+      const monthlyRetentionMonths = config.cleanup?.monthlyRetentionMonths ?? 24;
+      const runOnStartup = config.cleanup?.runOnStartup ?? false;
+      const cleanupIntervalHours = config.cleanup?.cleanupIntervalHours ?? 0;
+
       log('Starting usage plugin');
 
       // Initialize the store (creates tables if needed)
-      await config.store.initialize();
+      await store.initialize();
       log('Usage plugin migrations complete');
 
       // Store references for helper access
-      currentStore = config.store;
-      currentConfig = config;
+      currentStore = store;
+      currentConfig = { ...config, store, debug };
 
       // Try to get the feature limit function from subscriptions plugin
       try {
@@ -96,25 +134,19 @@ export function createUsagePlugin(config: UsagePluginConfig): Plugin {
       });
 
       // Run cleanup on startup if configured
-      if (config.cleanup?.runOnStartup) {
-        const dailyDays = config.cleanup.dailyRetentionDays || 90;
-        const monthlyMonths = config.cleanup.monthlyRetentionMonths || 24;
-
-        const dailyDeleted = await config.store.cleanupOldDaily(dailyDays);
-        const monthlyDeleted = await config.store.cleanupOldMonthly(monthlyMonths);
+      if (runOnStartup) {
+        const dailyDeleted = await store.cleanupOldDaily(dailyRetentionDays);
+        const monthlyDeleted = await store.cleanupOldMonthly(monthlyRetentionMonths);
         log('Startup cleanup complete', { dailyDeleted, monthlyDeleted });
       }
 
       // Set up periodic cleanup if configured
-      if (config.cleanup?.cleanupIntervalHours && config.cleanup.cleanupIntervalHours > 0) {
-        const intervalMs = config.cleanup.cleanupIntervalHours * 60 * 60 * 1000;
+      if (cleanupIntervalHours > 0) {
+        const intervalMs = cleanupIntervalHours * 60 * 60 * 1000;
         cleanupIntervalId = setInterval(async () => {
           try {
-            const dailyDays = config.cleanup?.dailyRetentionDays || 90;
-            const monthlyMonths = config.cleanup?.monthlyRetentionMonths || 24;
-
-            const dailyDeleted = await config.store.cleanupOldDaily(dailyDays);
-            const monthlyDeleted = await config.store.cleanupOldMonthly(monthlyMonths);
+            const dailyDeleted = await store.cleanupOldDaily(dailyRetentionDays);
+            const monthlyDeleted = await store.cleanupOldMonthly(monthlyRetentionMonths);
             log('Periodic cleanup complete', { dailyDeleted, monthlyDeleted });
           } catch (error) {
             console.error('[UsagePlugin] Cleanup error:', error);
@@ -123,7 +155,7 @@ export function createUsagePlugin(config: UsagePluginConfig): Plugin {
       }
 
       // Add API routes if enabled
-      if (config.api?.enabled !== false) {
+      if (apiEnabled) {
         // Get daily usage summary
         registry.addRoute({
           method: 'get',
@@ -211,7 +243,9 @@ export function createUsagePlugin(config: UsagePluginConfig): Plugin {
         cleanupIntervalId = null;
       }
 
-      await config.store.shutdown();
+      if (currentStore) {
+        await currentStore.shutdown();
+      }
       currentStore = null;
       currentConfig = null;
       log('Usage plugin stopped');

package/src/plugins/users/index.ts

@@ -41,4 +41,4 @@ export type {
 } from './types.js';
 
 // Stores
-export { postgresUserStore } from './stores/index.js';
+export { postgresUserStore, inMemoryUserStore } from './stores/index.js';

package/src/plugins/users/stores/in-memory-store.ts

@@ -0,0 +1,140 @@
+/**
+ * In-memory User Store for Demo/Testing
+ *
+ * Implements the UserStore interface with in-memory storage.
+ * Pre-populated with demo users for testing and showcase purposes.
+ */
+
+export function createInMemoryUserStore() {
+  const users = new Map<string, any>();
+  let idCounter = 1;
+
+  // Pre-populate demo users
+  const demoUsers = [
+    { email: 'demo@example.com', name: 'Demo User' },
+    { email: 'pro@example.com', name: 'Pro User' },
+    { email: 'enterprise@example.com', name: 'Enterprise User' },
+    { email: 'basic@example.com', name: 'Basic User' },
+  ];
+
+  demoUsers.forEach((u) => {
+    const id = String(idCounter++);
+    users.set(id, {
+      id,
+      email: u.email,
+      name: u.name,
+      created_at: new Date(),
+      updated_at: new Date(),
+    });
+  });
+
+  return {
+    name: 'in-memory',
+
+    async initialize() {
+      console.log('[InMemoryUserStore] Initialized with demo users');
+    },
+
+    async getById(id: string) {
+      return users.get(id) || null;
+    },
+
+    async getByEmail(email: string) {
+      for (const user of users.values()) {
+        if (user.email === email.toLowerCase()) {
+          return user;
+        }
+      }
+      return null;
+    },
+
+    async getByExternalId(externalId: string, provider: string) {
+      for (const user of users.values()) {
+        if (user.external_id === externalId && user.provider === provider) {
+          return user;
+        }
+      }
+      return null;
+    },
+
+    async create(input: any) {
+      const id = String(idCounter++);
+      const user = {
+        id,
+        email: input.email.toLowerCase(),
+        name: input.name || null,
+        external_id: input.external_id,
+        provider: input.provider,
+        picture: input.picture,
+        created_at: new Date(),
+        updated_at: new Date(),
+        metadata: input.metadata || {},
+      };
+      users.set(id, user);
+      return user;
+    },
+
+    async update(id: string, input: any) {
+      const user = users.get(id);
+      if (!user) return null;
+      Object.assign(user, input, { updated_at: new Date() });
+      return user;
+    },
+
+    async delete(id: string) {
+      return users.delete(id);
+    },
+
+    async search(params: any = {}) {
+      let result = Array.from(users.values());
+
+      if (params.query) {
+        const query = params.query.toLowerCase();
+        result = result.filter(
+          (u) =>
+            u.email.toLowerCase().includes(query) ||
+            (u.name && u.name.toLowerCase().includes(query))
+        );
+      }
+
+      if (params.provider) {
+        result = result.filter((u) => u.provider === params.provider);
+      }
+
+      const sortBy = params.sortBy || 'created_at';
+      const sortOrder = params.sortOrder || 'desc';
+      result.sort((a, b) => {
+        const aVal = a[sortBy];
+        const bVal = b[sortBy];
+        if (aVal < bVal) return sortOrder === 'asc' ? -1 : 1;
+        if (aVal > bVal) return sortOrder === 'asc' ? 1 : -1;
+        return 0;
+      });
+
+      const total = result.length;
+      const page = params.page || 1;
+      const limit = params.limit || 20;
+      const offset = (page - 1) * limit;
+      result = result.slice(offset, offset + limit);
+
+      return {
+        users: result,
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      };
+    },
+
+    async updateLastLogin(id: string) {
+      const user = users.get(id);
+      if (user) {
+        user.last_login_at = new Date();
+      }
+    },
+
+    async shutdown() {
+      console.log('[InMemoryUserStore] Shutdown');
+    },
+  };
+}

package/src/plugins/users/stores/index.ts

@@ -5,3 +5,4 @@
  */
 
 export { postgresUserStore } from './postgres-store.js';
+export { createInMemoryUserStore as inMemoryUserStore } from './in-memory-store.js';

package/src/plugins/users/types.ts

@@ -269,10 +269,15 @@ export interface UsersUiConfig {
 
 /**
  * Users plugin configuration
+ *
+ * All properties are optional - plugin will use smart defaults:
+ * - store: Postgres user store using registry's postgres instance
+ * - api.prefix: '/users'
+ * - debug: false
  */
 export interface UsersPluginConfig {
-  /** User storage backend */
-  store: UserStore;
+  /** User storage backend (default: postgres user store from registry) */
+  store?: UserStore;
   /** Sync configuration (optional) */
   sync?: UserSyncConfig;
   /** API configuration */

package/src/plugins/users/users-plugin.ts

@@ -30,22 +30,26 @@ import { getEntitlements } from '../entitlements/entitlements-plugin.js';
 import { getPreferences } from '../preferences/preferences-plugin.js';
 import { getActiveBan } from '../bans/bans-plugin.js';
 import { autoCreateUserTenant } from '../tenants/index.js';
+import { hasPostgres, getPostgres } from '../postgres-plugin.js';
+import { postgresUserStore } from './stores/index.js';
 
 // Store instance for helper access
 let currentStore: UserStore | null = null;
 let currentRegistry: PluginRegistry | null = null;
 
 /**
- * Create the Users plugin
+ * Create the Users plugin with smart defaults
+ *
+ * Config is optional - plugin will use defaults and get dependencies from registry.
+ * Gracefully handles missing dependencies with clear log messages.
  */
-export function createUsersPlugin(config: UsersPluginConfig): Plugin {
-  const debug = config.debug || false;
-  // Routes are mounted under /api by the control panel, so don't include /api in prefix
-  const apiPrefix = config.api?.prefix || '/'; // Framework adds /users prefix automatically
-
-  function log(message: string, data?: Record<string, unknown>) {
-    if (debug) {
-      console.log(`[UsersPlugin] ${message}`, data || '');
+export function createUsersPlugin(config: Partial<UsersPluginConfig> = {}): Plugin {
+  function log(message: string, data?: Record<string, unknown>, isError = false) {
+    const prefix = '[UsersPlugin]';
+    if (isError) {
+      console.error(`${prefix} ${message}`, data || '');
+    } else if (config.debug) {
+      console.log(`${prefix} ${message}`, data || '');
     }
   }
 
@@ -55,14 +59,42 @@ export function createUsersPlugin(config: UsersPluginConfig): Plugin {
     version: '1.0.0',
 
     async onStart(_pluginConfig: PluginConfig, registry: PluginRegistry): Promise<void> {
+      const logger = registry.getLogger('users');
+
+      // Check for postgres in registry
+      if (!hasPostgres()) {
+        logger.warn('No Database! Users plugin disabled.');
+        registry.registerHealthCheck({
+          name: 'users-store',
+          type: 'custom',
+          check: async () => ({
+            healthy: false,
+            details: {
+              error: 'PostgreSQL not available',
+              state: 'disabled',
+            },
+          }),
+        });
+        return;
+      }
+
+      // Smart defaults - get dependencies from registry
+      const store = config.store ?? postgresUserStore({
+        pool: () => getPostgres().getPool(),
+        autoCreateTables: true,
+      });
+
+      const debug = config.debug ?? false;
+      const apiPrefix = config.api?.prefix ?? '/users';
+
       log('Starting users plugin');
 
       // Initialize the store (creates tables if needed)
-      await config.store.initialize();
+      await store.initialize();
       log('Users plugin migrations complete');
 
       // Store references for helper access
-      currentStore = config.store;
+      currentStore = store;
       currentRegistry = registry;
 
       // Register health check
@@ -72,7 +104,7 @@ export function createUsersPlugin(config: UsersPluginConfig): Plugin {
         check: async () => {
           try {
             // Simple health check - try to search with limit 1
-            await config.store.search({ limit: 1 });
+            await store.search({ limit: 1 });
             return { healthy: true };
           } catch {
             return { healthy: false };
@@ -98,7 +130,7 @@ export function createUsersPlugin(config: UsersPluginConfig): Plugin {
                 sortOrder: (req.query.sortOrder as UserSearchParams['sortOrder']) || 'desc',
               };
 
-              const result = await config.store.search(params);
+              const result = await store.search(params);
               res.json(result);
             } catch (error) {
               console.error('[UsersPlugin] Search error:', error);
@@ -114,7 +146,7 @@ export function createUsersPlugin(config: UsersPluginConfig): Plugin {
           pluginId: 'users',
           handler: async (req: Request, res: Response) => {
             try {
-              const user = await config.store.getById(req.params.id);
+              const user = await store.getById(req.params.id);
               if (!user) {
                 return res.status(404).json({ error: 'User not found' });
               }
@@ -147,12 +179,12 @@ export function createUsersPlugin(config: UsersPluginConfig): Plugin {
               }
 
               // Check if user already exists
-              const existing = await config.store.getByEmail(input.email);
+              const existing = await store.getByEmail(input.email);
               if (existing) {
                 return res.status(409).json({ error: 'User with this email already exists' });
               }
 
-              const user = await config.store.create(input);
+              const user = await store.create(input);
 
               // Auto-create personal tenant if tenants plugin available
               if (registry.hasPlugin('tenants')) {
@@ -187,7 +219,7 @@ export function createUsersPlugin(config: UsersPluginConfig): Plugin {
               }
 
               // Check if user already exists
-              const existing = await config.store.getByEmail(email);
+              const existing = await store.getByEmail(email);
               if (existing) {
                 return res.status(409).json({ error: 'User with this email already exists' });
               }
@@ -200,7 +232,7 @@ export function createUsersPlugin(config: UsersPluginConfig): Plugin {
               expiresAt.setDate(expiresAt.getDate() + 7);
 
               // Create user with invited status
-              const user = await config.store.create({
+              const user = await store.create({
                 email,
                 name,
                 metadata: role ? { role } : undefined,
@@ -251,7 +283,7 @@ export function createUsersPlugin(config: UsersPluginConfig): Plugin {
                 return res.status(400).json({ error: 'Invitation token is required' });
               }
 
-              const user = await config.store.acceptInvitation(token);
+              const user = await store.acceptInvitation(token);
 
               if (!user) {
                 return res.status(404).json({
@@ -290,7 +322,7 @@ export function createUsersPlugin(config: UsersPluginConfig): Plugin {
                 metadata: req.body.metadata,
               };
 
-              const user = await config.store.update(req.params.id, input);
+              const user = await store.update(req.params.id, input);
               if (!user) {
                 return res.status(404).json({ error: 'User not found' });
               }
@@ -309,7 +341,7 @@ export function createUsersPlugin(config: UsersPluginConfig): Plugin {
           pluginId: 'users',
           handler: async (req: Request, res: Response) => {
             try {
-              const deleted = await config.store.delete(req.params.id);
+              const deleted = await store.delete(req.params.id);
               if (!deleted) {
                 return res.status(404).json({ error: 'User not found' });
               }
@@ -328,7 +360,7 @@ export function createUsersPlugin(config: UsersPluginConfig): Plugin {
           pluginId: 'users',
           handler: async (req: Request, res: Response) => {
             try {
-              const user = await config.store.getById(req.params.id);
+              const user = await store.getById(req.params.id);
               if (!user) {
                 return res.status(404).json({ error: 'User not found' });
               }
@@ -391,7 +423,7 @@ export function createUsersPlugin(config: UsersPluginConfig): Plugin {
           pluginId: 'users',
           handler: async (_req: Request, res: Response) => {
             try {
-              const allUsers = await config.store.search({ limit: 10000 });
+              const allUsers = await store.search({ limit: 10000 });
               const now = Date.now();
               const sevenDaysAgo = now - 7 * 24 * 60 * 60 * 1000;
 
@@ -419,7 +451,7 @@ export function createUsersPlugin(config: UsersPluginConfig): Plugin {
 
     async onStop(): Promise<void> {
       log('Stopping users plugin');
-      await config.store.shutdown();
+      if (currentStore) { await currentStore.shutdown(); };
       currentStore = null;
       currentRegistry = null;
       log('Users plugin stopped');

package/src/testing/index.ts

@@ -0,0 +1 @@
+export { createPgMemPool } from './pg-mem-pool.js';

package/src/testing/pg-mem-pool.ts

@@ -0,0 +1,33 @@
+/**
+ * pg-mem Pool Adapter
+ *
+ * Provides a pg.Pool-compatible interface for pg-mem (in-memory PostgreSQL).
+ * Used by demos to run without requiring an actual PostgreSQL installation.
+ *
+ * Copyright (c) 2025 QwickApps.com. All rights reserved.
+ */
+
+import { newDb } from 'pg-mem';
+
+/**
+ * Create an in-memory PostgreSQL database with a Pool-compatible interface
+ *
+ * @returns Pool-compatible interface backed by pg-mem
+ */
+export function createPgMemPool() {
+  const db = newDb();
+
+  // Get the Pool-compatible adapter from pg-mem
+  const { Pool } = db.adapters.createPg();
+  const pool = new Pool();
+
+  // Add a fake connection string for plugins that need it (like notifications)
+  // pg-mem doesn't use connection strings, but some plugins try to extract it
+  (pool as any).options = {
+    connectionString: 'postgresql://localhost/pgmem',
+  };
+
+  console.log('[pg-mem] In-memory PostgreSQL database created');
+
+  return pool;
+}

package/ui/src/api/controlPanelApi.ts

@@ -304,9 +304,18 @@ export interface WidgetContribution {
   title: string;
   /** Component name to render (matched by frontend widget registry) */
   component: string;
+  /**
+   * Widget type/category - determines which page(s) can display this widget
+   * - 'status': System health, service status, monitoring metrics (Dashboard)
+   * - 'maintenance': Operational tasks like seeding, service control, config (Maintenance page)
+   * - 'analytics': Charts, graphs, usage metrics (Dashboard or Analytics page)
+   * - 'monitoring': Performance, logs, real-time data (Monitoring page)
+   * - 'custom': Custom widgets for specific use cases
+   */
+  type: 'status' | 'maintenance' | 'analytics' | 'monitoring' | 'custom';
   /** Priority for ordering (lower = first, default: 100) */
   priority?: number;
-  /** Whether this widget is shown by default */
+  /** Whether this widget is shown by default on its designated page */
   showByDefault?: boolean;
   pluginId: string;
 }

package/ui/src/dashboard/PluginWidgetRenderer.tsx

@@ -19,12 +19,15 @@ interface WidgetContribution {
   id: string;
   title: string;
   component: string;
+  type: 'status' | 'maintenance' | 'analytics' | 'monitoring' | 'custom';
   priority?: number;
   showByDefault?: boolean;
   pluginId: string;
 }
 
 interface PluginWidgetRendererProps {
+  /** Filter widgets by type (e.g., 'status' for dashboard, 'maintenance' for maintenance page) */
+  widgetType?: 'status' | 'maintenance' | 'analytics' | 'monitoring' | 'custom';
   /** Only show widgets marked as showByDefault (default: true) */
   defaultOnly?: boolean;
   /** Additional widget IDs to show (beyond showByDefault) */
@@ -35,6 +38,7 @@ interface PluginWidgetRendererProps {
  * Renders widgets from plugins that have registered them via the server API
  */
 export function PluginWidgetRenderer({
+  widgetType,
   defaultOnly = true,
   additionalWidgetIds = [],
 }: PluginWidgetRendererProps) {
@@ -78,6 +82,10 @@ export function PluginWidgetRenderer({
   // Filter widgets to show
   const visibleWidgets = widgets
     .filter(widget => {
+      // Filter by widget type if specified
+      if (widgetType && widget.type !== widgetType) {
+        return false;
+      }
       // Show if marked as default, or if in additionalWidgetIds
       if (defaultOnly) {
         return widget.showByDefault || additionalWidgetIds.includes(widget.id);

package/ui/src/dashboard/builtInWidgets.tsx

@@ -16,7 +16,13 @@ import {
   AuthStatusWidget,
   NotificationsStatsWidget,
   CMSStatusWidget,
-  CMSMaintenanceWidget
+  CMSMaintenanceWidget,
+  SeedManagementWidget,
+  ServiceControlWidget,
+  EnvironmentConfigWidget,
+  DatabaseOpsWidget,
+  LogsMaintenanceWidget,
+  CacheMaintenanceWidget,
 } from './widgets';
 import { PreferencesPage } from '../pages/PreferencesPage';
 import type { WidgetComponent } from './WidgetComponentRegistry';
@@ -32,6 +38,12 @@ export const builtInWidgetComponents: Record<string, React.ComponentType> = {
   NotificationsStatsWidget: NotificationsStatsWidget,
   CMSStatusWidget: CMSStatusWidget,
   CMSMaintenanceWidget: CMSMaintenanceWidget,
+  SeedManagementWidget: SeedManagementWidget,
+  ServiceControlWidget: ServiceControlWidget,
+  EnvironmentConfigWidget: EnvironmentConfigWidget,
+  DatabaseOpsWidget: DatabaseOpsWidget,
+  LogsMaintenanceWidget: LogsMaintenanceWidget,
+  CacheMaintenanceWidget: CacheMaintenanceWidget,
   PreferencesPage: PreferencesPage,
 };
 
@@ -50,6 +62,12 @@ export function getBuiltInWidgetComponents(): WidgetComponent[] {
     { name: 'NotificationsStatsWidget', component: NotificationsStatsWidget },
     { name: 'CMSStatusWidget', component: CMSStatusWidget },
     { name: 'CMSMaintenanceWidget', component: CMSMaintenanceWidget },
+    { name: 'SeedManagementWidget', component: SeedManagementWidget },
+    { name: 'ServiceControlWidget', component: ServiceControlWidget },
+    { name: 'EnvironmentConfigWidget', component: EnvironmentConfigWidget },
+    { name: 'DatabaseOpsWidget', component: DatabaseOpsWidget },
+    { name: 'LogsMaintenanceWidget', component: LogsMaintenanceWidget },
+    { name: 'CacheMaintenanceWidget', component: CacheMaintenanceWidget },
     { name: 'PreferencesPage', component: PreferencesPage },
   ];
 }