@abpjs/tenant-management 0.7.6

package/dist/index.mjs

@@ -0,0 +1,530 @@
+// src/services/tenant-management.service.ts
+var TenantManagementService = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  /**
+   * Get all tenants (paginated)
+   * @returns Promise with paginated tenant response
+   */
+  getAll() {
+    return this.rest.request({
+      method: "GET",
+      url: "/api/multi-tenancy/tenants"
+    });
+  }
+  /**
+   * Get a tenant by ID
+   * @param id Tenant ID
+   * @returns Promise with tenant item
+   */
+  getById(id) {
+    return this.rest.request({
+      method: "GET",
+      url: `/api/multi-tenancy/tenants/${id}`
+    });
+  }
+  /**
+   * Create a new tenant
+   * @param body Tenant creation request
+   * @returns Promise with created tenant item
+   */
+  create(body) {
+    return this.rest.request({
+      method: "POST",
+      url: "/api/multi-tenancy/tenants",
+      body
+    });
+  }
+  /**
+   * Update an existing tenant
+   * @param body Tenant update request (includes id)
+   * @returns Promise with updated tenant item
+   */
+  update(body) {
+    const { id, ...data } = body;
+    return this.rest.request({
+      method: "PUT",
+      url: `/api/multi-tenancy/tenants/${id}`,
+      body: data
+    });
+  }
+  /**
+   * Delete a tenant
+   * @param id Tenant ID
+   * @returns Promise that resolves when deletion completes
+   */
+  delete(id) {
+    return this.rest.request({
+      method: "DELETE",
+      url: `/api/multi-tenancy/tenants/${id}`
+    });
+  }
+  /**
+   * Get default connection string for a tenant
+   * @param id Tenant ID
+   * @returns Promise with connection string (empty string if using shared database)
+   */
+  getDefaultConnectionString(id) {
+    return this.rest.request({
+      method: "GET",
+      url: `/api/multi-tenancy/tenants/${id}/default-connection-string`
+    });
+  }
+  /**
+   * Update default connection string for a tenant
+   * @param payload Request with tenant ID and connection string
+   * @returns Promise that resolves when update completes
+   */
+  updateDefaultConnectionString(payload) {
+    const { id, defaultConnectionString } = payload;
+    return this.rest.request({
+      method: "PUT",
+      url: `/api/multi-tenancy/tenants/${id}/default-connection-string`,
+      params: { defaultConnectionString }
+    });
+  }
+  /**
+   * Delete default connection string for a tenant (use shared database)
+   * @param id Tenant ID
+   * @returns Promise that resolves when deletion completes
+   */
+  deleteDefaultConnectionString(id) {
+    return this.rest.request({
+      method: "DELETE",
+      url: `/api/multi-tenancy/tenants/${id}/default-connection-string`
+    });
+  }
+};
+
+// src/hooks/useTenantManagement.ts
+import { useState, useCallback, useMemo } from "react";
+import { useRestService } from "@abpjs/core";
+function useTenantManagement() {
+  const restService = useRestService();
+  const service = useMemo(() => new TenantManagementService(restService), [restService]);
+  const [tenants, setTenants] = useState([]);
+  const [selectedTenant, setSelectedTenant] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [defaultConnectionString, setDefaultConnectionString] = useState("");
+  const [useSharedDatabase, setUseSharedDatabase] = useState(true);
+  const fetchTenants = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await service.getAll();
+      setTenants(response.items);
+      setIsLoading(false);
+      return { success: true };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Failed to fetch tenants";
+      setError(errorMessage);
+      setIsLoading(false);
+      return { success: false, error: errorMessage };
+    }
+  }, [service]);
+  const fetchTenantById = useCallback(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const tenant = await service.getById(id);
+        setSelectedTenant(tenant);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch tenant";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const createTenant = useCallback(
+    async (data) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.create(data);
+        await service.getAll().then((response) => setTenants(response.items));
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to create tenant";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const updateTenant = useCallback(
+    async (data) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.update(data);
+        await service.getAll().then((response) => setTenants(response.items));
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to update tenant";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const deleteTenant = useCallback(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.delete(id);
+        await service.getAll().then((response) => setTenants(response.items));
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to delete tenant";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const fetchConnectionString = useCallback(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const connectionString = await service.getDefaultConnectionString(id);
+        setDefaultConnectionString(connectionString || "");
+        setUseSharedDatabase(!connectionString);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch connection string";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const updateConnectionString = useCallback(
+    async (id, connectionString) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.updateDefaultConnectionString({
+          id,
+          defaultConnectionString: connectionString
+        });
+        setDefaultConnectionString(connectionString);
+        setUseSharedDatabase(false);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to update connection string";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const deleteConnectionString = useCallback(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.deleteDefaultConnectionString(id);
+        setDefaultConnectionString("");
+        setUseSharedDatabase(true);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to delete connection string";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const reset = useCallback(() => {
+    setTenants([]);
+    setSelectedTenant(null);
+    setIsLoading(false);
+    setError(null);
+    setDefaultConnectionString("");
+    setUseSharedDatabase(true);
+  }, []);
+  return {
+    tenants,
+    selectedTenant,
+    isLoading,
+    error,
+    defaultConnectionString,
+    useSharedDatabase,
+    fetchTenants,
+    fetchTenantById,
+    createTenant,
+    updateTenant,
+    deleteTenant,
+    fetchConnectionString,
+    updateConnectionString,
+    deleteConnectionString,
+    setSelectedTenant,
+    setUseSharedDatabase,
+    setDefaultConnectionString,
+    reset
+  };
+}
+
+// src/components/TenantManagementModal/TenantManagementModal.tsx
+import { useEffect, useCallback as useCallback2, useState as useState2 } from "react";
+import { useLocalization } from "@abpjs/core";
+import { Modal, Alert, Button, Checkbox, FormField } from "@abpjs/theme-shared";
+import {
+  Box,
+  Flex,
+  Input,
+  Spinner,
+  VStack
+} from "@chakra-ui/react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function TenantManagementModal({
+  visible,
+  onVisibleChange,
+  tenantId,
+  initialView = "tenant",
+  onSave
+}) {
+  const { t } = useLocalization();
+  const {
+    selectedTenant,
+    isLoading,
+    error,
+    defaultConnectionString,
+    useSharedDatabase,
+    fetchTenantById,
+    createTenant,
+    updateTenant,
+    fetchConnectionString,
+    updateConnectionString,
+    deleteConnectionString,
+    reset
+  } = useTenantManagement();
+  const [currentView, setCurrentView] = useState2(initialView);
+  const [tenantName, setTenantName] = useState2("");
+  const [tenantNameError, setTenantNameError] = useState2(null);
+  const [localConnectionString, setLocalConnectionString] = useState2("");
+  const [localUseSharedDatabase, setLocalUseSharedDatabase] = useState2(true);
+  const isEditing = !!tenantId;
+  const getModalTitle = () => {
+    if (currentView === "connectionString") {
+      return t("AbpTenantManagement::ConnectionStrings");
+    }
+    return isEditing ? t("AbpTenantManagement::Edit") : t("AbpTenantManagement::NewTenant");
+  };
+  useEffect(() => {
+    if (visible && tenantId) {
+      fetchTenantById(tenantId);
+      if (initialView === "connectionString") {
+        fetchConnectionString(tenantId);
+      }
+    }
+    if (visible) {
+      setCurrentView(initialView);
+    }
+    if (!visible) {
+      reset();
+      setTenantName("");
+      setTenantNameError(null);
+      setLocalConnectionString("");
+      setLocalUseSharedDatabase(true);
+    }
+  }, [visible, tenantId, initialView, fetchTenantById, fetchConnectionString, reset]);
+  useEffect(() => {
+    if (selectedTenant) {
+      setTenantName(selectedTenant.name);
+    }
+  }, [selectedTenant]);
+  useEffect(() => {
+    setLocalConnectionString(defaultConnectionString);
+    setLocalUseSharedDatabase(useSharedDatabase);
+  }, [defaultConnectionString, useSharedDatabase]);
+  const validateTenantName = useCallback2(
+    (name) => {
+      if (!name || name.trim().length === 0) {
+        setTenantNameError(t("AbpValidation::ThisFieldIsRequired"));
+        return false;
+      }
+      if (name.length > 256) {
+        setTenantNameError(
+          t("AbpValidation::ThisFieldMustBeBetween{0}And{1}Characters", "1", "256")
+        );
+        return false;
+      }
+      setTenantNameError(null);
+      return true;
+    },
+    [t]
+  );
+  const handleTenantSubmit = useCallback2(async () => {
+    if (!validateTenantName(tenantName)) {
+      return;
+    }
+    let result;
+    if (isEditing && tenantId) {
+      result = await updateTenant({ id: tenantId, name: tenantName.trim() });
+    } else {
+      result = await createTenant({ name: tenantName.trim() });
+    }
+    if (result.success) {
+      onSave?.();
+      onVisibleChange?.(false);
+    }
+  }, [
+    tenantName,
+    isEditing,
+    tenantId,
+    validateTenantName,
+    createTenant,
+    updateTenant,
+    onSave,
+    onVisibleChange
+  ]);
+  const handleConnectionStringSubmit = useCallback2(async () => {
+    if (!tenantId) return;
+    let result;
+    if (localUseSharedDatabase) {
+      result = await deleteConnectionString(tenantId);
+    } else {
+      result = await updateConnectionString(tenantId, localConnectionString);
+    }
+    if (result.success) {
+      onSave?.();
+      onVisibleChange?.(false);
+    }
+  }, [
+    tenantId,
+    localUseSharedDatabase,
+    localConnectionString,
+    deleteConnectionString,
+    updateConnectionString,
+    onSave,
+    onVisibleChange
+  ]);
+  const handleClose = useCallback2(() => {
+    onVisibleChange?.(false);
+  }, [onVisibleChange]);
+  const handleTenantNameChange = useCallback2(
+    (e) => {
+      const value = e.target.value;
+      setTenantName(value);
+      if (tenantNameError) {
+        validateTenantName(value);
+      }
+    },
+    [tenantNameError, validateTenantName]
+  );
+  const handleUseSharedDatabaseChange = useCallback2(() => {
+    setLocalUseSharedDatabase((prev) => {
+      const newValue = !prev;
+      if (newValue) {
+        setLocalConnectionString("");
+      }
+      return newValue;
+    });
+  }, []);
+  const handleConnectionStringChange = useCallback2((e) => {
+    setLocalConnectionString(e.target.value);
+  }, []);
+  const renderTenantForm = () => /* @__PURE__ */ jsx(VStack, { gap: 4, align: "stretch", children: /* @__PURE__ */ jsx(
+    FormField,
+    {
+      label: t("AbpTenantManagement::TenantName"),
+      htmlFor: "tenant-name",
+      invalid: !!tenantNameError,
+      errorText: tenantNameError || void 0,
+      required: true,
+      children: /* @__PURE__ */ jsx(
+        Input,
+        {
+          id: "tenant-name",
+          value: tenantName,
+          onChange: handleTenantNameChange,
+          placeholder: t("AbpTenantManagement::TenantName"),
+          maxLength: 256
+        }
+      )
+    }
+  ) });
+  const renderConnectionStringForm = () => /* @__PURE__ */ jsxs(VStack, { gap: 4, align: "stretch", children: [
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(
+      Checkbox,
+      {
+        id: "use-shared-database",
+        checked: localUseSharedDatabase,
+        onChange: handleUseSharedDatabaseChange,
+        children: t("AbpTenantManagement::DisplayName:UseSharedDatabase")
+      }
+    ) }),
+    !localUseSharedDatabase && /* @__PURE__ */ jsx(
+      FormField,
+      {
+        label: t("AbpTenantManagement::DisplayName:DefaultConnectionString"),
+        htmlFor: "connection-string",
+        children: /* @__PURE__ */ jsx(
+          Input,
+          {
+            id: "connection-string",
+            value: localConnectionString,
+            onChange: handleConnectionStringChange,
+            placeholder: t("AbpTenantManagement::DisplayName:DefaultConnectionString")
+          }
+        )
+      }
+    )
+  ] });
+  return /* @__PURE__ */ jsxs(
+    Modal,
+    {
+      visible,
+      onVisibleChange,
+      size: "md",
+      header: getModalTitle(),
+      footer: /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: handleClose, disabled: isLoading, children: t("AbpTenantManagement::Cancel") }),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            colorPalette: "blue",
+            onClick: currentView === "connectionString" ? handleConnectionStringSubmit : handleTenantSubmit,
+            loading: isLoading,
+            children: t("AbpTenantManagement::Save")
+          }
+        )
+      ] }),
+      children: [
+        isLoading && !selectedTenant && currentView === "tenant" && /* @__PURE__ */ jsx(Flex, { justify: "center", align: "center", py: 8, children: /* @__PURE__ */ jsx(Spinner, { size: "lg" }) }),
+        error && /* @__PURE__ */ jsx(Alert, { status: "error", mb: 4, children: error }),
+        /* @__PURE__ */ jsxs(Box, { children: [
+          currentView === "tenant" && renderTenantForm(),
+          currentView === "connectionString" && renderConnectionStringForm()
+        ] })
+      ]
+    }
+  );
+}
+export {
+  TenantManagementModal,
+  TenantManagementService,
+  useTenantManagement
+};

