The shared layer
behind the portfolio.

// Backend (Lambda / Hono / Express) — Cognito-first
import { createCognitoVerifier } from '@tjoc/auth/cognito';

const verify = createCognitoVerifier({
  region:     process.env.AWS_REGION!,
  userPoolId: process.env.COGNITO_USER_POOL_ID!,
  clientId:   process.env.COGNITO_CLIENT_ID!,
  tokenUse:   'access',
});

// Pass the bearer token, get a typed Principal back
const principal = await verify(req.headers.authorization);
// principal.sub, principal.email, principal.role, ...

// Browser — sign in / refresh / sign out
import { createCognitoClient } from '@tjoc/auth/browser';

const auth = createCognitoClient({
  userPoolId: import.meta.env.VITE_COGNITO_USER_POOL_ID,
  clientId:   import.meta.env.VITE_COGNITO_CLIENT_ID,
});

const { accessToken, refreshToken } = await auth.signIn({
  email: 'jane@acme.co',
  password: '...',
});

import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { DynamoDbAuditSink } from '@tjoc/audit/dynamodb';
import type { AuditEvent } from '@tjoc/audit';

const sink = new DynamoDbAuditSink({
  client: new DynamoDBClient({}),
  tableName: process.env.AUDIT_EVENTS_TABLE!,
});

// Emit anywhere a state change happens
export async function audit(event: AuditEvent): Promise<void> {
  await sink.emit(event).catch((err) => {
    // sinks never throw upstream — just log
    console.error('audit emit failed', err);
  });
}

// Usage at a handler
await audit({
  actorId:      session.userId,
  actorType:    session.role,
  action:       'job.published',
  resourceType: 'job',
  resourceId:   jobId,
  metadata:     { title, tier: profile.pricingTier },
});

import {
  createEmailSender,
  renderTemplate,
  userActionTemplates,
} from '@tjoc/notifications';

const sender = createEmailSender({
  apiKey: process.env.RESEND_API_KEY!,
  from: 'noreply@tjoc.dev',
  eventSink: {
    async log(event) {
      // event.status: 'success' | 'failure' | 'suppressed'
      await logEmailEvent(event);
    },
  },
});

// Render a pre-built welcome template
const rendered = renderTemplate(userActionTemplates.welcome, {
  name: 'Jane',
  productName: 'TJOC Jobs',
  loginUrl: 'https://jobs.tjoc.dev/login',
});

await sender.send({
  to: 'jane@acme.co',
  subject: rendered.subject,
  html: rendered.html,
  listUnsubscribeUrl: `https://api.jobs.tjoc.dev/unsubscribe?token=...`,
  // Caller-owned suppression check
  suppressionCheck: async (email) => isSuppressed(email),
});

import { AnalyticsService } from '@tjoc/analytics';

const analytics = new AnalyticsService({
  apiKey:  process.env.POSTHOG_API_KEY!,
  apiHost: 'https://eu.i.posthog.com',
});

// Capture an event keyed on a distinct ID
await analytics.trackEvent('lead_submitted', {
  userId: leadId,
  expectedHiresIn90Days: '2-5',
  hiringTimeline: 'next_quarter',
});

// Identify on conversion to seed person properties
await analytics.identify(clientUserId, {
  email:       'jane@acme.co',
  companyName: 'Acme Co.',
  fromLeadId:  leadId,
});

// v2.2.0: collapse the lead's anonymous distinct ID
// onto the new client's authenticated distinct ID
await analytics.alias(leadId, clientUserId);

// Feature flags + experiments
const enabled = await analytics.isFeatureEnabled('new-onboarding', clientUserId);
const variant = await analytics.getExperimentVariant('cta-copy', clientUserId);

import {
  AnthropicService,
  FallbackAIService,
  OpenAIService,
  formatPrompt,
  sanitizePrompt,
} from '@tjoc/ai-core';

// Primary: Claude — Fallback: GPT
const ai = new FallbackAIService(
  new AnthropicService({ apiKey: process.env.ANTHROPIC_API_KEY! }),
  new OpenAIService({ apiKey: process.env.OPENAI_API_KEY! }),
);

const TAILOR_TEMPLATE = `Tailor this CV for the role.
Role: {{role}}
CV: {{cv}}`;

const prompt = formatPrompt(TAILOR_TEMPLATE, {
  role: jobDescription,
  cv:   sanitizePrompt(cvText),
});

// Single completion — JSON schema lock done in the system message
const { text } = await ai.complete(prompt, {
  model:       'claude-haiku-4',
  system:      'Output JSON only.',
  maxTokens:   2048,
  temperature: 0.2,
});

// Or stream tokens as they arrive
for await (const chunk of ai.stream(prompt)) {
  process.stdout.write(chunk);
}