@antelopejs/dms 0.0.1

package/frontend-vue/layers/dms-core/app/composables/auth/useAuthFetch.ts

@@ -0,0 +1,134 @@
+import type { UseFetchOptions } from "#dms-inertia/frontend-module";
+
+export const CONTENT_LANGUAGE_HEADER = "x-content-language";
+
+const RETRY_HEADER = "x-auth-retry";
+const REALTIME_SESSION_HEADER = "x-realtime-session";
+const REALTIME_SESSION_STATE_KEY = "dms.realtime.sessionId";
+
+function hasRetryHeader(headers: HeadersInit | undefined): boolean {
+  if (!headers) return false;
+  if (headers instanceof Headers) {
+    return headers.has(RETRY_HEADER);
+  }
+  if (Array.isArray(headers)) {
+    return headers.some(([name]) => name.toLowerCase() === RETRY_HEADER);
+  }
+  return Object.keys(headers).some(
+    (name) => name.toLowerCase() === RETRY_HEADER,
+  );
+}
+
+function withRetryHeader<O>(options: O): O {
+  const source = (options ?? {}) as { headers?: HeadersInit } & Record<
+    string,
+    unknown
+  >;
+  const merged: Record<string, unknown> = { ...source };
+  const headers = new Headers(source.headers ?? undefined);
+  headers.set(RETRY_HEADER, "1");
+  merged.headers = headers;
+  return merged as O;
+}
+
+function isUnauthorized(error: unknown): boolean {
+  const response = (error as { response?: { status?: number } } | undefined)
+    ?.response;
+  return response?.status === HTTP_UNAUTHORIZED;
+}
+
+export const useAuthFetch = () => {
+  const { loggedIn: isLoggedIn } = useUserSession();
+  const { refreshSession, reconcileSession, redirectToAuth } =
+    useSessionRecovery();
+  const config = useDmsRuntimeConfig();
+  const dmsApp = useDmsApp();
+
+  const realtimeSessionId = useDmsState<string | undefined>(
+    REALTIME_SESSION_STATE_KEY,
+    () => undefined,
+  );
+
+  const baseFetch = $fetch.create({
+    baseURL: config.public.dms.baseURL,
+    headers: {
+      [CONTENT_LANGUAGE_HEADER]: dmsApp.$i18n.locale.value,
+    },
+    onRequest({ options }) {
+      if (realtimeSessionId.value) {
+        options.headers.set(REALTIME_SESSION_HEADER, realtimeSessionId.value);
+      }
+    },
+    async onResponseError({ response, options }) {
+      if (response.status !== HTTP_UNAUTHORIZED) {
+        return;
+      }
+
+      if (isLoggedIn.value && !hasRetryHeader(options?.headers)) {
+        return;
+      }
+
+      await reconcileSession();
+      if (isLoggedIn.value) {
+        return;
+      }
+
+      await redirectToAuth();
+    },
+  });
+
+  type AuthFetch = typeof baseFetch;
+  type AuthFetchArgs = Parameters<AuthFetch>;
+
+  function withSessionRetry<R>(
+    invoke: (
+      request: AuthFetchArgs[0],
+      options?: AuthFetchArgs[1],
+    ) => Promise<R>,
+  ) {
+    return async (request: AuthFetchArgs[0], options?: AuthFetchArgs[1]) => {
+      try {
+        return await invoke(request, options);
+      } catch (error) {
+        const headers = (options as { headers?: HeadersInit } | undefined)
+          ?.headers;
+        if (
+          !isUnauthorized(error) ||
+          hasRetryHeader(headers) ||
+          !isLoggedIn.value
+        ) {
+          throw error;
+        }
+
+        const refreshed = await refreshSession();
+        if (!refreshed) {
+          throw error;
+        }
+
+        return await invoke(request, withRetryHeader(options));
+      }
+    };
+  }
+
+  const $authFetch = withSessionRetry((request, options) =>
+    baseFetch(request, options),
+  ) as AuthFetch;
+  $authFetch.raw = withSessionRetry((request, options) =>
+    baseFetch.raw(request, options),
+  ) as AuthFetch["raw"];
+
+  function useFetchAuth<T>(
+    url: string | (() => string),
+    options?: UseFetchOptions<T>,
+  ) {
+    return useDmsFetch(url, {
+      ...options,
+      $fetch: $authFetch,
+    });
+  }
+
+  return {
+    $authFetch,
+    useFetchAuth,
+  };
+};