package/dist/models/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Tenant Management module type definitions
+ * Translated from @abp/ng.tenant-management v0.7.6
+ */
+import type { ABP } from '@abpjs/core';
+/**
+ * TenantManagement namespace containing all tenant-related types
+ */
+export declare namespace TenantManagement {
+    /**
+     * State interface for tenant management store
+     */
+    interface State {
+        result: Response;
+        selectedItem: Item;
+    }
+    /**
+     * API response for tenant list (paginated)
+     */
+    type Response = ABP.PagedResponse<Item>;
+    /**
+     * Single tenant item
+     */
+    interface Item {
+        id: string;
+        name: string;
+    }
+    /**
+     * Request payload for creating a new tenant
+     */
+    interface AddRequest {
+        name: string;
+    }
+    /**
+     * Request payload for updating an existing tenant
+     */
+    interface UpdateRequest extends AddRequest {
+        id: string;
+    }
+    /**
+     * Request payload for updating tenant's default connection string
+     */
+    interface DefaultConnectionStringRequest {
+        id: string;
+        defaultConnectionString: string;
+    }
+}

package/dist/services/index.d.ts

@@ -0,0 +1 @@
+export { TenantManagementService } from './tenant-management.service';

package/dist/services/tenant-management.service.d.ts

@@ -0,0 +1,57 @@
+import { RestService } from '@abpjs/core';
+import { TenantManagement } from '../models';
+/**
+ * Service for tenant management API calls
+ * Translated from @abp/ng.tenant-management v0.7.6
+ */
+export declare class TenantManagementService {
+    private rest;
+    constructor(rest: RestService);
+    /**
+     * Get all tenants (paginated)
+     * @returns Promise with paginated tenant response
+     */
+    getAll(): Promise<TenantManagement.Response>;
+    /**
+     * Get a tenant by ID
+     * @param id Tenant ID
+     * @returns Promise with tenant item
+     */
+    getById(id: string): Promise<TenantManagement.Item>;
+    /**
+     * Create a new tenant
+     * @param body Tenant creation request
+     * @returns Promise with created tenant item
+     */
+    create(body: TenantManagement.AddRequest): Promise<TenantManagement.Item>;
+    /**
+     * Update an existing tenant
+     * @param body Tenant update request (includes id)
+     * @returns Promise with updated tenant item
+     */
+    update(body: TenantManagement.UpdateRequest): Promise<TenantManagement.Item>;
+    /**
+     * Delete a tenant
+     * @param id Tenant ID
+     * @returns Promise that resolves when deletion completes
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Get default connection string for a tenant
+     * @param id Tenant ID
+     * @returns Promise with connection string (empty string if using shared database)
+     */
+    getDefaultConnectionString(id: string): Promise<string>;
+    /**
+     * Update default connection string for a tenant
+     * @param payload Request with tenant ID and connection string
+     * @returns Promise that resolves when update completes
+     */
+    updateDefaultConnectionString(payload: TenantManagement.DefaultConnectionStringRequest): Promise<void>;
+    /**
+     * Delete default connection string for a tenant (use shared database)
+     * @param id Tenant ID
+     * @returns Promise that resolves when deletion completes
+     */
+    deleteDefaultConnectionString(id: string): Promise<void>;
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@abpjs/tenant-management",
+  "version": "0.7.6",
+  "description": "ABP Framework tenant-management components for React - translated from @abp/ng.tenant-management",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "dependencies": {
+    "@chakra-ui/react": "^3.2.0",
+    "@emotion/react": "^11.11.0",
+    "@abpjs/core": "0.7.6",
+    "@abpjs/theme-shared": "0.7.6"
+  },
+  "devDependencies": {
+    "@abp/ng.tenant-management": "0.7.6",
+    "autoprefixer": "^10.4.16",
+    "postcss": "^8.4.32",
+    "tailwindcss": "^3.4.0"
+  },
+  "author": "tekthar.com",
+  "license": "LGPL-3.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/abpjs/abp-react"
+  },
+  "homepage": "https://docs.abpjs.io/docs/packages/tenant-management/overview",
+  "bugs": {
+    "url": "https://github.com/abpjs/abp-react/issues"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --clean && tsc -p tsconfig.build.json",
+    "dev": "tsup src/index.ts --format cjs,esm --watch",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "format": "prettier --write \"src/**/*.{ts,tsx,json,md}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,tsx,json,md}\"",
+    "type-check": "tsc --noEmit",
+    "test": "vitest"
+  }
+}