@jskit-ai/auth-web 0.1.4

package/src/client/composables/useDefaultSignOutView.js

@@ -0,0 +1,113 @@
+import { computed, onMounted, ref } from "vue";
+import { useShellWebErrorRuntime } from "@jskit-ai/shell-web/client/error";
+import {
+  useWebPlacementContext,
+  resolveSurfaceNavigationTargetFromPlacementContext
+} from "@jskit-ai/shell-web/client/placement";
+import { performSignOutRequest } from "../runtime/useSignOut.js";
+import { useAuthGuardRuntime } from "../runtime/inject.js";
+import {
+  normalizeAuthReturnToPath,
+  resolveAllowedReturnToOriginsFromPlacementContext
+} from "../lib/returnToPath.js";
+
+function readReturnToPathFromLocation({ allowedOrigins = [] } = {}) {
+  if (typeof window !== "object" || !window.location) {
+    return "/";
+  }
+  const params = new URLSearchParams(window.location.search || "");
+  return normalizeAuthReturnToPath(params.get("returnTo"), "/", {
+    allowedOrigins
+  });
+}
+
+function navigateToPath(path, { replace = true } = {}) {
+  if (typeof window !== "object" || !window.location) {
+    return;
+  }
+  if (replace) {
+    window.location.replace(path);
+    return;
+  }
+  window.location.assign(path);
+}
+
+export function useDefaultSignOutView() {
+  const authGuardRuntime = useAuthGuardRuntime({
+    required: true
+  });
+  const { context: placementContext } = useWebPlacementContext();
+  const errorRuntime = useShellWebErrorRuntime();
+  const status = ref("pending");
+  const errorMessage = ref("");
+  const returnToPath = ref("/");
+  const allowedReturnToOrigins = computed(() =>
+    resolveAllowedReturnToOriginsFromPlacementContext(placementContext.value)
+  );
+
+  function setErrorMessage(message, dedupeKey = "") {
+    const normalizedMessage = String(message || "").trim();
+    errorMessage.value = normalizedMessage;
+    if (!normalizedMessage) {
+      return;
+    }
+
+    errorRuntime.report({
+      source: "auth-web.default-signout-view",
+      message: normalizedMessage,
+      severity: "error",
+      channel: "banner",
+      dedupeKey: dedupeKey || `auth-web.default-signout-view:error:${normalizedMessage}`,
+      dedupeWindowMs: 3000
+    });
+  }
+
+  const loginRoute = computed(() => {
+    const loginTarget = resolveSurfaceNavigationTargetFromPlacementContext(placementContext.value, {
+      path: "/auth/login",
+      surfaceId: "auth"
+    });
+    const params = new URLSearchParams({
+      returnTo: returnToPath.value
+    });
+    return `${loginTarget.href}?${params.toString()}`;
+  });
+
+  function goToLogin() {
+    navigateToPath(loginRoute.value, { replace: false });
+  }
+
+  async function executeSignOut() {
+    status.value = "pending";
+    setErrorMessage("");
+
+    try {
+      await performSignOutRequest({
+        authGuardRuntime
+      });
+      status.value = "success";
+      navigateToPath(loginRoute.value, { replace: true });
+    } catch (error) {
+      status.value = "error";
+      setErrorMessage(String(error?.message || "Sign out failed."));
+    }
+  }
+
+  function retrySignOut() {
+    void executeSignOut();
+  }
+
+  onMounted(() => {
+    returnToPath.value = readReturnToPathFromLocation({
+      allowedOrigins: allowedReturnToOrigins.value
+    });
+    void executeSignOut();
+  });
+
+  return {
+    status,
+    errorMessage,
+    retrySignOut,
+    goToLogin
+  };
+}

package/src/client/index.js

@@ -0,0 +1,19 @@
+import { AuthWebClientProvider } from "./providers/AuthWebClientProvider.js";
+import DefaultLoginView from "./views/DefaultLoginView.vue";
+import DefaultSignOutView from "./views/DefaultSignOutView.vue";
+
+export { AuthWebClientProvider } from "./providers/AuthWebClientProvider.js";
+export { default as DefaultLoginView } from "./views/DefaultLoginView.vue";
+export { default as DefaultSignOutView } from "./views/DefaultSignOutView.vue";
+export { default as AuthProfileWidget } from "./views/AuthProfileWidget.vue";
+export { default as AuthProfileMenuLinkItem } from "./views/AuthProfileMenuLinkItem.vue";
+
+const routeComponents = Object.freeze({
+  "auth-login": DefaultLoginView,
+  "auth-signout": DefaultSignOutView,
+  "auth-default-login": DefaultLoginView
+});
+
+const clientProviders = Object.freeze([AuthWebClientProvider]);
+
+export { routeComponents, clientProviders };

package/src/client/lib/returnToPath.js

