@qwickapps/server 1.7.0 → 1.7.1

package/src/plugins/logs-plugin.ts

@@ -7,7 +7,7 @@
  * Copyright (c) 2025 QwickApps.com. All rights reserved.
  */
 
-import { existsSync, readFileSync, statSync } from 'fs';
+import { existsSync, readFileSync, statSync, truncateSync, unlinkSync } from 'fs';
 import { resolve } from 'path';
 import type { Request, Response } from 'express';
 import type { Plugin, PluginConfig, PluginRegistry } from '../core/plugin-registry.js';
@@ -165,6 +165,60 @@ export function createLogsPlugin(config: LogsPluginConfig = {}): Plugin {
         },
       });
 
+      // Register /clear route (slug prefix added automatically by framework)
+      registry.addRoute({
+        method: 'post',
+        path: '/clear',
+        pluginId: 'logs',
+        handler: (req: Request, res: Response) => {
+          try {
+            const sources = getSources();
+            const sourceName = (req.body.source as string) || sources[0]?.name;
+            const source = sources.find((s) => s.name === sourceName);
+
+            if (!source) {
+              return res.status(404).json({ error: `Source "${sourceName}" not found` });
+            }
+
+            if (source.type !== 'file' || !source.path) {
+              return res.status(400).json({ error: 'Clear only available for file sources' });
+            }
+
+            const resolvedPath = resolve(source.path);
+            if (!existsSync(resolvedPath)) {
+              return res.status(404).json({ error: `Log file not found: ${source.path}` });
+            }
+
+            // Truncate the file (clear contents but keep file)
+            truncateSync(resolvedPath, 0);
+            logger.info(`Cleared log file: ${source.name} (${source.path})`);
+
+            return res.json({
+              success: true,
+              message: `Log file "${source.name}" cleared successfully`,
+              source: source.name,
+            });
+          } catch (error) {
+            logger.error('Failed to clear log file', { error });
+            return res.status(500).json({
+              error: 'Failed to clear log file',
+              message: error instanceof Error ? error.message : String(error),
+            });
+          }
+        },
+      });
+
+      // Register maintenance widget
+      registry.addWidget({
+        id: 'logs-maintenance',
+        title: 'Log Management',
+        component: 'LogsMaintenanceWidget',
+        type: 'maintenance',
+        priority: 50,
+        showByDefault: true,
+        pluginId: 'logs',
+      });
+
       const sources = getSources();
       logger.debug(`Logs plugin initialized with ${sources.length} sources`);
     },

package/src/plugins/maintenance-plugin.ts

@@ -362,22 +362,65 @@ export function createMaintenancePlugin(config: MaintenancePluginConfig = {}): P
         });
       }
 
+      // Register maintenance widgets
+      if (config.enableSeeds !== false) {
+        registry.addWidget({
+          id: 'seed-management',
+          title: 'Seed Management',
+          component: 'SeedManagementWidget',
+          type: 'maintenance',
+          priority: 10,
+          showByDefault: true, // Show by default on maintenance page
+          pluginId: 'maintenance',
+        });
+      }
+
       // TODO: Register service control routes
       if (config.enableServiceControl !== false) {
         logger.debug('Service control enabled');
         // Routes will be added in #703
+
+        registry.addWidget({
+          id: 'service-control',
+          title: 'Service Control',
+          component: 'ServiceControlWidget',
+          type: 'maintenance',
+          priority: 20,
+          showByDefault: false,
+          pluginId: 'maintenance',
+        });
       }
 
       // TODO: Register environment variable management routes
       if (config.enableEnvManagement !== false) {
         logger.debug('Environment variable management enabled');
         // Routes will be added in #704
+
+        registry.addWidget({
+          id: 'environment-config',
+          title: 'Environment Configuration',
+          component: 'EnvironmentConfigWidget',
+          type: 'maintenance',
+          priority: 30,
+          showByDefault: false,
+          pluginId: 'maintenance',
+        });
       }
 
       // TODO: Register database operation routes
       if (config.enableDatabaseOps !== false) {
         logger.debug('Database operations enabled');
         // Routes will be added in #705
+
+        registry.addWidget({
+          id: 'database-ops',
+          title: 'Database Operations',
+          component: 'DatabaseOpsWidget',
+          type: 'maintenance',
+          priority: 40,
+          showByDefault: false,
+          pluginId: 'maintenance',
+        });
       }
 
       // Register UI page

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

