@qwickapps/server 1.6.1 → 1.7.0

package/src/plugins/tenants/types.ts

@@ -0,0 +1,249 @@
+/**
+ * Tenants Plugin Types
+ *
+ * Type definitions for multi-tenant data isolation and organization management.
+ * Storage-agnostic - supports any database through the TenantStore interface.
+ *
+ * Tenant-first design: Every user belongs to at least one tenant (their personal tenant).
+ * Organizations are multi-user tenants with role-based access control.
+ *
+ * Copyright (c) 2025 QwickApps.com. All rights reserved.
+ */
+
+/**
+ * Tenant type determines isolation level and capabilities
+ */
+export type TenantType = 'user' | 'organization' | 'group' | 'department';
+
+/**
+ * Tenant record in the database
+ */
+export interface Tenant {
+  /** Primary key - UUID */
+  id: string;
+  /** Tenant name (user's email for user tenants, org name for organizations) */
+  name: string;
+  /** Tenant type */
+  type: TenantType;
+  /** Owner user ID (user who created/owns this tenant) */
+  owner_id: string;
+  /** Additional metadata (JSON) */
+  metadata?: Record<string, unknown>;
+  /** When the tenant was created */
+  created_at: Date;
+  /** When the tenant was last updated */
+  updated_at: Date;
+}
+
+/**
+ * Tenant creation payload
+ */
+export interface CreateTenantInput {
+  name: string;
+  type: TenantType;
+  owner_id: string;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Tenant update payload
+ */
+export interface UpdateTenantInput {
+  name?: string;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Tenant search parameters
+ */
+export interface TenantSearchParams {
+  /** Search query (searches name) */
+  query?: string;
+  /** Filter by type */
+  type?: TenantType;
+  /** Filter by owner */
+  owner_id?: string;
+  /** Page number (1-indexed) */
+  page?: number;
+  /** Items per page */
+  limit?: number;
+  /** Sort field */
+  sortBy?: 'name' | 'type' | 'created_at';
+  /** Sort direction */
+  sortOrder?: 'asc' | 'desc';
+}
+
+/**
+ * Paginated tenant list response
+ */
+export interface TenantListResponse {
+  tenants: Tenant[];
+  total: number;
+  page: number;
+  limit: number;
+  totalPages: number;
+}
+
+/**
+ * Tenant membership record (many-to-many: users <-> tenants)
+ */
+export interface TenantMembership {
+  /** Primary key - UUID */
+  id: string;
+  /** Tenant ID */
+  tenant_id: string;
+  /** User ID */
+  user_id: string;
+  /** Role in this tenant (owner, admin, member, viewer) */
+  role: string;
+  /** When the user joined this tenant */
+  joined_at: Date;
+}
+
+/**
+ * Tenant membership creation payload
+ */
+export interface CreateTenantMembershipInput {
+  tenant_id: string;
+  user_id: string;
+  role: string;
+}
+
+/**
+ * Tenant membership update payload
+ */
+export interface UpdateTenantMembershipInput {
+  role?: string;
+}
+
+/**
+ * Tenant with membership info (for current user)
+ */
+export interface TenantWithMembership extends Tenant {
+  /** Current user's role in this tenant */
+  user_role: string;
+  /** Current user's membership record */
+  membership: TenantMembership;
+}
+
+/**
+ * Tenant store interface - all storage backends must implement this
+ */
+export interface TenantStore {
+  /** Store name (e.g., 'postgres', 'memory') */
+  name: string;
+
+  /**
+   * Initialize the store (create tables, etc.)
+   */
+  initialize(): Promise<void>;
+
+  /**
+   * Get a tenant by ID
+   */
+  getById(id: string): Promise<Tenant | null>;
+
+  /**
+   * Get multiple tenants by IDs (batch query)
+   */
+  getByIds(ids: string[]): Promise<Tenant[]>;
+
+  /**
+   * Get a tenant by name
+   */
+  getByName(name: string): Promise<Tenant | null>;
+
+  /**
+   * Create a new tenant
+   */
+  create(input: CreateTenantInput): Promise<Tenant>;
+
+  /**
+   * Update a tenant
+   */
+  update(id: string, input: UpdateTenantInput): Promise<Tenant | null>;
+
+  /**
+   * Delete a tenant (hard delete)
+   */
+  delete(id: string): Promise<boolean>;
+
+  /**
+   * Search tenants with pagination
+   */
+  search(params: TenantSearchParams): Promise<TenantListResponse>;
+
+  /**
+   * Get all tenants for a user (via memberships)
+   */
+  getTenantsForUser(userId: string): Promise<TenantWithMembership[]>;
+
+  /**
+   * Get a tenant for a user with membership info
+   */
+  getTenantForUser(tenantId: string, userId: string): Promise<TenantWithMembership | null>;
+
+  /**
+   * Add a user to a tenant (create membership)
+   */
+  addMember(input: CreateTenantMembershipInput): Promise<TenantMembership>;
+
+  /**
+   * Update a user's role in a tenant
+   */
+  updateMember(
+    tenantId: string,
+    userId: string,
+    input: UpdateTenantMembershipInput
+  ): Promise<TenantMembership | null>;
+
+  /**
+   * Remove a user from a tenant (delete membership)
+   */
+  removeMember(tenantId: string, userId: string): Promise<boolean>;
+
+  /**
+   * Get all members of a tenant
+   */
+  getMembers(tenantId: string): Promise<TenantMembership[]>;
+
+  /**
+   * Get a specific membership
+   */
+  getMembership(tenantId: string, userId: string): Promise<TenantMembership | null>;
+
+  /**
+   * Shutdown the store (close connections, cleanup)
+   */
+  shutdown(): Promise<void>;
+}
+
+/**
+ * PostgreSQL tenant store configuration
+ */
+export interface PostgresTenantStoreConfig {
+  /** PostgreSQL pool instance or a function that returns one (for lazy initialization) */
+  pool: unknown | (() => unknown);
+  /** Tenants table name (default: 'tenants') */
+  tenantsTable?: string;
+  /** Tenant memberships table name (default: 'tenant_memberships') */
+  membershipsTable?: string;
+  /** Schema name (default: 'public') */
+  schema?: string;
+  /** Auto-create tables on init (default: true) */
+  autoCreateTables?: boolean;
+}
+
+/**
+ * Tenants plugin configuration
+ */
+export interface TenantsPluginConfig {
+  /** Tenant store implementation */
+  store: TenantStore;
+  /** API route prefix (default: '/tenants') */
+  apiPrefix?: string;
+  /** Enable API endpoints (default: true) */
+  apiEnabled?: boolean;
+  /** Enable debug logging (default: false) */
+  debug?: boolean;
+}

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

@@ -29,6 +29,7 @@ import type {
 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';
 
 // Store instance for helper access
 let currentStore: UserStore | null = null;
@@ -152,6 +153,18 @@ export function createUsersPlugin(config: UsersPluginConfig): Plugin {
               }
 
               const user = await config.store.create(input);
+
+              // Auto-create personal tenant if tenants plugin available
+              if (registry.hasPlugin('tenants')) {
+                try {
+                  await autoCreateUserTenant(user.id);
+                  log('Auto-created personal tenant for user', { userId: user.id });
+                } catch (error) {
+                  console.error('[UsersPlugin] Failed to auto-create tenant:', error);
+                  // Don't fail user creation if tenant creation fails
+                }
+              }
+
               res.status(201).json(user);
             } catch (error) {
               console.error('[UsersPlugin] Create user error:', error);
@@ -493,6 +506,16 @@ export async function findOrCreateUser(data: {
     picture: data.picture,
   });
 
+  // Auto-create personal tenant if tenants plugin available
+  if (currentRegistry && currentRegistry.hasPlugin('tenants')) {
+    try {
+      await autoCreateUserTenant(user.id);
+    } catch (error) {
+      console.error('[UsersPlugin] Failed to auto-create tenant:', error);
+      // Don't fail user creation if tenant creation fails
+    }
+  }
+
   return user;
 }
 

package/ui/src/App.tsx

@@ -13,6 +13,7 @@ import { LogsPage } from './pages/LogsPage';
 import { SystemPage } from './pages/SystemPage';
 import { PluginsPage } from './pages/PluginsPage';
 import { UsersPage } from './pages/UsersPage';
+import { TenantsManagementPage } from './pages/TenantsManagementPage';
 import { EntitlementsPage } from './pages/EntitlementsPage';
 import { AuthPage } from './pages/AuthPage';
 import { RateLimitPage } from './pages/RateLimitPage';
@@ -44,11 +45,12 @@ const coreNavigationItems: NavigationItem[] = [
 // Built-in optional navigation items - shown if corresponding plugin is registered
 const builtInPluginNavItems: Record<string, NavigationItem> = {
   users: { id: 'users', label: 'Users', route: '/users', icon: 'people' },
+  tenants: { id: 'tenants', label: 'Tenants', route: '/tenants', icon: 'business' },
   'api-keys': { id: 'api-keys', label: 'API Keys', route: '/api-keys', icon: 'key' },
 };
 
 // Routes that have dedicated page components
-const dedicatedRoutes = new Set(['/', '/plugins', '/logs', '/system', '/users', '/entitlements', '/auth', '/rate-limits', '/notifications', '/integrations', '/api-keys', '/contentops/jobs', '/maintenance']);
+const dedicatedRoutes = new Set(['/', '/plugins', '/logs', '/system', '/users', '/tenants', '/entitlements', '/auth', '/rate-limits', '/notifications', '/integrations', '/api-keys', '/contentops/jobs', '/maintenance']);
 
 // Package version - injected at build time or fallback
 const SERVER_VERSION = '1.0.0';
@@ -212,6 +214,9 @@ export function App() {
             {registeredPlugins.has('users') && (
               <Route path="/users" element={<UsersPage />} />
             )}
+            {registeredPlugins.has('tenants') && (
+              <Route path="/tenants" element={<TenantsManagementPage />} />
+            )}
             {registeredPlugins.has('entitlements') && (
               <Route path="/entitlements" element={<EntitlementsPage />} />
             )}

package/ui/src/components/tenants/MemberInviteDialog.tsx

@@ -0,0 +1,139 @@
+/**
+ * MemberInviteDialog Component
+ *
+ * Dialog for inviting/adding a member to a tenant.
+ *
+ * Copyright (c) 2025 QwickApps.com. All rights reserved.
+ */
+
+import { useState, useEffect } from 'react';
+import {
+  TextField,
+  Select,
+  MenuItem,
+  FormControl,
+  InputLabel,
+  FormHelperText,
+} from '@mui/material';
+import { Dialog, DialogTitle, DialogContent, DialogActions, Button } from '@qwickapps/react-framework';
+
+export interface MemberInviteDialogProps {
+  /** Whether the dialog is open */
+  open: boolean;
+  /** Tenant name for display */
+  tenantName: string;
+  /** Callback when dialog is closed */
+  onClose: () => void;
+  /** Callback when form is submitted */
+  onSubmit: (data: { user_id: string; role: string }) => void | Promise<void>;
+}
+
+export function MemberInviteDialog({
+  open,
+  tenantName,
+  onClose,
+  onSubmit,
+}: MemberInviteDialogProps) {
+  const [userId, setUserId] = useState('');
+  const [role, setRole] = useState<string>('member');
+  const [errors, setErrors] = useState<Record<string, string>>({});
+  const [submitting, setSubmitting] = useState(false);
+
+  // Reset form when dialog opens
+  useEffect(() => {
+    if (open) {
+      setUserId('');
+      setRole('member');
+      setErrors({});
+      setSubmitting(false);
+    }
+  }, [open]);
+
+  const validate = () => {
+    const newErrors: Record<string, string> = {};
+
+    if (!userId.trim()) {
+      newErrors.userId = 'User ID is required';
+    }
+
+    if (!role) {
+      newErrors.role = 'Role is required';
+    }
+
+    setErrors(newErrors);
+    return Object.keys(newErrors).length === 0;
+  };
+
+  const handleSubmit = async () => {
+    if (!validate()) {
+      return;
+    }
+
+    setSubmitting(true);
+
+    try {
+      await onSubmit({
+        user_id: userId.trim(),
+        role,
+      });
+      onClose();
+    } catch (err) {
+      setErrors({
+        submit: err instanceof Error ? err.message : 'Failed to add member',
+      });
+    } finally {
+      setSubmitting(false);
+    }
+  };
+
+  return (
+    <Dialog open={open} onClose={onClose} maxWidth="sm" fullWidth>
+      <DialogTitle>Add Member to {tenantName}</DialogTitle>
+      <DialogContent>
+        <TextField
+          label="User ID"
+          value={userId}
+          onChange={(e) => setUserId(e.target.value)}
+          fullWidth
+          margin="normal"
+          error={!!errors.userId}
+          helperText={errors.userId || 'UUID of the user to add'}
+          autoFocus
+        />
+
+        <FormControl fullWidth margin="normal" error={!!errors.role}>
+          <InputLabel>Role</InputLabel>
+          <Select
+            value={role}
+            label="Role"
+            onChange={(e) => setRole(e.target.value)}
+          >
+            <MenuItem value="owner">Owner - Full control</MenuItem>
+            <MenuItem value="admin">Admin - Manage members</MenuItem>
+            <MenuItem value="member">Member - Standard access</MenuItem>
+            <MenuItem value="viewer">Viewer - Read-only</MenuItem>
+          </Select>
+          {errors.role && <FormHelperText>{errors.role}</FormHelperText>}
+        </FormControl>
+
+        {errors.submit && (
+          <FormHelperText error sx={{ mt: 2 }}>
+            {errors.submit}
+          </FormHelperText>
+        )}
+      </DialogContent>
+      <DialogActions>
+        <Button onClick={onClose} disabled={submitting}>
+          Cancel
+        </Button>
+        <Button
+          onClick={handleSubmit}
+          variant="contained"
+          disabled={submitting}
+        >
+          {submitting ? 'Adding...' : 'Add Member'}
+        </Button>
+      </DialogActions>
+    </Dialog>
+  );
+}