qarpeo 0.0.0-alpha.10

package/dist/runtime/app/composables/docs-version.mjs

@@ -0,0 +1,70 @@
+import { ref, computed } from "vue";
+export function useDocsVersion(options) {
+  let route;
+  let router;
+  let runtimeConfig;
+  try {
+    route = useRoute();
+  } catch {
+  }
+  try {
+    router = useRouter();
+  } catch {
+  }
+  try {
+    runtimeConfig = useRuntimeConfig();
+  } catch {
+  }
+  const qarpeoVersion = runtimeConfig?.public?.qarpeoVersion;
+  const derivedVersions = qarpeoVersion ? [{ id: "latest", label: `v${qarpeoVersion}`, prefix: "/docs", isLatest: true }] : [{ id: "latest", label: "latest", prefix: "/docs", isLatest: true }];
+  const configuredVersions = options?.versions || runtimeConfig?.public?.qarpeo?.docsVersions || derivedVersions;
+  const versions = ref(configuredVersions);
+  const currentVersion = computed(() => {
+    const p = route?.path || "";
+    const match = p.match(/^\/docs\/(v\d+|next)(?:\/.*)?$/);
+    if (match) return match[1];
+    return "latest";
+  });
+  const isLatest = computed(() => currentVersion.value === "latest");
+  const isArchived = computed(() => !isLatest.value);
+  const activeVersionItem = computed(() => {
+    return versions.value.find((v) => v.id === currentVersion.value) || {
+      id: currentVersion.value,
+      label: currentVersion.value === "latest" ? "Latest" : currentVersion.value,
+      prefix: currentVersion.value === "latest" ? "/docs" : `/docs/${currentVersion.value}`,
+      isLatest: isLatest.value,
+      isArchived: isArchived.value
+    };
+  });
+  function getVersionPath(targetVersionId) {
+    const p = route?.path || "/docs";
+    let subPath = "";
+    const match = p.match(/^\/docs\/(?:v\d+|next)(\/.*)?$/);
+    if (match) {
+      subPath = match[1] || "";
+    } else if (p.startsWith("/docs")) {
+      subPath = p.slice("/docs".length);
+    }
+    if (targetVersionId === "latest") {
+      return `/docs${subPath}` || "/docs";
+    }
+    return `/docs/${targetVersionId}${subPath}` || `/docs/${targetVersionId}`;
+  }
+  async function switchVersion(targetVersionId) {
+    const targetPath = getVersionPath(targetVersionId);
+    if (router?.push) {
+      await router.push(targetPath);
+    } else if (typeof navigateTo === "function") {
+      await navigateTo(targetPath);
+    }
+  }
+  return {
+    currentVersion,
+    isLatest,
+    isArchived,
+    versions,
+    activeVersionItem,
+    getVersionPath,
+    switchVersion
+  };
+}

package/dist/runtime/app/composables/impersonation.d.ts

@@ -0,0 +1,14 @@
+import type { QarpeoUser } from "../../types/auth";
+export declare function useImpersonation(): {
+    isImpersonating: import("vue").ComputedRef<boolean>;
+    impersonator: import("vue").ComputedRef<QarpeoUser | null>;
+    impersonatedUser: import("vue").ComputedRef<QarpeoUser | null>;
+    impersonateUser: (userId: string) => Promise<{
+        success: boolean;
+        user: QarpeoUser;
+    }>;
+    stopImpersonating: () => Promise<{
+        success: boolean;
+        user: QarpeoUser;
+    }>;
+};

package/dist/runtime/app/composables/impersonation.mjs

@@ -0,0 +1,44 @@
+import { computed } from "vue";
+export function useImpersonation() {
+  const { session, fetch: refreshSession } = useUserSession();
+  const runtimeConfig = useRuntimeConfig();
+  const authConfig = runtimeConfig.public?.qarpeo?.auth || {};
+  const authPrefix = authConfig.prefix || "/api/auth";
+  const isImpersonating = computed(() => {
+    const s = session.value;
+    return Boolean(s?.impersonator);
+  });
+  const impersonator = computed(() => {
+    const s = session.value;
+    return s?.impersonator || null;
+  });
+  const impersonatedUser = computed(() => {
+    if (!isImpersonating.value) return null;
+    const s = session.value;
+    return s?.user || null;
+  });
+  const impersonateUser = async (userId) => {
+    const res = await $fetch(`${authPrefix}/impersonate/start`, {
+      method: "POST",
+      body: { userId },
+      credentials: "include"
+    });
+    await refreshSession();
+    return res;
+  };
+  const stopImpersonating = async () => {
+    const res = await $fetch(`${authPrefix}/impersonate/stop`, {
+      method: "POST",
+      credentials: "include"
+    });
+    await refreshSession();
+    return res;
+  };
+  return {
+    isImpersonating,
+    impersonator,
+    impersonatedUser,
+    impersonateUser,
+    stopImpersonating
+  };
+}