package/frontend-vue/layers/dms-core/app/composables/auth/useCurrentUser.ts

@@ -0,0 +1,23 @@
+/**
+ * Global reactive access to the signed-in user's identity (name, email, ...).
+ *
+ * `user` is the shared session state from `useUserSession`, so every consumer
+ * (header menu, switch-account page, ...) re-renders as soon as it changes.
+ * `refresh` re-fetches the session through the frontend server session hook
+ * pulls a fresh `/api/auth/me`) and syncs the stored multi-account entry, so a
+ * profile edit propagates immediately without re-logging in.
+ */
+export function useCurrentUser() {
+  const { user, fetch: refreshSession } = useUserSession<User>();
+  const { syncActiveAccount } = useMultiAccount();
+
+  async function refresh(): Promise<void> {
+    await refreshSession();
+    syncActiveAccount();
+  }
+
+  return {
+    user,
+    refresh,
+  };
+}

package/frontend-vue/layers/dms-core/app/composables/auth/useMultiAccount.ts

@@ -0,0 +1,250 @@
+import { useStorage } from "@vueuse/core";
+import type {
+  StoredAccount,
+  SwitchAccountResponse,
+  ValidateAccountResponse,
+} from "../../types/auth";
+
+const STORAGE_KEY = "antelopejs-accounts";
+const SWITCH_ACCOUNT_ENDPOINT = "/auth/switch-account";
+const VALIDATE_ACCOUNT_ENDPOINT = "/auth/validate-account";
+const HTTP_POST = "POST" as const;
+
+type AccountsRef = ReturnType<typeof useStorage<StoredAccount[]>>;
+
+// Keyed on the DMS app rather than the module, so an SSR request never sees
+// another one's ref.
+const accountsStorageByApp = new WeakMap<object, AccountsRef>();
+
+/**
+ * The stored accounts, on a ref whose persistence outlives any component.
+ *
+ * `useStorage` registers its write watcher on the calling effect scope, so a
+ * ref created straight from a page's `setup` stops being written the moment
+ * that page unmounts. Account validation runs fire-and-forget on the switcher
+ * page and adopts a rotated refresh token when one comes back: navigating away
+ * mid-flight would drop that write, while the backend has already invalidated
+ * the token still sitting in storage — the account would silently need a full
+ * re-login. A detached scope keeps writes flowing whatever the caller's life.
+ */
+function useAccountsStorage(): AccountsRef {
+  const dmsApp = useDmsApp();
+  const existing = accountsStorageByApp.get(dmsApp);
+  if (existing) return existing;
+
+  const storage = effectScope(true).run(() =>
+    useStorage<StoredAccount[]>(STORAGE_KEY, [], undefined),
+  ) as AccountsRef;
+  accountsStorageByApp.set(dmsApp, storage);
+  return storage;
+}
+
+interface MinimalUser {
+  _id: string;
+  email: string;
+  name: string;
+}
+
+interface BrowserSession {
+  accountId: string;
+  activeTenantId?: string;
+}
+
+// Same statuses the validate-account route treats as a verdict on the token;
+// the two paths must agree on what "expired" means, or the switcher shows a
+// badge its own validation would not have set.
+const TOKEN_REJECTION_STATUSES = new Set([400, 401, 403]);
+
+interface UpstreamError {
+  status?: number;
+  statusCode?: number;
+}
+
+function isTokenRejection(error: unknown): boolean {
+  const { status, statusCode } = (error ?? {}) as UpstreamError;
+  const upstreamStatus = statusCode ?? status;
+  return (
+    upstreamStatus !== undefined && TOKEN_REJECTION_STATUSES.has(upstreamStatus)
+  );
+}
+
+function buildActiveAccount(
+  user: MinimalUser | null | undefined,
+  accountId: string | undefined,
+): StoredAccount | undefined {
+  if (!user || !accountId) {
+    return undefined;
+  }
+  return {
+    accountId,
+    userId: user._id,
+    email: user.email,
+    name: user.name,
+    lastUsed: new Date(),
+    isExpired: false,
+  } as StoredAccount;
+}
+
+function upsertAccount(
+  accounts: AccountsRef,
+  user: MinimalUser,
+  accountId: string,
+) {
+  const existingIndex = accounts.value.findIndex((a) => a.userId === user._id);
+  const account: StoredAccount = {
+    accountId,
+    userId: user._id,
+    email: user.email,
+    name: user.name,
+    lastUsed: new Date(),
+  };
+
+  if (existingIndex >= 0) {
+    accounts.value[existingIndex] = account;
+  } else {
+    accounts.value.push(account);
+  }
+}
+
+async function requestAccountSwitch(account: StoredAccount) {
+  await $fetch<SwitchAccountResponse>(SWITCH_ACCOUNT_ENDPOINT, {
+    method: HTTP_POST,
+    body: { accountId: account.accountId },
+  });
+
+  account.lastUsed = new Date();
+  account.isExpired = false;
+}
+
+async function refreshSessionSurfaces(refreshUser: () => Promise<unknown>) {
+  await refreshUser();
+
+  const { refresh: refreshSiteLayout } = useSiteLayout();
+  const { clear: clearPermissions } = usePermissions();
+  clearPermissions();
+  await refreshSiteLayout();
+}
+
+export async function validateAccount(account: StoredAccount) {
+  const response = await $fetch<ValidateAccountResponse>(
+    VALIDATE_ACCOUNT_ENDPOINT,
+    {
+      method: HTTP_POST,
+      body: { accountId: account.accountId },
+    },
+  ).catch(() => undefined);
+
+  if (!response || response.valid === null) {
+    return;
+  }
+
+  account.isExpired = !response.valid;
+}
+
+function createSwitchAccount(
+  accounts: AccountsRef,
+  addCurrentAccount: () => void,
+  refreshUser: () => Promise<unknown>,
+) {
+  return async function switchAccount(userId: string) {
+    const account = accounts.value.find((a) => a.userId === userId);
+    if (!account) {
+      return;
+    }
+
+    addCurrentAccount();
+
+    try {
+      await requestAccountSwitch(account);
+    } catch (error) {
+      // Only a verdict on the token expires the account. A 500, a timeout or
+      // an unreachable backend says nothing about it, and painting a healthy
+      // account "Session expired" is exactly what the three-state verdict in
+      // `validateAccount` exists to avoid — the switch path must agree with it.
+      if (isTokenRejection(error)) {
+        account.isExpired = true;
+      }
+      throw error;
+    }
+
+    await refreshSessionSurfaces(refreshUser);
+  };
+}
+
+function createValidateAllAccounts(
+  accounts: AccountsRef,
+  getCurrentUserId: () => string | undefined,
+) {
+  return async function validateAllAccounts() {
+    const currentUserId = getCurrentUserId();
+    await Promise.allSettled(
+      accounts.value
+        .filter((a) => a.userId !== currentUserId)
+        .map((account) => validateAccount(account)),
+    );
+  };
+}
+
+export function useMultiAccount() {
+  const accounts = useAccountsStorage();
+  const { user, session, fetch: refreshUser } =
+    useUserSession<User, BrowserSession>();
+
+  const getActiveAccount = (): StoredAccount | undefined =>
+    buildActiveAccount(
+      user.value,
+      session.value?.accountId as string | undefined,
+    );
+
+  const addCurrentAccount = () => {
+    if (!user.value || !session.value) {
+      return;
+    }
+    const accountId = session.value.accountId as string | undefined;
+    if (accountId) upsertAccount(accounts, user.value, accountId);
+  };
+
+  const removeAccount = async (userId: string): Promise<void> => {
+    const account = accounts.value.find((item) => item.userId === userId);
+    if (account) {
+      await $fetch("/auth/remove-account", {
+        method: "POST",
+        body: { accountId: account.accountId },
+      });
+    }
+    accounts.value = accounts.value.filter((a) => a.userId !== userId);
+  };
+
+  const syncActiveAccount = () => {
+    const currentUser = user.value;
+    if (!currentUser) {
+      return;
+    }
+    const stored = accounts.value.find((a) => a.userId === currentUser._id);
+    if (!stored) {
+      return;
+    }
+    stored.name = currentUser.name;
+    stored.email = currentUser.email;
+  };
+
+  const switchAccount = createSwitchAccount(
+    accounts,
+    addCurrentAccount,
+    refreshUser,
+  );
+  const validateAllAccounts = createValidateAllAccounts(
+    accounts,
+    () => user.value?._id,
+  );
+
+  return {
+    accounts,
+    getActiveAccount,
+    addCurrentAccount,
+    removeAccount,
+    syncActiveAccount,
+    switchAccount,
+    validateAllAccounts,
+  };
+}

