Computer >> Hướng Dẫn Máy Tính >  >> Lập Trình >> Redis

Xác Thực An Toàn, Type-Safe Trong SvelteKit Với Lucia, PlanetScale Và Upstash Redis

Sau khi guide trước trên blog Upstash lọt vào Bytes newsletter, tôi quyết định tiếp tục party SvelteKit.

Là fan cứng Svelte, tôi thấy ngày càng nhiều người tham gia mỗi ngày — và điều đó khiến tôi vô cùng hào hứng cho tương lai.

Một công cụ vẫn còn under the radar là Lucia.

Trong guide này tôi sẽ chỉ cách setup authentication với Lucia. Chúng ta dùng PlanetScale cho database, và Upstash Redis xử lý session.

Dưới đây screenshot mục tiêu cuối guide. Example repository tại đây.

Xác Thực An Toàn, Type-Safe Trong SvelteKit Với Lucia, PlanetScale Và Upstash Redis

Guide này bằng SvelteKit, nhưng vì Lucia hỗ trợ mọi framework, hầu hết guide áp dụng dễ dàng cho framework phổ biến khác.

Lucia Là Gì?

Đơn giản, Lucia là library TypeScript làm cho việc xử lý user và session dễ như ăn kẹo. Ban đầu library này tạo cho SvelteKit, nhưng liên tục evolve và giờ đủ versatile chơi tốt với hầu hết framework.

Điều tuyệt vời về Lucia là nó trang bị mọi thứ cần thiết quản lý độ phức tạp authentication mà không hy sinh UX. Hãy nghĩ Lucia như một bộ primitive — tùy bạn cấu trúc code và xử lý UX. Lucia có vài phần quan trọng cần hiểu:

Middleware cho phép Lucia đọc request và response cho các framework và runtime khác nhau.

Ví dụ cấu hình middleware:

import { lucia } from "lucia";
import { node } from "lucia/middleware";
// import { nextjs } from "lucia/middleware";
// import { h3 } from "lucia/middleware";
export const auth = lucia({
  env: "DEV",
  // "PROD" nếu deploy lên HTTPS
  middleware: node(),
});

Database adapters cho phép Lucia lưu và truy xuất user và session. Bằng cách cung cấp adapter, Lucia biết cách query cho các type này. Có 2 loại adapter: regular adapters, và session adapters. Trong guide này dùng database mySQL trên PlanetScale lưu user, và instance Redis trên Upstash xử lý session.

Ví dụ cấu hình database adapter:

import { prisma } from "@lucia-auth/adapter-prisma";
import { PrismaClient } from "@prisma/client";
import { lucia } from "lucia";
const client = new PrismaClient();
const auth = lucia({
  env: "DEV",
  adapter: prisma(client),
});

Với background đó, bắt đầu ngay.

Yêu Cầu Tiên Quyết

Để chạy app và follow along cần:

  • Hiểu cơ bản SvelteKit. Xử lý form và routing là thêm.
  • Quen thuộc cơ bản Drizzle ORM.
  • Tài khoản và database trên PlanetScale.
  • Truy cập instance Redis, ví dụ Upstash Redis.

Bắt Đầu

Để hiệu quả, không tạo toàn bộ app từ đầu.

Thay vào đó, clone thư mục sveltekit-lucia-redis từ repo examples Upstash để follow along.

Sau khi download repo, điều hướng vào app dùng cd và cài dependencies qua package manager ưu thích, set biến .env bằng cách duplicate .env.example.

Hiểu Các Phần Quan Trọng

Tóm tắt nhanh các phần quan trọng.

  • src/lib/server/auth/index.ts - Cấu hình Lucia ở đây.
  • src/lib/server/drizzle - Drizzle giúp tạo schema mySQL dễ dàng push lên PlanetScale dùng Drizzle Kit.
  • src/lib/server/planetscale - Export Upstash Client dùng trong Lucia adapter config quản lý user.
  • src/lib/server/upstash - Export Upstash Client dùng trong Lucia adapter config quản lý session.

Phân Tích Code

Cấu Hình Lucia

Điều đầu tiên cấu hình Lucia. Tạo file mới src/lib/server/auth/index.ts.

