🗄️ Turso × SvelteKit 完全ソースコード徹底解説

• Embedded Replicas — アプリケーションプロセスと同じホスト上にローカル SQLite ファイルとして DB を複製し、読み取りをマイクロ秒単位で完結させる機能。 VM・VPS・モバイルアプリで特に有効。Reads are served from the local file; writes propagate to the remote primary（公式ドキュメント準拠）。
• Multi-DB-per-organization — 1 つの Turso 組織アカウントで複数（無料プランは 100 個、上位プランは無制限）の独立した DB を管理できる。マルチテナント SaaS に最適。
• DB Branching — 本番 DB をブランチとして分岐させ、スキーマ変更のテストや PR ごとのプレビュー環境を作成できる（Neon の branching に相当する機能）。
• Groups — 複数 DB を1つのグループにまとめ、同一ロケーション設定・共有 WAL ファイルで管理する機能。グループ単位でロケーションを追加すると全 DB にレプリカが展開される。

brew install tursodatabase/tap/turso

curl -sSfL https://get.tur.so/install.sh | bash

irm get.tur.so/install.ps1 | iex

# 新規登録（ブラウザが開く）
turso auth signup

# 既存アカウントでログイン
turso auth login

# ログイン状態確認
turso auth whoami

# 東京リージョンで DB を作成
turso db create my-svelte-db --location nrt

# DB 一覧を確認
turso db list

# 特定グループ内の DB だけ確認
turso db list --group my-group

# DB の詳細情報（URL を含む）を表示
turso db show my-svelte-db

# URL だけを取り出す（環境変数にコピーしやすい形式）
turso db show my-svelte-db --url

# 認証トークン生成（デフォルトは無期限）
turso db tokens create my-svelte-db

# 有効期限付きトークン（例: 7日間）
turso db tokens create my-svelte-db --expiration 7d

# シェルに接続
turso db shell my-svelte-db

# シェル内で SQL を実行（例）
CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT NOT NULL);
INSERT INTO users VALUES (1, 'Alice');
SELECT * FROM users;

# シェルを終了
.quit

bun create svelte@latest my-app
cd my-app
bun install

npm create svelte@latest my-app
cd my-app
npm install

• Which Svelte app template? → Skeleton project（最小構成）
• Add type checking with TypeScript? → Yes, using TypeScript syntax
• Add ESLint? → Yes
• Add Prettier? → Yes
• Add Vitest? → プロジェクト規模に応じて任意

# Turso 公式クライアント（必須）
bun add @libsql/client

# Drizzle ORM（スキーマ型安全化・マイグレーション管理に推奨）
bun add drizzle-orm
bun add -D drizzle-kit

my-app/
├── src/
│   ├── lib/
│   │   └── server/          ← クライアントに絶対渡らない領域
│   │       ├── db.ts        ← createClient() の初期化
│   │       └── schema.ts    ← Drizzle テーブル定義
│   └── routes/
│       └── +page.server.ts  ← load() / actions() からのみ db を参照
├── drizzle/                 ← drizzle-kit が生成するマイグレーションファイル
├── drizzle.config.ts        ← drizzle-kit の設定
├── .env                     ← シークレット（gitignore 必須）
└── svelte.config.js

// svelte.config.js
import adapter from '@sveltejs/adapter-auto';
import {"{"} vitePreprocess {"}"} from '@sveltejs/vite-plugin-svelte';

/** @type {"{"} import('@sveltejs/kit').Config {"}"} */
const config = {"{"}
  preprocess: vitePreprocess(),
  kit: {"{"}
    adapter: adapter(),
    alias: {"{"}
      $db: 'src/lib/server/db.ts',
      $schema: 'src/lib/server/schema.ts'
    {"}"}
  {"}"}
{"}"};

export default config;

# .env  （git に絶対コミットしない）
TURSO_DATABASE_URL="libsql://my-svelte-db-yourname.turso.io"
TURSO_AUTH_TOKEN="eyJhbGciOiJFZERTQSIsInR5cCI6IkpXVCJ9..."

# .gitignore に必ず含めること
.env
.env.local
.env.*.local

