qarpeo 0.0.0-alpha.10

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

@@ -0,0 +1,67 @@
+import { ref } from "vue";
+import { useAuth } from "./auth.mjs";
+export function usePasswordless() {
+  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 sendOtp = async (email) => {
+    loading.value = true;
+    error.value = null;
+    try {
+      const res = await $fetch(`${authPrefix}/otp/send`, {
+        method: "POST",
+        body: { email }
+      });
+      return res;
+    } catch (err) {
+      error.value = err.data?.message || err.message || "Failed to send OTP code";
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const verifyOtp = async (email, code) => {
+    loading.value = true;
+    error.value = null;
+    try {
+      const res = await $fetch(`${authPrefix}/otp/verify`, {
+        method: "POST",
+        body: { email, code },
+        credentials: "include"
+      });
+      await refreshSession();
+      return res;
+    } catch (err) {
+      error.value = err.data?.message || err.message || "Failed to verify OTP code";
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const sendMagicLink = async (email) => {
+    loading.value = true;
+    error.value = null;
+    try {
+      const res = await $fetch(`${authPrefix}/magic-link/send`, {
+        method: "POST",
+        body: { email }
+      });
+      return res;
+    } catch (err) {
+      error.value = err.data?.message || err.message || "Failed to send magic link";
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    loading,
+    error,
+    sendOtp,
+    verifyOtp,
+    sendMagicLink
+  };
+}

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

@@ -0,0 +1,43 @@
+import type { QarpeoSubscription } from "../../../types";
+/**
+ * Reactive composable for managing customer subscription status, initiating checkout sessions,
+ * opening the customer billing portal, and reporting/querying metered usage.
+ *
+ * Usage: const { subscription, isSubscribed, checkout, openPortal, reportUsage, getUsage } = useSubscription()
+ */
+export declare function useSubscription(): {
+    subscription: import("vue").ComputedRef<QarpeoSubscription | null>;
+    isSubscribed: import("vue").ComputedRef<boolean>;
+    plan: import("vue").ComputedRef<string | null>;
+    status: import("vue").ComputedRef<string | null>;
+    loading: import("vue").ComputedRef<boolean>;
+    error: any;
+    checkout: (planId?: string, options?: {
+        priceId?: string;
+        mode?: "subscription" | "payment" | "setup";
+        trialDays?: number;
+        customerEmail?: string;
+        successUrl?: string;
+        cancelUrl?: string;
+    }) => Promise<any>;
+    openPortal: (options?: {
+        returnUrl?: string;
+    }) => Promise<any>;
+    reportUsage: (eventName: string, quantity?: number, metadata?: Record<string, any>) => Promise<any>;
+    getUsage: (eventName?: string, options?: {
+        since?: number;
+        until?: number;
+    }) => Promise<any>;
+    refresh: any;
+};
+/** Convenient standalone composable for initiating one-off or subscription checkout flows. */
+export declare function useCheckout(): {
+    checkout: (planId?: string, options?: {
+        priceId?: string;
+        mode?: "subscription" | "payment" | "setup";
+        trialDays?: number;
+        customerEmail?: string;
+        successUrl?: string;
+        cancelUrl?: string;
+    }) => Promise<any>;
+};

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

@@ -0,0 +1,74 @@
+import { computed } from "vue";
+export function useSubscription() {
+  const runtimeConfig = useRuntimeConfig();
+  const paymentsConfig = runtimeConfig.public?.qarpeo?.payments || {};
+  const prefix = paymentsConfig.prefix || "/api/payments";
+  const { data, status, error, refresh } = useAsyncData(
+    "qarpeo:subscription",
+    () => $fetch(`${prefix}/subscription`),
+    { default: () => ({ subscription: null, isSubscribed: false }) }
+  );
+  const subscription = computed(() => data.value?.subscription || null);
+  const isSubscribed = computed(() => Boolean(data.value?.isSubscribed));
+  const plan = computed(() => subscription.value?.planId || null);
+  const subStatus = computed(() => subscription.value?.status || null);
+  const loading = computed(() => status.value === "pending");
+  async function checkout(planId, options) {
+    const res = await $fetch(`${prefix}/checkout`, {
+      method: "POST",
+      body: {
+        planId,
+        ...options
+      }
+    });
+    if (res?.url) {
+      if (typeof window !== "undefined") {
+        window.location.href = res.url;
+      }
+    }
+    return res;
+  }
+  async function openPortal(options) {
+    const res = await $fetch(`${prefix}/portal`, {
+      method: "POST",
+      body: options
+    });
+    if (res?.url) {
+      if (typeof window !== "undefined") {
+        window.location.href = res.url;
+      }
+    }
+    return res;
+  }
+  async function reportUsage(eventName, quantity = 1, metadata) {
+    return $fetch(`${prefix}/usage`, {
+      method: "POST",
+      body: { eventName, quantity, metadata }
+    });
+  }
+  async function getUsage(eventName, options) {
+    const params = new URLSearchParams();
+    if (eventName) params.set("eventName", eventName);
+    if (options?.since) params.set("since", String(options.since));
+    if (options?.until) params.set("until", String(options.until));
+    const qs = params.toString();
+    return $fetch(`${prefix}/usage${qs ? `?${qs}` : ""}`);
+  }
+  return {
+    subscription,
+    isSubscribed,
+    plan,
+    status: subStatus,
+    loading,
+    error,
+    checkout,
+    openPortal,
+    reportUsage,
+    getUsage,
+    refresh
+  };
+}
+export function useCheckout() {
+  const { checkout } = useSubscription();
+  return { checkout };
+}

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

@@ -0,0 +1,96 @@
+import { type Ref, type MaybeRefOrGetter } from "vue";
+import type { RealtimeMessage, RealtimeUser, UsePresenceOptions, UsePresenceReturn, UseRoomStateReturn } from "../../../types";
+export interface UseRealtimeOptions {
+    /** Base path for the WebSocket endpoint. @default "/api/realtime/ws" */
+    path?: string;
+    /** Custom user details for presence identification. */
+    user?: Partial<RealtimeUser>;
+    /** Initial presence state to send upon connection. */
+    presence?: Record<string, any>;
+    /** Enable automatic heartbeat ping every N milliseconds. @default 30000 */
+    heartbeatInterval?: number;
+    /** Alias for `heartbeatInterval`. @default 30000 */
+    heartbeat?: number;
+    /** Enable automatic reconnect on abnormal connection drop. @default true */
+    autoReconnect?: boolean;
+    /** Alias for `autoReconnect`. @default true */
+    reconnect?: boolean;
+    /** Maximum number of reconnection attempts before giving up. @default 10 */
+    maxReconnectAttempts?: number;
+    /** Initial delay for exponential backoff in milliseconds. @default 1000 */
+    reconnectBaseDelay?: number;
+    /** Maximum reconnection delay ceiling in milliseconds. @default 15000 */
+    reconnectMaxDelay?: number;
+    /** Replay unreceived messages automatically on reconnect using sequence numbers. @default true */
+    replayOnReconnect?: boolean;
+    /** Maximum number of messages retained in client history ref. @default 100 */
+    historyLimit?: number;
+}
+export interface UseRealtimeReturn<Events extends Record<string, any> = Record<string, any>> {
+    /** Whether the WebSocket connection is actively open. */
+    connected: Ref<boolean>;
+    /** Whether the WebSocket is currently attempting to connect or reconnect. */
+    connecting: Ref<boolean>;
+    /** Latest connection or socket error. */
+    error: Ref<Error | null>;
+    /** Reactive list of users currently present in the room. */
+    presence: Ref<RealtimeUser[]>;
+    /** Replay buffer of messages received since connection (or history:sync on reconnect). */
+    history: Ref<RealtimeMessage[]>;
+    /** Synchronized room state from the Durable Object. */
+    state: Ref<Record<string, any>>;
+    /** Raw active WebSocket reference. */
+    ws: Ref<WebSocket | null>;
+    /** Listen for an event broadcasted in the room. Returns an unsubscribe function. */
+    on: <E extends string = string>(event: E, handler: (payload: E extends keyof Events ? Events[E] : any, message: RealtimeMessage) => void) => () => void;
+    /**
+     * Remove a specific handler (or all handlers) for an event.
+     * If `handler` is omitted, all listeners for that event are removed.
+     */
+    off: <E extends string = string>(event: E, handler?: (payload: E extends keyof Events ? Events[E] : any, message: RealtimeMessage) => void) => void;
+    /** Broadcast an event to peers in the room. */
+    send: <E extends string = string>(event: E, payload: E extends keyof Events ? Events[E] : any, options?: {
+        self?: boolean;
+    }) => void;
+    /** Update current user's live presence data (broadcasted to all peers). */
+    updatePresence: (presenceData: Record<string, any>) => void;
+    /** Replace the synchronized room state. */
+    setState: (newState: Record<string, any>) => void;
+    /** Merge a partial patch into the synchronized room state. */
+    patchState: (patch: Record<string, any>) => void;
+    /** Manually initiate connection. */
+    connect: () => void;
+    /** Manually close the connection. */
+    disconnect: () => void;
+}
+/**
+ * Universal Vue 3 / Nuxt 5 composable for edge-first WebSockets and room pub/sub.
+ *
+ * @param room Name or reactive reference to the target room (e.g. "doc:123", "chat:support").
+ * @param options Configuration options.
+ */
+export declare function useRealtime<Events extends Record<string, any> = Record<string, any>>(room: MaybeRefOrGetter<string>, options?: UseRealtimeOptions): UseRealtimeReturn<Events>;
+/**
+ * High-level composable for live presence, user tracking, typing indicators, and cursors.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * const { myPresence, updatePresence, peers, onlineCount, onCursorMove } = usePresence("doc:42", {
+ *   initial: { status: "viewing" }
+ * })
+ * </script>
+ * ```
+ */
+export declare function usePresence<T extends Record<string, any> = Record<string, any>>(room: MaybeRefOrGetter<string>, options?: UsePresenceOptions<T>): UsePresenceReturn<T>;
+/**
+ * High-level composable for synchronized reactive room state across all connected users.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * const { state, patchState } = useRoomState("poll:101", { votes: 0 })
+ * </script>
+ * ```
+ */
+export declare function useRoomState<T extends Record<string, any> = Record<string, any>>(room: MaybeRefOrGetter<string>, initialState?: T): UseRoomStateReturn<T>;