@qwickapps/server 1.7.0 → 1.7.2

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

@@ -23,58 +23,26 @@ import type {
 } from './types.js';
 import { getUserById } from '../users/users-plugin.js';
 import { getAuthenticatedUser, isAuthenticated } from '../auth/index.js';
+import { hasPostgres, getPostgres } from '../postgres-plugin.js';
+import { postgresTenantStore } from './stores/index.js';
 
 // Store instance and registry for helper access
 let currentStore: TenantStore | null = null;
 let currentRegistry: PluginRegistry | null = null;
 
 /**
- * Create the Tenants plugin
+ * Create the Tenants 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 createTenantsPlugin(config: TenantsPluginConfig): Plugin {
-  const debug = config.debug || false;
-  const apiPrefix = config.apiPrefix || '/';
-  const apiEnabled = config.apiEnabled !== false;
-
-  function log(message: string, data?: Record<string, unknown>) {
-    if (debug) {
-      console.log(`[TenantsPlugin] ${message}`, data || '');
-    }
-  }
-
-  /**
-   * Helper to check if user has access to a tenant
-   */
-  async function canAccessTenant(userId: string, tenantId: string): Promise<boolean> {
-    try {
-      const membership = await config.store.getTenantForUser(tenantId, userId);
-      return membership !== null;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Helper to check if user has admin/owner role in a tenant
-   */
-  async function canManageTenant(userId: string, tenantId: string): Promise<boolean> {
-    try {
-      const membership = await config.store.getTenantForUser(tenantId, userId);
-      return membership !== null && ['owner', 'admin'].includes(membership.user_role);
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Helper to check if user is owner of a tenant
-   */
-  async function isOwnerOfTenant(userId: string, tenantId: string): Promise<boolean> {
-    try {
-      const membership = await config.store.getTenantForUser(tenantId, userId);
-      return membership !== null && membership.user_role === 'owner';
-    } catch {
-      return false;
+export function createTenantsPlugin(config: Partial<TenantsPluginConfig> = {}): Plugin {
+  function log(message: string, data?: Record<string, unknown>, isError = false) {
+    const prefix = '[TenantsPlugin]';
+    if (isError) {
+      console.error(`${prefix} ${message}`, data || '');
+    } else if (config.debug) {
+      console.log(`${prefix} ${message}`, data || '');
     }
   }
 
@@ -84,14 +52,43 @@ export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
     version: '1.0.0',
 
     async onStart(_pluginConfig: PluginConfig, registry: PluginRegistry): Promise<void> {
+      const logger = registry.getLogger('tenants');
+
+      // Check for postgres in registry
+      if (!hasPostgres()) {
+        logger.warn('No Database! Tenants plugin disabled.');
+        registry.registerHealthCheck({
+          name: 'tenants-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 ?? postgresTenantStore({
+        pool: () => getPostgres().getPool(),
+        autoCreateTables: true,
+      });
+
+      const debug = config.debug ?? false;
+      const apiPrefix = config.apiPrefix ?? '/tenants';
+      const apiEnabled = config.apiEnabled ?? true;
+
       log('Starting tenants plugin');
 
       // Initialize the store (creates tables if needed)
-      await config.store.initialize();
+      await store.initialize();
       log('Tenants plugin migrations complete');
 
       // Store references for helper access
-      currentStore = config.store;
+      currentStore = store;
       currentRegistry = registry;
 
       // Register health check
@@ -101,7 +98,7 @@ export function createTenantsPlugin(config: TenantsPluginConfig): 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 };
@@ -109,6 +106,42 @@ export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
         },
       });
 
+      /**
+       * Helper to check if user has access to a tenant
+       */
+      async function canAccessTenant(userId: string, tenantId: string): Promise<boolean> {
+        try {
+          const membership = await store.getTenantForUser(tenantId, userId);
+          return membership !== null;
+        } catch {
+          return false;
+        }
+      }
+
+      /**
+       * Helper to check if user has admin/owner role in a tenant
+       */
+      async function canManageTenant(userId: string, tenantId: string): Promise<boolean> {
+        try {
+          const membership = await store.getTenantForUser(tenantId, userId);
+          return membership !== null && ['owner', 'admin'].includes(membership.user_role);
+        } catch {
+          return false;
+        }
+      }
+
+      /**
+       * Helper to check if user is owner of a tenant
+       */
+      async function isOwnerOfTenant(userId: string, tenantId: string): Promise<boolean> {
+        try {
+          const membership = await store.getTenantForUser(tenantId, userId);
+          return membership !== null && membership.user_role === 'owner';
+        } catch {
+          return false;
+        }
+      }
+
       if (!apiEnabled) return;
 
       // ========================================================================
@@ -118,7 +151,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 {
@@ -140,7 +173,7 @@ export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
 
             // Users can only search their own tenants
             // Get all tenants user belongs to
-            const userTenants = await config.store.getTenantsForUser(user.id);
+            const userTenants = await store.getTenantsForUser(user.id);
             res.json({
               tenants: userTenants,
               total: userTenants.length,
@@ -186,7 +219,7 @@ export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
               });
             }
 
-            const tenant = await config.store.getById(req.params.id);
+            const tenant = await store.getById(req.params.id);
             if (!tenant) {
               return res.status(404).json({ error: 'Tenant not found' });
             }
@@ -201,7 +234,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 {
@@ -252,10 +285,10 @@ export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
               });
             }
 
-            const tenant = await config.store.create(input);
+            const tenant = await store.create(input);
 
             // Automatically add creator as owner
-            await config.store.addMember({
+            await store.addMember({
               tenant_id: tenant.id,
               user_id: user.id,
               role: 'owner',
@@ -306,7 +339,7 @@ export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
               metadata: req.body.metadata,
             };
 
-            const tenant = await config.store.update(req.params.id, input);
+            const tenant = await store.update(req.params.id, input);
             if (!tenant) {
               return res.status(404).json({ error: 'Tenant not found' });
             }
@@ -351,7 +384,7 @@ export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
               });
             }
 
-            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: 'Tenant not found' });
             }