• 型安全: TypeScript の型推論が効き、変数名の typo をビルド時に検出できる
• クライアント完全除外: SvelteKit がビルド時にサーバー専用と判定し、バンドルから削除する（$env/static/private を +page.svelte からインポートするとビルドエラーになる）
• デッドコード除去: 値が定数になるため、未使用の環境変数参照が最適化される

// src/lib/server/db.ts
import {"{"} createClient {"}"} from '@libsql/client';
import {"{"} TURSO_DATABASE_URL, TURSO_AUTH_TOKEN {"}"} from '$env/static/private';

export const client = createClient({"{"}
  url: TURSO_DATABASE_URL,
  authToken: TURSO_AUTH_TOKEN
{"}"});

// Cloudflare Pages 向け: +page.server.ts での例
import {"{"} createClient {"}"} from '@libsql/client';

export const load = async ({"{"} platform {"}"}) => {"{"}
  // platform.env は Cloudflare Workers のバインディング
  const db = createClient({"{"}
    url: platform?.env?.TURSO_DATABASE_URL ?? '',
    authToken: platform?.env?.TURSO_AUTH_TOKEN ?? ''
  {"}"});
  const result = await db.execute('SELECT * FROM users');
  return {"{"} users: result.rows {"}"};
{"}"};

// src/lib/server/db.ts
import {"{"} createClient, type Client {"}"} from '@libsql/client';
import {"{"} TURSO_DATABASE_URL, TURSO_AUTH_TOKEN {"}"} from '$env/static/private';

export const db: Client = createClient({"{"}‍
  url: TURSO_DATABASE_URL,
  authToken: TURSO_AUTH_TOKEN,
{"}"});

• libSQL クライアントは ステートレス かつ スレッドセーフ
• 通信は HTTP/HTTPS ベースのため コネクションプール管理が不要（PostgreSQL とは根本的に異なる設計）
• Node.js / Bun はモジュールを初回 import 時に一度だけ評価するためシングルトンが自然に成立する
• Cloudflare Workers 環境はリクエストごとに隔離されるが、libSQL クライアントは軽量なため複数インスタンスになっても問題なし

// 1. 本番: Turso クラウド（HTTPS + JWT 認証）
url: 'libsql://your-db-name.turso.io'

// 2. ローカル SQLite ファイル（開発・Embedded Replica のローカル側）
url: 'file:local.db'
url: 'file:/absolute/path/to/local.db'

// 3. ローカル sqld 開発サーバー（docker run ghcr.io/tursodatabase/libsql-server）
//    TLS なし → tls: false が必要
url: 'http://127.0.0.1:8080'

// 4. メモリ内 SQLite（テスト用、プロセス終了で消える）
url: ':memory:'

// シンプル形（パラメータなし）
const result = await db.execute('SELECT * FROM users');

// positional バインド（? プレースホルダー）
const r2 = await db.execute({"{"}‍
  sql: 'SELECT * FROM users WHERE id = ? AND active = ?',
  args: [42, 1],
{"}"});

// named バインド（:name プレースホルダー）
const r3 = await db.execute({"{"}‍
  sql: 'SELECT * FROM users WHERE email = :email',
  args: {"{"} email: 'user@example.com' {"}"}‍,
{"}"});

// rows を型付きオブジェクトに変換
const users = result.rows.map((row) => ({"{"}‍
  id:    Number(row.id),
  name:  String(row.name),
  email: String(row.email),
{"}"}));

// CREATE TABLE + 複数 INSERT を 1 往復で実行
const results = await db.batch([
  {"{"}
    sql: `CREATE TABLE IF NOT EXISTS posts (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            title TEXT NOT NULL,
            body TEXT,
            created_at INTEGER NOT NULL
          )`,
    args: [],
  {"}"}‍,
  {"{"}
    sql: 'INSERT INTO posts (title, body, created_at) VALUES (?, ?, ?)',
    args: ['First Post', 'Hello Turso!', Date.now()],
  {"}"}‍,
  {"{"}
    sql: 'INSERT INTO posts (title, body, created_at) VALUES (?, ?, ?)',
    args: ['Second Post', 'SvelteKit is great.', Date.now()],
  {"}"}‍,
], 'write');
console.log('挿入行数:', results[1].rowsAffected); // 1
console.log('最初の rowid:', results[1].lastInsertRowid); // 1n