package/frontend-vue/layers/dms-core/app/composables/auth/usePermissions.ts

@@ -0,0 +1,73 @@
+const PERMISSIONS_REFRESH_MS = 300_000;
+const PERMISSIONS_ENDPOINT = "/dms/permissions";
+const WILDCARD_PERMISSION = "*";
+
+interface PermissionsState {
+  permissions: Ref<Set<string>>;
+  isLoaded: Ref<boolean>;
+  lastFetchTime: Ref<number>;
+  fetchGeneration: Ref<number>;
+}
+
+function usePermissionsState(): PermissionsState {
+  return {
+    permissions: useDmsState<Set<string>>("dms-user-permissions", () => new Set()),
+    isLoaded: useDmsState<boolean>("dms-permissions-loaded", () => false),
+    lastFetchTime: useDmsState<number>("dms-permissions-lastFetch", () => 0),
+    fetchGeneration: useDmsState<number>("dms-permissions-gen", () => 0),
+  };
+}
+
+function createFetchPermissions(state: PermissionsState) {
+  const runFetch = async () => {
+    const generation = state.fetchGeneration.value;
+    const { $authFetch } = useAuthFetch();
+    const result = await $authFetch<string[]>(PERMISSIONS_ENDPOINT);
+    if (state.fetchGeneration.value !== generation) return;
+    state.permissions.value = new Set(result);
+    state.isLoaded.value = true;
+    state.lastFetchTime.value = Date.now();
+  };
+
+  // A refetch asked while one is in flight gets its own pass instead of the
+  // older response, so an invalidation is never swallowed. Scoped to the DMS app
+  // app, so concurrent server-rendered requests never share a pass.
+  const deduper = useTrailingDeduper("permissions");
+  return (): Promise<void> => deduper.run(runFetch);
+}
+
+export function usePermissions() {
+  const state = usePermissionsState();
+  const fetchPermissions = createFetchPermissions(state);
+
+  async function refreshIfStale() {
+    const elapsed = Date.now() - state.lastFetchTime.value;
+    if (elapsed < PERMISSIONS_REFRESH_MS) {
+      return;
+    }
+    await fetchPermissions();
+  }
+
+  function hasPermission(permissionId: string): boolean {
+    if (state.permissions.value.has(WILDCARD_PERMISSION)) {
+      return true;
+    }
+    return state.permissions.value.has(permissionId);
+  }
+
+  function clear() {
+    state.fetchGeneration.value++;
+    state.permissions.value = new Set();
+    state.isLoaded.value = false;
+    state.lastFetchTime.value = 0;
+  }
+
+  return {
+    permissions: state.permissions,
+    isLoaded: state.isLoaded,
+    fetchPermissions,
+    refreshIfStale,
+    hasPermission,
+    clear,
+  };
+}