package/dist/runtime/app/composables/notifications.d.ts

@@ -0,0 +1,35 @@
+import { computed, ref } from "#imports";
+import type { NotificationRecord } from "../../../types";
+export interface UseNotificationsReturn {
+    /** All fetched notifications */
+    notifications: ReturnType<typeof ref<NotificationRecord[]>>;
+    /** Count of unread notifications */
+    unreadCount: ReturnType<typeof computed<number>>;
+    /** Whether the initial fetch is in progress */
+    pending: ReturnType<typeof ref<boolean>>;
+    /** Mark a single notification as read */
+    markAsRead: (id: string) => Promise<void>;
+    /** Mark all notifications as read */
+    markAllAsRead: () => Promise<void>;
+    /** Delete a notification */
+    remove: (id: string) => Promise<void>;
+    /** Subscribe to browser Web Push notifications */
+    subscribeToWebPush: () => Promise<boolean>;
+    /** Unsubscribe from browser Web Push notifications */
+    unsubscribeFromWebPush: () => Promise<boolean>;
+    /** Whether browser Web Push is currently subscribed */
+    isPushSubscribed: ReturnType<typeof ref<boolean>>;
+    /** Refresh the notifications list */
+    refresh: () => Promise<void>;
+}
+/**
+ * Composable for managing in-app notifications and Web Push subscriptions.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * const { notifications, unreadCount, markAsRead, subscribeToWebPush } = useNotifications()
+ * </script>
+ * ```
+ */
+export declare function useNotifications(): UseNotificationsReturn;

package/dist/runtime/app/composables/notifications.mjs

@@ -0,0 +1,139 @@
+import { computed, onMounted, onUnmounted, ref, useRuntimeConfig } from "#imports";
+export function useNotifications() {
+  const config = useRuntimeConfig();
+  const vapidPublicKey = config.public?.qarpeo?.notifications?.vapidPublicKey || "";
+  const notifications = ref([]);
+  const pending = ref(false);
+  const isPushSubscribed = ref(false);
+  let pollInterval = null;
+  const unreadCount = computed(
+    () => notifications.value.filter((n) => !n.read).length
+  );
+  async function refresh() {
+    pending.value = true;
+    try {
+      const data = await $fetch(
+        "/api/notifications",
+        { query: { limit: 50 } }
+      );
+      notifications.value = data.notifications || [];
+    } catch (err) {
+      console.error("[useNotifications] Failed to fetch notifications:", err);
+    } finally {
+      pending.value = false;
+    }
+  }
+  async function markAsRead(id) {
+    await $fetch(`/api/notifications/${id}/read`, { method: "POST" });
+    const n = notifications.value.find((x) => x.id === id);
+    if (n) {
+      n.read = true;
+      n.readAt = Date.now();
+    }
+  }
+  async function markAllAsRead() {
+    await $fetch("/api/notifications/read-all", { method: "POST" });
+    for (const n of notifications.value) {
+      n.read = true;
+      n.readAt = Date.now();
+    }
+  }
+  async function remove(id) {
+    await $fetch(`/api/notifications/${id}`, { method: "DELETE" });
+    notifications.value = notifications.value.filter((n) => n.id !== id);
+  }
+  function urlBase64ToUint8Array(base64String) {
+    const padding = "=".repeat((4 - base64String.length % 4) % 4);
+    const base64 = (base64String + padding).replace(/-/g, "+").replace(/_/g, "/");
+    const rawData = atob(base64);
+    const outputArray = new Uint8Array(rawData.length);
+    for (let i = 0; i < rawData.length; ++i) {
+      outputArray[i] = rawData.charCodeAt(i);
+    }
+    return outputArray;
+  }
+  async function checkPushStatus() {
+    if (typeof window === "undefined" || !("serviceWorker" in navigator)) return;
+    try {
+      const reg = await navigator.serviceWorker.ready;
+      const sub = await reg.pushManager.getSubscription();
+      isPushSubscribed.value = Boolean(sub);
+    } catch {
+      isPushSubscribed.value = false;
+    }
+  }
+  async function subscribeToWebPush() {
+    if (typeof window === "undefined" || !("serviceWorker" in navigator)) {
+      console.warn("[useNotifications] Service workers not supported");
+      return false;
+    }
+    if (!vapidPublicKey) {
+      console.warn("[useNotifications] VAPID public key not configured");
+      return false;
+    }
+    try {
+      await navigator.serviceWorker.register("/sw-notifications.js", { scope: "/" });
+      const reg = await navigator.serviceWorker.ready;
+      const permission = await Notification.requestPermission();
+      if (permission !== "granted") return false;
+      const sub = await reg.pushManager.subscribe({
+        userVisibleOnly: true,
+        applicationServerKey: urlBase64ToUint8Array(vapidPublicKey)
+      });
+      const json = sub.toJSON();
+      await $fetch("/api/notifications/push/subscribe", {
+        method: "POST",
+        body: {
+          endpoint: json.endpoint,
+          keys: json.keys
+        }
+      });
+      isPushSubscribed.value = true;
+      return true;
+    } catch (err) {
+      console.error("[useNotifications] Push subscribe failed:", err);
+      return false;
+    }
+  }
+  async function unsubscribeFromWebPush() {
+    if (typeof window === "undefined" || !("serviceWorker" in navigator)) return false;
+    try {
+      const reg = await navigator.serviceWorker.ready;
+      const sub = await reg.pushManager.getSubscription();
+      if (!sub) return true;
+      await $fetch("/api/notifications/push/unsubscribe", {
+        method: "POST",
+        body: { endpoint: sub.endpoint }
+      });
+      await sub.unsubscribe();
+      isPushSubscribed.value = false;
+      return true;
+    } catch (err) {
+      console.error("[useNotifications] Push unsubscribe failed:", err);
+      return false;
+    }
+  }
+  onMounted(async () => {
+    await refresh();
+    await checkPushStatus();
+    pollInterval = setInterval(refresh, 6e4);
+  });
+  onUnmounted(() => {
+    if (pollInterval !== null) {
+      clearInterval(pollInterval);
+      pollInterval = null;
+    }
+  });
+  return {
+    notifications,
+    unreadCount,
+    pending,
+    markAsRead,
+    markAllAsRead,
+    remove,
+    subscribeToWebPush,
+    unsubscribeFromWebPush,
+    isPushSubscribed,
+    refresh
+  };
+}

