qarpeo 0.0.0-alpha.10

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

@@ -0,0 +1,294 @@
+import { ref, computed, toValue } from "vue";
+export function useStorage() {
+  const runtimeConfig = useRuntimeConfig();
+  const storageConfig = runtimeConfig.public?.qarpeo?.storage || runtimeConfig.public?.qarpeo?.blob || {};
+  const prefix = storageConfig.prefix || "/api/storage";
+  const cdnUrl = storageConfig.cdnUrl;
+  const isUploading = ref(false);
+  const progress = ref(0);
+  const error = ref(null);
+  let activeXhr = null;
+  const reset = () => {
+    isUploading.value = false;
+    progress.value = 0;
+    error.value = null;
+    activeXhr = null;
+  };
+  const abort = () => {
+    if (activeXhr) {
+      activeXhr.abort();
+      activeXhr = null;
+    }
+    isUploading.value = false;
+  };
+  const upload = async (file, options = {}) => {
+    isUploading.value = true;
+    progress.value = 0;
+    error.value = null;
+    const filename = options.filename || (file instanceof File ? file.name : "upload");
+    const mimeType = file.type || "application/octet-stream";
+    if (options.presigned) {
+      try {
+        const ticket = await $fetch(`${prefix}/presigned`, {
+          method: "POST",
+          body: { filename, type: mimeType, size: file.size, access: options.access },
+          credentials: "include"
+        });
+        return new Promise((resolve, reject) => {
+          const xhr = new XMLHttpRequest();
+          activeXhr = xhr;
+          xhr.upload.addEventListener("progress", (event) => {
+            if (event.lengthComputable) {
+              progress.value = Math.round(event.loaded / event.total * 100);
+            }
+          });
+          xhr.addEventListener("load", () => {
+            isUploading.value = false;
+            activeXhr = null;
+            if (xhr.status >= 200 && xhr.status < 300) {
+              const fileUrl = cdnUrl ? `${cdnUrl.replace(/\/$/, "")}/${ticket.key}` : `${prefix}/file/${ticket.key}`;
+              resolve({
+                key: ticket.key,
+                pathname: ticket.key,
+                url: fileUrl,
+                size: file.size || 0,
+                type: mimeType,
+                etag: xhr.getResponseHeader("etag") || "",
+                access: ticket.access || options.access || "public",
+                customMetadata: options.customMetadata
+              });
+            } else {
+              const err = new Error(xhr.responseText || `Upload failed with HTTP ${xhr.status}`);
+              error.value = err;
+              reject(err);
+            }
+          });
+          xhr.addEventListener("error", () => {
+            isUploading.value = false;
+            activeXhr = null;
+            const err = new Error("Network error during presigned file upload");
+            error.value = err;
+            reject(err);
+          });
+          xhr.addEventListener("abort", () => {
+            isUploading.value = false;
+            activeXhr = null;
+            const err = new Error("File upload aborted");
+            error.value = err;
+            reject(err);
+          });
+          xhr.open("PUT", ticket.uploadUrl);
+          xhr.setRequestHeader("Content-Type", mimeType);
+          xhr.send(file);
+        });
+      } catch (err) {
+        isUploading.value = false;
+        error.value = err;
+        throw err;
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      activeXhr = xhr;
+      const formData = new FormData();
+      formData.append("file", file, filename);
+      if (options.customMetadata) {
+        formData.append("metadata", JSON.stringify(options.customMetadata));
+      }
+      xhr.upload.addEventListener("progress", (event) => {
+        if (event.lengthComputable) {
+          progress.value = Math.round(event.loaded / event.total * 100);
+        }
+      });
+      xhr.addEventListener("load", () => {
+        isUploading.value = false;
+        activeXhr = null;
+        if (xhr.status >= 200 && xhr.status < 300) {
+          try {
+            const data = JSON.parse(xhr.responseText);
+            const result = data.files ? data.files[0] : data;
+            resolve(result);
+          } catch (err) {
+            error.value = err;
+            reject(err);
+          }
+        } else {
+          const err = new Error(xhr.responseText || `Upload failed with HTTP ${xhr.status}`);
+          error.value = err;
+          reject(err);
+        }
+      });
+      xhr.addEventListener("error", () => {
+        isUploading.value = false;
+        activeXhr = null;
+        const err = new Error("Network error during file upload");
+        error.value = err;
+        reject(err);
+      });
+      xhr.addEventListener("abort", () => {
+        isUploading.value = false;
+        activeXhr = null;
+        const err = new Error("File upload aborted");
+        error.value = err;
+        reject(err);
+      });
+      const uploadUrl = options.access ? `${prefix}/upload?access=${options.access}` : `${prefix}/upload`;
+      xhr.open("POST", uploadUrl);
+      xhr.withCredentials = true;
+      xhr.send(formData);
+    });
+  };
+  const uploadMultiple = async (files, options = {}) => {
+    isUploading.value = true;
+    progress.value = 0;
+    error.value = null;
+    const fileArray = Array.from(files);
+    if (fileArray.length === 0) {
+      isUploading.value = false;
+      return [];
+    }
+    const formData = new FormData();
+    for (const file of fileArray) {
+      formData.append("files", file, file.name);
+    }
+    if (options.customMetadata) {
+      formData.append("metadata", JSON.stringify(options.customMetadata));
+    }
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      activeXhr = xhr;
+      xhr.upload.addEventListener("progress", (event) => {
+        if (event.lengthComputable) {
+          progress.value = Math.round(event.loaded / event.total * 100);
+        }
+      });
+      xhr.addEventListener("load", () => {
+        isUploading.value = false;
+        activeXhr = null;
+        if (xhr.status >= 200 && xhr.status < 300) {
+          try {
+            const data = JSON.parse(xhr.responseText);
+            const result = Array.isArray(data) ? data : data.files || [data];
+            resolve(result);
+          } catch (err) {
+            error.value = err;
+            reject(err);
+          }
+        } else {
+          const err = new Error(xhr.responseText || `Upload failed with HTTP ${xhr.status}`);
+          error.value = err;
+          reject(err);
+        }
+      });
+      xhr.addEventListener("error", () => {
+        isUploading.value = false;
+        activeXhr = null;
+        const err = new Error("Network error during multi-file upload");
+        error.value = err;
+        reject(err);
+      });
+      xhr.addEventListener("abort", () => {
+        isUploading.value = false;
+        activeXhr = null;
+        const err = new Error("Multi-file upload aborted");
+        error.value = err;
+        reject(err);
+      });
+      const uploadUrl = options.access ? `${prefix}/upload?access=${options.access}` : `${prefix}/upload`;
+      xhr.open("POST", uploadUrl);
+      xhr.withCredentials = true;
+      xhr.send(formData);
+    });
+  };
+  const deleteFile = async (key) => {
+    const cleanKey = key.replace(/^\/+/, "");
+    return await $fetch(`${prefix}/file/${cleanKey}`, {
+      method: "DELETE",
+      credentials: "include"
+    });
+  };
+  const getDownloadUrl = async (key, options) => {
+    const cleanKey = key.replace(/^\/+/, "");
+    const res = await $fetch(`${prefix}/sign`, {
+      method: "POST",
+      body: {
+        key: cleanKey,
+        expiresIn: options?.expiresIn,
+        download: options?.download,
+        filename: options?.filename
+      },
+      credentials: "include"
+    });
+    return res.url;
+  };
+  const getOptimizedImageUrl = (key, transform) => {
+    if (!key) return "";
+    if (key.startsWith("http://") || key.startsWith("https://")) {
+      return key;
+    }
+    const cleanKey = key.replace(/^\/+/, "");
+    const baseUrl = cdnUrl ? `${cdnUrl.replace(/\/$/, "")}/${cleanKey}` : `${prefix}/file/${cleanKey}`;
+    if (!transform) return baseUrl;
+    let appliedTransform = { ...transform };
+    if (transform.preset && storageConfig.images?.presets?.[transform.preset]) {
+      appliedTransform = {
+        ...storageConfig.images.presets[transform.preset],
+        ...transform
+      };
+    }
+    const cfOpts = [];
+    if (appliedTransform.width) cfOpts.push(`width=${appliedTransform.width}`);
+    if (appliedTransform.height) cfOpts.push(`height=${appliedTransform.height}`);
+    if (appliedTransform.quality) cfOpts.push(`quality=${appliedTransform.quality}`);
+    if (appliedTransform.format) cfOpts.push(`format=${appliedTransform.format}`);
+    if (appliedTransform.fit) cfOpts.push(`fit=${appliedTransform.fit}`);
+    if (cfOpts.length === 0) return baseUrl;
+    const useCfResizing = storageConfig.images?.resizing !== false;
+    if (useCfResizing) {
+      const cfParamStr = cfOpts.join(",");
+      try {
+        const parsed = new URL(baseUrl);
+        return `${parsed.origin}/cdn-cgi/image/${cfParamStr}${parsed.pathname}${parsed.search}`;
+      } catch {
+        const cleanPath = baseUrl.startsWith("/") ? baseUrl : `/${baseUrl}`;
+        return `/cdn-cgi/image/${cfParamStr}${cleanPath}`;
+      }
+    }
+    const params = new URLSearchParams();
+    const presetName = transform.preset || appliedTransform.preset;
+    if (presetName) params.set("preset", presetName);
+    if (appliedTransform.width) params.set("w", String(appliedTransform.width));
+    if (appliedTransform.height) params.set("h", String(appliedTransform.height));
+    if (appliedTransform.quality) params.set("q", String(appliedTransform.quality));
+    if (appliedTransform.format) params.set("f", appliedTransform.format);
+    if (appliedTransform.fit) params.set("fit", appliedTransform.fit);
+    const qs = params.toString();
+    return qs ? `${baseUrl}?${qs}` : baseUrl;
+  };
+  return {
+    isUploading,
+    progress,
+    error,
+    upload,
+    uploadMultiple,
+    deleteFile,
+    getDownloadUrl,
+    getOptimizedImageUrl,
+    reset,
+    abort
+  };
+}
+export const useUpload = useStorage;
+export function useBlobUrl(key, transform) {
+  const { getOptimizedImageUrl } = useStorage();
+  return computed(() => {
+    const rawKey = toValue(key);
+    if (!rawKey) return "";
+    const rawTransform = toValue(transform);
+    return getOptimizedImageUrl(rawKey, rawTransform);
+  });
+}
+export function getBlobUrl(key, transform) {
+  const { getOptimizedImageUrl } = useStorage();
+  return getOptimizedImageUrl(key, transform);
+}

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

