@qwickapps/server 1.7.0 → 1.7.2

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

@@ -22,6 +22,8 @@ import type {
 } from './types.js';
 import type { AuthenticatedRequest } from '../auth/types.js';
 import { getUserByEmail, getUserById, getUsersByIds } from '../users/users-plugin.js';
+import { hasPostgres, getPostgres } from '../postgres-plugin.js';
+import { postgresBanStore } from './stores/index.js';
 
 // Store instance for helper access
 let currentStore: BanStore | null = null;
@@ -29,17 +31,18 @@ let banCleanupInterval: NodeJS.Timeout | null = null;
 let pluginConfig: BansPluginConfig | null = null;
 
 /**
- * Create the Bans plugin
+ * Create the Bans 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 createBansPlugin(config: BansPluginConfig): 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 /bans prefix automatically
-  const apiEnabled = config.api?.enabled !== false;
-
-  function log(message: string, data?: Record<string, unknown>) {
-    if (debug) {
-      console.log(`[BansPlugin] ${message}`, data || '');
+export function createBansPlugin(config: Partial<BansPluginConfig> = {}): Plugin {
+  function log(message: string, data?: Record<string, unknown>, isError = false) {
+    const prefix = '[BansPlugin]';
+    if (isError) {
+      console.error(`${prefix} ${message}`, data || '');
+    } else if (config.debug) {
+      console.log(`${prefix} ${message}`, data || '');
     }
   }
 
@@ -49,26 +52,68 @@ export function createBansPlugin(config: BansPluginConfig): Plugin {
     version: '1.0.0',
 
     async onStart(_pluginConfig: PluginConfig, registry: PluginRegistry): Promise<void> {
-      log('Starting bans plugin');
+      const logger = registry.getLogger('bans');
 
       // Check for users plugin dependency
       if (!registry.hasPlugin('users')) {
-        throw new Error('Bans plugin requires Users plugin to be loaded first');
+        logger.warn('Users plugin not loaded! Bans plugin disabled.');
+        registry.registerHealthCheck({
+          name: 'bans-store',
+          type: 'custom',
+          check: async () => ({
+            healthy: false,
+            details: {
+              error: 'Users plugin not available',
+              state: 'disabled',
+            },
+          }),
+        });
+        return;
+      }
+
+      // Check for postgres in registry
+      if (!hasPostgres()) {
+        logger.warn('No Database! Bans plugin disabled.');
+        registry.registerHealthCheck({
+          name: 'bans-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 ?? postgresBanStore({
+        pool: () => getPostgres().getPool(),
+        autoCreateTables: true,
+      });
+
+      const debug = config.debug ?? false;
+      const apiPrefix = config.api?.prefix ?? '/bans';
+      const apiEnabled = config.api?.enabled ?? true;
+      const supportTemporary = config.supportTemporary ?? true;
+
+      log('Starting bans plugin');
+
       // Initialize the store (creates tables if needed)
-      await config.store.initialize();
+      await store.initialize();
       log('Bans plugin migrations complete');
 
       // Store references for helper access
-      currentStore = config.store;
-      pluginConfig = config;
+      currentStore = store;
+      pluginConfig = { ...config, store, debug, supportTemporary };
 
       // Start ban cleanup interval if temporary bans are supported
-      if (config.supportTemporary) {
+      if (supportTemporary) {
         banCleanupInterval = setInterval(async () => {
           try {
-            const cleaned = await config.store.cleanupExpiredBans();
+            const cleaned = await store.cleanupExpiredBans();
             if (cleaned > 0) {
               log('Cleaned up expired bans', { count: cleaned });
             }
@@ -85,7 +130,7 @@ export function createBansPlugin(config: BansPluginConfig): Plugin {
         check: async () => {
           try {
             // Simple health check - list with limit 0
-            await config.store.listActiveBans({ limit: 0 });
+            await store.listActiveBans({ limit: 0 });
             return { healthy: true };
           } catch {
             return { healthy: false };
@@ -105,7 +150,7 @@ export function createBansPlugin(config: BansPluginConfig): Plugin {
               const limit = Math.min(parseInt(req.query.limit as string) || 50, 100);
               const offset = parseInt(req.query.offset as string) || 0;
 
-              const result = await config.store.listActiveBans({ limit, offset });
+              const result = await store.listActiveBans({ limit, offset });
 
               // Batch fetch users for all bans (single query instead of N queries)
               const userIds = [...new Set(result.bans.map((ban) => ban.user_id))];
@@ -133,7 +178,7 @@ export function createBansPlugin(config: BansPluginConfig): Plugin {
           pluginId: 'bans',
           handler: async (req: Request, res: Response) => {
             try {
-              const ban = await config.store.getActiveBan(req.params.userId);
+              const ban = await store.getActiveBan(req.params.userId);
               res.json({
                 isBanned: ban !== null,
                 ban,
@@ -152,7 +197,7 @@ export function createBansPlugin(config: BansPluginConfig): Plugin {
           pluginId: 'bans',
           handler: async (req: Request, res: Response) => {
             try {
-              const bans = await config.store.listBans(req.params.userId);
+              const bans = await store.listBans(req.params.userId);
               res.json({ bans });
             } catch (error) {
               console.error('[BansPlugin] Get ban history error:', error);
@@ -185,7 +230,7 @@ export function createBansPlugin(config: BansPluginConfig): Plugin {
                 return res.status(404).json({ error: 'User not found' });
               }
 
-              const ban = await config.store.createBan(input);
+              const ban = await store.createBan(input);
 
               // Call onBan callback if provided
               if (config.callbacks?.onBan) {
@@ -227,7 +272,7 @@ export function createBansPlugin(config: BansPluginConfig): Plugin {
                 note: req.body?.note,
               };
 
-              const removed = await config.store.removeBan(input);
+              const removed = await store.removeBan(input);
               if (!removed) {
                 return res.status(404).json({ error: 'No active ban found' });
               }
@@ -292,7 +337,7 @@ export function createBansPlugin(config: BansPluginConfig): Plugin {
                 metadata: req.body.metadata,
               };
 
-              const ban = await config.store.createBan(input);
+              const ban = await store.createBan(input);
 
               // Call onBan callback if provided
               if (config.callbacks?.onBan) {
@@ -335,7 +380,7 @@ export function createBansPlugin(config: BansPluginConfig): Plugin {
                 note: req.body?.note,
               };
 
-              const removed = await config.store.removeBan(input);
+              const removed = await store.removeBan(input);
               if (!removed) {
                 return res.status(404).json({ error: 'No active ban found' });
               }
@@ -370,7 +415,7 @@ export function createBansPlugin(config: BansPluginConfig): Plugin {
         banCleanupInterval = null;
       }
 
-      await config.store.shutdown();
+      if (currentStore) { await currentStore.shutdown(); };
       currentStore = null;
       pluginConfig = null;
 

package/src/plugins/bans/index.ts

@@ -28,10 +28,8 @@ export type {
 } from './types.js';
 
 // Stores
-export { postgresBanStore } from './stores/index.js';
+export { postgresBanStore, inMemoryBanStore } from './stores/index.js';
+
+// UI Components are exported from main package index (@qwickapps/server)
+// Do NOT export here to avoid loading UI dependencies when importing plugins
 
-// UI Components
-export { BansStatusWidget } from './BansStatusWidget.js';
-export type { BansStatusWidgetProps } from './BansStatusWidget.js';
-export { BansManagementPage } from './BansManagementPage.js';
-export type { BansManagementPageProps } from './BansManagementPage.js';

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

@@ -0,0 +1,106 @@
+/**
+ * In-memory Ban Store for Demo/Testing
+ *
+ * Implements the BanStore interface with in-memory storage.
+ * Supports temporary and permanent bans with expiration.
+ */
+
+export function createInMemoryBanStore() {
+  const bans = new Map<string, any>();
+  let idCounter = 1;
+
+  function isActiveBan(ban: any): boolean {
+    if (!ban.is_active) return false;
+    if (ban.expires_at && new Date(ban.expires_at) <= new Date()) return false;
+    return true;
+  }
+
+  return {
+    name: 'in-memory',
+
+    async initialize() {
+      console.log('[InMemoryBanStore] Initialized');
+    },
+
+    async isBanned(userId: string) {
+      for (const ban of bans.values()) {
+        if (ban.user_id === userId && isActiveBan(ban)) {
+          return true;
+        }
+      }
+      return false;
+    },
+
+    async getActiveBan(userId: string) {
+      for (const ban of bans.values()) {
+        if (ban.user_id === userId && isActiveBan(ban)) {
+          return ban;
+        }
+      }
+      return null;
+    },
+
+    async createBan(input: any) {
+      const id = String(idCounter++);
+      const now = new Date();
+      const ban = {
+        id,
+        user_id: input.user_id,
+        reason: input.reason,
+        banned_by: input.banned_by || 'system',
+        banned_at: now,
+        expires_at: input.duration ? new Date(now.getTime() + input.duration * 1000) : null,
+        is_active: true,
+        metadata: input.metadata || {},
+      };
+      bans.set(id, ban);
+      return ban;
+    },
+
+    async removeBan(input: any) {
+      for (const ban of bans.values()) {
+        if (ban.user_id === input.user_id && isActiveBan(ban)) {
+          ban.is_active = false;
+          ban.removed_at = new Date();
+          ban.removed_by = input.removed_by;
+          return true;
+        }
+      }
+      return false;
+    },
+
+    async listBans(userId: string) {
+      const userBans: any[] = [];
+      for (const ban of bans.values()) {
+        if (ban.user_id === userId) {
+          userBans.push(ban);
+        }
+      }
+      return userBans;
+    },
+
+    async listActiveBans(options: { limit?: number; offset?: number } = {}) {
+      const activeBans = Array.from(bans.values()).filter(isActiveBan);
+      const total = activeBans.length;
+      const offset = options.offset || 0;
+      const limit = options.limit || 50;
+      const result = activeBans.slice(offset, offset + limit);
+      return { bans: result, total };
+    },
+
+    async cleanupExpiredBans() {
+      let cleaned = 0;
+      for (const ban of bans.values()) {
+        if (ban.is_active && ban.expires_at && new Date(ban.expires_at) <= new Date()) {
+          ban.is_active = false;
+          cleaned++;
+        }
+      }
+      return cleaned;
+    },
+
+    async shutdown() {
+      console.log('[InMemoryBanStore] Shutdown');
+    },
+  };
+}

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