const tx = await db.transaction('write');
try {"{"}
  const stockRes = await tx.execute({"{"}‍
    sql: 'SELECT stock FROM products WHERE id = ?',
    args: [productId],
  {"}"});
  const stock = Number(stockRes.rows[0]?.stock ?? 0);
  if (stock < quantity) {"{"}
    await tx.rollback();
    return {"{"} error: '在庫不足' {"}"};
  {"}"}
  await tx.execute({"{"}‍
    sql: 'UPDATE products SET stock = stock - ? WHERE id = ?',
    args: [quantity, productId],
  {"}"});
  await tx.execute({"{"}‍
    sql: 'INSERT INTO orders (product_id, qty, created_at) VALUES (?, ?, ?)',
    args: [productId, quantity, Date.now()],
  {"}"});
  await tx.commit();
  return {"{"} success: true {"}"};
} catch (e) {"{"}
  await tx.rollback();
  throw e;
{"}"}

// executeMultiple — セミコロン区切り SQL を一括実行（マイグレーション用、パラメータ不可）
await db.executeMultiple(`
  CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    email TEXT UNIQUE NOT NULL,
    created_at INTEGER NOT NULL
  );
  CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
`);

// sync — Embedded Replica のローカルコピーをリモートと手動同期
await db.sync();

// close — クライアントを終了し内部リソースを解放
db.close();

const newId = Number(result.lastInsertRowid); // 安全範囲内の場合
const safe = result.toJSON(); // BigInt が string に変換される

// ❌ 文字列結合でクエリを組み立てる
const name = formData.get('name');
await db.execute(`SELECT * FROM users WHERE name = '${"$"}{"{"}name{"}"}'`);
// name に  ' OR 1=1 --  が入ると全件流出する

// ✅ positional バインド（? プレースホルダー）
await db.execute({"{"}‍
  sql: 'SELECT * FROM users WHERE name = ?',
  args: [name],
{"}"});

// ✅ named バインド（:プレースホルダー名）
await db.execute({"{"}‍
  sql: 'SELECT * FROM users WHERE email = :email AND active = :active',
  args: {"{"} email: userEmail, active: 1 {"}"}‍,
{"}"});

// ✅ INSERT でも同様
await db.execute({"{"}‍
  sql: 'INSERT INTO posts (title, body, user_id) VALUES (?, ?, ?)',
  args: [title, body, userId],
{"}"});

// ✅ ESCAPE 句でエスケープする
function escapeLike(str: string): string {"{"}
  return str
    .replace(/\/g, '\\')
    .replace(/%/g, '\%')
    .replace(/_/g, '\_');
{"}"}

await db.execute({"{"}‍
  sql: "SELECT * FROM products WHERE name LIKE ? ESCAPE '\\'",
  args: [`${"$"}{"{"}escapeLike(userInput){"}"}%`],
{"}"});

// ❌ 文字列結合（危険）
// `WHERE id IN (${"$"}{"{"}ids.join(','){"}"})`

// ✅ ? プレースホルダーを動的に生成
const ids = [1, 2, 3, 4, 5];
const placeholders = ids.map(() => '?').join(', ');

const result = await db.execute({"{"}‍
  sql: `SELECT * FROM posts WHERE user_id IN (${"$"}{"{"}placeholders{"}"})`,
  args: ids,
{"}"});

const ALLOWED_SORT_COLUMNS = ['name', 'created_at', 'email'] as const;
type SortColumn = typeof ALLOWED_SORT_COLUMNS[number];

function isSortColumn(col: string): col is SortColumn {"{"}
  return (ALLOWED_SORT_COLUMNS as readonly string[]).includes(col);
{"}"}

const sortBy = url.searchParams.get('sort') ?? 'created_at';
if (!isSortColumn(sortBy)) throw new Error('不正なソート列');
await db.execute(`SELECT * FROM users ORDER BY ${"$"}{"{"}sortBy{"}"} DESC`);