@@ -0,0 +1,82 @@
+/**
+ * @file Composables/tenant.ts Client-side multi-tenancy and custom domains composable. Provides
+ *   reactive access to the active tenant and domain management functions.
+ */
+import type { TenantRecord, CustomDomainRecord } from "../../../types";
+/**
+ * Reactive Multi-Tenancy & Custom Domains Composable.
+ *
+ * @param basePath API prefix for tenant endpoints (default: '/api/tenants')
+ */
+export declare function useTenant(basePath?: string): {
+    loading: Readonly<import("vue").Ref<boolean, boolean>>;
+    error: Readonly<import("vue").Ref<Error | null, Error | null>>;
+    tenant: Readonly<import("vue").Ref<{
+        readonly id: string;
+        readonly slug: string;
+        readonly name: string;
+        readonly plan?: string | undefined;
+        readonly organizationId?: string | undefined;
+        readonly customDomain?: string | undefined;
+        readonly logoUrl?: string | undefined;
+        readonly metadata?: {
+            readonly [x: string]: any;
+        } | undefined;
+        readonly createdAt: number;
+        readonly updatedAt: number;
+    } | null, {
+        readonly id: string;
+        readonly slug: string;
+        readonly name: string;
+        readonly plan?: string | undefined;
+        readonly organizationId?: string | undefined;
+        readonly customDomain?: string | undefined;
+        readonly logoUrl?: string | undefined;
+        readonly metadata?: {
+            readonly [x: string]: any;
+        } | undefined;
+        readonly createdAt: number;
+        readonly updatedAt: number;
+    } | null>>;
+    domains: Readonly<import("vue").Ref<readonly {
+        readonly id: string;
+        readonly tenantId: string;
+        readonly domain: string;
+        readonly status: import("../../../types").DomainStatus;
+        readonly sslStatus: import("../../../types").DomainSslStatus;
+        readonly verificationRecords?: readonly {
+            readonly type: "cname" | "txt";
+            readonly name: string;
+            readonly value: string;
+            readonly target?: string | undefined;
+        }[] | undefined;
+        readonly cnameTarget?: string | undefined;
+        readonly cloudflareHostnameId?: string | undefined;
+        readonly errorMessage?: string | undefined;
+        readonly createdAt: number;
+        readonly updatedAt: number;
+    }[], readonly {
+        readonly id: string;
+        readonly tenantId: string;
+        readonly domain: string;
+        readonly status: import("../../../types").DomainStatus;
+        readonly sslStatus: import("../../../types").DomainSslStatus;
+        readonly verificationRecords?: readonly {
+            readonly type: "cname" | "txt";
+            readonly name: string;
+            readonly value: string;
+            readonly target?: string | undefined;
+        }[] | undefined;
+        readonly cnameTarget?: string | undefined;
+        readonly cloudflareHostnameId?: string | undefined;
+        readonly errorMessage?: string | undefined;
+        readonly createdAt: number;
+        readonly updatedAt: number;
+    }[]>>;
+    isCustomDomain: import("vue").ComputedRef<boolean>;
+    fetchCurrentTenant: () => Promise<TenantRecord | null>;
+    fetchDomains: (targetTenant?: string) => Promise<CustomDomainRecord[]>;
+    addDomain: (domain: string, targetTenant?: string) => Promise<CustomDomainRecord | null>;
+    verifyDomain: (domain: string, targetTenant?: string) => Promise<CustomDomainRecord | null>;
+    removeDomain: (domain: string, targetTenant?: string) => Promise<boolean>;
+};

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

