feat: add settings, profile, and sms consent backend services

src/actions/profile.ts

@@ -0,0 +1,18 @@
+"use server";
+
+import { verifySession } from "@/lib/dal";
+import { getMemberProfile } from "@/services/profile";
+import { transformError } from "@/utils/errors";
+import type { ActionResult } from "@/lib/action-types";
+import type { MemberProfile } from "@/services/profile";
+
+export async function fetchProfile(): Promise<ActionResult<MemberProfile>> {
+  try {
+    const session = await verifySession();
+    const profile = await getMemberProfile(session.ownerid, session.isAdmin);
+    return { success: true, data: profile };
+  } catch (error) {
+    const appError = transformError(error);
+    return { success: false, error: appError.message };
+  }
+}

src/actions/settings.ts

@@ -0,0 +1,62 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { verifySession } from "@/lib/dal";
+import { UpdatePreferencesSchema, RevokeSmsConsentSchema } from "@/schema/settings";
+import { getMemberSmsConsent, revokeSmsConsent } from "@/services/sms-consent";
+import { getUserPreferences, updateUserPreferences } from "@/services/user-preference";
+import { transformError } from "@/utils/errors";
+import type { ActionResult } from "@/lib/action-types";
+import type { SmsConsentRecord } from "@/services/sms-consent";
+import type { UserPreferenceData } from "@/services/user-preference";
+
+export async function fetchSmsConsent(): Promise<ActionResult<SmsConsentRecord | null>> {
+  try {
+    const session = await verifySession();
+    const consent = await getMemberSmsConsent(session.ownerid);
+    return { success: true, data: consent };
+  } catch (error) {
+    const appError = transformError(error);
+    return { success: false, error: appError.message };
+  }
+}
+
+export async function revokeSmsConsentAction(input: { method: string; message: string | null }): Promise<ActionResult> {
+  try {
+    const session = await verifySession();
+    const validated = RevokeSmsConsentSchema.parse(input);
+    await revokeSmsConsent(session.ownerid, validated.method, validated.message);
+    revalidatePath("/settings");
+    return { success: true };
+  } catch (error) {
+    const appError = transformError(error);
+    return { success: false, error: appError.message };
+  }
+}
+
+export async function fetchUserPreferences(): Promise<ActionResult<UserPreferenceData>> {
+  try {
+    const session = await verifySession();
+    const prefs = await getUserPreferences(session.ownerid);
+    return { success: true, data: prefs };
+  } catch (error) {
+    const appError = transformError(error);
+    return { success: false, error: appError.message };
+  }
+}
+
+export async function updateUserPreferencesAction(input: {
+  notifyEmailDefault?: boolean;
+  notifySmsDefault?: boolean;
+}): Promise<ActionResult<UserPreferenceData>> {
+  try {
+    const session = await verifySession();
+    const validated = UpdatePreferencesSchema.parse(input);
+    const updated = await updateUserPreferences(session.ownerid, validated);
+    revalidatePath("/settings");
+    return { success: true, data: updated };
+  } catch (error) {
+    const appError = transformError(error);
+    return { success: false, error: appError.message };
+  }
+}

src/schema/settings.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+
+export const UpdatePreferencesSchema = z
+  .object({
+    notifyEmailDefault: z.boolean().optional(),
+    notifySmsDefault: z.boolean().optional(),
+  })
+  .refine((data) => data.notifyEmailDefault !== undefined || data.notifySmsDefault !== undefined, {
+    message: "At least one notification preference must be provided",
+  });
+
+export const RevokeSmsConsentSchema = z.object({
+  method: z.string().min(1).max(50),
+  message: z.string().max(500).nullable(),
+});
+
+export type UpdatePreferences = z.infer<typeof UpdatePreferencesSchema>;
+export type RevokeSmsConsent = z.infer<typeof RevokeSmsConsentSchema>;

src/services/profile.ts