package/dist/runtime/app/composables/organization.d.ts

@@ -0,0 +1,127 @@
+import type { QarpeoOrganization, QarpeoMember } from "../../types/auth";
+export type QarpeoUserOrg = QarpeoOrganization & {
+    role: string;
+    memberId: string;
+};
+export declare function useOrganization(): {
+    organization: import("vue").ComputedRef<QarpeoOrganization | null>;
+    organizations: import("vue").Ref<{
+        id: string;
+        name: string;
+        slug: string;
+        logoUrl?: string | null | undefined;
+        createdAt: number;
+        role: string;
+        memberId: string;
+    }[], QarpeoUserOrg[] | {
+        id: string;
+        name: string;
+        slug: string;
+        logoUrl?: string | null | undefined;
+        createdAt: number;
+        role: string;
+        memberId: string;
+    }[]>;
+    role: import("vue").ComputedRef<string | null>;
+    members: import("vue").Ref<{
+        id: string;
+        organizationId: string;
+        userId: string;
+        role: "owner" | "admin" | "member" | string;
+        createdAt: number;
+        user?: {
+            [x: string]: any;
+            id: string;
+            email: string;
+            name?: string | null | undefined;
+            avatarUrl?: string | null | undefined;
+            emailVerified?: boolean | undefined;
+            role?: string | undefined;
+        } | undefined;
+        email?: string | undefined;
+        name?: string | undefined;
+        avatarUrl?: string | undefined;
+    }[], (QarpeoMember & {
+        email?: string;
+        name?: string;
+        avatarUrl?: string;
+    })[] | {
+        id: string;
+        organizationId: string;
+        userId: string;
+        role: "owner" | "admin" | "member" | string;
+        createdAt: number;
+        user?: {
+            [x: string]: any;
+            id: string;
+            email: string;
+            name?: string | null | undefined;
+            avatarUrl?: string | null | undefined;
+            emailVerified?: boolean | undefined;
+            role?: string | undefined;
+        } | undefined;
+        email?: string | undefined;
+        name?: string | undefined;
+        avatarUrl?: string | undefined;
+    }[]>;
+    loading: import("vue").Ref<boolean, boolean>;
+    fetchOrganizations: () => Promise<{
+        id: string;
+        name: string;
+        slug: string;
+        logoUrl?: string | null | undefined;
+        createdAt: number;
+        role: string;
+        memberId: string;
+    }[]>;
+    createOrganization: (input: {
+        name: string;
+        slug?: string;
+        logoUrl?: string | null;
+    }) => Promise<{
+        organization: QarpeoOrganization;
+        member: QarpeoMember;
+    }>;
+    switchOrganization: (organizationId: string) => Promise<{
+        success: boolean;
+        organization: QarpeoOrganization;
+        role: string;
+    }>;
+    inviteMember: (input: {
+        email: string;
+        role?: string;
+        organizationId?: string;
+    }) => Promise<{
+        invitationId: string;
+        token: string;
+        expiresAt: number;
+        inviteUrl: string;
+    }>;
+    removeMember: (memberId: string, organizationId?: string) => Promise<{
+        success: boolean;
+    }>;
+    fetchMembers: (organizationId?: string) => Promise<{
+        id: string;
+        organizationId: string;
+        userId: string;
+        role: "owner" | "admin" | "member" | string;
+        createdAt: number;
+        user?: {
+            [x: string]: any;
+            id: string;
+            email: string;
+            name?: string | null | undefined;
+            avatarUrl?: string | null | undefined;
+            emailVerified?: boolean | undefined;
+            role?: string | undefined;
+        } | undefined;
+        email?: string | undefined;
+        name?: string | undefined;
+        avatarUrl?: string | undefined;
+    }[]>;
+    joinOrganization: (token: string) => Promise<{
+        success: boolean;
+        organizationId: string;
+        role: string;
+    }>;
+};