// Unix epoch ms で保存・取得する（推奨パターン）
await db.execute({"{"}‍
  sql: 'INSERT INTO posts (title, created_at) VALUES (?, ?)',
  args: ['Hello', Date.now()],
{"}"});
const result = await db.execute('SELECT * FROM posts ORDER BY created_at DESC');
const posts = result.rows.map((row) => ({"{"}‍
  title:     String(row.title),
  createdAt: new Date(Number(row.created_at)),
{"}"}));

-- 複合主キーで主キー検索が支配的な場合に有効
CREATE TABLE kv_store (
  namespace TEXT NOT NULL,
  key       TEXT NOT NULL,
  value     TEXT,
  PRIMARY KEY (namespace, key)
) WITHOUT ROWID;
-- 注意: INTEGER PRIMARY KEY は WITHOUT ROWID と併用できない（rowid の別名のため）

export const db: Client = createClient({"{"}‍
  url: TURSO_DATABASE_URL,
  authToken: TURSO_AUTH_TOKEN,
{"}"});
await db.execute('PRAGMA foreign_keys = ON');

-- 通常のインデックス
CREATE INDEX idx_users_email ON users(email);

-- 複合インデックス（user_id で絞り込み + created_at でソート）
CREATE INDEX idx_posts_user_date ON posts(user_id, created_at DESC);

-- 部分インデックス（active = 1 のユーザーのみ → インデックスが小さく高速）
CREATE INDEX idx_active_users ON users(email) WHERE active = 1;

-- UNIQUE 制約付きインデックス
CREATE UNIQUE INDEX idx_users_email_unique ON users(email);

bun add drizzle-orm @libsql/client
bun add -d drizzle-kit

// drizzle.config.ts
import 'dotenv/config';
import {"{"} defineConfig {"}"} from 'drizzle-kit';

export default defineConfig({"{"}
  schema: './src/lib/server/schema.ts',
  out: './drizzle',
  dialect: 'turso',
  dbCredentials: {"{"}
    url: process.env.TURSO_DATABASE_URL!,
    authToken: process.env.TURSO_AUTH_TOKEN!,
  {"}"},
{"}"});

// src/lib/server/schema.ts
import {"{"} sqliteTable, text, integer, index {"}"} from 'drizzle-orm/sqlite-core';
import {"{"} sql {"}"} from 'drizzle-orm';
import {"{"} relations {"}"} from 'drizzle-orm';

export const users = sqliteTable('users', {"{"}
  id: text('id').primaryKey(),
  email: text('email').notNull().unique(),
  name: text('name').notNull(),
  createdAt: integer('created_at', {"{"} mode: 'timestamp_ms' {"}"})
    .notNull()
    .default(sql`(unixepoch() * 1000)`),
{"}"}, (t) => ({"{"}
  emailIdx: index('users_email_idx').on(t.email),
{"}"}));

export const posts = sqliteTable('posts', {"{"}
  id: text('id').primaryKey(),
  userId: text('user_id').notNull().references(() => users.id, {"{"} onDelete: 'cascade' {"}"}),
  title: text('title').notNull(),
  body: text('body').notNull(),
  publishedAt: integer('published_at', {"{"} mode: 'timestamp_ms' {"}"}),
{"}"});

export const usersRelations = relations(users, ({"{"} many {"}"}) => ({"{"} posts: many(posts) {"}"}));
export const postsRelations = relations(posts, ({"{"} one {"}"}) => ({"{"}
  user: one(users, {"{"} fields: [posts.userId], references: [users.id] {"}"}),
{"}"}));

export type User = typeof users.$inferSelect;
export type NewUser = typeof users.$inferInsert;

// src/lib/server/db.ts
import {"{"} drizzle {"}"} from 'drizzle-orm/libsql';
import {"{"} createClient {"}"} from '@libsql/client';
import {"{"} TURSO_DATABASE_URL, TURSO_AUTH_TOKEN {"}"} from '$env/static/private';
import * as schema from './schema';

const client = createClient({"{"} url: TURSO_DATABASE_URL, authToken: TURSO_AUTH_TOKEN {"}"});
export const db = drizzle(client, {"{"} schema {"}"});

import {"{"} db {"}"} from '$lib/server/db';
import {"{"} posts, users {"}"} from '$lib/server/schema';
import {"{"} desc, like, and, eq {"}"} from 'drizzle-orm';