@@ -400,7 +433,7 @@ export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
               });
             }
 
-            const tenants = await config.store.getTenantsForUser(req.params.userId);
+            const tenants = await store.getTenantsForUser(req.params.userId);
             res.json({ tenants, total: tenants.length });
           } catch (error) {
             console.error('[TenantsPlugin] Get user tenants error:', error);
@@ -444,7 +477,7 @@ export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
               });
             }
 
-            const members = await config.store.getMembers(req.params.tenantId);
+            const members = await store.getMembers(req.params.tenantId);
             res.json({ members, total: members.length });
           } catch (error) {
             console.error('[TenantsPlugin] Get members error:', error);
@@ -506,7 +539,7 @@ export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
               });
             }
 
-            const membership = await config.store.addMember(input);
+            const membership = await store.addMember(input);
             log('Member added to tenant', {
               tenantId: input.tenant_id,
               userId: input.user_id,
@@ -568,7 +601,7 @@ export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
               });
             }
 
-            const membership = await config.store.updateMember(req.params.tenantId, req.params.userId, input);
+            const membership = await store.updateMember(req.params.tenantId, req.params.userId, input);
             if (!membership) {
               return res.status(404).json({ error: 'Membership not found' });
             }
@@ -618,7 +651,7 @@ export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
               });
             }
 
-            const deleted = await config.store.removeMember(req.params.tenantId, req.params.userId);
+            const deleted = await store.removeMember(req.params.tenantId, req.params.userId);
             if (!deleted) {
               return res.status(404).json({ error: 'Membership not found' });
             }
@@ -641,7 +674,9 @@ export function createTenantsPlugin(config: TenantsPluginConfig): Plugin {
 
     async onStop(): Promise<void> {
       log('Stopping tenants plugin');
-      await config.store.shutdown();
+      if (currentStore) {
+        await currentStore.shutdown();
+      }
       currentStore = null;
       currentRegistry = null;
     },

package/src/plugins/tenants/types.ts

@@ -236,10 +236,16 @@ export interface PostgresTenantStoreConfig {
 
 /**
  * Tenants plugin configuration
+ *
+ * All properties are optional - plugin will use smart defaults:
+ * - store: Postgres tenant store using registry's postgres instance
+ * - apiPrefix: '/tenants'
+ * - apiEnabled: true
+ * - debug: false
  */
 export interface TenantsPluginConfig {
-  /** Tenant store implementation */
-  store: TenantStore;
+  /** Tenant store implementation (default: postgres tenant store from registry) */
+  store?: TenantStore;
   /** API route prefix (default: '/tenants') */
   apiPrefix?: string;
   /** Enable API endpoints (default: true) */

package/src/plugins/usage/index.ts

@@ -38,8 +38,6 @@ export type {
 // Stores
 export { postgresUsageStore } from './stores/index.js';
 
-// UI Components
-export { UsageStatusWidget } from './UsageStatusWidget.js';
-export type { UsageStatusWidgetProps } from './UsageStatusWidget.js';
-export { UsageManagementPage } from './UsageManagementPage.js';
-export type { UsageManagementPageProps } from './UsageManagementPage.js';
+// UI Components are exported from main package index (@qwickapps/server)
+// Do NOT export here to avoid loading UI dependencies when importing plugins
+