package/frontend-vue/layers/dms-core/app/composables/auth/useSessionRecovery.ts

@@ -0,0 +1,50 @@
+import { runDeduped } from "../../utils/dedupedRefresh";
+
+const AUTH_PATH = "/auth";
+const IN_FLIGHT_REFRESH_KEY = "__dmsAuthInFlightRefresh";
+
+export const useSessionRecovery = () => {
+  const dmsApp = useDmsApp();
+  const { loggedIn, fetch: fetchSession } = useUserSession();
+  // useDmsRoute() must not be called here: this composable runs inside route
+  // middleware (via useAuthFetch), where the DMS runtime warns that useDmsRoute is
+  // misleading. Resolve the route lazily from the router instead.
+  const router = useDmsRouter();
+
+  // Refresh the user session at most once concurrently (see runDeduped): the
+  // realtime stream, $authFetch and route middleware can all hit a 401 at the
+  // same time, and parallel /api/auth/refresh calls with the same rotating
+  // refresh token would invalidate the session and log the user out.
+  function refreshSession(): Promise<boolean> {
+    return runDeduped(
+      dmsApp as unknown as Record<PropertyKey, unknown>,
+      IN_FLIGHT_REFRESH_KEY,
+      () =>
+        fetchSession()
+          .then(() => true)
+          .catch(() => false),
+    );
+  }
+
+  async function reconcileSession(): Promise<void> {
+    if (loggedIn.value) {
+      await refreshSession();
+    }
+  }
+
+  async function redirectToAuth(redirect?: string): Promise<void> {
+    const route = router.currentRoute.value;
+    if (route.path.startsWith(AUTH_PATH)) {
+      return;
+    }
+    redirect ??= route.fullPath;
+    await dmsApp.runWithContext(() =>
+      navigateDms({
+        path: AUTH_PATH,
+        query: { redirect },
+      }),
+    );
+  }
+
+  return { loggedIn, refreshSession, reconcileSession, redirectToAuth };
+};