const rows = await db
  .select()
  .from(posts)
  .where(and(like(posts.title, '%Turso%'), eq(posts.userId, userId)))
  .orderBy(desc(posts.publishedAt))
  .limit(20);

const [newPost] = await db
  .insert(posts)
  .values({"{"} id: crypto.randomUUID(), userId, title, body, publishedAt: new Date() {"}"})
  .returning();

await db
  .update(posts)
  .set({"{"} title: newTitle {"}"})
  .where(eq(posts.id, postId));

await db
  .delete(posts)
  .where(eq(posts.id, postId));

const rows = await db
  .select({"{"}
    postTitle: posts.title,
    authorName: users.name,
  {"}"})
  .from(posts)
  .innerJoin(users, eq(posts.userId, users.id));

// schema に relations を定義済みで drizzle(client, {"{"} schema {"}"}) とした場合のみ使える
const usersWithPosts = await db.query.users.findMany({"{"}
  with: {"{"} posts: true {"}"},
  where: (u, {"{"} eq {"}"}) => eq(u.email, 'alice@example.com'),
{"}"});

// src/routes/posts/+page.server.ts
import type {"{"} PageServerLoad {"}"} from './$types';
import {"{"} db {"}"} from '$lib/server/db';
import {"{"} posts, users {"}"} from '$lib/server/schema';
import {"{"} desc, eq {"}"} from 'drizzle-orm';

export const load: PageServerLoad = async ({"{"} url, depends, setHeaders {"}"}) => {"{"}
  depends('app:posts');
  setHeaders({"{"} 'cache-control': 'private, max-age=10' {"}"});

  const limit = Number(url.searchParams.get('limit') ?? 20);
  const rows = await db
    .select({"{"}
      id: posts.id,
      title: posts.title,
      author: users.name,
      publishedAt: posts.publishedAt,
    {"}"})
    .from(posts)
    .innerJoin(users, eq(posts.userId, users.id))
    .orderBy(desc(posts.publishedAt))
    .limit(limit);

  return {"{"} posts: rows {"}"};
{"}"};

// src/routes/posts/[id]/+page.server.ts
import {"{"} error {"}"} from '@sveltejs/kit';
import type {"{"} PageServerLoad {"}"} from './$types';
import {"{"} db {"}"} from '$lib/server/db';
import {"{"} posts {"}"} from '$lib/server/schema';
import {"{"} eq {"}"} from 'drizzle-orm';

export const load: PageServerLoad = async ({"{"} params {"}"}) => {"{"}
  const [post] = await db.select().from(posts).where(eq(posts.id, params.id));
  if (!post) throw error(404, 'Post not found');
  return {"{"} post {"}"};
{"}"};

// src/routes/posts/new/+page.server.ts
import type {"{"} Actions, PageServerLoad {"}"} from './$types';
import {"{"} fail, redirect {"}"} from '@sveltejs/kit';
import {"{"} db {"}"} from '$lib/server/db';
import {"{"} posts {"}"} from '$lib/server/schema';

export const actions: Actions = {"{"}
  create: async ({"{"} request, locals {"}"}) => {"{"}
    const data = await request.formData();
    const title = data.get('title')?.toString().trim() ?? '';
    const body = data.get('body')?.toString().trim() ?? '';

    if (title.length < 3 || title.length > 200) {"{"}
      return fail(400, {"{"} title, body, error: 'タイトルは3〜200文字' {"}"});
    {"}"}
    if (!locals.user) {"{"}
      return fail(401, {"{"} error: '未ログイン' {"}"});
    {"}"}

    const id = crypto.randomUUID();
    await db.insert(posts).values({"{"}
      id,
      userId: locals.user.id,
      title,
      body,
      publishedAt: new Date(),
    {"}"});

    throw redirect(303, `/posts/${"$"}{"{"}id{"}"}`);
  {"}"},
{"}"};

<!-- src/routes/posts/new/+page.svelte -->
<script lang="ts">
  import {"{"} enhance {"}"} from '$app/forms';
  let {"{"} form {"}"} = $props();
</script>