@@ -378,6 +378,7 @@ export function createNotificationsPlugin(config: NotificationsPluginConfig): Pl
           id: 'notifications-stats',
           title: 'Notifications',
           component: 'NotificationsStatsWidget',
+          type: 'status',
           priority: 25, // After ServiceHealthWidget (10) and AuthStatusWidget (20)
           showByDefault: true,
           pluginId: 'notifications',

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

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

package/src/plugins/postgres-plugin.ts

@@ -56,7 +56,10 @@ const { Pool } = pg;
  */
 export interface PostgresPluginConfig {
   /** Database connection URL (e.g., postgresql://user:pass@host:5432/db) */
-  url: string;
+  url?: string;
+
+  /** Pre-configured pg.Pool instance (alternative to url) */
+  pool?: pg.Pool;
 
   /** Maximum number of clients in the pool (default: 20) */
   maxConnections?: number;
@@ -193,14 +196,22 @@ export function createPostgresPlugin(
 
   const createInstance = (): PostgresInstance => {
     if (!pool) {
-      pool = new Pool({
-        connectionString: config.url,
-        max: config.maxConnections ?? 20,
-        min: config.minConnections ?? 2,
-        idleTimeoutMillis: config.idleTimeoutMs ?? 30000,
-        connectionTimeoutMillis: config.connectionTimeoutMs ?? 5000,
-        statement_timeout: config.statementTimeoutMs,
-      });
+      if (config.pool) {
+        // Use pre-configured pool (e.g., pg-mem for testing)
+        pool = config.pool;
+      } else if (config.url) {
+        // Create pool from URL
+        pool = new Pool({
+          connectionString: config.url,
+          max: config.maxConnections ?? 20,
+          min: config.minConnections ?? 2,
+          idleTimeoutMillis: config.idleTimeoutMs ?? 30000,
+          connectionTimeoutMillis: config.connectionTimeoutMs ?? 5000,
+          statement_timeout: config.statementTimeoutMs,
+        });
+      } else {
+        throw new Error('PostgresPluginConfig must have either url or pool');
+      }
 
       // Handle pool errors
       pool.on('error', (err) => {

package/src/plugins/tenants/index.ts

@@ -11,7 +11,7 @@
 export { createTenantsPlugin, getTenantStore, autoCreateUserTenant } from './tenants-plugin.js';
 
 // Store implementations
-export { postgresTenantStore } from './stores/postgres-store.js';
+export { postgresTenantStore, inMemoryTenantStore } from './stores/index.js';
 
 // Types
 export type {

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

@@ -0,0 +1,335 @@
+/**
+ * In-memory Tenant Store for Demo/Testing
+ *
+ * Implements the TenantStore interface with in-memory storage.
+ * Pre-populated with demo tenants and memberships.
+ */
+
+import type {
+  Tenant,
+  TenantStore,
+  CreateTenantInput,
+  UpdateTenantInput,
+  TenantSearchParams,
+  TenantListResponse,
+  TenantMembership,
+  CreateTenantMembershipInput,
+  UpdateTenantMembershipInput,
+  TenantWithMembership,
+  TenantType,
+} from '../types.js';
+
+/**
+ * Default demo user ID used for pre-populated tenants.
+ * Matches the user ID assigned by basic auth guard.
+ */
+export const DEMO_USER_ID = 'basic-auth-user';
+
+/**
+ * Logger interface for in-memory stores.
+ */
+export interface InMemoryStoreLogger {
+  info: (message: string) => void;
+  debug?: (message: string) => void;
+}
+
+/**
+ * Options for creating an in-memory tenant store.
+ */
+export interface InMemoryTenantStoreOptions {
+  /**
+   * Demo user ID for pre-populated tenants.
+   * @default 'basic-auth-user'
+   */
+  demoUserId?: string;
+
+  /**
+   * Optional logger for store operations.
+   * If not provided, uses console.log as fallback.
+   */
+  logger?: InMemoryStoreLogger;
+}
+
+/**
+ * Creates an in-memory tenant store for demo/testing purposes.
+ * Pre-populated with 4 demo tenants (organization, group, department, user).
+ *
+ * This store is NOT suitable for production use - data is lost on restart.
+ * Use postgresTenantsStore for production deployments.
+ *
+ * @param options - Configuration options for the store
+ * @returns TenantStore implementation with in-memory storage
+ *
+ * @example
+ * ```typescript
+ * import { createInMemoryTenantStore } from '@qwickapps/server';
+ *
+ * const store = createInMemoryTenantStore({
+ *   demoUserId: 'test-user-123',
+ *   logger: console,
+ * });
+ *
+ * await store.initialize();
+ * const tenants = await store.getTenantsForUser('test-user-123');
+ * ```
+ */
+export function createInMemoryTenantStore(
+  options: InMemoryTenantStoreOptions = {}
+): TenantStore {
+  const demoUserId = options.demoUserId || DEMO_USER_ID;
+  const logger = options.logger || {
+    info: (msg: string) => console.log(msg),
+    debug: (msg: string) => console.log(msg),
+  };
+
+  const tenants = new Map<string, Tenant>();
+  const memberships = new Map<string, TenantMembership>();
+  let tenantIdCounter = 1;
+  let membershipIdCounter = 1;
+
+  // Pre-populate demo tenants
+  const demoTenants: Array<{ name: string; type: TenantType; owner_id: string }> = [
+    { name: 'Acme Corporation', type: 'organization', owner_id: demoUserId },
+    { name: 'Engineering Team', type: 'group', owner_id: demoUserId },
+    { name: 'Finance Department', type: 'department', owner_id: demoUserId },
+    { name: 'Demo User Workspace', type: 'user', owner_id: demoUserId },
+  ];
+
+  demoTenants.forEach((t) => {
+    const id = `tenant-${tenantIdCounter++}`;
+    const tenant: Tenant = {
+      id,
+      name: t.name,
+      type: t.type,
+      owner_id: t.owner_id,
+      metadata: {},
+      created_at: new Date(),
+      updated_at: new Date(),
+    };
+    tenants.set(id, tenant);
+
+    // Auto-create membership for owner
+    const membershipId = `membership-${membershipIdCounter++}`;
+    const membership: TenantMembership = {
+      id: membershipId,
+      tenant_id: id,
+      user_id: t.owner_id,
+      role: 'owner',
+      joined_at: new Date(),
+    };
+    memberships.set(membershipId, membership);
+  });
+
+  return {
+    name: 'in-memory',
+
+    async initialize(): Promise<void> {
+      logger.info('[InMemoryTenantStore] Initialized with demo tenants');
+    },
+
+    async getById(id: string): Promise<Tenant | null> {
+      return tenants.get(id) || null;
+    },
+
+    async getByIds(ids: string[]): Promise<Tenant[]> {
+      return ids.map((id) => tenants.get(id)).filter((t): t is Tenant => t !== undefined);
+    },
+
+    async getByName(name: string): Promise<Tenant | null> {
+      for (const tenant of tenants.values()) {
+        if (tenant.name.toLowerCase() === name.toLowerCase()) {
+          return tenant;
+        }
+      }
+      return null;
+    },
+
+    async create(input: CreateTenantInput): Promise<Tenant> {
+      const id = `tenant-${tenantIdCounter++}`;
+      const tenant: Tenant = {
+        id,
+        name: input.name,
+        type: input.type,
+        owner_id: input.owner_id,
+        metadata: input.metadata || {},
+        created_at: new Date(),
+        updated_at: new Date(),
+      };
+      tenants.set(id, tenant);
+
+      // Auto-create membership for owner
+      const membershipId = `membership-${membershipIdCounter++}`;
+      const membership: TenantMembership = {
+        id: membershipId,
+        tenant_id: id,
+        user_id: input.owner_id,
+        role: 'owner',
+        joined_at: new Date(),
+      };
+      memberships.set(membershipId, membership);
+
+      return tenant;
+    },
+
+    async update(id: string, input: UpdateTenantInput): Promise<Tenant | null> {
+      const tenant = tenants.get(id);
+      if (!tenant) return null;
+
+      const updated: Tenant = {
+        ...tenant,
+        ...input,
+        id: tenant.id, // Preserve ID
+        created_at: tenant.created_at, // Preserve created_at
+        updated_at: new Date(),
+      };
+      tenants.set(id, updated);
+      return updated;
+    },
+
+    async delete(id: string): Promise<boolean> {
+      // Delete all memberships for this tenant
+      for (const [key, membership] of memberships.entries()) {
+        if (membership.tenant_id === id) {
+          memberships.delete(key);
+        }
+      }
+      return tenants.delete(id);
+    },
+
+    async search(params: TenantSearchParams = {}): Promise<TenantListResponse> {
+      let result = Array.from(tenants.values());
+
+      if (params.query) {
+        const query = params.query.toLowerCase();
+        result = result.filter((t) => t.name.toLowerCase().includes(query));
+      }
+
+      if (params.type) {
+        result = result.filter((t) => t.type === params.type);
+      }
+
+      if (params.owner_id) {
+        result = result.filter((t) => t.owner_id === params.owner_id);
+      }
+
+      const sortBy = params.sortBy || 'created_at';
+      const sortOrder = params.sortOrder || 'desc';
+
+      result.sort((a, b) => {
+        const aVal = a[sortBy as keyof Tenant];
+        const bVal = b[sortBy as keyof Tenant];
+        if (aVal == null || bVal == null) return 0;
+        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 {
+        tenants: result,
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      };
+    },
+
+    async getTenantsForUser(userId: string): Promise<TenantWithMembership[]> {
+      const userMemberships = Array.from(memberships.values()).filter(
+        (m) => m.user_id === userId
+      );
+      const results: TenantWithMembership[] = [];
+      for (const membership of userMemberships) {
+        const tenant = tenants.get(membership.tenant_id);
+        if (tenant) {
+          results.push({
+            ...tenant,
+            user_role: membership.role,
+            membership,
+          });
+        }
+      }
+      return results;
+    },
+
+    async getTenantForUser(
+      tenantId: string,
+      userId: string
+    ): Promise<TenantWithMembership | null> {
+      const membership = await this.getMembership(tenantId, userId);
+      if (!membership) return null;
+
+      const tenant = tenants.get(tenantId);
+      if (!tenant) return null;
+
+      return {
+        ...tenant,
+        user_role: membership.role,
+        membership,
+      };
+    },
+
+    async getMembers(tenantId: string): Promise<TenantMembership[]> {
+      return Array.from(memberships.values()).filter((m) => m.tenant_id === tenantId);
+    },
+
+    async getMembership(tenantId: string, userId: string): Promise<TenantMembership | null> {
+      for (const membership of memberships.values()) {
+        if (membership.tenant_id === tenantId && membership.user_id === userId) {
+          return membership;
+        }
+      }
+      return null;
+    },
+
+    async addMember(input: CreateTenantMembershipInput): Promise<TenantMembership> {
+      const id = `membership-${membershipIdCounter++}`;
+      const membership: TenantMembership = {
+        id,
+        tenant_id: input.tenant_id,
+        user_id: input.user_id,
+        role: input.role,
+        joined_at: new Date(),
+      };
+      memberships.set(id, membership);
+      return membership;
+    },
+
+    async updateMember(
+      tenantId: string,
+      userId: string,
+      input: UpdateTenantMembershipInput
+    ): Promise<TenantMembership | null> {
+      for (const membership of memberships.values()) {
+        if (membership.tenant_id === tenantId && membership.user_id === userId) {
+          const updated: TenantMembership = {
+            ...membership,
+            ...input,
+          };
+          memberships.set(membership.id, updated);
+          return updated;
+        }
+      }
+      return null;
+    },
+
+    async removeMember(tenantId: string, userId: string): Promise<boolean> {
+      for (const [key, membership] of memberships.entries()) {
+        if (membership.tenant_id === tenantId && membership.user_id === userId) {
+          memberships.delete(key);
+          return true;
+        }
+      }
+      return false;
+    },
+
+    async shutdown(): Promise<void> {
+      logger.info('[InMemoryTenantStore] Shutdown');
+    },
+  };
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Tenant Stores Index
+ *
+ * Copyright (c) 2025 QwickApps.com. All rights reserved.
+ */
+
+export { postgresTenantStore } from './postgres-store.js';
+export {
+  createInMemoryTenantStore as inMemoryTenantStore,
+  DEMO_USER_ID,
+  type InMemoryStoreLogger,
+  type InMemoryTenantStoreOptions,
+} from './in-memory-store.js';

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

@@ -33,7 +33,7 @@ let currentRegistry: PluginRegistry | null = null;
  */
 export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
   const debug = config.debug || false;
-  const apiPrefix = config.apiPrefix || '/';
+  const apiPrefix = config.apiPrefix || ''; // Empty string to avoid double slashes in template literals
   const apiEnabled = config.apiEnabled !== false;
 
   function log(message: string, data?: Record<string, unknown>) {
@@ -118,7 +118,7 @@ export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
       // List/Search tenants
       registry.addRoute({
         method: 'get',
-        path: apiPrefix,
+        path: apiPrefix || '/',
         pluginId: 'tenants',
         handler: async (req: Request, res: Response) => {
           try {
@@ -201,7 +201,7 @@ export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
       // Create tenant
       registry.addRoute({
         method: 'post',
-        path: apiPrefix,
+        path: apiPrefix || '/',
         pluginId: 'tenants',
         handler: async (req: Request, res: Response) => {
           try {

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';