SvelteKit is the full-stack framework for Svelte — with file-based routing, server load functions, and form actions. UUID v7 as database primary keys integrates cleanly: generate IDs server-side, store them with Drizzle ORM, and use them for cursor pagination. See UUID in Svelte and SvelteKit for the broader Svelte context.

Setup

npm install uuid
npm install drizzle-orm drizzle-kit @libsql/client

Type-safe locals with trace IDs

// src/app.d.ts
declare global {
  namespace App {
    interface Locals {
      traceId: string;
    }
  }
}
export {};
// src/hooks.server.ts
import { v7 as uuidv7 } from 'uuid';
import type { Handle } from '@sveltejs/kit';

export const handle: Handle = async ({ event, resolve }) => {
  // Attach UUID v7 trace ID to every server request
  event.locals.traceId = uuidv7();

  const response = await resolve(event);
  response.headers.set('X-Trace-ID', event.locals.traceId);
  return response;
};

Drizzle schema with UUID v7

// src/lib/server/schema.ts
import { sqliteTable, text, real } from 'drizzle-orm/sqlite-core';
import { v7 as uuidv7 } from 'uuid';

export const orders = sqliteTable('orders', {
  id:         text('id').primaryKey().$defaultFn(() => uuidv7()),
  customerId: text('customer_id').notNull(),
  total:      real('total').notNull(),
  status:     text('status').default('pending').notNull(),
});
// src/lib/server/db.ts
import { drizzle } from 'drizzle-orm/libsql';
import { createClient } from '@libsql/client';
import * as schema from './schema';

const client = createClient({
  url: process.env.DATABASE_URL ?? 'file:local.db',
});

export const db = drizzle(client, { schema });

Server load function with cursor pagination

// src/routes/orders/+page.server.ts
import type { PageServerLoad } from './$types';
import { db } from '$lib/server/db';
import { orders } from '$lib/server/schema';
import { gt } from 'drizzle-orm';

export const load: PageServerLoad = async ({ url, locals }) => {
  const cursor = url.searchParams.get('cursor') ?? undefined;
  const limit = 20;

  const rows = await db
    .select()
    .from(orders)
    .where(cursor ? gt(orders.id, cursor) : undefined)
    .orderBy(orders.id)
    .limit(limit);

  const nextCursor = rows.length === limit ? rows[rows.length - 1].id : null;

  return {
    orders: rows,
    nextCursor,
    traceId: locals.traceId,
  };
};

UUID v7 lexicographic ORDER BY id equals chronological order. No created_at index needed. See UUID v7 for Cursor Pagination.

Form action: create an order

// src/routes/orders/+page.server.ts (continued)
import { fail, redirect } from '@sveltejs/kit';
import { validate } from 'uuid';
import type { Actions } from './$types';

export const actions: Actions = {
  create: async ({ request, locals }) => {
    const data = await request.formData();
    const customerId = data.get('customerId') as string;
    const total = Number(data.get('total'));

    if (!customerId || isNaN(total)) {
      return fail(400, { error: 'customerId and total are required' });
    }

    const [order] = await db
      .insert(orders)
      .values({ customerId, total })
      .returning();

    // order.id is UUID v7, generated by $defaultFn
    console.log(`[${locals.traceId}] Created order ${order.id}`);
    throw redirect(303, `/orders/${order.id}`);
  },
};

Dynamic route: order detail page

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

export const load: PageServerLoad = async ({ params }) => {
  if (!validate(params.id)) {
    throw error(400, 'Invalid UUID');
  }

  const [order] = await db
    .select()
    .from(orders)
    .where(eq(orders.id, params.id));

  if (!order) {
    throw error(404, 'Order not found');
  }

  return { order };
};

Svelte component: paginated order list

<!-- src/routes/orders/+page.svelte -->
<script lang="ts">
  import type { PageData } from './$types';

  export let data: PageData;
</script>

<ul>
  {#each data.orders as order (order.id)}
    <li>
      <a href="/orders/{order.id}">{order.id}</a>
      — ${order.total} ({order.status})
    </li>
  {/each}
</ul>

{#if data.nextCursor}
  <a href="?cursor={data.nextCursor}">Next page →</a>
{/if}

<small>Trace ID: {data.traceId}</small>

Timestamp extraction from UUID v7

// Extract creation time from a UUID v7 order ID (server-side only)
function extractOrderTime(orderId: string): Date {
  const hex = orderId.replace(/-/g, '').slice(0, 12);
  const ms = parseInt(hex, 16);
  return new Date(ms);
}

See UUID Bit Fields for the 48-bit timestamp layout.

Further reading

External references

Frequently asked questions

How do I generate UUID v7 in SvelteKit?

Install the uuid npm package and import v7 as uuidv7 from it. Generate UUIDs only in server-side code — +page.server.ts load functions, form actions, and hooks.server.ts. Never generate UUID v7 in +page.ts (universal load) or Svelte components, as client-side generation can cause hydration mismatches. See UUID in Svelte and SvelteKit.

How do I add UUID v7 trace IDs to every SvelteKit request?

Use hooks.server.ts to intercept every request: generate a UUID v7, attach it to event.locals.traceId, and set it on the response header. The locals object is typed via app.d.ts. Each load function and form action can then read locals.traceId. See UUID v7 in Microservices.

Can I use UUID v7 as a SvelteKit page parameter?

Yes. Define a route like src/routes/orders/[id]/+page.server.ts and validate the params.id value with the uuid package's validate() function before querying the database. This prevents invalid IDs from reaching the database layer.