<form method="POST" action="?/create" use:enhance>
  <input name="title" value={"{"}form?.title ?? ''{"}"}  required />
  {"{"}#if form?.error{"}"}<p class="text-red-600">{"{"}form.error{"}"}</p>{"{"}/if{"}"}
  <textarea name="body">{"{"}form?.body ?? ''{"}"}</textarea>
  <button type="submit">投稿</button>
</form>

export const actions: Actions = {"{"}
  create: async ({"{"} request {"}"}) => {"{"} /* ... */ {"}"},
  delete: async ({"{"} request {"}"}) => {"{"}
    const data = await request.formData();
    const id = data.get('id')?.toString() ?? '';
    await db.delete(posts).where(eq(posts.id, id));
    return {"{"} success: true {"}"};
  {"}"},
  update: async ({"{"} request {"}"}) => {"{"} /* ... */ {"}"},
{"}"};

const data = await request.formData();
const file = data.get('avatar') as File;

if (file && file.size > 0) {"{"}
  const buffer = Buffer.from(await file.arrayBuffer());
  // Turso BLOB に直接保存（小サイズ限定）
  await db.update(users).set({"{"} avatar: buffer {"}"}).where(eq(users.id, userId));

  // 大サイズは R2 / S3 に委譲してURLだけ保存
  // const url = await uploadToR2(buffer, file.name);
  // await db.update(users).set({"{"} avatarUrl: url {"}"}).where(eq(users.id, userId));
{"}"}

[SvelteKit Server / Bun / Node.js]
       │
       ├── 読み取り → ローカル SQLite ファイル (local-replica.db)
       │               ↑ ネットワーク往復なし / レイテンシ 0.1ms 以下
       │
       └── 書き込み → リモート Turso プライマリ
                       ↓ 自動同期（syncInterval または手動 sync()）
                  ローカルファイルへ反映

// src/lib/server/db.ts（Embedded Replica 版）
import {"{"} createClient {"}"} from '@libsql/client';
import {"{"} TURSO_DATABASE_URL, TURSO_AUTH_TOKEN {"}"} from '$env/static/private';

export const db = createClient({"{"}
  url: 'file:local-replica.db',     // ローカルレプリカファイル
  syncUrl: TURSO_DATABASE_URL,      // 同期元リモート Turso
  authToken: TURSO_AUTH_TOKEN,
  syncInterval: 60,                  // 60秒ごとに自動同期
{"}"});

// 書き込み
await db.execute({"{"}
  sql: 'INSERT INTO posts VALUES (?, ?, ?)',
  args: [id, title, body],
{"}"});

// 書き込み直後に読む場合は手動 sync() で整合性を保証
await db.sync();

// この時点でローカルファイルに書き込んだデータが反映されている
const rows = await db.execute({"{"} sql: 'SELECT * FROM posts WHERE id = ?', args: [id] {"}"});

bun add -D @sveltejs/adapter-cloudflare

// svelte.config.js
import adapter from '@sveltejs/adapter-cloudflare';
import {"{"} vitePreprocess {"}"} from '@sveltejs/vite-plugin-svelte';