@@ -0,0 +1,32 @@
+import "server-only";
+import { getMemberById } from "@/lib/api/member-api";
+import { splitName } from "@/utils/name";
+import { AppError } from "@/utils/errors";
+
+export interface MemberProfile {
+  firstName: string;
+  lastName: string;
+  email: string;
+  phone: string;
+  altPhone: string | undefined;
+  role: "Admin" | "Member";
+}
+
+export async function getMemberProfile(ownerid: number, isAdmin: boolean): Promise<MemberProfile> {
+  const member = await getMemberById(ownerid);
+
+  if (!member) {
+    throw new AppError("NOT_FOUND", "Member not found");
+  }
+
+  const { firstName, lastName } = splitName(member.ownername);
+
+  return {
+    firstName,
+    lastName,
+    email: member.owneremail,
+    phone: member.ownerphone,
+    altPhone: member.owneraltphone,
+    role: isAdmin ? "Admin" : "Member",
+  };
+}

src/services/sms-consent.ts

@@ -0,0 +1,65 @@
+import "server-only";
+import prisma from "@/lib/db";
+import { transformError } from "@/utils/errors";
+
+export interface SmsConsentRecord {
+  id: number;
+  memberId: number;
+  consentedAt: Date;
+  consentMethod: string;
+  consentText: string;
+  consentPurpose: string;
+  revokedAt: Date | null;
+  revokeMethod: string | null;
+}
+
+export async function getMemberSmsConsent(memberId: number): Promise<SmsConsentRecord | null> {
+  try {
+    const consent = await prisma.smsConsent.findFirst({
+      where: { memberId, revokedAt: null },
+      select: {
+        id: true,
+        memberId: true,
+        consentedAt: true,
+        consentMethod: true,
+        consentText: true,
+        consentPurpose: true,
+        revokedAt: true,
+        revokeMethod: true,
+      },
+      orderBy: { consentedAt: "desc" },
+    });
+
+    return consent;
+  } catch (error) {
+    throw transformError(error);
+  }
+}
+
+export async function hasActiveConsent(memberId: number): Promise<boolean> {
+  try {
+    const consent = await prisma.smsConsent.findFirst({
+      where: { memberId, revokedAt: null },
+      select: { id: true },
+    });
+
+    return consent !== null;
+  } catch (error) {
+    throw transformError(error);
+  }
+}
+
+export async function revokeSmsConsent(memberId: number, method: string, message: string | null): Promise<void> {
+  try {
+    await prisma.smsConsent.updateMany({
+      where: { memberId, revokedAt: null },
+      data: {
+        revokedAt: new Date(),
+        revokeMethod: method,
+        revokeMessage: message,
+      },
+    });
+  } catch (error) {
+    throw transformError(error);
+  }
+}

src/services/user-preference.ts

@@ -0,0 +1,48 @@
+import "server-only";
+import prisma from "@/lib/db";
+import { transformError } from "@/utils/errors";
+
+export interface UserPreferenceData {
+  notifyEmailDefault: boolean;
+  notifySmsDefault: boolean;
+}
+
+const DEFAULTS: UserPreferenceData = {
+  notifyEmailDefault: true,
+  notifySmsDefault: false,
+};
+
+export async function getUserPreferences(memberId: number): Promise<UserPreferenceData> {
+  try {
+    const prefs = await prisma.userPreference.findUnique({
+      where: { memberId },
+      select: { notifyEmailDefault: true, notifySmsDefault: true },
+    });
+
+    return prefs ?? DEFAULTS;
+  } catch (error) {
+    throw transformError(error);
+  }
+}
+
+export async function updateUserPreferences(
+  memberId: number,
+  data: Partial<UserPreferenceData>,
+): Promise<UserPreferenceData> {
+  try {
+    const updated = await prisma.userPreference.upsert({
+      where: { memberId },
+      create: {
+        memberId,
+        notifyEmailDefault: data.notifyEmailDefault ?? DEFAULTS.notifyEmailDefault,
+        notifySmsDefault: data.notifySmsDefault ?? DEFAULTS.notifySmsDefault,
+      },
+      update: data,
+      select: { notifyEmailDefault: true, notifySmsDefault: true },
+    });
+
+    return updated;
+  } catch (error) {
+    throw transformError(error);
+  }
+}

src/utils/name.ts

@@ -0,0 +1,13 @@
+export function splitName(fullName: string): { firstName: string; lastName: string } {
+  const trimmed = fullName.trim();
+  const spaceIndex = trimmed.indexOf(" ");
+
+  if (spaceIndex === -1) {
+    return { firstName: trimmed, lastName: "" };
+  }
+
+  return {
+    firstName: trimmed.slice(0, spaceIndex),
+    lastName: trimmed.slice(spaceIndex + 1),
+  };
+}