v1.10.0 リリースノート: お問い合わせ機能の追加

{
  "blockIps": ["127.0.0.1"]
}

import type { NextRequest } from 'next/server';
import { NextResponse } from 'next/server';
import { get } from '@vercel/edge-config';
 
export const config = { matcher: '/((?!api|_next|static|public|favicon).*)' };
 
export const middleware = async (request: NextRequest) => {
  const blockIps = await get<string[]>('blockIps');
  const accessIp = request.ip;
 
  if (accessIp && blockIps?.includes(accessIp)) {
    request.nextUrl.pathname = '/forbidden';
    return NextResponse.rewrite(request.nextUrl, { status: 403 });
  }
};

import { z } from 'zod';
 
export const ContactSchema = z.object({
  email: z
    .string()
    .min(1, { message: 'メールアドレスを入力してください' })
    .max(255, { message: 'メールアドレスは 255 文字以内で入力してください' })
    .email({ message: 'メールアドレスの形式が正しくありません' }),
  name: z
    .string()
    .min(1, { message: '名前を入力してください' })
    .max(255, { message: '名前は 255 文字以内で入力してください' }),
  type: z.enum(['jobScouting', 'projectConsultation', 'feedback', 'collaboration', 'other'], {
    message: 'お問い合わせ種別を選択してください',
  }),
  content: z
    .string()
    .min(1, { message: 'お問い合わせ内容を入力してください' })
    .max(2000, { message: 'お問い合わせ内容は 2000 文字以内で入力してください' }),
  shouldSendReplyMail: z.boolean(),
  recaptchaToken: z.string().optional(),
});

import { Ratelimit } from '@upstash/ratelimit';
import { Redis } from '@upstash/redis';
 
type SlidingWindowProps = Parameters<typeof Ratelimit.slidingWindow>;
 
const rateLimiter = (tokens: SlidingWindowProps[0], windowValue: SlidingWindowProps[1]) =>
  new Ratelimit({
    redis: Redis.fromEnv(),
    limiter: Ratelimit.slidingWindow(tokens, windowValue),
  });
 
const getIpHash = async (ip: string) => {
  const buffer = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(ip));
  return Array.from(new Uint8Array(buffer))
    .map((b) => b.toString(16).padStart(2, '0'))
    .join('');
};
 
export const contactRouter = {
  send: publicProcedure.input(ContactSchema).mutation(async ({ input, ctx }) => {
    if (!ctx.ip) {
      throw new TRPCError({ code: 'BAD_REQUEST' });
    }
 
    const ip = ctx.ip;
    const ipHash = await getIpHash(ip);
    const { success } = await rateLimiter(1, '1 m').limit(ipHash);
 
    if (!success) {
      throw new TRPCError({ code: 'TOO_MANY_REQUESTS' });
    }
 
    // ...
  }),
};

export const verifyRecaptcha = async ({
  recaptchaToken,
  expectedAction,
}: {
  recaptchaToken: string;
  expectedAction: string;
}) => {
  const request = {
    event: {
      token: recaptchaToken,
      expectedAction,
      siteKey: env.RECAPTCHA_SITE_KEY,
    },
  } satisfies RecaptchaRequest;
 
  const response = await fetch(
    `https://recaptchaenterprise.googleapis.com/v1/projects/${env.GCP_PROJECT_ID}/assessments?key=${env.RECAPTCHA_SECRET_KEY}`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(request),
    },
  );
 
  if (!response.ok) {
    throw new Error('Failed to verify recaptcha');
  }
 
  return (await response.json()) as RecaptchaResponse;
}

import { importPKCS8, SignJWT } from 'jose';
 
import { env } from '../../../env';
 
interface Token {
  access_token: string;
  expires_in: number;
  token_type: string;
}
 
type TokenWithExpiration = Token & {
  expires_at: number;
};
 
const payload = {
  iss: env.GCP_CLIENT_EMAIL,
  scope: 'https://www.googleapis.com/auth/spreadsheets',
  aud: 'https://www.googleapis.com/oauth2/v4/token',
  exp: Math.floor(Date.now() / 1000) + 60 * 60,
  iat: Math.floor(Date.now() / 1000),
};
 
const createToken = async () => {
  const privateKey = await importPKCS8(env.GCP_PRIVATE_KEY, 'RS256');
 
  const token = await new SignJWT(payload)
    .setProtectedHeader({ alg: 'RS256' })
    .setIssuedAt()
    .setIssuer(env.GCP_CLIENT_EMAIL)
    .setAudience('https://www.googleapis.com/oauth2/v4/token')
    .setExpirationTime('1h')
    .sign(privateKey);
 
  const form = {
    grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
    assertion: token,
  };
 
  const tokenResponse = await fetch('https://www.googleapis.com/oauth2/v4/token', {
    method: 'POST',
    body: JSON.stringify(form),
    headers: { 'Content-Type': 'application/json' },
  });
 
  if (!tokenResponse.ok) {
    throw new Error('Failed to get token');
  }
 
  const json = (await tokenResponse.json()) as Token;
 
  return {
    ...json,
    expires_at: Math.floor(Date.now() / 1000) + json.expires_in,
  };
};
 
