@antelopejs/dms-saas 0.0.1

package/frontend-vue/app/composables/useSupportRequest.ts

@@ -0,0 +1,74 @@
+interface PendingSupportRequest {
+  requestId: string;
+  fingerprint: string;
+}
+
+interface SupportRequestIdentity {
+  requestId: string;
+}
+
+interface SupportTransportError {
+  statusCode?: number;
+  status?: number;
+  data?: unknown;
+}
+
+type SupportRequestBody<T> = T & SupportRequestIdentity;
+type SupportSender<T, R> = (body: SupportRequestBody<T>) => Promise<R>;
+const TERMINAL_STATUSES = new Set([400, 409, 422]);
+const STORAGE_PREFIX = "saas:support-request:";
+
+async function fingerprint(payload: string): Promise<string> {
+  const bytes = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(payload),
+  );
+  return Array.from(new Uint8Array(bytes), (byte) =>
+    byte.toString(16).padStart(2, "0"),
+  ).join("");
+}
+
+function isTerminal(error: unknown): boolean {
+  const result = error as SupportTransportError | null;
+  return (
+    TERMINAL_STATUSES.has(result?.statusCode ?? result?.status ?? 0) &&
+    typeof result?.data === "string" &&
+    result.data.startsWith("saas.errors.support.")
+  );
+}
+
+function clearPending(key: string, value: string): void {
+  if (sessionStorage.getItem(key) === value) sessionStorage.removeItem(key);
+}
+
+/** Retains request identity across ambiguous transport and page reloads, without storing message content. */
+export async function sendSupportRequest<T extends object, R>(
+  scope: string,
+  body: T,
+  send: SupportSender<T, R>,
+): Promise<R> {
+  const payload = JSON.stringify(body);
+  const digest = await fingerprint(payload);
+  const key = `${STORAGE_PREFIX}${scope}`;
+  const saved = sessionStorage.getItem(key);
+  const pending: PendingSupportRequest = saved
+    ? JSON.parse(saved)
+    : { requestId: crypto.randomUUID(), fingerprint: digest };
+  if (pending.fingerprint !== digest)
+    throw new Error(
+      "Retry the pending support request unchanged before submitting different content.",
+    );
+  const value = JSON.stringify(pending);
+  sessionStorage.setItem(key, value);
+  try {
+    const result = await send({
+      ...JSON.parse(payload),
+      requestId: pending.requestId,
+    } as SupportRequestBody<T>);
+    clearPending(key, value);
+    return result;
+  } catch (error) {
+    if (isTerminal(error)) clearPending(key, value);
+    throw error;
+  }
+}

package/frontend-vue/app/composables/useTenantPlan.ts

@@ -0,0 +1,95 @@
+import type { PlanInterval } from "./usePlanIntervalLabel";
+
+const TENANT_PLAN_ENDPOINT = "/api/saas/tenant/plan";
+const TENANT_PLAN_STATE_KEY = "saas-tenant-plan";
+
+export interface TenantPlanFeature {
+  featureId: string;
+  displayName: string;
+  tooltip: string | null;
+  unit: string | null;
+  valueType: "boolean" | "number" | "string";
+  isDetailRow: boolean;
+  order: number;
+}
+
+export interface TenantPlanView {
+  _id: string;
+  name: string;
+  price: number;
+  currency: string;
+  interval: PlanInterval;
+  order: number;
+  checkoutAvailable: boolean;
+  featureValues: Record<string, unknown>;
+}
+
+export interface CurrentPlan {
+  _id: string;
+  name: string;
+  description: string;
+  price: number;
+  currency: string;
+  interval: PlanInterval;
+}
+
+export interface PendingPlanChange {
+  planId: string;
+  planName: string;
+  effectiveAt: string | null;
+}
+
+export interface TenantPlanResponse {
+  current: CurrentPlan | null;
+  available: TenantPlanView[];
+  features: TenantPlanFeature[];
+  status: string | null;
+  freeUntil: string | null;
+  isComplimentary: boolean;
+  isPlanChangeLocked: boolean;
+  canRecoverComplimentary: boolean;
+  paidUsageStartedAt: string | null;
+  paidUsagePeriods: PaidUsagePeriod[] | null;
+  currentPeriodEnd: string | null;
+  pendingPlan: PendingPlanChange | null;
+}
+
+export interface PaidUsagePeriod {
+  stripeSubscriptionId: string;
+  start: string;
+  end: string | null;
+}
+
+export interface ChangePlanResult {
+  changed: boolean;
+  scheduled: boolean;
+  planId: string;
+  effectiveAt: string | null;
+  checkoutUrl: string | null;
+}
+
+/** The payload resolves inheritance for every public plan and carries the
+ * features catalogue, so the plan card and the free-access banner share it. */
+export function useTenantPlan() {
+  const { $authFetch } = useAuthFetch();
+  const shared = useSharedRequest(TENANT_PLAN_STATE_KEY, () =>
+    $authFetch<TenantPlanResponse>(TENANT_PLAN_ENDPOINT),
+  );
+
+  function changePlan(planId: string): Promise<ChangePlanResult> {
+    const returnUrl =
+      typeof window !== "undefined" ? window.location.href : "/";
+    return $authFetch<ChangePlanResult>(TENANT_PLAN_ENDPOINT, {
+      method: "PUT",
+      body: { planId, successUrl: returnUrl, cancelUrl: returnUrl },
+    });
+  }
+
+  function cancelPendingChange(): Promise<ChangePlanResult> {
+    return $authFetch<ChangePlanResult>(`${TENANT_PLAN_ENDPOINT}/pending`, {
+      method: "DELETE",
+    });
+  }
+
+  return { ...shared, changePlan, cancelPendingChange };
+}

package/frontend-vue/app/composables/useTenantSwitch.ts

@@ -0,0 +1,22 @@
+const SWITCH_TENANT_ENDPOINT = "/auth/switch-tenant";
+
+/**
+ * A full page load is required, not a router navigation: the tenant lives in
+ * the session cookie and every already-fetched page payload belongs to the
+ * previous one.
+ */
+export async function useTenantSwitch(
+  tenantId: string,
+  redirectTo?: string,
+): Promise<void> {
+  await $fetch(SWITCH_TENANT_ENDPOINT, {
+    method: "POST",
+    body: { tenantId },
+  });
+  if (typeof window === "undefined") return;
+  if (redirectTo) {
+    window.location.href = redirectTo;
+    return;
+  }
+  window.location.reload();
+}

package/frontend-vue/app/composables/useWorkspaceAccessCache.ts

@@ -0,0 +1,25 @@
+export interface WorkspaceAccess {
+  blocked: boolean;
+  status?: string;
+  isTenantOwner: boolean;
+  /** Owner-only, and only while blocked: what the suspended screen offers to
+   * settle. Members and unblocked workspaces get null. */
+  unpaidInvoice: UnpaidInvoiceRef | null;
+}
+
+export interface CachedWorkspaceAccess {
+  tenantId: string;
+  access: WorkspaceAccess;
+}
+
+/**
+ * Per-session cache of the current workspace's subscription access, shared
+ * between the global workspace-suspended middleware (reader/writer) and the
+ * suspended screen (invalidator once the workspace unblocks).
+ */
+export function useWorkspaceAccessCache() {
+  return useDmsState<CachedWorkspaceAccess | null>(
+    "saas-workspace-access",
+    () => null,
+  );
+}