@@ -0,0 +1,120 @@
+import { ref, computed, readonly } from "vue";
+export function useTenant(basePath = "/api/tenants") {
+  const loading = ref(false);
+  const error = ref(null);
+  const tenant = ref(null);
+  const domains = ref([]);
+  const isCustomDomain = computed(() => Boolean(tenant.value?.customDomain));
+  const fetchJson = async (url, options = {}) => {
+    if (typeof globalThis.$fetch === "function") {
+      return globalThis.$fetch(url, options);
+    }
+    const res = await fetch(url, options);
+    if (!res.ok) {
+      throw new Error(`Tenant request failed: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+  };
+  async function fetchCurrentTenant() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const res = await fetchJson(`${basePath}/current`);
+      tenant.value = res.tenant || null;
+    } catch (e) {
+      error.value = e;
+    } finally {
+      loading.value = false;
+    }
+    return tenant.value;
+  }
+  async function fetchDomains(targetTenant) {
+    const t = targetTenant || tenant.value?.slug || tenant.value?.id;
+    if (!t) return [];
+    loading.value = true;
+    error.value = null;
+    try {
+      const res = await fetchJson(`${basePath}/${t}/domains`);
+      domains.value = res.domains || [];
+    } catch (e) {
+      error.value = e;
+    } finally {
+      loading.value = false;
+    }
+    return domains.value;
+  }
+  async function addDomain(domain, targetTenant) {
+    const t = targetTenant || tenant.value?.slug || tenant.value?.id;
+    if (!t) throw new Error("No active tenant selected.");
+    loading.value = true;
+    error.value = null;
+    try {
+      const res = await fetchJson(`${basePath}/${t}/domains`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ domain })
+      });
+      if (res.domain) {
+        domains.value = [res.domain, ...domains.value.filter((d) => d.domain !== domain)];
+      }
+      return res.domain;
+    } catch (e) {
+      error.value = e;
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function verifyDomain(domain, targetTenant) {
+    const t = targetTenant || tenant.value?.slug || tenant.value?.id;
+    if (!t) throw new Error("No active tenant selected.");
+    loading.value = true;
+    error.value = null;
+    try {
+      const res = await fetchJson(
+        `${basePath}/${t}/domains/${encodeURIComponent(domain)}/verify`,
+        { method: "POST" }
+      );
+      if (res.domain) {
+        domains.value = domains.value.map((d) => d.domain === domain ? res.domain : d);
+      }
+      return res.domain;
+    } catch (e) {
+      error.value = e;
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function removeDomain(domain, targetTenant) {
+    const t = targetTenant || tenant.value?.slug || tenant.value?.id;
+    if (!t) throw new Error("No active tenant selected.");
+    loading.value = true;
+    error.value = null;
+    try {
+      await fetchJson(
+        `${basePath}/${t}/domains/${encodeURIComponent(domain)}`,
+        { method: "DELETE" }
+      );
+      domains.value = domains.value.filter((d) => d.domain !== domain);
+      return true;
+    } catch (e) {
+      error.value = e;
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+  return {
+    loading: readonly(loading),
+    error: readonly(error),
+    tenant: readonly(tenant),
+    domains: readonly(domains),
+    isCustomDomain,
+    fetchCurrentTenant,
+    fetchDomains,
+    addDomain,
+    verifyDomain,
+    removeDomain
+  };
+}

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

@@ -0,0 +1,3 @@
+export declare function useTurnstile(): {
+    siteKey: import("vue").ComputedRef<string>;
+};

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

@@ -0,0 +1,10 @@
+import { computed } from "vue";
+export function useTurnstile() {
+  const runtimeConfig = useRuntimeConfig();
+  const siteKey = computed(() => {
+    return runtimeConfig.public?.turnstile?.siteKey || runtimeConfig.public?.qarpeo?.auth?.turnstile?.siteKey || "";
+  });
+  return {
+    siteKey
+  };
+}

package/dist/runtime/app/composables/two-factor.d.ts

@@ -0,0 +1,12 @@
+export interface TwoFactorSetupResult {
+    secret: string;
+    otpauthUrl: string;
+    backupCodes: string[];
+}
+export declare function useTwoFactor(): {
+    loading: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<string | null, string | null>;
+    setup2FA: () => Promise<TwoFactorSetupResult>;
+    verify2FA: (code: string, secret?: string) => Promise<any>;
+    disable2FA: (code: string) => Promise<any>;
+};

package/dist/runtime/app/composables/two-factor.mjs

@@ -0,0 +1,65 @@
+import { ref } from "vue";
+export function useTwoFactor() {
+  const runtimeConfig = useRuntimeConfig();
+  const authConfig = runtimeConfig.public?.qarpeo?.auth || {};
+  const authPrefix = authConfig.prefix || "/api/auth";
+  const loading = ref(false);
+  const error = ref(null);
+  const setup2FA = async () => {
+    loading.value = true;
+    error.value = null;
+    try {
+      const res = await $fetch(`${authPrefix}/2fa/setup`, {
+        method: "POST",
+        credentials: "include"
+      });
+      return res;
+    } catch (err) {
+      error.value = err.data?.message || err.message || "Failed to initiate 2FA setup";
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const verify2FA = async (code, secret) => {
+    loading.value = true;
+    error.value = null;
+    try {
+      const res = await $fetch(`${authPrefix}/2fa/verify`, {
+        method: "POST",
+        body: { code, secret },
+        credentials: "include"
+      });
+      return res;
+    } catch (err) {
+      error.value = err.data?.message || err.message || "Failed to verify 2FA code";
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const disable2FA = async (code) => {
+    loading.value = true;
+    error.value = null;
+    try {
+      const res = await $fetch(`${authPrefix}/2fa/disable`, {
+        method: "POST",
+        body: { code },
+        credentials: "include"
+      });
+      return res;
+    } catch (err) {
+      error.value = err.data?.message || err.message || "Failed to disable 2FA";
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    loading,
+    error,
+    setup2FA,
+    verify2FA,
+    disable2FA
+  };
+}

package/dist/runtime/app/middleware/auth.global.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/app/middleware/auth.global.mjs

@@ -0,0 +1,44 @@
+import { defineNuxtRouteMiddleware, useRuntimeConfig, navigateTo, useUserSession } from "#imports";
+import { useAuth } from "../composables/auth.mjs";
+function matchRouteRule(path, rules) {
+  for (const [pattern, rule] of Object.entries(rules)) {
+    if (!rule) continue;
+    const regexPattern = "^" + pattern.replace(/:[a-zA-Z0-9_]+/g, "[^/]+").replace(/\/\*\*/g, "(/.*)?").replace(/\/\*/g, "/[^/]+") + "$";
+    if (new RegExp(regexPattern).test(path)) {
+      return rule;
+    }
+  }
+  return null;
+}
+export default defineNuxtRouteMiddleware((to) => {
+  const runtimeConfig = useRuntimeConfig();
+  const authConfig = runtimeConfig.public?.qarpeo?.auth || {};
+  const rules = authConfig.rules || {};
+  const rule = matchRouteRule(to.path, rules);
+  if (!rule) return;
+  const { loggedIn, user } = useAuth();
+  if (!loggedIn.value) {
+    const loginPath = rule.redirect || authConfig.redirect?.login || "/login";
+    return navigateTo(`${loginPath}?redirect=${encodeURIComponent(to.fullPath)}`);
+  }
+  const { session } = useUserSession();
+  const typedSession = session.value;
+  const mfaRedirect = authConfig.mfa?.redirect || "/auth/2fa/verify";
+  if (typedSession?.mfaRequired && !typedSession?.mfaVerified && to.path !== mfaRedirect && !to.path.startsWith("/auth/2fa")) {
+    return navigateTo(`${mfaRedirect}?redirect=${encodeURIComponent(to.fullPath)}`);
+  }
+  if (typeof rule === "object" && rule.role) {
+    const allowedRoles = Array.isArray(rule.role) ? rule.role : [rule.role];
+    const userRole = user.value?.role || "user";
+    if (!allowedRoles.includes(userRole)) {
+      return navigateTo("/unauthorized");
+    }
+  }
+  if (typeof rule === "object" && rule.organization) {
+    const currentOrgId = typedSession?.currentOrganizationId;
+    if (!currentOrgId) {
+      const redirectPath = rule.redirect || "/org-select";
+      return navigateTo(redirectPath);
+    }
+  }
+});