@@ -0,0 +1,20 @@
+import {
+  normalizeReturnToPath as normalizeSharedReturnToPath,
+  resolveAllowedOriginsFromPlacementContext
+} from "@jskit-ai/kernel/shared/support";
+
+const AUTH_LOOP_PATHNAMES = Object.freeze(["/auth/login", "/auth/signout"]);
+
+function resolveAllowedReturnToOriginsFromPlacementContext(contextValue = null) {
+  return resolveAllowedOriginsFromPlacementContext(contextValue);
+}
+
+function normalizeAuthReturnToPath(value, fallback = "/", { allowedOrigins = [] } = {}) {
+  return normalizeSharedReturnToPath(value, {
+    fallback,
+    allowedOrigins,
+    blockedPathnames: AUTH_LOOP_PATHNAMES
+  });
+}
+
+export { normalizeAuthReturnToPath, resolveAllowedReturnToOriginsFromPlacementContext };

package/src/client/lib/surfaceLinkTarget.js

@@ -0,0 +1,19 @@
+import { resolveShellLinkPath } from "@jskit-ai/shell-web/client/navigation/linkResolver";
+
+function resolveSurfaceLinkTarget({
+  context = null,
+  surface = "",
+  explicitTo = "",
+  workspaceSuffix = "",
+  nonWorkspaceSuffix = ""
+} = {}) {
+  const fallbackPath = String(nonWorkspaceSuffix || "").trim() || String(workspaceSuffix || "").trim() || "/";
+  return resolveShellLinkPath({
+    context,
+    surface,
+    explicitTo,
+    relativePath: fallbackPath
+  });
+}
+
+export { resolveSurfaceLinkTarget };

package/src/client/providers/AuthWebClientProvider.js

@@ -0,0 +1,72 @@
+import DefaultLoginView from "../views/DefaultLoginView.vue";
+import AuthProfileWidget from "../views/AuthProfileWidget.vue";
+import AuthProfileMenuLinkItem from "../views/AuthProfileMenuLinkItem.vue";
+import { CLIENT_MODULE_VUE_APP_TOKEN } from "@jskit-ai/kernel/client/moduleBootstrap";
+import { createAuthGuardRuntime } from "../runtime/authGuardRuntime.js";
+import { useLoginView } from "../runtime/useLoginView.js";
+import {
+  WEB_PLACEMENT_RUNTIME_CLIENT_TOKEN,
+  resolveSurfaceNavigationTargetFromPlacementContext
+} from "@jskit-ai/shell-web/client/placement";
+import {
+  AUTH_GUARD_RUNTIME_CLIENT_TOKEN,
+  AUTH_GUARD_RUNTIME_INJECTION_KEY
+} from "../runtime/tokens.js";
+
+const AUTH_WEB_PROFILE_WIDGET_COMPONENT_TOKEN = "auth.web.profile.widget";
+const AUTH_WEB_PROFILE_MENU_LINK_ITEM_COMPONENT_TOKEN = "auth.web.profile.menu.link-item";
+const REALTIME_SOCKET_CLIENT_TOKEN = "runtime.realtime.client.socket";
+
+class AuthWebClientProvider {
+  static id = "auth.web.client";
+
+  register(app) {
+    if (!app || typeof app.singleton !== "function") {
+      throw new Error("AuthWebClientProvider requires application singleton().");
+    }
+
+    app.singleton("auth.login.component", () => DefaultLoginView);
+    app.singleton("auth.login.useLoginView", () => useLoginView);
+    app.singleton(AUTH_WEB_PROFILE_WIDGET_COMPONENT_TOKEN, () => AuthProfileWidget);
+    app.singleton(AUTH_WEB_PROFILE_MENU_LINK_ITEM_COMPONENT_TOKEN, () => AuthProfileMenuLinkItem);
+    app.singleton(AUTH_GUARD_RUNTIME_CLIENT_TOKEN, () => {
+      if (!app.has(WEB_PLACEMENT_RUNTIME_CLIENT_TOKEN)) {
+        throw new Error("AuthWebClientProvider requires shell-web placement runtime.");
+      }
+
+      const placementRuntime = app.make(WEB_PLACEMENT_RUNTIME_CLIENT_TOKEN);
+      const realtimeSocket = app.has(REALTIME_SOCKET_CLIENT_TOKEN) ? app.make(REALTIME_SOCKET_CLIENT_TOKEN) : null;
+      const loginRouteTarget = resolveSurfaceNavigationTargetFromPlacementContext(placementRuntime.getContext(), {
+        path: "/auth/login",
+        surfaceId: "auth"
+      });
+      return createAuthGuardRuntime({
+        loginRoute: loginRouteTarget.href,
+        placementRuntime,
+        realtimeSocket
+      });
+    });
+  }
+
+  async boot(app) {
+    if (!app || typeof app.make !== "function") {
+      throw new Error("AuthWebClientProvider requires application make().");
+    }
+
+    const authGuardRuntime = app.make(AUTH_GUARD_RUNTIME_CLIENT_TOKEN);
+    await authGuardRuntime.initialize();
+
+    if (!app.has(CLIENT_MODULE_VUE_APP_TOKEN)) {
+      return;
+    }
+
+    const vueApp = app.make(CLIENT_MODULE_VUE_APP_TOKEN);
+    if (!vueApp || typeof vueApp.provide !== "function") {
+      return;
+    }
+
+    vueApp.provide(AUTH_GUARD_RUNTIME_INJECTION_KEY, authGuardRuntime);
+  }
+}
+
+export { AuthWebClientProvider };