import { planetscale } from "@lucia-auth/adapter-mysql";
import { dev } from "$app/environment";
import { lucia } from "lucia";
import { sveltekit } from "lucia/middleware";
import { ps } from "../planetscale";
export enum PROVIDER_ID {
  EMAIL = "email",
}
export const auth = lucia({
  adapter: {
    user: planetscale(ps, {
      user: "users",
      key: "keys",
      /**
       * Sessions được xử lý bởi Upstash Redis.
       */
      session: null,
    }),
  },
  middleware: sveltekit(),
  env: dev ? "DEV" : "PROD",
  getUserAttributes: (data) => {
    return {
      userId: data.id,
      email: data.email,
    };
  },
});
export type Auth = typeof auth;

Tóm tắt nhanh:

Import function lucia từ package lucia setup config cho Lucia.

Điều đầu tiên cấu hình property adapter. Nơi nói cho Lucia cách handle user và session.

Set property session thành null vì muốn dùng Redis handle session. Nếu dùng string 'session' ở đây, Lucia sẽ dùng cùng adapter cho cả user và session (strings này tương ứng table trong database).

Đừng lo session adapter, sẽ đến sau.

Property middleware cho Lucia biết dùng SvelteKit. Cho phép Lucia đọc request và response object.

Chú ý exported type Auth. Đây là type của object auth. Cần nó setup SvelteKit locals.

Type Inference Tuyệt Với Lucia

Lucia viết bằng TypeScript, nên type inference tuyệt vời out of the box. Đảm bảo SvelteKit biết type Auth vừa tạo.

Mở app.d.ts thêm:

import type { Auth as LuciaAuth } from "$lib/server/auth";
import type { AuthRequest, Session, User } from "lucia";
declare global {
  namespace App {
    // interface Error {}
    interface Locals {
      auth: AuthRequest;
      session: Session | null;
    }
    interface PageData {
      user?: User;
    }
    // interface Platform {}
  }
}
/// <reference types="lucia" />
declare global {
  namespace Lucia {
    type Auth = LuciaAuth;
    type DatabaseUserAttributes = {
      email: string;
    };
    type DatabaseSessionAttributes = {};
  }
}
export {};

Bằng cách thêm type Auth vào namespace Lucia, giờ truy cập object auth từ locals trong route SvelteKit.

Cũng bất cứ gì import từ Lucia giờ có type đúng.

Với types này, setup hooks.server.ts. Nơi bind AuthRequest và Session object vào request hiện tại.

Làm cho dễ truy cập trên server qua locals.

import type { Handle } from "@sveltejs/kit";
import { sequence } from "@sveltejs/kit/hooks";
import { auth } from "$lib/server";
const auth_handle: Handle = async ({ event, resolve }) => {
  event.locals.auth = auth.handleRequest(event);
  event.locals.session = await event.locals.auth.validate();
  return resolve(event);
};
export const handle = sequence(auth_handle);

Import sequence helper function cho phép chạy nhiều hook theo sequence. Hữu ích sau khi protect route.

Tạo User Model

Với Lucia configured, tạo user model.

Dùng Drizzle ORM, vì nó hot trending.

Xác Thực An Toàn, Type-Safe Trong SvelteKit Với Lucia, PlanetScale Và Upstash Redis

Meme của họ cũng on point. Nhìn cái này.

Trước khi tiếp tục, tạo database trên PlanetScale. Setup file config Drizzle. Giúp Drizzle CLI kết nối database.

import dotenv from "dotenv";
import type { Config } from "drizzle-kit";
dotenv.process();
const username = process.env.DATABASE_USERNAME;
const password = process.env.DATABASE_PASSWORD;
const host = process.env.DATABASE_HOST;
const db = process.env.DATABASE_NAME;
const connectionString = `mysql://${username}:${password}@${host}/${db}?ssl={"rejectUnauthorized":true}`;
export default {
  schema: "./src/lib/server/drizzle/schema/index.ts",
  driver: "mysql2",
  dbCredentials: {
    connectionString: connectionString,
  },
} satisfies Config;

Vì dùng mySQL adapter, Lucia expect user model có cấu trúc cụ thể. Tham khảo docs để biết thêm.

