Split codebase (#455)

2026-05-17 21:27:05 +02:00 · 2026-05-07 15:50:10 -07:00
parent d2dc719cc6
commit 10559c8f4f
742 changed files with 7686 additions and 3249 deletions
@@ -0,0 +1,169 @@
+import type { Folder } from "@yaakapp-internal/models";
+import { modelTypeLabel, patchModel } from "@yaakapp-internal/models";
+import { HStack, Icon, InlineCode } from "@yaakapp-internal/ui";
+import { useMemo } from "react";
+import { openFolderSettings } from "../commands/openFolderSettings";
+import { openWorkspaceSettings } from "../commands/openWorkspaceSettings";
+import { IconTooltip } from "../components/core/IconTooltip";
+import type { TabItem } from "../components/core/Tabs/Tabs";
+import { capitalize } from "../lib/capitalize";
+import { showConfirm } from "../lib/confirm";
+import { resolvedModelName } from "../lib/resolvedModelName";
+import { useHttpAuthenticationSummaries } from "./useHttpAuthentication";
+import type { AuthenticatedModel } from "./useInheritedAuthentication";
+import { useInheritedAuthentication } from "./useInheritedAuthentication";
+import { useModelAncestors } from "./useModelAncestors";
+
+export function useAuthTab<T extends string>(tabValue: T, model: AuthenticatedModel | null) {
+  const authentication = useHttpAuthenticationSummaries();
+  const inheritedAuth = useInheritedAuthentication(model);
+  const ancestors = useModelAncestors(model);
+  const parentModel = ancestors[0] ?? null;
+
+  return useMemo<TabItem[]>(() => {
+    if (model == null) return [];
+
+    const tab: TabItem = {
+      value: tabValue,
+      label: "Auth",
+      options: {
+        value: model.authenticationType,
+        items: [
+          ...authentication.map((a) => ({
+            label: a.label || "UNKNOWN",
+            shortLabel: a.shortLabel,
+            value: a.name,
+          })),
+          { type: "separator" },
+          {
+            label: "Inherit from Parent",
+            shortLabel:
+              inheritedAuth != null && inheritedAuth.authenticationType !== "none" ? (
+                <HStack space={1.5}>
+                  {authentication.find((a) => a.name === inheritedAuth.authenticationType)
+                    ?.shortLabel ?? "UNKNOWN"}
+                  <IconTooltip
+                    icon="magic_wand"
+                    iconSize="xs"
+                    content="Authentication was inherited from an ancestor"
+                  />
+                </HStack>
+              ) : (
+                "Auth"
+              ),
+            value: null,
+          },
+          { label: "No Auth", shortLabel: "No Auth", value: "none" },
+        ],
+        itemsAfter: (() => {
+          const actions: (
+            | { type: "separator"; label: string }
+            | { label: string; leftSlot: React.ReactNode; onSelect: () => Promise<void> }
+          )[] = [];
+
+          // Promote: move auth from current model up to parent
+          if (
+            parentModel &&
+            model.authenticationType &&
+            model.authenticationType !== "none" &&
+            (parentModel.authenticationType == null || parentModel.authenticationType === "none")
+          ) {
+            actions.push(
+              { type: "separator", label: "Actions" },
+              {
+                label: `Promote to ${capitalize(parentModel.model)}`,
+                leftSlot: (
+                  <Icon
+                    icon={parentModel.model === "workspace" ? "corner_right_up" : "folder_up"}
+                  />
+                ),
+                onSelect: async () => {
+                  const confirmed = await showConfirm({
+                    id: "promote-auth-confirm",
+                    title: "Promote Authentication",
+                    confirmText: "Promote",
+                    description: (
+                      <>
+                        Move authentication config to{" "}
+                        <InlineCode>{resolvedModelName(parentModel)}</InlineCode>?
+                      </>
+                    ),
+                  });
+                  if (confirmed) {
+                    await patchModel(model, { authentication: {}, authenticationType: null });
+                    await patchModel(parentModel, {
+                      authentication: model.authentication,
+                      authenticationType: model.authenticationType,
+                    });
+
+                    if (parentModel.model === "folder") {
+                      openFolderSettings(parentModel.id, "auth");
+                    } else {
+                      openWorkspaceSettings("auth");
+                    }
+                  }
+                },
+              },
+            );
+          }
+
+          // Copy from ancestor: copy auth config down to current model
+          const ancestorWithAuth = ancestors.find(
+            (a) => a.authenticationType != null && a.authenticationType !== "none",
+          );
+          if (ancestorWithAuth) {
+            if (actions.length === 0) {
+              actions.push({ type: "separator", label: "Actions" });
+            }
+            actions.push({
+              label: `Copy from ${modelTypeLabel(ancestorWithAuth)}`,
+              leftSlot: (
+                <Icon
+                  icon={
+                    ancestorWithAuth.model === "workspace" ? "corner_right_down" : "folder_down"
+                  }
+                />
+              ),
+              onSelect: async () => {
+                const confirmed = await showConfirm({
+                  id: "copy-auth-confirm",
+                  title: "Copy Authentication",
+                  confirmText: "Copy",
+                  description: (
+                    <>
+                      Copy{" "}
+                      {authentication.find((a) => a.name === ancestorWithAuth.authenticationType)
+                        ?.label ?? "authentication"}{" "}
+                      config from <InlineCode>{resolvedModelName(ancestorWithAuth)}</InlineCode>?
+                      This will override the current authentication but will not affect the{" "}
+                      {modelTypeLabel(ancestorWithAuth).toLowerCase()}.
+                    </>
+                  ),
+                });
+                if (confirmed) {
+                  await patchModel(model, {
+                    authentication: { ...ancestorWithAuth.authentication },
+                    authenticationType: ancestorWithAuth.authenticationType,
+                  });
+                }
+              },
+            });
+          }
+
+          return actions.length > 0 ? actions : undefined;
+        })(),
+        onChange: async (authenticationType) => {
+          let authentication: Folder["authentication"] = model.authentication;
+          if (model.authenticationType !== authenticationType) {
+            authentication = {
+              // Reset auth if changing types
+            };
+          }
+          await patchModel(model, { authentication, authenticationType });
+        },
+      },
+    };
+
+    return [tab];
+  }, [authentication, inheritedAuth, model, parentModel, tabValue, ancestors]);
+}