@@ -5,3 +5,4 @@
  */
 
 export { postgresBanStore } from './postgres-store.js';
+export { createInMemoryBanStore as inMemoryBanStore } from './in-memory-store.js';

package/src/plugins/bans/types.ts

@@ -107,22 +107,29 @@ export interface BanCallbacks {
 
 /**
  * Bans plugin configuration
+ *
+ * All properties are optional - plugin will use smart defaults:
+ * - store: Postgres ban store using registry's postgres instance
+ * - supportTemporary: true
+ * - api.prefix: '/bans'
+ * - api.enabled: true
+ * - debug: false
  */
 export interface BansPluginConfig {
-  /** Ban storage backend */
-  store: BanStore;
-  /** Support temporary bans (with expiration) */
+  /** Ban storage backend (default: postgres ban store from registry) */
+  store?: BanStore;
+  /** Support temporary bans (with expiration) (default: true) */
   supportTemporary?: boolean;
   /** Callbacks */
   callbacks?: BanCallbacks;
   /** API configuration */
   api?: {
-    /** API route prefix (default: '/api/bans') */
+    /** API route prefix (default: '/bans') */
     prefix?: string;
-    /** Enable API endpoints */
+    /** Enable API endpoints (default: true) */
     enabled?: boolean;
   };
-  /** Enable debug logging */
+  /** Enable debug logging (default: false) */
   debug?: boolean;
 }
 

package/src/plugins/cache-plugin.test.ts

@@ -141,12 +141,12 @@ describe('Cache Plugin', () => {
       expect(hasCache('test')).toBe(true);
     });
 
-    it('should log debug message on successful connection', async () => {
+    it('should log info message on successful connection', async () => {
       const plugin = createCachePlugin(mockConfig, 'test');
       await plugin.onStart({}, mockRegistry);
 
       const logger = mockRegistry.getLogger('cache:test');
-      expect(logger.debug).toHaveBeenCalledWith(
+      expect(logger.info).toHaveBeenCalledWith(
         expect.stringContaining('connected')
       );
     });