package/frontend-vue/layers/dms-core/app/composables/components/useComponentEvent.ts

@@ -0,0 +1,29 @@
+import { isUndefined } from "../../utils/type-check";
+
+function sendComponentEvent(name: string, componentId: string, data?: unknown) {
+  if (!isUndefined(window)) {
+    const customEvent = new CustomEvent<ComponentEventData>(name, {
+      detail: {
+        component: componentId,
+        data,
+      },
+    });
+    window.dispatchEvent(customEvent);
+  }
+}
+
+export function useComponentEvent(componentId?: string) {
+  if (componentId) {
+    onMounted(() => {
+      sendComponentEvent(Events.LOAD, componentId);
+    });
+
+    onBeforeUnmount(() => {
+      sendComponentEvent(Events.UNLOAD, componentId);
+    });
+  }
+
+  return {
+    sendComponentEvent,
+  };
+}

package/frontend-vue/layers/dms-core/app/composables/data-types/useDataType.ts

@@ -0,0 +1,39 @@
+import type { Component } from "vue";
+
+export type RecordWithDefault<T> = Record<string, T> & { default: T };
+
+export type DataTypeFormatter = (
+  value: unknown,
+  locale: string,
+  options?: unknown,
+) => unknown;
+
+/**
+ * Reshapes a server value into its form-state representation.
+ * Must be idempotent: form reset re-applies the mapper to values that
+ * may already be mapped (e.g. restored from a submit-success snapshot).
+ */
+export type BeforeStateMapper = (value: unknown, options?: unknown) => unknown;
+
+export interface DataType {
+  id: string;
+  formatter?: RecordWithDefault<DataTypeFormatter>;
+  beforeStateMapper?: BeforeStateMapper;
+  displayComponent?: Component;
+}
+const dataTypes: Record<string, DataType> = {};
+
+export const useDataTypes = () => {
+  function registerDataType(dataType: DataType) {
+    dataTypes[dataType.id] = dataType;
+  }
+
+  function getDataType(id: string) {
+    return dataTypes[id];
+  }
+
+  return {
+    registerDataType,
+    getDataType,
+  };
+};

package/frontend-vue/layers/dms-core/app/composables/functions/useDefinedFunction.ts

@@ -0,0 +1,23 @@
+type CallableFunction = (...args: any[]) => unknown;
+
+const registeredFunctions = ref<Map<string, CallableFunction>>(new Map());
+
+export function useDefinedFunctions() {
+  const registerFunction = (id: string, fn: CallableFunction) => {
+    registeredFunctions.value.set(id, fn);
+  };
+
+  const getFunction = (id: string): CallableFunction | undefined => {
+    return registeredFunctions.value.get(id);
+  };
+
+  const unregisterFunction = (id: string) => {
+    registeredFunctions.value.delete(id);
+  };
+
+  return {
+    registerFunction,
+    getFunction,
+    unregisterFunction,
+  };
+}

package/frontend-vue/layers/dms-core/app/composables/leave-guard/index.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./useLeaveGuard";

package/frontend-vue/layers/dms-core/app/composables/leave-guard/types.ts

@@ -0,0 +1,19 @@
+import type { MaybePromise } from "../../types/utils";
+
+export const PAGE_GUARD_PREFIX = "page-leave-guard";
+
+export type LeaveGuardCallback = () => MaybePromise<boolean>;
+
+export interface LeaveGuardEntry {
+  id: string;
+  callback: LeaveGuardCallback;
+}
+
+export type LeaveGuardRegistry = Map<string, LeaveGuardEntry[]>;
+
+export interface UseLeaveGuardReturn {
+  addGuard: (containerId: string, callback: LeaveGuardCallback) => () => void;
+  removeGuard: (containerId: string, guardId: string) => void;
+  executeGuards: (containerId: string) => Promise<boolean>;
+  clearGuards: (containerId: string) => void;
+}