@qwickapps/server 1.2.0 → 1.3.1

package/src/plugins/health-plugin.ts

@@ -6,30 +6,50 @@
  * Copyright (c) 2025 QwickApps.com. All rights reserved.
  */
 
-import type { ControlPanelPlugin, HealthCheck, PluginContext } from '../core/types.js';
+import type { Plugin, PluginConfig, PluginRegistry } from '../core/plugin-registry.js';
+import type { HealthCheck } from '../core/types.js';
 
 export interface HealthPluginConfig {
   checks: HealthCheck[];
   aggregateEndpoint?: string;
+  /** Whether to show the ServiceHealthWidget on the dashboard (default: true) */
+  showWidget?: boolean;
 }
 
 /**
  * Create a health check plugin
  */
-export function createHealthPlugin(config: HealthPluginConfig): ControlPanelPlugin {
+export function createHealthPlugin(config: HealthPluginConfig): Plugin {
   return {
-    name: 'health',
-    order: 10,
+    id: 'health',
+    name: 'Health Plugin',
+    version: '1.0.0',
 
-    async onInit(context: PluginContext): Promise<void> {
-      const { registerHealthCheck, logger } = context;
+    async onStart(_pluginConfig: PluginConfig, registry: PluginRegistry): Promise<void> {
+      const logger = registry.getLogger('health');
 
       // Register all health checks
       for (const check of config.checks) {
-        registerHealthCheck(check);
+        registry.registerHealthCheck(check);
+      }
+
+      // Register the ServiceHealthWidget (shown by default unless disabled)
+      if (config.showWidget !== false) {
+        registry.addWidget({
+          id: 'service-health',
+          title: 'Service Health',
+          component: 'ServiceHealthWidget',
+          priority: 10,
+          showByDefault: true,
+          pluginId: 'health',
+        });
       }
 
       logger.debug(`Registered ${config.checks.length} health checks`);
     },
+
+    async onStop(): Promise<void> {
+      // Nothing to cleanup
+    },
   };
 }

package/src/plugins/index.ts

@@ -22,9 +22,137 @@ export type { FrontendAppPluginConfig } from './frontend-app-plugin.js';
 export { createPostgresPlugin, getPostgres, hasPostgres } from './postgres-plugin.js';
 export type { PostgresPluginConfig, PostgresInstance, TransactionCallback } from './postgres-plugin.js';
 
-// Backward compatibility aliases (deprecated)
-export { createPostgresPlugin as createDatabasePlugin, getPostgres as getDatabase, hasPostgres as hasDatabase } from './postgres-plugin.js';
-export type { PostgresPluginConfig as DatabasePluginConfig, PostgresInstance as DatabaseInstance } from './postgres-plugin.js';
-
 export { createCachePlugin, getCache, hasCache } from './cache-plugin.js';
 export type { CachePluginConfig, CacheInstance } from './cache-plugin.js';
+
+// Auth plugin
+export {
+  createAuthPlugin,
+  createAuthPluginFromEnv,
+  getAuthStatus,
+  isAuthenticated,
+  getAuthenticatedUser,
+  getAccessToken,
+  requireAuth,
+  requireRoles,
+  requireAnyRole,
+  auth0Adapter,
+  basicAdapter,
+  supabaseAdapter,
+  supertokensAdapter,
+  isAuthenticatedRequest,
+} from './auth/index.js';
+export type {
+  AuthPluginConfig,
+  AuthAdapter,
+  AuthenticatedUser,
+  AuthenticatedRequest,
+  Auth0AdapterConfig,
+  SupabaseAdapterConfig,
+  BasicAdapterConfig,
+  SupertokensAdapterConfig,
+  AuthPluginState,
+  AuthEnvPluginOptions,
+  AuthConfigStatus,
+} from './auth/index.js';
+
+// Users plugin
+export {
+  createUsersPlugin,
+  getUserStore,
+  getUserById,
+  getUserByEmail,
+  findOrCreateUser,
+  postgresUserStore,
+} from './users/index.js';
+export type {
+  UsersPluginConfig,
+  UserStore,
+  User,
+  CreateUserInput,
+  UpdateUserInput,
+  UserSearchParams,
+  UserListResponse,
+  PostgresUserStoreConfig,
+  UserSyncConfig,
+  UsersApiConfig,
+  UsersUiConfig,
+} from './users/index.js';
+
+// Bans plugin (separate from Users, depends on Users)
+export {
+  createBansPlugin,
+  getBanStore,
+  isUserBanned,
+  isEmailBanned,
+  getActiveBan,
+  banUser,
+  unbanUser,
+  listActiveBans,
+  postgresBanStore,
+} from './bans/index.js';
+export type {
+  BansPluginConfig,
+  BanStore,
+  Ban,
+  CreateBanInput,
+  RemoveBanInput,
+  BanCallbacks,
+  PostgresBanStoreConfig,
+} from './bans/index.js';
+
+// Entitlements plugin
+export {
+  createEntitlementsPlugin,
+  getEntitlementSource,
+  isSourceReadonly,
+  getEntitlements,
+  refreshEntitlements,
+  hasEntitlement,
+  hasAnyEntitlement,
+  hasAllEntitlements,
+  grantEntitlement,
+  revokeEntitlement,
+  setEntitlements,
+  getAvailableEntitlements,
+  getEntitlementStats,
+  invalidateEntitlementCache,
+  storeExternalIdMapping,
+  invalidateByExternalId,
+  requireEntitlement,
+  requireAnyEntitlement,
+  requireAllEntitlements,
+  postgresEntitlementSource,
+} from './entitlements/index.js';
+export type {
+  EntitlementsPluginConfig,
+  EntitlementSource,
+  EntitlementResult,
+  EntitlementDefinition,
+  EntitlementCallbacks,
+  EntitlementsCacheConfig,
+  EntitlementsApiConfig,
+  PostgresEntitlementSourceConfig,
+  UserEntitlement,
+  CachedEntitlements,
+  EntitlementStats,
+} from './entitlements/index.js';
+
+// Preferences plugin (depends on Users)
+export {
+  createPreferencesPlugin,
+  getPreferencesStore,
+  getPreferences,
+  updatePreferences,
+  deletePreferences,
+  getDefaultPreferences,
+  postgresPreferencesStore,
+  deepMerge,
+} from './preferences/index.js';
+export type {
+  PreferencesPluginConfig,
+  PreferencesStore,
+  UserPreferences,
+  PostgresPreferencesStoreConfig,
+  PreferencesApiConfig,
+} from './preferences/index.js';

package/src/plugins/logs-plugin.ts

@@ -10,7 +10,8 @@
 import { existsSync, readFileSync, statSync } from 'fs';
 import { resolve } from 'path';
 import type { Request, Response } from 'express';
-import type { ControlPanelPlugin, LogSource, PluginContext } from '../core/types.js';
+import type { Plugin, PluginConfig, PluginRegistry } from '../core/plugin-registry.js';
+import type { LogSource } from '../core/types.js';
 import { getLoggingSubsystem } from '../core/logging.js';
 
 export interface LogsPluginConfig {
@@ -61,7 +62,7 @@ function getDefaultSources(): LogSource[] {
 /**
  * Create a logs plugin
  */
-export function createLogsPlugin(config: LogsPluginConfig = {}): ControlPanelPlugin {
+export function createLogsPlugin(config: LogsPluginConfig = {}): Plugin {
   const maxLines = config.retention?.maxLines || 10000;
 
   // Use provided sources or default to logging subsystem paths
@@ -73,13 +74,18 @@ export function createLogsPlugin(config: LogsPluginConfig = {}): ControlPanelPlu
   };
 
   return {
-    name: 'logs',
-    order: 20,
+    id: 'logs',
+    name: 'Logs Plugin',
+    version: '1.0.0',
 
-    routes: [
-      {
+    async onStart(_pluginConfig: PluginConfig, registry: PluginRegistry): Promise<void> {
+      const logger = registry.getLogger('logs');
+
+      // Register /logs/sources route
+      registry.addRoute({
         method: 'get',
         path: '/logs/sources',
+        pluginId: 'logs',
         handler: (_req: Request, res: Response) => {
           const sources = getSources();
           res.json({
@@ -89,10 +95,13 @@ export function createLogsPlugin(config: LogsPluginConfig = {}): ControlPanelPlu
             })),
           });
         },
-      },
-      {
+      });
+
+      // Register /logs route
+      registry.addRoute({
         method: 'get',
         path: '/logs',
+        pluginId: 'logs',
         handler: (req: Request, res: Response) => {
           try {
             const sources = getSources();
@@ -124,10 +133,13 @@ export function createLogsPlugin(config: LogsPluginConfig = {}): ControlPanelPlu
             });
           }
         },
-      },
-      {
+      });
+
+      // Register /logs/stats route
+      registry.addRoute({
         method: 'get',
         path: '/logs/stats',
+        pluginId: 'logs',
         handler: (req: Request, res: Response) => {
           try {
             const sources = getSources();
@@ -151,12 +163,14 @@ export function createLogsPlugin(config: LogsPluginConfig = {}): ControlPanelPlu
             });
           }
         },
-      },
-    ],
+      });
 
