@dbs-portal/module-tenant-management/dist/hooks/use-tenants.js

Tenant management and multi-tenancy support module

/**
 * Tenant Management Hooks
 */
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
import { TenantService } from '../services/tenant-service';
const tenantService = new TenantService();
// Query Keys
export const tenantKeys = {
    all: ['tenants'],
    lists: () => [...tenantKeys.all, 'list'],
    list: (filters) => [...tenantKeys.lists(), filters],
    details: () => [...tenantKeys.all, 'detail'],
    detail: (id) => [...tenantKeys.details(), id],
    lookup: () => [...tenantKeys.all, 'lookup'],
    analytics: (id, period) => [...tenantKeys.all, 'analytics', id, period],
    backups: (id) => [...tenantKeys.all, 'backups', id],
    features: () => [...tenantKeys.all, 'features'],
    statistics: () => [...tenantKeys.all, 'statistics']
};
/**
 * Get tenants with pagination and filtering
 */
export function useTenants(page = 1, pageSize = 10, search, isActive, sortBy, sortOrder, options) {
    return useQuery({
        queryKey: tenantKeys.list({ page, pageSize, search, isActive, sortBy, sortOrder }),
        queryFn: () => tenantService.getTenants(page, pageSize, search, isActive, sortBy, sortOrder),
        staleTime: 5 * 60 * 1000, // 5 minutes
        enabled: options?.enabled !== false
    });
}
/**
 * Get single tenant by ID
 */
export function useTenant(id) {
    return useQuery({
        queryKey: tenantKeys.detail(id),
        queryFn: () => tenantService.getTenant(id),
        enabled: !!id,
        staleTime: 10 * 60 * 1000, // 10 minutes
    });
}
/**
 * Get tenant lookup data
 */
export function useTenantLookup() {
    return useQuery({
        queryKey: tenantKeys.lookup(),
        queryFn: () => tenantService.getTenantLookup(),
        staleTime: 15 * 60 * 1000, // 15 minutes
    });
}
/**
 * Create new tenant
 */
export function useCreateTenant() {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: (tenant) => tenantService.createTenant(tenant),
        onSuccess: () => {
            queryClient.invalidateQueries({ queryKey: tenantKeys.lists() });
            queryClient.invalidateQueries({ queryKey: tenantKeys.lookup() });
            queryClient.invalidateQueries({ queryKey: tenantKeys.statistics() });
        },
    });
}
/**
 * Update existing tenant
 */
export function useUpdateTenant() {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: (tenant) => tenantService.updateTenant(tenant),
        onSuccess: (updatedTenant) => {
            queryClient.invalidateQueries({ queryKey: tenantKeys.lists() });
            queryClient.invalidateQueries({ queryKey: tenantKeys.detail(updatedTenant.id) });
            queryClient.invalidateQueries({ queryKey: tenantKeys.lookup() });
        },
    });
}
/**
 * Delete tenant
 */
export function useDeleteTenant() {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: (id) => tenantService.deleteTenant(id),
        onSuccess: (_, deletedId) => {
            queryClient.invalidateQueries({ queryKey: tenantKeys.lists() });
            queryClient.removeQueries({ queryKey: tenantKeys.detail(deletedId) });
            queryClient.invalidateQueries({ queryKey: tenantKeys.lookup() });
            queryClient.invalidateQueries({ queryKey: tenantKeys.statistics() });
        },
    });
}
/**
 * Activate tenant
 */
export function useActivateTenant() {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: (id) => tenantService.activateTenant(id),
        onSuccess: (_, id) => {
            queryClient.invalidateQueries({ queryKey: tenantKeys.lists() });
            queryClient.invalidateQueries({ queryKey: tenantKeys.detail(id) });
            queryClient.invalidateQueries({ queryKey: tenantKeys.lookup() });
        },
    });
}
/**
 * Deactivate tenant
 */
export function useDeactivateTenant() {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: (id) => tenantService.deactivateTenant(id),
        onSuccess: (_, id) => {
            queryClient.invalidateQueries({ queryKey: tenantKeys.lists() });
            queryClient.invalidateQueries({ queryKey: tenantKeys.detail(id) });
            queryClient.invalidateQueries({ queryKey: tenantKeys.lookup() });
        },
    });
}
/**
 * Get tenant analytics
 */
export function useTenantAnalytics(id, period = 'month') {
    return useQuery({
        queryKey: tenantKeys.analytics(id, period),
        queryFn: () => tenantService.getTenantAnalytics(id, period),
        enabled: !!id,
        staleTime: 5 * 60 * 1000, // 5 minutes
    });
}
/**
 * Test tenant connection
 */
