Server-only modules - サーバー専用モジュール

// src/lib/server/database.ts
import { PrismaClient } from '@prisma/client';

// データベースクライアント（サーバー専用）
export const prisma = new PrismaClient();

// データベースクエリ関数
export async function getUsers() {
  return prisma.user.findMany();
}

export async function getUserById(id: string) {
  return prisma.user.findUnique({
    where: { id }
  });
}

// src/lib/server/secrets.ts
// 機密データ（サーバー専用）
export const databaseUrl = process.env.DATABASE_URL;
export const apiSecret = process.env.API_SECRET;
export const encryptionKey = process.env.ENCRYPTION_KEY;

// src/lib/auth.server.ts
import { hash, verify } from 'argon2';

export async function hashPassword(password: string): Promise<string> {
  return hash(password);
}

export async function verifyPassword(
  password: string,
  hashedPassword: string
): Promise<boolean> {
  return verify(hashedPassword, password);
}

// src/lib/email.server.ts
import nodemailer from 'nodemailer';

const transporter = nodemailer.createTransport({
  host: process.env.SMTP_HOST,
  port: Number(process.env.SMTP_PORT),
  auth: {
    user: process.env.SMTP_USER,
    pass: process.env.SMTP_PASS
  }
});

export async function sendEmail(
  to: string,
  subject: string,
  html: string
) {
  return transporter.sendMail({
    from: process.env.SMTP_FROM,
    to,
    subject,
    html
  });
}

// src/routes/api/data/+server.ts
import { STRIPE_SECRET_KEY, DATABASE_URL } from '$env/static/private';
import { json } from '@sveltejs/kit';
import type { RequestHandler } from './$types';

export const GET: RequestHandler = async () => {
  // STRIPE_SECRET_KEY はサーバーでのみ使用可能
  const stripe = new Stripe(STRIPE_SECRET_KEY);

  const charges = await stripe.charges.list({ limit: 10 });

  return json(charges.data);
};

// src/routes/api/config/+server.ts
import { env } from '$env/dynamic/private';
import { json } from '@sveltejs/kit';
import type { RequestHandler } from './$types';

export const GET: RequestHandler = async () => {
  // env.SOME_VAR は実行時に評価される
  return json({
    configured: !!env.EXTERNAL_API_KEY
  });
};

// src/routes/api/pdf/+server.ts
import { read } from '$app/server';
import type { RequestHandler } from './$types';

export const GET: RequestHandler = async ({ url }) => {
  const filename = url.searchParams.get('file');

  if (!filename) {
    return new Response('Filename required', { status: 400 });
  }

  // ファイルシステムからPDFを読み取る
  const file = read(`/files/${filename}.pdf`);

  return new Response(file, {
    headers: {
      'Content-Type': 'application/pdf'
    }
  });
};

// src/lib/server/secrets.ts
export const atlantisCoordinates = [/* 機密データ */];

// src/routes/utils.ts
// サーバー専用モジュールからの再エクスポート
export { atlantisCoordinates } from '$lib/server/secrets';

// 安全なユーティリティ関数
export const add = (a: number, b: number) => a + b;

<!-- src/routes/+page.svelte -->
<script lang="ts">
  // add関数のみを使用しているが...
  import { add } from './utils';
</script>

Cannot import $lib/server/secrets.ts into code that runs in the browser,
as this could leak sensitive information.

 src/routes/+page.svelte imports
  src/routes/utils.ts imports
   $lib/server/secrets.ts

If you're only using the import as a type, change it to `import type`.

// これも検出される
const module = await import(`$lib/server/${name}.ts`);

src/
├── lib/
│   ├── server/           # サーバー専用
│   │   ├── database.ts   # DB接続
│   │   ├── auth.ts       # 認証ロジック
│   │   └── email.ts      # メール送信
│   ├── shared/           # 共有コード
│   │   ├── types.ts      # 型定義
│   │   ├── utils.ts      # ユーティリティ
│   │   └── validation.ts # バリデーション
│   └── components/       # UIコンポーネント
└── routes/
    └── api/
        └── ...

// src/lib/server/database.ts
import { PrismaClient } from '@prisma/client';
export const prisma = new PrismaClient();

// 型もエクスポート
export type { User, Post } from '@prisma/client';

<!-- src/routes/+page.svelte -->
<script lang="ts">
  // 型のみのインポートは許可される
  import type { User, Post } from '$lib/server/database';
  import type { PageData } from './$types';

  let { data }: { data: PageData } = $props();
</script>

// src/lib/server/external-api.ts
import { EXTERNAL_API_KEY } from '$env/static/private';

interface ApiResponse<T> {
  data: T;
  error?: string;
}

export async function fetchFromExternalApi<T>(
  endpoint: string
): Promise<ApiResponse<T>> {
  const response = await fetch(`https://api.example.com${endpoint}`, {
    headers: {
      'Authorization': `Bearer ${EXTERNAL_API_KEY}`,
      'Content-Type': 'application/json'
    }
  });

  if (!response.ok) {
    return {
      data: null as T,
      error: `API error: ${response.status}`
    };
  }

  return {
    data: await response.json()
  };
}

// src/lib/server/db.ts
import { DATABASE_URL } from '$env/static/private';
import { drizzle } from 'drizzle-orm/postgres-js';
import postgres from 'postgres';

// コネクションプールの設定
const client = postgres(DATABASE_URL, {
  max: 10,  // 最大接続数
  idle_timeout: 20,
  connect_timeout: 10
});

export const db = drizzle(client);

// クリーンアップ用（テスト等）
export async function closeDb() {
  await client.end();
}

// src/lib/server/session.ts
import { SESSION_SECRET } from '$env/static/private';
import { SignJWT, jwtVerify } from 'jose';

const secret = new TextEncoder().encode(SESSION_SECRET);

export interface SessionData {
  userId: string;
  email: string;
  role: 'user' | 'admin';
}

export async function createSession(data: SessionData): Promise<string> {
  return new SignJWT({ ...data })
    .setProtectedHeader({ alg: 'HS256' })
    .setIssuedAt()
    .setExpirationTime('7d')
    .sign(secret);
}

export async function verifySession(token: string): Promise<SessionData | null> {
  try {
    const { payload } = await jwtVerify(token, secret);
    return payload as unknown as SessionData;
  } catch {
    return null;
  }
}

// src/lib/server/utils.test.ts
import { describe, it, expect } from 'vitest';
// テスト環境ではサーバー専用モジュールをインポート可能
import { hashPassword } from './auth';

describe('auth utils', () => {
  it('should hash password', async () => {
    const hash = await hashPassword('password123');
    expect(hash).not.toBe('password123');
  });
});