persona-core-workflow-a

# Persona Core Workflow A — KYC Inquiry Flow

## Overview
Build a complete KYC onboarding flow: create an inquiry from a template, embed the Persona verification UI in your web app, handle completion callbacks, and store verification results.

## Prerequisites
- Completed `persona-install-auth` setup
- Inquiry Template configured in Persona Dashboard
- Web application with a frontend (React, HTML, etc.)

## Instructions

### Step 1: Backend — Create Inquiry Endpoint
```typescript
// server.ts — Express endpoint to create inquiries
import express from 'express';
import axios from 'axios';

const app = express();
app.use(express.json());

const persona = axios.create({
  baseURL: 'https://withpersona.com/api/v1',
  headers: {
    'Authorization': `Bearer ${process.env.PERSONA_API_KEY}`,
    'Persona-Version': '2023-01-05',
  },
});

app.post('/api/verify', async (req, res) => {
  const { userId, email } = req.body;

  const { data } = await persona.post('/inquiries', {
    data: {
      attributes: {
        'inquiry-template-id': process.env.PERSONA_TEMPLATE_ID,
        'reference-id': userId,
        'fields': {
          'email-address': { type: 'string', value: email },
        },
      },
    },
  });

  res.json({
    inquiryId: data.data.id,
    sessionToken: data.data.attributes['session-token'],
  });
});
```

### Step 2: Frontend — Embed Persona Flow
```html
<!-- Include Persona's JavaScript SDK -->
<script src="https://cdn.withpersona.com/dist/persona-v5.0.0.js"></script>

<button id="verify-btn">Verify Identity</button>

<script>
document.getElementById('verify-btn').addEventListener('click', async () => {
  // Get inquiry from your backend
  const resp = await fetch('/api/verify', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ userId: 'user-123', email: 'alice@example.com' }),
  });
  const { inquiryId, sessionToken } = await resp.json();

  // Launch Persona embedded flow
  const client = new Persona.Client({
    inquiryId,
    sessionToken,
    onComplete: ({ inquiryId, status }) => {
      console.log(`Verification ${status} for inquiry ${inquiryId}`);
      // Notify your backend
      fetch(`/api/verify/${inquiryId}/complete`, { method: 'POST' });
    },
    onCancel: ({ inquiryId }) => {
      console.log('User cancelled verification');
    },
    onError: (error) => {
      console.error('Persona error:', error);
    },
  });

  client.open();
});
</script>
```

### Step 3: Backend — Handle Completion
```typescript
app.post('/api/verify/:inquiryId/complete', async (req, res) => {
  const { inquiryId } = req.params;

  // Fetch the completed inquiry from Persona
  const { data } = await persona.get(`/inquiries/${inquiryId}`);
  const attrs = data.data.attributes;

  const result = {
    inquiryId,
    status: attrs.status,                    // completed, approved, declined
    referenceId: attrs['reference-id'],      // your user ID
    createdAt: attrs['created-at'],
    completedAt: attrs['completed-at'],
  };

  // Store in your database
  await db.users.update(result.referenceId, {
    kycStatus: result.status,
    kycInquiryId: result.inquiryId,
    kycCompletedAt: result.completedAt,
  });

  res.json({ status: result.status });
});
```

### Step 4: Resume Incomplete Inquiries
```typescript
app.get('/api/verify/resume/:userId', async (req, res) => {
  // Find existing incomplete inquiry for this user
  const { data } = await persona.get('/inquiries', {
    params: {
      'filter[reference-id]': req.params.userId,
      'filter[status]': 'created',
      'page[size]': 1,
    },
  });

  if (data.data.length > 0) {
    const inquiry = data.data[0];
    // Resume the existing inquiry instead of creating a new one
    const resumeResp = await persona.post(`/inquiries/${inquiry.id}/resume`);
    res.json({
      inquiryId: inquiry.id,
      sessionToken: resumeResp.data.data.attributes['session-token'],
    });
  } else {
    res.json({ message: 'No pending inquiry' });
  }
});
```

## Output
- Backend endpoint creating inquiries from templates
- Embedded Persona verification UI in web app
- Completion callback storing verification results
- Resume flow for incomplete verifications

## Error Handling
| Error | Cause | Solution |
|-------|-------|----------|
| `422 Invalid template` | Wrong template ID | Verify `itmpl_*` in Dashboard |
| SDK not loading | CSP blocking CDN | Add `cdn.withpersona.com` to CSP |
| `onComplete` not firing | User abandoned flow | Use `onCancel` handler |
| Stale session token | Token expired | Create new inquiry or resume |

## Resources
- [Inquiries Overview](https://docs.withpersona.com/inquiries)
- [Embedded Flow Integration](https://docs.withpersona.com/api-quickstart-tutorial)
- [Resume Inquiry](https://docs.withpersona.com/accessing-inquiry-status)

## Next Steps
- Add verification checks: `persona-core-workflow-b`
- Set up webhooks: `persona-webhooks-events`