Đặt code sau vào src/lib/server/drizzle/schema/index.ts.

import { relations } from "drizzle-orm";
import { bigint, datetime, index, int, mysqlEnum, mysqlTable, timestamp, unique, varchar, } from "drizzle-orm/mysql-core";
export const users = mysqlTable(
  "users",
  {
    id: varchar("id", { length: 255 }).primaryKey(),
    createdAt: timestamp("createdAt").defaultNow().onUpdateNow().notNull(),
    updatedAt: timestamp("updatedAt").defaultNow().onUpdateNow().notNull(),
    email: varchar("email", { length: 191 }).notNull(),
  },
  (table) => {
    return {
      idIdx: index("users_id_idx").on(table.id),
      userIdKey: unique("users_id_key").on(table.id),
    };
  },
);
export const keys = mysqlTable(
  "keys",
  {
    id: varchar("id", { length: 255 }).primaryKey(),
    hashedPassword: varchar("hashed_password", { length: 255 }),
    userId: varchar("user_id", { length: 255 }).notNull(),
  },
  (table) => {
    return {
      userIdIdx: index("keys_user_id_idx").on(table.userId),
      keyIdKey: unique("keys_id_key").on(table.id),
    };
  },
);

Chạy pnpm drizzle-kit push:mysql push schema lên PlanetScale.

Voila! Giờ có user model Lucia dùng quản lý user.

Thiết Lập Quản Lý Session

Với user model, setup session management.

Dùng Upstash Redis handle session. Đăng ký free account tại đây.

Xác Thực An Toàn, Type-Safe Trong SvelteKit Với Lucia, PlanetScale Và Upstash Redis

Khi vào dashboard, chỉ cần tạo database mới và copy biến môi trường.

Xác Thực An Toàn, Type-Safe Trong SvelteKit Với Lucia, PlanetScale Và Upstash Redis

Thêm biến vào file .env. Thêm sau vào src/lib/server/upstash/index.ts.

import { Redis } from "@upstash/redis";
import { UPSTASH_REDIS_REST_TOKEN, UPSTASH_REDIS_REST_URL, } from "$env/static/private";
export const upstashClient = new Redis({
  url: UPSTASH_REDIS_REST_URL,
  token: UPSTASH_REDIS_REST_TOKEN,
});

Nhớ lúc config Lucia, set session thành null. Vì muốn dùng Redis handle session. Config giờ trông vậy:

import { planetscale } from "@lucia-auth/adapter-mysql";
import { upstash } from "@lucia-auth/adapter-session-redis";
import { dev } from "$app/environment";
import { lucia } from "lucia";
import { sveltekit } from "lucia/middleware";
import { ps } from "../planetscale";
import { upstashClient } from "../upstash";
export enum PROVIDER_ID {
  EMAIL = "email",
}
export const auth = lucia({
  adapter: {
    user: planetscale(ps, {
      user: "users",
      key: "keys",
      session: null,
    }),
    // Chỉ dẫn Lucia dùng Upstash Redis cho session
    session: upstash(upstashClient),
  },
  middleware: sveltekit(),
  env: dev ? "DEV" : "PROD",
  getUserAttributes: (data) => {
    return {
      userId: data.id,
      email: data.email,
    };
  },
});
export type Auth = typeof auth;

May mắn Lucia có sẵn adapter Upstash Redis out of the box. Chỉ cần import và truyền Upstash client.

Dễ dàng quá!

Tạo Routes

Với Lucia configured, tạo routes.

Tạo folder sau trong src/routes. Đừng lo file, sẽ đi qua từng cái.

  • src/routes/auth
    • src/routes/auth/signin
    • src/routes/auth/signup
  • src/routes/app

Tip: Gom "features" dưới cùng folder name hoặc group giúp dễ quản lý khi redirect và protect routes.

Tạo Signin Page

Cuối cùng làm front-end! Bắt đầu signin page.

Tạo file mới src/routes/auth/signin/+page.svelte. Bỏ qua styling, focus functionality — full code ở example repo.