package/dist/runtime/app/composables/organization.mjs

@@ -0,0 +1,138 @@
+import { ref, computed } from "vue";
+export function useOrganization() {
+  const { session, fetch: refreshSession } = useUserSession();
+  const runtimeConfig = useRuntimeConfig();
+  const authConfig = runtimeConfig.public?.qarpeo?.auth || {};
+  const authPrefix = authConfig.prefix || "/api/auth";
+  const organizations = ref([]);
+  const members = ref(
+    []
+  );
+  const loading = ref(false);
+  const organization = computed(() => {
+    const s = session.value;
+    return s?.currentOrganization || null;
+  });
+  const role = computed(() => {
+    const s = session.value;
+    return s?.currentRole || null;
+  });
+  const fetchOrganizations = async () => {
+    loading.value = true;
+    try {
+      const data = await $fetch(`${authPrefix}/organization/list`, {
+        credentials: "include"
+      }).catch(() => []);
+      organizations.value = data || [];
+      return organizations.value;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const createOrganization = async (input) => {
+    loading.value = true;
+    try {
+      const res = await $fetch(`${authPrefix}/organization/create`, {
+        method: "POST",
+        body: input,
+        credentials: "include"
+      });
+      await refreshSession();
+      await fetchOrganizations();
+      return res;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const switchOrganization = async (organizationId) => {
+    loading.value = true;
+    try {
+      const res = await $fetch(`${authPrefix}/organization/switch`, {
+        method: "POST",
+        body: { organizationId },
+        credentials: "include"
+      });
+      await refreshSession();
+      return res;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const inviteMember = async (input) => {
+    const targetOrgId = input.organizationId || organization.value?.id;
+    if (!targetOrgId) {
+      throw new Error("No active organization selected");
+    }
+    return await $fetch(`${authPrefix}/organization/invite`, {
+      method: "POST",
+      body: {
+        organizationId: targetOrgId,
+        email: input.email,
+        role: input.role || "member"
+      },
+      credentials: "include"
+    });
+  };
+  const removeMember = async (memberId, organizationId) => {
+    const targetOrgId = organizationId || organization.value?.id;
+    if (!targetOrgId) {
+      throw new Error("No active organization selected");
+    }
+    const res = await $fetch(
+      `${authPrefix}/organization/members/${memberId}?organizationId=${targetOrgId}`,
+      {
+        method: "DELETE",
+        credentials: "include"
+      }
+    );
+    members.value = members.value.filter((m) => m.id !== memberId);
+    await refreshSession();
+    return res;
+  };
+  const fetchMembers = async (organizationId) => {
+    const targetOrgId = organizationId || organization.value?.id;
+    if (!targetOrgId) return [];
+    loading.value = true;
+    try {
+      const data = await $fetch(
+        `${authPrefix}/organization/members?organizationId=${targetOrgId}`,
+        {
+          credentials: "include"
+        }
+      ).catch(() => []);
+      members.value = data || [];
+      return members.value;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const joinOrganization = async (token) => {
+    loading.value = true;
+    try {
+      const res = await $fetch(`${authPrefix}/organization/join`, {
+        method: "POST",
+        body: { token },
+        credentials: "include"
+      });
+      await refreshSession();
+      await fetchOrganizations();
+      return res;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    organization,
+    organizations,
+    role,
+    members,
+    loading,
+    fetchOrganizations,
+    createOrganization,
+    switchOrganization,
+    inviteMember,
+    removeMember,
+    fetchMembers,
+    joinOrganization
+  };
+}

package/dist/runtime/app/composables/passkey.d.ts

@@ -0,0 +1,6 @@
+export declare function usePasskey(): {
+    loading: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<string | null, string | null>;
+    registerPasskey: () => Promise<any>;
+    loginWithPasskey: () => Promise<any>;
+};

package/dist/runtime/app/composables/passkey.mjs

@@ -0,0 +1,105 @@
+import { ref } from "vue";
+import { useAuth } from "./auth.mjs";
+export function usePasskey() {
+  const runtimeConfig = useRuntimeConfig();
+  const authConfig = runtimeConfig.public?.qarpeo?.auth || {};
+  const authPrefix = authConfig.prefix || "/api/auth";
+  const { fetch: refreshSession } = useAuth();
+  const loading = ref(false);
+  const error = ref(null);
+  const registerPasskey = async () => {
+    if (typeof window === "undefined" || !window.PublicKeyCredential) {
+      throw new Error("WebAuthn is not supported on this browser or device");
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      const options = await $fetch(`${authPrefix}/webauthn/register/options`, {
+        method: "POST",
+        credentials: "include"
+      });
+      const challengeBytes = new Uint8Array(
+        options.challenge.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))
+      );
+      const userIdBytes = new TextEncoder().encode(options.user.id);
+      const credential = await navigator.credentials.create({
+        publicKey: {
+          ...options,
+          challenge: challengeBytes,
+          user: {
+            ...options.user,
+            id: userIdBytes
+          }
+        }
+      });
+      const res = await $fetch(`${authPrefix}/webauthn/register/verify`, {
+        method: "POST",
+        body: {
+          id: credential.id,
+          rawId: credential.id,
+          type: credential.type,
+          response: {
+            clientDataJSON: credential.response.clientDataJSON,
+            attestationObject: credential.response.attestationObject
+          }
+        },
+        credentials: "include"
+      });
+      return res;
+    } catch (err) {
+      error.value = err.data?.message || err.message || "Failed to register passkey";
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const loginWithPasskey = async () => {
+    if (typeof window === "undefined" || !window.PublicKeyCredential) {
+      throw new Error("WebAuthn is not supported on this browser or device");
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      const options = await $fetch(`${authPrefix}/webauthn/login/options`, {
+        method: "POST"
+      });
+      const challengeBytes = new Uint8Array(
+        options.challenge.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))
+      );
+      const assertion = await navigator.credentials.get({
+        publicKey: {
+          challenge: challengeBytes,
+          timeout: options.timeout || 6e4,
+          userVerification: options.userVerification || "preferred"
+        }
+      });
+      const res = await $fetch(`${authPrefix}/webauthn/login/verify`, {
+        method: "POST",
+        body: {
+          id: assertion.id,
+          rawId: assertion.id,
+          type: assertion.type,
+          response: {
+            clientDataJSON: assertion.response.clientDataJSON,
+            authenticatorData: assertion.response.authenticatorData,
+            signature: assertion.response.signature
+          }
+        },
+        credentials: "include"
+      });
+      await refreshSession();
+      return res;
+    } catch (err) {
+      error.value = err.data?.message || err.message || "Failed to authenticate with passkey";
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    loading,
+    error,
+    registerPasskey,
+    loginWithPasskey
+  };
+}

package/dist/runtime/app/composables/passwordless.d.ts

@@ -0,0 +1,7 @@
+export declare function usePasswordless(): {
+    loading: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<string | null, string | null>;
+    sendOtp: (email: string) => Promise<any>;
+    verifyOtp: (email: string, code: string) => Promise<any>;
+    sendMagicLink: (email: string) => Promise<any>;
+};