@abpjs/saas 0.7.2

package/dist/index.mjs

@@ -0,0 +1,1172 @@
+// src/constants/routes.ts
+var SAAS_ROUTES = {
+  routes: [
+    {
+      name: "Saas",
+      path: "saas",
+      layout: "application",
+      order: 50,
+      children: [
+        {
+          name: "Tenants",
+          path: "tenants",
+          order: 1,
+          requiredPolicy: "Saas.Tenants"
+        },
+        {
+          name: "Editions",
+          path: "editions",
+          order: 2,
+          requiredPolicy: "Saas.Editions"
+        }
+      ]
+    }
+  ]
+};
+
+// src/services/saas.service.ts
+var SaasService = class {
+  constructor(restService) {
+    this.restService = restService;
+  }
+  // ==================== Tenant Operations ====================
+  /**
+   * Get paginated list of tenants
+   * @param params Query parameters for filtering and pagination
+   * @returns Promise with paginated tenant response
+   */
+  async getTenants(params = {}) {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/saas/tenants",
+      params
+    });
+  }
+  /**
+   * Get a tenant by ID
+   * @param id Tenant ID
+   * @returns Promise with tenant data
+   */
+  async getTenantById(id) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/saas/tenants/${id}`
+    });
+  }
+  /**
+   * Create a new tenant
+   * @param body Tenant creation request
+   * @returns Promise with created tenant data
+   */
+  async createTenant(body) {
+    return this.restService.request({
+      method: "POST",
+      url: "/api/saas/tenants",
+      body
+    });
+  }
+  /**
+   * Update an existing tenant
+   * @param body Tenant update request (must include id)
+   * @returns Promise with updated tenant data
+   */
+  async updateTenant(body) {
+    const { id, ...rest } = body;
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/saas/tenants/${id}`,
+      body: rest
+    });
+  }
+  /**
+   * Delete a tenant by ID
+   * @param id Tenant ID to delete
+   * @returns Promise that resolves when deletion is complete
+   */
+  async deleteTenant(id) {
+    return this.restService.request({
+      method: "DELETE",
+      url: `/api/saas/tenants/${id}`
+    });
+  }
+  // ==================== Connection String Operations ====================
+  /**
+   * Get the default connection string for a tenant
+   * @param id Tenant ID
+   * @returns Promise with connection string (empty string if using shared database)
+   */
+  async getDefaultConnectionString(id) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/saas/tenants/${id}/default-connection-string`,
+      responseType: "text"
+    });
+  }
+  /**
+   * Update the default connection string for a tenant
+   * @param payload Object containing tenant ID and connection string
+   * @returns Promise that resolves when update is complete
+   */
+  async updateDefaultConnectionString(payload) {
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/saas/tenants/${payload.id}/default-connection-string`,
+      params: { defaultConnectionString: payload.defaultConnectionString }
+    });
+  }
+  /**
+   * Delete the default connection string for a tenant (revert to shared database)
+   * @param id Tenant ID
+   * @returns Promise that resolves when deletion is complete
+   */
+  async deleteDefaultConnectionString(id) {
+    return this.restService.request({
+      method: "DELETE",
+      url: `/api/saas/tenants/${id}/default-connection-string`
+    });
+  }
+  // ==================== Edition Operations ====================
+  /**
+   * Get paginated list of editions
+   * @param params Query parameters for filtering and pagination
+   * @returns Promise with paginated editions response
+   */
+  async getEditions(params = {}) {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/saas/editions",
+      params
+    });
+  }
+  /**
+   * Get an edition by ID
+   * @param id Edition ID
+   * @returns Promise with edition data
+   */
+  async getEditionById(id) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/saas/editions/${id}`
+    });
+  }
+  /**
+   * Create a new edition
+   * @param body Edition creation request
+   * @returns Promise with created edition data
+   */
+  async createEdition(body) {
+    return this.restService.request({
+      method: "POST",
+      url: "/api/saas/editions",
+      body
+    });
+  }
+  /**
+   * Update an existing edition
+   * @param body Edition update request (must include id)
+   * @returns Promise with updated edition data
+   */
+  async updateEdition(body) {
+    const { id, ...rest } = body;
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/saas/editions/${id}`,
+      body: rest
+    });
+  }
+  /**
+   * Delete an edition by ID
+   * @param id Edition ID to delete
+   * @returns Promise that resolves when deletion is complete
+   */
+  async deleteEdition(id) {
+    return this.restService.request({
+      method: "DELETE",
+      url: `/api/saas/editions/${id}`
+    });
+  }
+  // ==================== Statistics Operations ====================
+  /**
+   * Get usage statistics for editions
+   * @returns Promise with usage statistics data
+   */
+  async getUsageStatistics() {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/saas/editions/statistics/usage-statistic"
+    });
+  }
+};
+
+// src/hooks/useTenants.ts
+import { useState, useCallback, useMemo } from "react";
+import { useRestService } from "@abpjs/core";
+function useTenants() {
+  const restService = useRestService();
+  const service = useMemo(() => new SaasService(restService), [restService]);
+  const [tenants, setTenants] = useState([]);
+  const [totalCount, setTotalCount] = useState(0);
+  const [selectedTenant, setSelectedTenant] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [sortKey, setSortKey] = useState("name");
+  const [sortOrder, setSortOrder] = useState("");
+  const [defaultConnectionString, setDefaultConnectionString] = useState("");
+  const [useSharedDatabase, setUseSharedDatabase] = useState(true);
+  const fetchTenants = useCallback(
+    async (params) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const response = await service.getTenants(params);
+        setTenants(response.items || []);
+        setTotalCount(response.totalCount || 0);
+        setIsLoading(false);
+        return { success: true, data: response };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch tenants";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const getTenantById = useCallback(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const tenant = await service.getTenantById(id);
+        setSelectedTenant(tenant);
+        setIsLoading(false);
+        return { success: true, data: tenant };
+      } 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 (tenant) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const created = await service.createTenant(tenant);
+        setIsLoading(false);
+        return { success: true, data: created };
+      } 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 (tenant) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const updated = await service.updateTenant(tenant);
+        setIsLoading(false);
+        return { success: true, data: updated };
+      } 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.deleteTenant(id);
+        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 getDefaultConnectionString = useCallback(
+    async (id) => {
+      setError(null);
+      try {
+        const connString = await service.getDefaultConnectionString(id);
+        setDefaultConnectionString(connString || "");
+        setUseSharedDatabase(!connString);
+        return { success: true, data: connString };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch connection string";
+        setError(errorMessage);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const updateDefaultConnectionString = useCallback(
+    async (payload) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.updateDefaultConnectionString(payload);
+        setDefaultConnectionString(payload.defaultConnectionString);
+        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 deleteDefaultConnectionString = 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([]);
+    setTotalCount(0);
+    setSelectedTenant(null);
+    setIsLoading(false);
+    setError(null);
+    setSortKey("name");
+    setSortOrder("");
+    setDefaultConnectionString("");
+    setUseSharedDatabase(true);
+  }, []);
+  return {
+    tenants,
+    totalCount,
+    selectedTenant,
+    isLoading,
+    error,
+    sortKey,
+    sortOrder,
+    defaultConnectionString,
+    useSharedDatabase,
+    fetchTenants,
+    getTenantById,
+    createTenant,
+    updateTenant,
+    deleteTenant,
+    getDefaultConnectionString,
+    updateDefaultConnectionString,
+    deleteDefaultConnectionString,
+    setSelectedTenant,
+    setSortKey,
+    setSortOrder,
+    reset
+  };
+}
+
+// src/hooks/useEditions.ts
+import { useState as useState2, useCallback as useCallback2, useMemo as useMemo2 } from "react";
+import { useRestService as useRestService2 } from "@abpjs/core";
+function useEditions() {
+  const restService = useRestService2();
+  const service = useMemo2(() => new SaasService(restService), [restService]);
+  const [editions, setEditions] = useState2([]);
+  const [totalCount, setTotalCount] = useState2(0);
+  const [selectedEdition, setSelectedEdition] = useState2(null);
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [sortKey, setSortKey] = useState2("displayName");
+  const [sortOrder, setSortOrder] = useState2("");
+  const [usageStatistics, setUsageStatistics] = useState2({});
+  const fetchEditions = useCallback2(
+    async (params) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const response = await service.getEditions(params);
+        setEditions(response.items || []);
+        setTotalCount(response.totalCount || 0);
+        setIsLoading(false);
+        return { success: true, data: response };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch editions";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const getEditionById = useCallback2(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const edition = await service.getEditionById(id);
+        setSelectedEdition(edition);
+        setIsLoading(false);
+        return { success: true, data: edition };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch edition";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const createEdition = useCallback2(
+    async (edition) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const created = await service.createEdition(edition);
+        setIsLoading(false);
+        return { success: true, data: created };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to create edition";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const updateEdition = useCallback2(
+    async (edition) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const updated = await service.updateEdition(edition);
+        setIsLoading(false);
+        return { success: true, data: updated };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to update edition";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const deleteEdition = useCallback2(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.deleteEdition(id);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to delete edition";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const fetchUsageStatistics = useCallback2(
+    async () => {
+      setError(null);
+      try {
+        const response = await service.getUsageStatistics();
+        setUsageStatistics(response.data || {});
+        return { success: true, data: response.data };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch usage statistics";
+        setError(errorMessage);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const reset = useCallback2(() => {
+    setEditions([]);
+    setTotalCount(0);
+    setSelectedEdition(null);
+    setIsLoading(false);
+    setError(null);
+    setSortKey("displayName");
+    setSortOrder("");
+    setUsageStatistics({});
+  }, []);
+  return {
+    editions,
+    totalCount,
+    selectedEdition,
+    isLoading,
+    error,
+    sortKey,
+    sortOrder,
+    usageStatistics,
+    fetchEditions,
+    getEditionById,
+    createEdition,
+    updateEdition,
+    deleteEdition,
+    fetchUsageStatistics,
+    setSelectedEdition,
+    setSortKey,
+    setSortOrder,
+    reset
+  };
+}
+
+// src/components/Tenants/TenantsComponent.tsx
+import { useEffect, useState as useState3, useCallback as useCallback3 } from "react";
+import { useLocalization } from "@abpjs/core";
+import { Modal, Button, FormField, useConfirmation, Toaster } from "@abpjs/theme-shared";
+import {
+  Box,
+  Flex,
+  Input,
+  Table,
+  Spinner,
+  VStack,
+  Text,
+  Badge
+} from "@chakra-ui/react";
+import { NativeSelectRoot, NativeSelectField } from "@chakra-ui/react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function TenantsComponent({
+  onTenantCreated,
+  onTenantUpdated,
+  onTenantDeleted
+}) {
+  const { t } = useLocalization();
+  const { warn } = useConfirmation();
+  const {
+    tenants,
+    totalCount,
+    selectedTenant,
+    isLoading,
+    error,
+    fetchTenants,
+    getTenantById,
+    createTenant,
+    updateTenant,
+    deleteTenant,
+    getDefaultConnectionString,
+    updateDefaultConnectionString,
+    deleteDefaultConnectionString,
+    setSelectedTenant
+  } = useTenants();
+  const { editions, fetchEditions } = useEditions();
+  const [modalType, setModalType] = useState3(null);
+  const [modalVisible, setModalVisible] = useState3(false);
+  const [modalBusy, setModalBusy] = useState3(false);
+  const [page, setPage] = useState3(0);
+  const pageSize = 10;
+  const [filter, setFilter] = useState3("");
+  const [tenantName, setTenantName] = useState3("");
+  const [tenantEditionId, setTenantEditionId] = useState3("");
+  const [connStringUseShared, setConnStringUseShared] = useState3(true);
+  const [connString, setConnString] = useState3("");
+  useEffect(() => {
+    fetchTenants({
+      skipCount: page * pageSize,
+      maxResultCount: pageSize,
+      filter: filter || void 0,
+      getEditionNames: true
+    });
+  }, [page, pageSize, fetchTenants]);
+  useEffect(() => {
+    fetchEditions();
+  }, [fetchEditions]);
+  const handleSearch = useCallback3(() => {
+    setPage(0);
+    fetchTenants({
+      skipCount: 0,
+      maxResultCount: pageSize,
+      filter: filter || void 0,
+      getEditionNames: true
+    });
+  }, [filter, pageSize, fetchTenants]);
+  const handleAddTenant = useCallback3(() => {
+    setSelectedTenant(null);
+    setTenantName("");
+    setTenantEditionId("");
+    setModalType("tenant");
+    setModalVisible(true);
+  }, [setSelectedTenant]);
+  const handleEditTenant = useCallback3(
+    async (id) => {
+      const result = await getTenantById(id);
+      if (result.success && result.data) {
+        setTenantName(result.data.name);
+        setTenantEditionId(result.data.editionId || "");
+        setModalType("tenant");
+        setModalVisible(true);
+      }
+    },
+    [getTenantById]
+  );
+  const handleEditConnectionString = useCallback3(
+    async (id) => {
+      const tenantResult = await getTenantById(id);
+      if (tenantResult.success) {
+        const connResult = await getDefaultConnectionString(id);
+        setConnStringUseShared(!connResult.data);
+        setConnString(connResult.data || "");
+        setModalType("connectionString");
+        setModalVisible(true);
+      }
+    },
+    [getTenantById, getDefaultConnectionString]
+  );
+  const handleDeleteTenant = useCallback3(
+    async (tenant) => {
+      const status = await warn(
+        t("Saas::TenantDeletionConfirmationMessage").replace("{0}", tenant.name),
+        t("Saas::AreYouSure")
+      );
+      if (status === Toaster.Status.confirm) {
+        const result = await deleteTenant(tenant.id);
+        if (result.success) {
+          onTenantDeleted?.(tenant.id);
+          fetchTenants({
+            skipCount: page * pageSize,
+            maxResultCount: pageSize,
+            filter: filter || void 0,
+            getEditionNames: true
+          });
+        }
+      }
+    },
+    [warn, t, deleteTenant, onTenantDeleted, fetchTenants, page, pageSize, filter]
+  );
+  const handleSaveTenant = useCallback3(async () => {
+    if (!tenantName.trim()) return;
+    setModalBusy(true);
+    try {
+      if (selectedTenant?.id) {
+        const result = await updateTenant({
+          id: selectedTenant.id,
+          name: tenantName,
+          editionId: tenantEditionId || void 0,
+          concurrencyStamp: selectedTenant.concurrencyStamp
+        });
+        if (result.success && result.data) {
+          onTenantUpdated?.(result.data);
+          setModalVisible(false);
+          fetchTenants({
+            skipCount: page * pageSize,
+            maxResultCount: pageSize,
+            filter: filter || void 0,
+            getEditionNames: true
+          });
+        }
+      } else {
+        const result = await createTenant({
+          name: tenantName,
+          editionId: tenantEditionId || void 0
+        });
+        if (result.success && result.data) {
+          onTenantCreated?.(result.data);
+          setModalVisible(false);
+          fetchTenants({
+            skipCount: page * pageSize,
+            maxResultCount: pageSize,
+            filter: filter || void 0,
+            getEditionNames: true
+          });
+        }
+      }
+    } finally {
+      setModalBusy(false);
+    }
+  }, [
+    tenantName,
+    tenantEditionId,
+    selectedTenant,
+    updateTenant,
+    createTenant,
+    onTenantUpdated,
+    onTenantCreated,
+    fetchTenants,
+    page,
+    pageSize,
+    filter
+  ]);
+  const handleSaveConnectionString = useCallback3(async () => {
+    if (!selectedTenant?.id) return;
+    setModalBusy(true);
+    try {
+      if (connStringUseShared || !connString.trim()) {
+        await deleteDefaultConnectionString(selectedTenant.id);
+      } else {
+        await updateDefaultConnectionString({
+          id: selectedTenant.id,
+          defaultConnectionString: connString
+        });
+      }
+      setModalVisible(false);
+    } finally {
+      setModalBusy(false);
+    }
+  }, [
+    selectedTenant,
+    connStringUseShared,
+    connString,
+    deleteDefaultConnectionString,
+    updateDefaultConnectionString
+  ]);
+  const handleSave = useCallback3(() => {
+    if (modalType === "tenant") {
+      handleSaveTenant();
+    } else if (modalType === "connectionString") {
+      handleSaveConnectionString();
+    }
+  }, [modalType, handleSaveTenant, handleSaveConnectionString]);
+  const handleCloseModal = useCallback3(() => {
+    setModalVisible(false);
+    setModalType(null);
+    setSelectedTenant(null);
+  }, [setSelectedTenant]);
+  const totalPages = Math.ceil(totalCount / pageSize);
+  const getModalTitle = () => {
+    if (modalType === "connectionString") {
+      return t("Saas::ConnectionStrings");
+    }
+    return selectedTenant?.id ? t("Saas::Edit") : t("Saas::NewTenant");
+  };
+  return /* @__PURE__ */ jsxs(Box, { id: "saas-tenants-wrapper", className: "card", children: [
+    /* @__PURE__ */ jsxs(Flex, { justifyContent: "space-between", alignItems: "center", mb: 4, children: [
+      /* @__PURE__ */ jsx(Text, { fontSize: "xl", fontWeight: "bold", children: t("Saas::Tenants") }),
+      /* @__PURE__ */ jsx(Button, { colorPalette: "blue", onClick: handleAddTenant, children: t("Saas::NewTenant") })
+    ] }),
+    /* @__PURE__ */ jsxs(Flex, { gap: 2, mb: 4, children: [
+      /* @__PURE__ */ jsx(
+        Input,
+        {
+          value: filter,
+          onChange: (e) => setFilter(e.target.value),
+          placeholder: t("AbpUi::PagerSearch"),
+          onKeyDown: (e) => e.key === "Enter" && handleSearch()
+        }
+      ),
+      /* @__PURE__ */ jsx(Button, { onClick: handleSearch, children: t("AbpUi::Search") })
+    ] }),
+    error && /* @__PURE__ */ jsx(Box, { mb: 4, p: 3, bg: "red.100", borderRadius: "md", children: /* @__PURE__ */ jsx(Text, { color: "red.800", children: error }) }),
+    isLoading && tenants.length === 0 && /* @__PURE__ */ jsx(Flex, { justifyContent: "center", p: 8, children: /* @__PURE__ */ jsx(Spinner, { size: "lg" }) }),
+    !isLoading && tenants.length === 0 ? /* @__PURE__ */ jsx(Text, { textAlign: "center", p: 8, color: "gray.500", children: t("Saas::NoTenantsFound") }) : /* @__PURE__ */ jsxs(Box, { borderWidth: "1px", borderRadius: "md", overflow: "hidden", children: [
+      /* @__PURE__ */ jsxs(Table.Root, { children: [
+        /* @__PURE__ */ jsx(Table.Header, { children: /* @__PURE__ */ jsxs(Table.Row, { children: [
+          /* @__PURE__ */ jsx(Table.ColumnHeader, { children: t("Saas::Actions") }),
+          /* @__PURE__ */ jsx(Table.ColumnHeader, { children: t("Saas::TenantName") }),
+          /* @__PURE__ */ jsx(Table.ColumnHeader, { children: t("Saas::EditionName") })
+        ] }) }),
+        /* @__PURE__ */ jsx(Table.Body, { children: tenants.map((tenant) => /* @__PURE__ */ jsxs(Table.Row, { children: [
+          /* @__PURE__ */ jsx(Table.Cell, { children: /* @__PURE__ */ jsxs(Flex, { gap: 1, children: [
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                colorPalette: "blue",
+                variant: "outline",
+                onClick: () => handleEditTenant(tenant.id),
+                children: t("Saas::Edit")
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                variant: "outline",
+                onClick: () => handleEditConnectionString(tenant.id),
+                children: t("Saas::ConnectionStrings")
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                colorPalette: "red",
+                variant: "outline",
+                onClick: () => handleDeleteTenant(tenant),
+                children: t("Saas::Delete")
+              }
+            )
+          ] }) }),
+          /* @__PURE__ */ jsx(Table.Cell, { children: /* @__PURE__ */ jsx(Text, { fontWeight: "medium", children: tenant.name }) }),
+          /* @__PURE__ */ jsx(Table.Cell, { children: tenant.editionName ? /* @__PURE__ */ jsx(Badge, { colorPalette: "blue", children: tenant.editionName }) : /* @__PURE__ */ jsx(Text, { color: "gray.500", children: "-" }) })
+        ] }, tenant.id)) })
+      ] }),
+      totalCount > pageSize && /* @__PURE__ */ jsxs(Flex, { justifyContent: "space-between", alignItems: "center", p: 4, borderTopWidth: "1px", children: [
+        /* @__PURE__ */ jsx(Text, { fontSize: "sm", children: `${page * pageSize + 1} - ${Math.min((page + 1) * pageSize, totalCount)} / ${totalCount}` }),
+        /* @__PURE__ */ jsxs(Flex, { gap: 2, children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              disabled: page === 0,
+              onClick: () => setPage((p) => Math.max(0, p - 1)),
+              children: t("AbpUi::Previous")
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              disabled: page >= totalPages - 1,
+              onClick: () => setPage((p) => p + 1),
+              children: t("AbpUi::Next")
+            }
+          )
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(
+      Modal,
+      {
+        visible: modalVisible,
+        onVisibleChange: setModalVisible,
+        header: getModalTitle(),
+        footer: /* @__PURE__ */ jsxs(Flex, { gap: 2, children: [
+          /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: handleCloseModal, children: t("Saas::Cancel") }),
+          /* @__PURE__ */ jsx(Button, { colorPalette: "blue", onClick: handleSave, loading: modalBusy, children: t("AbpIdentity::Save") })
+        ] }),
+        children: [
+          modalType === "tenant" && /* @__PURE__ */ jsxs(VStack, { gap: 4, align: "stretch", children: [
+            /* @__PURE__ */ jsx(FormField, { label: t("Saas::TenantName"), required: true, children: /* @__PURE__ */ jsx(
+              Input,
+              {
+                value: tenantName,
+                onChange: (e) => setTenantName(e.target.value),
+                placeholder: t("Saas::TenantName"),
+                autoFocus: true
+              }
+            ) }),
+            editions.length > 0 && /* @__PURE__ */ jsx(FormField, { label: t("Saas::Edition"), children: /* @__PURE__ */ jsx(NativeSelectRoot, { children: /* @__PURE__ */ jsxs(
+              NativeSelectField,
+              {
+                value: tenantEditionId,
+                onChange: (e) => setTenantEditionId(e.target.value),
+                children: [
+                  /* @__PURE__ */ jsx("option", { value: "", children: t("Saas::SelectEdition") }),
+                  editions.map((edition) => /* @__PURE__ */ jsx("option", { value: edition.id, children: edition.displayName }, edition.id))
+                ]
+              }
+            ) }) })
+          ] }),
+          modalType === "connectionString" && /* @__PURE__ */ jsxs(VStack, { gap: 4, align: "stretch", children: [
+            /* @__PURE__ */ jsxs(Flex, { alignItems: "center", gap: 2, children: [
+              /* @__PURE__ */ jsx(
+                "input",
+                {
+                  type: "checkbox",
+                  id: "useSharedDatabase",
+                  checked: connStringUseShared,
+                  onChange: (e) => setConnStringUseShared(e.target.checked)
+                }
+              ),
+              /* @__PURE__ */ jsx("label", { htmlFor: "useSharedDatabase", children: t("Saas::DisplayName:UseSharedDatabase") })
+            ] }),
+            !connStringUseShared && /* @__PURE__ */ jsx(FormField, { label: t("Saas::DisplayName:DefaultConnectionString"), children: /* @__PURE__ */ jsx(
+              Input,
+              {
+                value: connString,
+                onChange: (e) => setConnString(e.target.value),
+                placeholder: t("Saas::DisplayName:DefaultConnectionString")
+              }
+            ) })
+          ] })
+        ]
+      }
+    )
+  ] });
+}
+
+// src/components/Editions/EditionsComponent.tsx
+import { useEffect as useEffect2, useState as useState4, useCallback as useCallback4 } from "react";
+import { useLocalization as useLocalization2 } from "@abpjs/core";
+import { Modal as Modal2, Button as Button2, FormField as FormField2, useConfirmation as useConfirmation2, Toaster as Toaster2 } from "@abpjs/theme-shared";
+import {
+  Box as Box2,
+  Flex as Flex2,
+  Input as Input2,
+  Table as Table2,
+  Spinner as Spinner2,
+  VStack as VStack2,
+  Text as Text2
+} from "@chakra-ui/react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function EditionsComponent({
+  onEditionCreated,
+  onEditionUpdated,
+  onEditionDeleted,
+  onManageFeatures
+}) {
+  const { t } = useLocalization2();
+  const { warn } = useConfirmation2();
+  const {
+    editions,
+    totalCount,
+    selectedEdition,
+    isLoading,
+    error,
+    fetchEditions,
+    getEditionById,
+    createEdition,
+    updateEdition,
+    deleteEdition,
+    setSelectedEdition
+  } = useEditions();
+  const [modalVisible, setModalVisible] = useState4(false);
+  const [modalBusy, setModalBusy] = useState4(false);
+  const [page, setPage] = useState4(0);
+  const pageSize = 10;
+  const [filter, setFilter] = useState4("");
+  const [displayName, setDisplayName] = useState4("");
+  useEffect2(() => {
+    fetchEditions({
+      skipCount: page * pageSize,
+      maxResultCount: pageSize,
+      filter: filter || void 0
+    });
+  }, [page, pageSize, fetchEditions]);
+  const handleSearch = useCallback4(() => {
+    setPage(0);
+    fetchEditions({
+      skipCount: 0,
+      maxResultCount: pageSize,
+      filter: filter || void 0
+    });
+  }, [filter, pageSize, fetchEditions]);
+  const handleAddEdition = useCallback4(() => {
+    setSelectedEdition(null);
+    setDisplayName("");
+    setModalVisible(true);
+  }, [setSelectedEdition]);
+  const handleEditEdition = useCallback4(
+    async (id) => {
+      const result = await getEditionById(id);
+      if (result.success && result.data) {
+        setDisplayName(result.data.displayName);
+        setModalVisible(true);
+      }
+    },
+    [getEditionById]
+  );
+  const handleDeleteEdition = useCallback4(
+    async (edition) => {
+      const status = await warn(
+        t("Saas::EditionDeletionConfirmationMessage").replace("{0}", edition.displayName),
+        t("Saas::AreYouSure")
+      );
+      if (status === Toaster2.Status.confirm) {
+        const result = await deleteEdition(edition.id);
+        if (result.success) {
+          onEditionDeleted?.(edition.id);
+          fetchEditions({
+            skipCount: page * pageSize,
+            maxResultCount: pageSize,
+            filter: filter || void 0
+          });
+        }
+      }
+    },
+    [warn, t, deleteEdition, onEditionDeleted, fetchEditions, page, pageSize, filter]
+  );
+  const handleManageFeatures = useCallback4(
+    (editionId) => {
+      onManageFeatures?.(editionId);
+    },
+    [onManageFeatures]
+  );
+  const handleSave = useCallback4(async () => {
+    if (!displayName.trim()) return;
+    setModalBusy(true);
+    try {
+      if (selectedEdition?.id) {
+        const result = await updateEdition({
+          id: selectedEdition.id,
+          displayName,
+          concurrencyStamp: selectedEdition.concurrencyStamp
+        });
+        if (result.success && result.data) {
+          onEditionUpdated?.(result.data);
+          setModalVisible(false);
+          fetchEditions({
+            skipCount: page * pageSize,
+            maxResultCount: pageSize,
+            filter: filter || void 0
+          });
+        }
+      } else {
+        const result = await createEdition({
+          displayName
+        });
+        if (result.success && result.data) {
+          onEditionCreated?.(result.data);
+          setModalVisible(false);
+          fetchEditions({
+            skipCount: page * pageSize,
+            maxResultCount: pageSize,
+            filter: filter || void 0
+          });
+        }
+      }
+    } finally {
+      setModalBusy(false);
+    }
+  }, [
+    displayName,
+    selectedEdition,
+    updateEdition,
+    createEdition,
+    onEditionUpdated,
+    onEditionCreated,
+    fetchEditions,
+    page,
+    pageSize,
+    filter
+  ]);
+  const handleCloseModal = useCallback4(() => {
+    setModalVisible(false);
+    setSelectedEdition(null);
+  }, [setSelectedEdition]);
+  const totalPages = Math.ceil(totalCount / pageSize);
+  return /* @__PURE__ */ jsxs2(Box2, { id: "saas-editions-wrapper", className: "card", children: [
+    /* @__PURE__ */ jsxs2(Flex2, { justifyContent: "space-between", alignItems: "center", mb: 4, children: [
+      /* @__PURE__ */ jsx2(Text2, { fontSize: "xl", fontWeight: "bold", children: t("Saas::Editions") }),
+      /* @__PURE__ */ jsx2(Button2, { colorPalette: "blue", onClick: handleAddEdition, children: t("Saas::NewEdition") })
+    ] }),
+    /* @__PURE__ */ jsxs2(Flex2, { gap: 2, mb: 4, children: [
+      /* @__PURE__ */ jsx2(
+        Input2,
+        {
+          value: filter,
+          onChange: (e) => setFilter(e.target.value),
+          placeholder: t("AbpUi::PagerSearch"),
+          onKeyDown: (e) => e.key === "Enter" && handleSearch()
+        }
+      ),
+      /* @__PURE__ */ jsx2(Button2, { onClick: handleSearch, children: t("AbpUi::Search") })
+    ] }),
+    error && /* @__PURE__ */ jsx2(Box2, { mb: 4, p: 3, bg: "red.100", borderRadius: "md", children: /* @__PURE__ */ jsx2(Text2, { color: "red.800", children: error }) }),
+    isLoading && editions.length === 0 && /* @__PURE__ */ jsx2(Flex2, { justifyContent: "center", p: 8, children: /* @__PURE__ */ jsx2(Spinner2, { size: "lg" }) }),
+    !isLoading && editions.length === 0 ? /* @__PURE__ */ jsx2(Text2, { textAlign: "center", p: 8, color: "gray.500", children: t("Saas::NoEditionsFound") }) : /* @__PURE__ */ jsxs2(Box2, { borderWidth: "1px", borderRadius: "md", overflow: "hidden", children: [
+      /* @__PURE__ */ jsxs2(Table2.Root, { children: [
+        /* @__PURE__ */ jsx2(Table2.Header, { children: /* @__PURE__ */ jsxs2(Table2.Row, { children: [
+          /* @__PURE__ */ jsx2(Table2.ColumnHeader, { children: t("Saas::Actions") }),
+          /* @__PURE__ */ jsx2(Table2.ColumnHeader, { children: t("Saas::EditionName") })
+        ] }) }),
+        /* @__PURE__ */ jsx2(Table2.Body, { children: editions.map((edition) => /* @__PURE__ */ jsxs2(Table2.Row, { children: [
+          /* @__PURE__ */ jsx2(Table2.Cell, { children: /* @__PURE__ */ jsxs2(Flex2, { gap: 1, children: [
+            /* @__PURE__ */ jsx2(
+              Button2,
+              {
+                size: "sm",
+                colorPalette: "blue",
+                variant: "outline",
+                onClick: () => handleEditEdition(edition.id),
+                children: t("Saas::Edit")
+              }
+            ),
+            onManageFeatures && /* @__PURE__ */ jsx2(
+              Button2,
+              {
+                size: "sm",
+                variant: "outline",
+                onClick: () => handleManageFeatures(edition.id),
+                children: t("Saas::Features")
+              }
+            ),
+            /* @__PURE__ */ jsx2(
+              Button2,
+              {
+                size: "sm",
+                colorPalette: "red",
+                variant: "outline",
+                onClick: () => handleDeleteEdition(edition),
+                children: t("Saas::Delete")
+              }
+            )
+          ] }) }),
+          /* @__PURE__ */ jsx2(Table2.Cell, { children: /* @__PURE__ */ jsx2(Text2, { fontWeight: "medium", children: edition.displayName }) })
+        ] }, edition.id)) })
+      ] }),
+      totalCount > pageSize && /* @__PURE__ */ jsxs2(Flex2, { justifyContent: "space-between", alignItems: "center", p: 4, borderTopWidth: "1px", children: [
+        /* @__PURE__ */ jsx2(Text2, { fontSize: "sm", children: `${page * pageSize + 1} - ${Math.min((page + 1) * pageSize, totalCount)} / ${totalCount}` }),
+        /* @__PURE__ */ jsxs2(Flex2, { gap: 2, children: [
+          /* @__PURE__ */ jsx2(
+            Button2,
+            {
+              size: "sm",
+              disabled: page === 0,
+              onClick: () => setPage((p) => Math.max(0, p - 1)),
+              children: t("AbpUi::Previous")
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            Button2,
+            {
+              size: "sm",
+              disabled: page >= totalPages - 1,
+              onClick: () => setPage((p) => p + 1),
+              children: t("AbpUi::Next")
+            }
+          )
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx2(
+      Modal2,
+      {
+        visible: modalVisible,
+        onVisibleChange: setModalVisible,
+        header: selectedEdition?.id ? t("Saas::Edit") : t("Saas::NewEdition"),
+        footer: /* @__PURE__ */ jsxs2(Flex2, { gap: 2, children: [
+          /* @__PURE__ */ jsx2(Button2, { variant: "outline", onClick: handleCloseModal, children: t("Saas::Cancel") }),
+          /* @__PURE__ */ jsx2(Button2, { colorPalette: "blue", onClick: handleSave, loading: modalBusy, children: t("AbpIdentity::Save") })
+        ] }),
+        children: /* @__PURE__ */ jsx2(VStack2, { gap: 4, align: "stretch", children: /* @__PURE__ */ jsx2(FormField2, { label: t("Saas::EditionName"), required: true, children: /* @__PURE__ */ jsx2(
+          Input2,
+          {
+            value: displayName,
+            onChange: (e) => setDisplayName(e.target.value),
+            placeholder: t("Saas::EditionName"),
+            autoFocus: true
+          }
+        ) }) })
+      }
+    )
+  ] });
+}
+export {
+  EditionsComponent,
+  SAAS_ROUTES,
+  SaasService,
+  TenantsComponent,
+  useEditions,
+  useTenants
+};