export function useTestTenantConnection() {
    return useMutation({
        mutationFn: (id) => tenantService.testTenantConnection(id),
    });
}
/**
 * Update tenant connection
 */
export function useUpdateTenantConnection() {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: ({ id, connectionString }) => tenantService.updateTenantConnection(id, connectionString),
        onSuccess: (_, { id }) => {
            queryClient.invalidateQueries({ queryKey: tenantKeys.detail(id) });
        },
    });
}
/**
 * Get available features
 */
export function useAvailableFeatures() {
    return useQuery({
        queryKey: tenantKeys.features(),
        queryFn: () => tenantService.getAvailableFeatures(),
        staleTime: 30 * 60 * 1000, // 30 minutes
    });
}
/**
 * Update tenant features
 */
export function useUpdateTenantFeatures() {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: ({ id, features }) => tenantService.updateTenantFeatures(id, features),
        onSuccess: (_, { id }) => {
            queryClient.invalidateQueries({ queryKey: tenantKeys.detail(id) });
        },
    });
}
/**
 * Get tenant backups
 */
export function useTenantBackups(id) {
    return useQuery({
        queryKey: tenantKeys.backups(id),
        queryFn: () => tenantService.getTenantBackups(id),
        enabled: !!id,
        staleTime: 2 * 60 * 1000, // 2 minutes
    });
}
/**
 * Create tenant backup
 */
export function useCreateTenantBackup() {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: ({ id, name, description, options }) => tenantService.createTenantBackup(id, name, description, options),
        onSuccess: (_, { id }) => {
            queryClient.invalidateQueries({ queryKey: tenantKeys.backups(id) });
        },
    });
}
/**
 * Restore tenant from backup
 */
export function useRestoreTenantFromBackup() {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: (request) => tenantService.restoreTenantFromBackup(request),
        onSuccess: (_, request) => {
            queryClient.invalidateQueries({ queryKey: tenantKeys.detail(request.tenantId) });
            queryClient.invalidateQueries({ queryKey: tenantKeys.backups(request.tenantId) });
        },
    });
}
/**
 * Delete tenant backup
 */
export function useDeleteTenantBackup() {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: ({ tenantId, backupId }) => tenantService.deleteTenantBackup(tenantId, backupId),
        onSuccess: (_, { tenantId }) => {
            queryClient.invalidateQueries({ queryKey: tenantKeys.backups(tenantId) });
        },
    });
}
/**
 * Get tenant statistics
 */
export function useTenantStatistics() {
    return useQuery({
        queryKey: tenantKeys.statistics(),
        queryFn: () => tenantService.getTenantStatistics(),
        staleTime: 5 * 60 * 1000, // 5 minutes
    });
}
/**
 * Bulk activate tenants
 */
export function useBulkActivateTenants() {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: (tenantIds) => tenantService.bulkActivateTenants(tenantIds),
        onSuccess: () => {
            queryClient.invalidateQueries({ queryKey: tenantKeys.lists() });
            queryClient.invalidateQueries({ queryKey: tenantKeys.lookup() });
        },
    });
}
/**
 * Bulk deactivate tenants
 */
export function useBulkDeactivateTenants() {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: (tenantIds) => tenantService.bulkDeactivateTenants(tenantIds),
        onSuccess: () => {
            queryClient.invalidateQueries({ queryKey: tenantKeys.lists() });
            queryClient.invalidateQueries({ queryKey: tenantKeys.lookup() });
        },
    });
}
/**
 * Bulk delete tenants
 */
export function useBulkDeleteTenants() {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: (tenantIds) => tenantService.bulkDeleteTenants(tenantIds),
        onSuccess: () => {
            queryClient.invalidateQueries({ queryKey: tenantKeys.lists() });
            queryClient.invalidateQueries({ queryKey: tenantKeys.lookup() });
            queryClient.invalidateQueries({ queryKey: tenantKeys.statistics() });
        },
    });
}
/**
 * Clone tenant
 */
export function useCloneTenant() {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: ({ sourceId, newName, newDisplayName, options }) => tenantService.cloneTenant(sourceId, newName, newDisplayName, options),
        onSuccess: () => {
            queryClient.invalidateQueries({ queryKey: tenantKeys.lists() });
            queryClient.invalidateQueries({ queryKey: tenantKeys.lookup() });
            queryClient.invalidateQueries({ queryKey: tenantKeys.statistics() });
        },
    });
}
//# sourceMappingURL=use-tenants.js.map