NextJS 小记（2）

import { AuthError } from 'next-auth';
import { createResponse } from './request';

export class ActionError extends Error {
  public code: number = 0;
  constructor(message: string, code?: number) {
    super(message);
    if (code) this.code = code;
  }
}

/**
* 通用的错误处理包装函数
*/
export const handleActionError = async <T>(action: () => Promise<T>) => {
  try {
    const result = await action();
    return createResponse.success(result);
  } catch (error) {
    if (error instanceof AuthError) {
        return createResponse.error(error.cause?.err?.message || error.message || '认证失败');
    } else if (error instanceof ActionError) {
        return createResponse.error(error.message || '未知错误');
    } else {
        return createResponse.error('服务器错误');
    }
  }
};

Credentials({
  credentials: {
    type: { label: '登录类型', type: 'radio', options: ['password', 'phone'] },
    username: { label: '用户名', type: 'text', placeholder: '用户名' },
    password: { label: '密码', type: 'password' },
  },
  async authorize(credentials) {
    const c = credentials as LoginType;
    // 首先判断登录类型
    if (isPasswordLogin(c)) {
      // 检查登录频率、查找用户并比对密码
      await checkLoginAttempts(c.username);
      const user = await findUserByUsername(c.username);
      if (!user) {
        throw new ActionError('用户不存在');
      }
      if (!verifyPassword(c.password, user.password)) {
        throw new ActionError('密码错误');
      }
      deleteLoginAttempts(c.username); // 验证成功后删除登录频率限制
      // 完善返回的用户信息，进行数据脱敏，判断是否分配子平台，然后返回用户信息
      const userInfo = await getFinalUser(user);
      const company = await hasCompany(user.id);
      if (!company) {
        throw new ActionError('未分配公司');
      }
      // 返回用户信息，将作为 profile
      return userInfo;
    } else if (isPhoneLogin(c)) {
      // 如果是验证码登录，执行相关操作
    }
    // 如果不符合所有登录方式
    throw new ActionError('登录类型错误');
  },
})

/**
* 登录
* @param data
* @returns
*/
export const loginAction = async (data: z.infer<typeof loginFormSchema>) => {
  const validate = loginFormSchema.safeParse(data);
  if (!validate.success) {
    return createResponse.error(validate.error.errors[0].message);
  }
  return handleActionError(async () => {
    let user: User | null;
    if (isPasswordLogin(data)) {
      user = await signIn('credentials', {
        type: data.type,
        username: data.username,
        password: data.password,
        redirect: false,
      });
    } else {
      user = await signIn('credentials', {
        type: data.type,
        phone: data.phone,
        code: data.code,
        redirect: false,
      });
    }
    if (!user) {
      return createResponse.error('用户名或密码错误');
    }
    const info = getSelfInfo(user);
    return createResponse.success(info);
  });
};

import { getToken as authGetToken } from '@auth/core/jwt';
import { cookies, headers } from 'next/headers';

export async function getToken() {
  const token = await authGetToken({
    secret: process.env.AUTH_SECRET,
    raw: true, // 添加这个参数是为了获取原始 Token 而不是解开后的
    req: {
      headers: {
        ...Object.fromEntries(await headers()),
        Cookie: (await cookies())
          .getAll()
          .map((c) => `${c.name}=${c.value}`)
          .join('; '),
      },
    },
  });
  return token;
}

import { auth } from '@/auth';
import { forbidden, notFound, unauthorized } from 'next/navigation';

type DefaultResponseType =
  | DefaultResponseType[]
  | Record<string, DefaultResponseType | string | number | boolean | object | DefaultResponseType[]>
  | null
  | undefined;

export async function pageRequestWithAuth<T = DefaultResponseType>(
  url: string | URL,
  options?: RequestInit
): Promise<T> {
  const a = await auth();
  if (!a || !a.user) {
    unauthorized();
  }
  const token = await getToken(); // 上面的获取 Token 方法
  const finalURL = new URL(url, backend_url);
  // 发起请求
  const response = await fetch(finalURL, {
    ...options,
    headers: {
      ...options?.headers,
      Authorization: `Bearer ${token}`,
    },
  });
  // response 在遇到非 200 响应码的时候并不会跑出错误，因此我们需要判断一下
  if (!response.ok) {
    if (response.status === 401) {
      unauthorized();
    }
    if (response.status === 403) {
      forbidden();
    }
    if (response.status === 404) {
      notFound();
    }
  }
  // 获取内容
  const data = await response.json();
  // 如果后端全部返回 200 响应码，需要我们判断 code 这种类型的判断码时，需要做个 fallback（记得与后端商量好）
  if (data.code === 200) {
    return data.data;
  }
  if (data.code === 401) {
    unauthorized();
  }
  if (data.code === 403) {
    forbidden();
  }
  if (data.code === 404) {
    notFound();
  }
  // 如果都不是以上情况，那么说明这种情况非预期，直接抛出错误，可以在日志里面查看
  throw new Error(data?.message || response.statusText);
}

pageRequestWithAuth.postWithCompany = async function <T = DefaultResponseType>(
  url: string,
  body?: PostParam,
  options?: RequestInit
): Promise<T> {
  const sessoion = await auth();
  if (!sessoion || !sessoion.user) {
    unauthorized();
  }
  // 获取用户当前操作的公司（用户信息类型多加一个 currentViewCompanyId 字段，这部分可以看此文章开头的部分，先在类型里面添加，登录的时候做个判断保险，然后在 AuthJS 的 jwt 方法里面修改信息，下面会提到）
  const compayId = sessoion.user.currentViewCompanyId;
  if (!compayId) {
    forbidden();
  }
  return pageRequestWithAuth.post(url, body, {
    ...options,
    headers: {
    ...options?.headers,
    'X-Company': compayId,
    },
  });
};

{
  callbacks: {
    async jwt({ token, user, trigger, session }) { 
      if (user) {
        token.user = user;
      }
      if (trigger === 'update' || trigger === 'signIn') {
        /**
        * 获取已存用户信息，这里需要说明一下：
        * 当用户登录的时候，user 的值是有的
        * 当再次触发的时候，user 是没有值的，因此只能获取先前保存的值
        */
        const existUserInfo = (user ?? token?.user) as {
          username: string;
          currentViewCompanyId?: number;
        };
        const username = existUserInfo.username;
        // 从数据库中获取用户信息
        const dbuser = await findUserByUsername(username);
        if (dbuser) {
          // 更新用户信息
          const userInfo = await getFinalUser(dbuser);
          // 通过 Session 查询用户信息，如果没有 当前操作的子平台，那说明可能是刚登录，此时查询数据库写入一个默认的即可，否则说明之前登录过了，需要更新
          if (!session?.user?.currentViewCompanyId) {
            const userCompanies = await getUserCompanies(dbuser.id);
            userInfo.currentViewCompanyId = userCompanies?.[0]?.id;
          } else {
            // 这里为什么是 赋值 session.user.currentViewCompanyId 呢？下面会说明
            userInfo.currentViewCompanyId = session.user.currentViewCompanyId;
          }
          token.user = userInfo;
        }
      }
      return token;
    },
  },
}

export const dynamic = 'force-dynamic';

const router = useRouter(); 

const handle = async () => {
  // 一顿操作后...
  router.refresh(); 
}