let token: Promise<TokenWithExpiration> | null = null;
 
export const authenticate = async () => {
  if (token === null) {
    token = createToken();
  }
 
  let resolvedToken = await token;
 
  if (resolvedToken.expires_at < Math.floor(Date.now() / 1000)) {
    token = createToken();
    resolvedToken = await token;
  }
 
  return resolvedToken;
};

import { env } from '../../../env';
import { GoogleSheetsError } from '../../exceptions';
import { authenticate } from './token';
 
export const appendGoogleSheets = async ({ sheetName, values }: { sheetName: string; values: string[][] }) => {
  const { access_token } = await authenticate();
 
  const params = {
    range: `${sheetName}!A2`,
    insertDataOption: 'INSERT_ROWS',
    valueInputOption: 'USER_ENTERED',
    resource: {
      values,
    },
  };
 
  const response = await fetch(
    `https://sheets.googleapis.com/v4/spreadsheets/${env.GOOGLE_SHEETS_ID}/values/${encodeURIComponent(params.range)}:append?valueInputOption=${params.valueInputOption}&insertDataOption=${params.insertDataOption}`,
    {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${access_token}`,
        Accept: 'application/json',
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(params.resource),
    },
  );
 
  if (!response.ok) {
    throw new GoogleSheetsError('Google Sheets API request failed: ' + response.statusText);
  }
 
  console.log('Append to Google Sheets was successful');
};

import type { z } from 'zod';
 
import type { ContactSchema } from '@kkhys/validators';
 
type SendEmailParameters = Parameters<typeof GmailApp.sendEmail>;
type ContactSchemaProps = z.infer<typeof ContactSchema>;
 
const sheet = SpreadsheetApp.openById(import.meta.env.VITE_GOOGLE_SHEETS_ID).getActiveSheet();
const lastRow = sheet.getLastRow();
 
const emailColumn = 1;
const nameColumn = 2;
const typeColumn = 3;
const contentColumn = 4;
 
export const sendContactEmail = () => {
  const recipient = '[email protected]' satisfies SendEmailParameters[0];
  const subject = 'お問い合わせがありました' satisfies SendEmailParameters[1];
  const body = generateBody() satisfies SendEmailParameters[2];
  const options = {
    // from: '[email protected]',
    name: 'Keisuke Hayashi',
    // htmlBody: html,
  } satisfies SendEmailParameters[3];
 
  const lock = LockService.getScriptLock();
  if (lock.tryLock(1000)) {
    GmailApp.sendEmail(recipient, subject, body, options);
    lock.releaseLock();
  }
};
 
const generateBody = () => {
  const email = sheet.getRange(lastRow, emailColumn).getValue() as ContactSchemaProps['email'];
  const name = sheet.getRange(lastRow, nameColumn).getValue() as ContactSchemaProps['name'];
  const type = sheet.getRange(lastRow, typeColumn).getValue() as ContactSchemaProps['type'];
  const content = sheet.getRange(lastRow, contentColumn).getValue() as ContactSchemaProps['content'];
 
  return `kkhys.me にお問い合わせがありました。
 
# 名前
${name}
 
# メールアドレス
${email}
 
# お問い合わせ種別
${type}
 
# お問い合わせ内容
${content}
`;
};

export const sendLineMessage = async ({ message }: { message: string }) => {
  const response = await fetch('https://api.line.me/v2/bot/message/push', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${env.LINE_CHANNEL_ACCESS_TOKEN}`,
    },
    body: JSON.stringify({
      to: env.LINE_USER_ID,
      messages: [
        {
          type: 'text',
          text: message,
        },
      ],
    }),
  });
 
  if (!response.ok) {
    throw new LineError('Failed to send a message to LINE');
  }
 
  console.log('Successfully sent a message to LINE');
};

import { Resend } from 'resend';
 
const resend = new Resend(env.RESEND_API_KEY);
const administrator = {
  name: 'Keisuke Hayashi',
  email: '[email protected]',
};
 
export const sendEmail = async ({
  to,
  subject,
  body: { html, text },
  tags,
}: {
  to: string;
  subject: string;
  body: Record<'html' | 'text', string>;
  tags?: { name: string; value: string }[];
}) => {
  const { data, error } = await resend.emails.send({
    from: `${administrator.name} <${administrator.email}>`,
    to,
    subject,
    html,
    text,
    tags,
    headers: {
      'X-Entity-Ref-ID': new Date().getTime().toString(),
    },
  });
 
  if (error) {
    throw new EmailError(`Failed to send email to ${to}. Error: ${JSON.stringify(error)}`);
  }
 
  console.log(`Successfully sent email to ${to}. Response: ${JSON.stringify(data)}`);
};