<script lang="ts">
import { enhance } from '$app/forms';
import { Button, Input, Label, PasswordInput } from '$lib/components/common';
import type { ActionData } from './$types';
export let form: ActionData;
let loading = false;
let email = '';
let password = '';
</script>
<form method="POST" use:enhance={() => {
  loading = true;
  return async ({ update }) => {
    loading = false;
    update();
  };
}} >
  {#if form && form.error}
    <div class="p-2 mb-4 text-sm text-center text-red-900 bg-red-200 rounded-sm">
      Error: {form.error}
    </div>
  {/if}
  <div class="grid gap-2.5">
    <div class="grid gap-1">
      <Label for="email">Email</Label>
      <Input bind:value={email} name="email" placeholder="Email" type="email" autoCapitalize="none" autoComplete="email" autoCorrect="off" required={true} />
    </div>
    <div class="grid gap-1">
      <Label for="password">Password</Label>
      <PasswordInput name="password" placeholder="Password" bind:value={password} />
    </div>
    <div class="mt-6 col-span-full">
      <Button type="submit" class="w-full" disabled={loading}>
        {#if loading}
          Loading...
        {:else}
          Sign in
        {/if}
      </Button>
    </div>
  </div>
</form>

Action use:enhance progressive enhance form, cho phép show loading state khi submit. Đọc thêm về enhance tại đây.

Phần còn lại tự giải thích.

Xử Lý Request Signin

SvelteKit làm xử lý POST request dễ dàng. Chỉ cần tạo file +page.server.ts cùng thư mục +page.svelte export object actions với ít nhất property default.

import { fail, redirect } from "@sveltejs/kit";
import { auth, PROVIDER_ID } from "$lib/server";
import { LuciaError } from "lucia";
import type { Actions, PageServerLoad } from "./$types";
export const actions = { /* our actions here */ };

Khám phá key elements phần file này:

Import PROVIDER_ID enum và auth từ src/lib/server/auth tạo trước. Object auth chứa mọi method cần thiết quản lý user và session.

Xem object actions. Lấy form data từ request object, làm housekeeping cơ bản.

actions = {
  default: async ({ request, locals }) => {
    const formData = await request.formData();
    const email = formData.get("email") as string;
    const password = formData.get("password") as string;
    const fields = [email, password];
    if (fields.some(field => !field)) {
      return fail(400, { error: "All fields are required" });
    }

Tiếp, thử sign in user. Nếu user không tồn tại hoặc password sai, Lucia throw error. Chúng ta chuẩn bị catch error trả về 400 kèm error message.

try {
  const user = await auth.useKey(PROVIDER_ID.EMAIL, email.toLowerCase(), password);
  const session = await auth.createSession({
    userId: user.userId,
    attributes: {}
  });
  locals.auth.setSession(session);
} catch (err) {
  if (
    err instanceof LuciaError &&
    (err.message === 'AUTH_INVALID_KEY_ID' || err.message === 'AUTH_INVALID_PASSWORD')
  ) {
    return fail(400, { error: 'Incorrect username of password' });
  }
  return fail(400, { error: 'An unknown error occurred' });
}

Nếu user tồn tại và password đúng, tạo session mới.

Và cuối, redirect user đến dashboard.

return redirect('/app');

Như bạn thấy, Lucia trừu tượng hóa nhiều complexity của authentication. Chỉ cần gọi đúng method, Lucia lo phần còn lại.

Xác Thực An Toàn, Type-Safe Trong SvelteKit Với Lucia, PlanetScale Và Upstash Redis

Không cần hash password, tạo session, quản lý cookie. Lucia làm hết. Và type-safe!

Tạo Signup Page

Tạo file mới src/routes/auth/signup/+page.svelte.

Signup page rất giống signin, không nhiều giải thích. Khác biệt duy nhất: hỏi password confirmation.

<script lang="ts">
import { enhance } from '$app/forms';
import { Button, Input, Label, PasswordInput } from '$lib/components/common';
import type { ActionData } from './$types';
export let form: ActionData;
let loading = false;
let email = '';
let password = '';
let passwordConfirmation = '';
</script>
<form method="POST" use:enhance={() => {
  loading = true;
  return async ({ update }) => {
    loading = false;
    update();
  };
}} >
  {#if form && form.error}
    <div class="p-2 mb-4 text-sm text-center text-red-900 bg-red-200 rounded-sm">
      Error: {form.error}
    </div>
  {/if}
  <div class="grid gap-2.5">
    <div class="grid gap-1">
      <Label for="email">Email</Label>
      <Input bind:value={email} name="email" placeholder="Email" type="email" autoCapitalize="none" autoComplete="email" autoCorrect="off" required={true} />
    </div>
    <div class="grid gap-1">
      <Label for="password">Password</Label>
      <PasswordInput name="password" placeholder="Password" bind:value={password} />
    </div>
    <div class="grid gap-1">
      <Label for="passwordConfirmation">Confirm password</Label>
      <PasswordInput name="passwordConfirmation" placeholder="Repeat password" bind:value={passwordConfirmation} />
    </div>
    <div class="mt-6 col-span-full">
      <Button type="submit" class="w-full" disabled={loading}>
        {#if loading}
          Loading...
        {:else}
          Sign in
        {/if}
      </Button>
    </div>
  </div>
</form>

Xử Lý Request Signup

Tạo file mới src/routes/auth/signup/+page.server.ts.

Signup dùng pattern tương tự signin nhưng có vài khác biệt từ lấy data từ form, validate field, đến tạo user và handle user đã tồn tại.

Import giống signin, bỏ qua phần đó.

Bắt đầu lấy form data từ request object, housekeeping cơ bản. Check password match.

const formData = await request.formData();
const email = formData.get('email') as string;
const password = formData.get('password') as string;
const passwordConfirmation = formData.get('passwordConfirmation') as string;
const fields = [email, password, passwordConfirmation];
if (fields.some((field) => !field)) {
  return fail(400, { error: 'All fields are required' });
}
if (password !== passwordConfirmation) {
  return fail(400, { error: 'Passwords do not match' });
}

Tiếp, tìm user bằng email dùng Drizzle ORM. Nếu user tồn tại, trả về 400 kèm error.

try {
  const user = await db.query.users.findFirst({
    where: eq(schema.users.email, email.toLowerCase()),
  });
  if (user) {
    return fail(400, { error: "User with this email already exists" });
  }

Nếu user không tồn tại, tạo user mới dùng Lucia.

const newUser = await auth.createUser({
  key: {
    providerId: PROVIDER_ID.EMAIL,
    providerUserId: email.toLowerCase(),
    password: password,
  },
  attributes: {
    email,
  },
});

Và cuối, tạo session mới redirect user đến dashboard.

const session = await auth.createSession({
  userId: newUser.userId,
  attributes: {},
});
locals.auth.setSession(session);

Dễ như ăn kẹo!

Bonus: Tạo Signout Page

Khi đang ở đó, tạo endpoint sign out user. Tạo file mới src/routes/auth/signout/+server.ts.

Thêm code sau:

import { auth } from "$lib/server";
import type { RequestHandler } from "./$types";
export const POST: RequestHandler = async ({ locals }) => {
  const session = await locals.auth.validate();
  if (!session) {
    return new Response(null, { status: 400 });
  }
  // Invalidate session hoặc delete all sessions:
  await auth.invalidateAllUserSessions(session.userId);
  await auth.invalidateSession(session.sessionId);
  // Xóa cookie.
  locals.auth.setSession(null);
  return new Response(null, { status: 200 });
};

Lại Lucia hỗ trợ invalidate session dễ dàng. Chỉ cần gọi endpoint này khi user click sign out.

<script lang="ts">
import { goto } from '$app/navigation';
import { Button } from '$lib/components/common';
async function handleSignOut() {
  const response = await fetch('/auth/signout', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' }
  });
  if (response.ok) {
    goto('/auth/signin', { replaceState: true, invalidateAll: true });
  }
}
</script>
<Button on:click={handleSignOut}>Sign out</Button>

Kết Thúc

Đã tạo thành công authentication type-safe với Lucia, PlanetScale, Upstash Redis. Và mới chỉ cào được bề mặt khả năng Lucia.

Lại nhắc, repo cho guide tại đây. Muốn tìm hiểu thêm Lucia, khuyến khích check docs.

Trước khi đi, ghé cộng đồng Discord Upstash — chúng tôi vui lắm. Và nếu muốn content SvelteKit hơn, tìm trên blog tôi tại đây.