Node SDK

import { TempsClient } from '@temps-sdk/node-sdk';

const temps = new TempsClient({
  baseUrl: 'https://your-temps-instance.com/api',
  apiKey: 'your-api-key',
});

// List projects
const { data: projects } = await temps.projects.list();

// Trigger a deployment of the main branch
await temps.projects.triggerPipeline({
  path: { id: 1 },
  body: { branch: 'main' },
});

// Rollback
await temps.deployments.rollback({
  path: { project_id: 1, deployment_id: 5 },
});

const client = temps.rawClient;

import type {
  ProjectResponse,
  DeploymentResponse,
  CreateProjectRequest,
} from '@temps-sdk/node-sdk';

import { ErrorTracking } from '@temps-sdk/node-sdk';

ErrorTracking.init({
  dsn: 'https://public-key@your-instance.temps.dev/1',
  environment: 'production',
  release: '1.0.0',
});

// Capture an exception
try {
  riskyOperation();
} catch (error) {
  const eventId = ErrorTracking.captureException(error);
}

// Capture with extra context
ErrorTracking.captureException(error, {
  tags: { subsystem: 'payments' },
  extra: { orderId: '12345', amount: 99.99 },
  level: 'fatal',
});

// Capture a message
ErrorTracking.captureMessage('Disk usage above 90%', 'warning');

// Capture a raw event
ErrorTracking.captureEvent({
  message: 'Custom event',
  level: 'info',
  tags: { source: 'cron' },
});

// Set the current user (attached to all subsequent events)
ErrorTracking.setUser({
  id: '123',
  email: 'alice@example.com',
  username: 'alice',
  ip_address: '{{auto}}',
});

// Set global tags
ErrorTracking.setTag('region', 'eu-west-1');
ErrorTracking.setTags({ service: 'api', version: '2.0' });

// Set extra data
ErrorTracking.setExtra('requestId', 'abc-123');
ErrorTracking.setExtras({ query: 'SELECT ...', duration: 150 });

// Set structured context
ErrorTracking.setContext('order', {
  id: 'order-456',
  total: 99.99,
  items: 3,
});

// Clear user on logout
ErrorTracking.setUser(null);

// Permanent scope modification
ErrorTracking.configureScope((scope) => {
  scope.setTag('transaction', 'checkout');
  scope.setUser({ id: '123' });
});

// Temporary scope (discarded after callback)
ErrorTracking.withScope((scope) => {
  scope.setTag('component', 'payment-form');
  ErrorTracking.captureMessage('Payment processed');
});

ErrorTracking.addBreadcrumb({
  category: 'auth',
  message: 'User logged in',
  level: 'info',
  data: { method: 'oauth' },
});

ErrorTracking.addBreadcrumb({
  category: 'http',
  message: 'GET /api/users',
  level: 'info',
  type: 'http',
  data: { status: 200, duration: 45 },
});

// Clear all breadcrumbs
ErrorTracking.clearBreadcrumbs();

const transaction = ErrorTracking.startTransaction({
  name: 'POST /api/checkout',
  op: 'http.server',
});

const dbSpan = transaction.startChild({
  op: 'db.query',
  description: 'SELECT * FROM orders WHERE id = ?',
});
// ... query ...
dbSpan.finish();

transaction.setMeasurement('order_total', 99.99, 'usd');
transaction.setStatus('ok');
transaction.finish();

const eventId = ErrorTracking.captureException(error);

ErrorTracking.captureUserFeedback({
  event_id: eventId,
  name: 'Alice',
  email: 'alice@example.com',
  comments: 'The checkout button did nothing.',
});

// Flush pending events (waits up to 2s by default)
await ErrorTracking.flush(2000);

// Close the client (disables further capturing + flushes)
await ErrorTracking.close(2000);

// After the user signs in
useEffect(() => {
  if (user) fetch('/api/enrich-visitor', { method: 'POST' });
}, [user]);

import { TempsClient } from '@temps-sdk/node-sdk';

const client = new TempsClient({
  baseUrl: process.env.TEMPS_API_URL,
  apiKey: process.env.TEMPS_API_KEY,
});

await client.analytics.enrichVisitor({
  path: { visitor_id: visitorId },
  query: { project_id: Number(process.env.TEMPS_PROJECT_ID) },
  body: {
    custom_data: {
      userId: user.id,
      email: user.email,
      subscriptionTier: user.subscription?.tier ?? 'free',
      signupDate: user.createdAt.toISOString(),
    },
  },
});
// Returns: { success: true, visitor_id: string, message: string }

// app/api/enrich-visitor/route.ts
import { cookies } from 'next/headers';
import { TempsClient } from '@temps-sdk/node-sdk';

// On Temps, TEMPS_API_URL and TEMPS_API_TOKEN (a deployment token) are injected.
// A deployment token may only enrich visitors of its own project, using the
// sealed cookie value, which is exactly what this route sends.
const client = new TempsClient({
  baseUrl: process.env.TEMPS_API_URL!,
  apiKey: process.env.TEMPS_API_TOKEN!,
});

export async function POST() {
  const visitorId = (await cookies()).get('_temps_visitor_id')?.value;
  const user = await getCurrentUser(); // your own auth/session lookup
  if (!visitorId || !user) return Response.json({ success: false }, { status: 400 });

  await client.analytics.enrichVisitor({
    path: { visitor_id: visitorId },
    query: { project_id: Number(process.env.TEMPS_PROJECT_ID) },
    body: {
      custom_data: {
        userId: user.id,
        email: user.email,
        subscriptionTier: user.subscription?.tier ?? 'free',
      },
    },
  });

  return Response.json({ success: true });
}

// By GUID
const { data: byGuid } = await client.analytics.getVisitorByGuid({
  path: { visitor_id: '550e8400-e29b-41d4-a716-446655440000' },
  query: { project_id: 1 },
});

// By numeric ID
const { data: byId } = await client.analytics.getVisitorById({
  path: { id: 123 },
  query: { project_id: 1 },
});

console.log(byId?.custom_data);
// { userId: '123', email: 'user@example.com', subscriptionTier: 'pro' }

import { flags } from '@temps-sdk/node-sdk';

await flags.init();

if (flags.get('checkout.v2', { key: user.id }, false)) {
  // ...
}