export default {"{"}
  preprocess: vitePreprocess(),
  kit: {"{"}
    adapter: adapter({"{"}
      routes: {"{"}
        include: ['/*'],
        exclude: ['<all>'],
      {"}"},
    {"}"},
  {"}"},
{"}"};

1. Settings → Environment variables を開く
2. Production / Preview それぞれに TURSO_DATABASE_URL と TURSO_AUTH_TOKEN を追加
3. 認証トークンは必ず Encrypted で登録（プレーンテキスト禁止）

// src/lib/server/db.ts（Cloudflare Pages 用）
// Cloudflare Workers / Pages では必ず /web 版を import する
import {"{"} createClient {"}"} from '@libsql/client/web';
import {"{"} TURSO_DATABASE_URL, TURSO_AUTH_TOKEN {"}"} from '$env/static/private';

export const db = createClient({"{"}
  url: TURSO_DATABASE_URL,
  authToken: TURSO_AUTH_TOKEN,
{"}"});

import {"{"} env {"}"} from '$env/dynamic/private';

export const db = createClient({"{"}
  url: env.TURSO_DATABASE_URL,
  authToken: env.TURSO_AUTH_TOKEN,
{"}"});

// src/lib/server/schema.ts
import {"{"} sqliteTable, text, integer {"}"} from 'drizzle-orm/sqlite-core';
import {"{"} sql {"}"} from 'drizzle-orm';

export const auditLog = sqliteTable('audit_log', {"{"}
  id:        text('id').primaryKey(),
  actorId:   text('actor_id').notNull(),
  action:    text('action').notNull(),       // 'user.rename', 'post.delete' 等
  targetId:  text('target_id'),
  payload:   text('payload', {"{"} mode: 'json' {"}"}),
  createdAt: integer('created_at', {"{"} mode: 'timestamp_ms' {"}"})
               .notNull()
               .default(sql`(unixepoch() * 1000)`),
{"}"});

// src/lib/server/user.ts
import {"{"} client {"}"} from './db';   // @libsql/client インスタンス

async function updateUserWithAudit(
  userId:  string,
  newName: string,
  actorId: string,
) {"{"}
  const tx = await client.transaction('write');
  try {"{"}
    await tx.execute({"{"}
      sql:  'UPDATE users SET name = ? WHERE id = ?',
      args: [newName, userId],
    {"}"});
    await tx.execute({"{"}
      sql: `INSERT INTO audit_log
              (id, actor_id, action, target_id, payload, created_at)
            VALUES (?, ?, ?, ?, ?, ?)`,
      args: [
        crypto.randomUUID(),
        actorId,
        'user.rename',
        userId,
        JSON.stringify({"{"} newName {"}"}),
        Date.now(),
      ],
    {"}"});
    await tx.commit();
  {"}"} catch (e) {"{"}
    await tx.rollback();
    throw e;
  {"}"}
{"}"}

// posts テーブルに version 列を追加
version: integer('version').notNull().default(0),

import {"{"} db {"}"} from '$lib/server/db';
import {"{"} sql {"}"} from 'drizzle-orm';

async function updatePostTitle(
  id:              string,
  newTitle:        string,
  expectedVersion: number,
) {"{"}
  const result = await db.run(
    sql`UPDATE posts
        SET    title   = ${"$"}{"{"}newTitle{"}"},
               version = version + 1
        WHERE  id      = ${"$"}{"{"}id{"}"}
        AND    version = ${"$"}{"{"}expectedVersion{"}"}`
  );
  if (result.rowsAffected === 0) {"{"}
    throw new Error(
      '競合検出: 他のユーザーが更新しました。最新を取得してリトライしてください。'
    );
  {"}"}
{"}"}

// src/routes/api/posts/+server.ts
import {"{"} db {"}"} from '$lib/server/db';
import {"{"} posts {"}"} from '$lib/server/schema';
import {"{"} gt, asc {"}"} from 'drizzle-orm';

export async function GET({"{"} url {"}"}: {"{"} url: URL {"}"}) {"{"}
  const cursor = url.searchParams.get('cursor');  // 最後に取得した id

  const rows = await db
    .select()
    .from(posts)
    .where(cursor ? gt(posts.id, cursor) : undefined)
    .orderBy(asc(posts.id))
    .limit(21);   // 1件多く取って次ページ有無判定

  const hasNext    = rows.length > 20;
  const items      = hasNext ? rows.slice(0, 20) : rows;
  const nextCursor = hasNext ? items[items.length - 1].id : null;

  return Response.json({"{"} items, nextCursor {"}"});
{"}"}

// src/lib/server/bulk.ts
import {"{"} client {"}"} from './db';   // @libsql/client インスタンス

interface Row {"{"}
  id:   string;
  name: string;
{"}"}

async function bulkInsert(rows: Row[]) {"{"}
  const CHUNK = 100;   // SQLite のバインド変数上限（999）を考慮
  for (let i = 0; i < rows.length; i += CHUNK) {"{"}
    const slice        = rows.slice(i, i + CHUNK);
    const placeholders = slice.map(() => '(?, ?)').join(', ');
    const args         = slice.flatMap((r) => [r.id, r.name]);
    await client.execute({"{"}
      sql:  `INSERT INTO users (id, name) VALUES ${"$"}{"{"}placeholders{"}"}`,
      args,
    {"}"});
  {"}"}
{"}"}