-    async onInit(context: PluginContext): Promise<void> {
       const sources = getSources();
-      context.logger.debug(`Logs plugin initialized with ${sources.length} sources`);
+      logger.debug(`Logs plugin initialized with ${sources.length} sources`);
+    },
+
+    async onStop(): Promise<void> {
+      // Nothing to cleanup
     },
   };
 }

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

@@ -38,6 +38,7 @@ import {
   hasPostgres,
   type PostgresPluginConfig,
 } from './postgres-plugin.js';
+import type { PluginRegistry } from '../core/plugin-registry.js';
 
 describe('PostgreSQL Plugin', () => {
   const mockConfig: PostgresPluginConfig = {
@@ -46,21 +47,42 @@ describe('PostgreSQL Plugin', () => {
     healthCheck: false, // Disable for unit tests
   };
 
-  const mockContext = {
-    config: { productName: 'Test', port: 3000 },
-    app: {} as any,
-    router: {} as any,
-    logger: {
+  // Create a mock registry that matches the new Plugin interface
+  const createMockRegistry = (): PluginRegistry => ({
+    hasPlugin: vi.fn().mockReturnValue(false),
+    getPlugin: vi.fn().mockReturnValue(null),
+    listPlugins: vi.fn().mockReturnValue([]),
+    addRoute: vi.fn(),
+    addMenuItem: vi.fn(),
+    addPage: vi.fn(),
+    addWidget: vi.fn(),
+    addConfigComponent: vi.fn(),
+    getRoutes: vi.fn().mockReturnValue([]),
+    getMenuItems: vi.fn().mockReturnValue([]),
+    getPages: vi.fn().mockReturnValue([]),
+    getWidgets: vi.fn().mockReturnValue([]),
+    getConfigComponents: vi.fn().mockReturnValue([]),
+    getPluginContributions: vi.fn().mockReturnValue({ routes: [], menuItems: [], pages: [], widgets: [], config: undefined }),
+    getConfig: vi.fn().mockReturnValue({}),
+    setConfig: vi.fn().mockResolvedValue(undefined),
+    subscribe: vi.fn().mockReturnValue(() => {}),
+    emit: vi.fn(),
+    registerHealthCheck: vi.fn(),
+    getApp: vi.fn().mockReturnValue({} as any),
+    getRouter: vi.fn().mockReturnValue({} as any),
+    getLogger: vi.fn().mockReturnValue({
       debug: vi.fn(),
       info: vi.fn(),
       warn: vi.fn(),
       error: vi.fn(),
-    },
-    registerHealthCheck: vi.fn(),
-  };
+    }),
+  });
+
+  let mockRegistry: PluginRegistry;
 
   beforeEach(() => {
     vi.clearAllMocks();
+    mockRegistry = createMockRegistry();
   });
 
   afterEach(async () => {
@@ -74,33 +96,34 @@ describe('PostgreSQL Plugin', () => {
   describe('createPostgresPlugin', () => {
     it('should create a plugin with correct name', () => {
       const plugin = createPostgresPlugin(mockConfig, 'test');
-      expect(plugin.name).toBe('postgres:test');
+      expect(plugin.name).toBe('PostgreSQL (test)');
     });
 
     it('should use "default" as instance name when not specified', () => {
       const plugin = createPostgresPlugin(mockConfig);
-      expect(plugin.name).toBe('postgres:default');
+      expect(plugin.name).toBe('PostgreSQL (default)');
     });
 
-    it('should have low order number (initialize early)', () => {
-      const plugin = createPostgresPlugin(mockConfig);
-      expect(plugin.order).toBeLessThan(10);
+    it('should have correct plugin id', () => {
+      const plugin = createPostgresPlugin(mockConfig, 'test');
+      expect(plugin.id).toBe('postgres:test');
     });
   });
 
-  describe('onInit', () => {
+  describe('onStart', () => {
     it('should register the postgres instance', async () => {
       const plugin = createPostgresPlugin(mockConfig, 'test');
-      await plugin.onInit?.(mockContext as any);
+      await plugin.onStart({}, mockRegistry);
 
       expect(hasPostgres('test')).toBe(true);
     });
 
     it('should log debug message on successful connection', async () => {
       const plugin = createPostgresPlugin(mockConfig, 'test');
-      await plugin.onInit?.(mockContext as any);
+      await plugin.onStart({}, mockRegistry);
 
-      expect(mockContext.logger.debug).toHaveBeenCalledWith(
+      const logger = mockRegistry.getLogger('postgres:test');
+      expect(logger.debug).toHaveBeenCalledWith(
         expect.stringContaining('connected')
       );
     });
@@ -108,9 +131,9 @@ describe('PostgreSQL Plugin', () => {
     it('should register health check when enabled', async () => {
       const configWithHealth = { ...mockConfig, healthCheck: true };
       const plugin = createPostgresPlugin(configWithHealth, 'test');
-      await plugin.onInit?.(mockContext as any);
+      await plugin.onStart({}, mockRegistry);
 
-      expect(mockContext.registerHealthCheck).toHaveBeenCalledWith(
+      expect(mockRegistry.registerHealthCheck).toHaveBeenCalledWith(
         expect.objectContaining({
           name: 'postgres',
           type: 'custom',
@@ -125,9 +148,9 @@ describe('PostgreSQL Plugin', () => {
         healthCheckName: 'custom-db',
       };
       const plugin = createPostgresPlugin(configWithCustomName, 'test');
-      await plugin.onInit?.(mockContext as any);
+      await plugin.onStart({}, mockRegistry);
 
-      expect(mockContext.registerHealthCheck).toHaveBeenCalledWith(
+      expect(mockRegistry.registerHealthCheck).toHaveBeenCalledWith(
         expect.objectContaining({
           name: 'custom-db',
         })
@@ -138,7 +161,7 @@ describe('PostgreSQL Plugin', () => {
   describe('getPostgres', () => {
     it('should return registered instance', async () => {
       const plugin = createPostgresPlugin(mockConfig, 'test');
-      await plugin.onInit?.(mockContext as any);
+      await plugin.onStart({}, mockRegistry);
 
       const db = getPostgres('test');
       expect(db).toBeDefined();
@@ -161,7 +184,7 @@ describe('PostgreSQL Plugin', () => {
 
     it('should return true for registered instance', async () => {
       const plugin = createPostgresPlugin(mockConfig, 'test');
-      await plugin.onInit?.(mockContext as any);
+      await plugin.onStart({}, mockRegistry);
 
       expect(hasPostgres('test')).toBe(true);
     });
@@ -170,7 +193,7 @@ describe('PostgreSQL Plugin', () => {
   describe('PostgresInstance', () => {
     it('should execute query and return rows', async () => {
       const plugin = createPostgresPlugin(mockConfig, 'test');
-      await plugin.onInit?.(mockContext as any);
+      await plugin.onStart({}, mockRegistry);
 
       const db = getPostgres('test');
       const result = await db.query('SELECT 1');
@@ -179,7 +202,7 @@ describe('PostgreSQL Plugin', () => {
 
     it('should return null from queryOne when no rows', async () => {
       const plugin = createPostgresPlugin(mockConfig, 'test');
-      await plugin.onInit?.(mockContext as any);
+      await plugin.onStart({}, mockRegistry);
 
       const db = getPostgres('test');
       const result = await db.queryOne('SELECT 1');
@@ -188,7 +211,7 @@ describe('PostgreSQL Plugin', () => {
 
     it('should return pool stats', async () => {
       const plugin = createPostgresPlugin(mockConfig, 'test');
-      await plugin.onInit?.(mockContext as any);
+      await plugin.onStart({}, mockRegistry);
 
       const db = getPostgres('test');
       const stats = db.getStats();
@@ -198,14 +221,14 @@ describe('PostgreSQL Plugin', () => {
     });
   });
 
-  describe('onShutdown', () => {
+  describe('onStop', () => {
     it('should close pool and unregister instance', async () => {
       const plugin = createPostgresPlugin(mockConfig, 'test');
-      await plugin.onInit?.(mockContext as any);
+      await plugin.onStart({}, mockRegistry);
 
       expect(hasPostgres('test')).toBe(true);
 
-      await plugin.onShutdown?.();
+      await plugin.onStop();
 
       expect(hasPostgres('test')).toBe(false);
     });

package/src/plugins/postgres-plugin.ts

@@ -47,7 +47,7 @@
  */
 
 import pg from 'pg';
-import type { ControlPanelPlugin, PluginContext } from '../core/types.js';
+import type { Plugin, PluginConfig, PluginRegistry } from '../core/plugin-registry.js';
 
 const { Pool } = pg;
 
@@ -173,7 +173,7 @@ export function hasPostgres(name = 'default'): boolean {
  *
  * @param config - PostgreSQL configuration
  * @param instanceName - Name for this PostgreSQL instance (default: 'default')
- * @returns A control panel plugin
+ * @returns A plugin
  *
  * @example
  * ```typescript
@@ -187,8 +187,9 @@ export function hasPostgres(name = 'default'): boolean {
 export function createPostgresPlugin(
   config: PostgresPluginConfig,
   instanceName = 'default'
-): ControlPanelPlugin {
+): Plugin {
   let pool: pg.Pool | null = null;
+  const pluginId = `postgres:${instanceName}`;
 
   const createInstance = (): PostgresInstance => {
     if (!pool) {
@@ -282,11 +283,12 @@ export function createPostgresPlugin(
   };
 
   return {
-    name: `postgres:${instanceName}`,
-    order: 5, // Initialize early, before other plugins that may need DB
+    id: pluginId,
+    name: `PostgreSQL (${instanceName})`,
+    version: '1.0.0',
 
-    async onInit(context: PluginContext): Promise<void> {
-      const { registerHealthCheck, logger } = context;
+    async onStart(_pluginConfig: PluginConfig, registry: PluginRegistry): Promise<void> {
+      const logger = registry.getLogger(pluginId);
 
       // Create and register the instance
       const instance = createInstance();
@@ -303,7 +305,7 @@ export function createPostgresPlugin(
 
       // Register health check if enabled
       if (config.healthCheck !== false) {
-        registerHealthCheck({
+        registry.registerHealthCheck({
           name: config.healthCheckName ?? 'postgres',
           type: 'custom',
           interval: config.healthCheckInterval ?? 30000,
@@ -334,7 +336,7 @@ export function createPostgresPlugin(
       }
     },
 
-    async onShutdown(): Promise<void> {
+    async onStop(): Promise<void> {
       const instance = instances.get(instanceName);
       if (instance) {
         await instance.close();