Example Flows

import express, { Request, Response } from "express";
import axios from "axios";

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

const CMS_API_KEY = process.env.CMS_API_KEY;
const REDACTO_BASE_URL = process.env.REDACTO_BASE_URL || "https://api.redacto.io";
const ORG_UUID = process.env.ORG_UUID;
const WORKSPACE_UUID = process.env.WORKSPACE_UUID;

// Step 1: Generate token for temporary ID (before consent)
app.post("/api/consent/temp-token", async (req: Request, res: Response) => {
  const { temp_id } = req.body;

  if (!temp_id) {
    res.status(400).json({ error: "temp_id is required" });
    return;
  }

  try {
    const response = await axios.post(
      `${REDACTO_BASE_URL}/consent/public/organisations/${ORG_UUID}/workspaces/${WORKSPACE_UUID}/tokens/generate`,
      { org_user_id: temp_id },
      {
        headers: {
          "X-CMS-API-Key": CMS_API_KEY,
          "Content-Type": "application/json",
        },
      }
    );

    res.json({
      token: response.data.detail.token,
      refresh_token: response.data.detail.refresh_token,
    });
  } catch (error) {
    console.error("Error generating token:", error);
    res.status(500).json({ error: "Failed to generate token" });
  }
});

// Step 2: Complete registration after consent is given
app.post("/api/register", async (req: Request, res: Response) => {
  const { email, password, name, temp_id } = req.body;

  try {
    // 1. Create user in your system
    const user = await createUser({ email, password, name });

    // 2. Create primary consent user in Redacto
    await axios.post(
      `${REDACTO_BASE_URL}/consent/organisations/${ORG_UUID}/workspaces/${WORKSPACE_UUID}/consent-ledger/consent-users/`,
      {
        org_user_id: user.id,
        primary_email: email,
        name: name,
      },
      {
        headers: {
          "X-CMS-API-Key": CMS_API_KEY,
          "Content-Type": "application/json",
        },
      }
    );

    // 3. Link temp consent user to the primary user
    if (temp_id) {
      await axios.post(
        `${REDACTO_BASE_URL}/consent/organisations/${ORG_UUID}/workspaces/${WORKSPACE_UUID}/consent-ledger/consent-users/link-users`,
        {
          primary_org_user_id: user.id,
          alias_org_user_ids: [temp_id],
        },
        {
          headers: {
            "X-CMS-API-Key": CMS_API_KEY,
            "Content-Type": "application/json",
          },
        }
      );
    }

    // 4. Generate new tokens for the registered user
    const tokenResponse = await axios.post(
      `${REDACTO_BASE_URL}/consent/public/organisations/${ORG_UUID}/workspaces/${WORKSPACE_UUID}/tokens/generate`,
      { org_user_id: user.id, email: email },
      {
        headers: {
          "X-CMS-API-Key": CMS_API_KEY,
          "Content-Type": "application/json",
        },
      }
    );

    res.json({
      user: { id: user.id, email, name },
      token: tokenResponse.data.detail.token,
      refresh_token: tokenResponse.data.detail.refresh_token,
    });
  } catch (error) {
    console.error("Registration error:", error);
    res.status(500).json({ error: "Registration failed" });
  }
});

// Helper function (implement based on your auth system)
async function createUser(data: { email: string; password: string; name: string }) {
  // Your user creation logic here
  return { id: `user_${Date.now()}`, ...data };
}

app.listen(3000, () => console.log("Server running on port 3000"));

import { RedactoNoticeConsent } from "@redacto.io/consent-sdk-react";
import { useState, useEffect } from "react";
import { v4 as uuidv4 } from "uuid";

const NOTICE_UUID = process.env.NEXT_PUBLIC_NOTICE_UUID;
const REDACTO_BASE_URL = process.env.NEXT_PUBLIC_REDACTO_BASE_URL;

interface FormData {
  email: string;
  password: string;
  name: string;
}

interface Tokens {
  token: string;
  refresh_token: string;
}

function SignUpPage() {
  const [tempId, setTempId] = useState<string>("");
  const [tokens, setTokens] = useState<Tokens | null>(null);
  const [showConsent, setShowConsent] = useState(false);
  const [formData, setFormData] = useState<FormData>({ email: "", password: "", name: "" });
  const [consentGiven, setConsentGiven] = useState(false);

  useEffect(() => {
    // Generate temporary ID on mount
    const id = `temp_${uuidv4()}`;
    setTempId(id);
    fetchTempToken(id);
  }, []);

  const fetchTempToken = async (id: string) => {
    const response = await fetch("/api/consent/temp-token", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ temp_id: id }),
    });
    const data = await response.json();
    setTokens(data);
    setShowConsent(true);
  };

  const handleConsentAccept = () => {
    setConsentGiven(true);
    setShowConsent(false);
  };

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();

    const response = await fetch("/api/register", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ ...formData, temp_id: tempId }),
    });

    if (response.ok) {
      // Registration complete, redirect to dashboard
      window.location.href = "/dashboard";
    }
  };

  return (
    <div>
      {/* Step 1: Show consent modal first */}
      {showConsent && tokens && (
        <RedactoNoticeConsent
          noticeId={NOTICE_UUID!}
          accessToken={tokens.token}
          refreshToken={tokens.refresh_token}
          baseUrl={REDACTO_BASE_URL}
          onAccept={handleConsentAccept}
          onDecline={() => {
            // User declined - cannot proceed with registration
            window.location.href = "/consent-required";
          }}
          onError={(error) => console.error("Consent error:", error)}
        />
      )}

      {/* Step 2: Show registration form after consent */}
      {consentGiven && (
        <form onSubmit={handleSubmit}>
          <h1>Complete Your Registration</h1>
          <input
            type="email"
            placeholder="Email"
            value={formData.email}
            onChange={(e) => setFormData({ ...formData, email: e.target.value })}
            required
          />
          <input
            type="password"
            placeholder="Password"
            value={formData.password}
            onChange={(e) => setFormData({ ...formData, password: e.target.value })}
            required
          />
          <input
            type="text"
            placeholder="Full Name"
            value={formData.name}
            onChange={(e) => setFormData({ ...formData, name: e.target.value })}
            required
          />
          <button type="submit">Create Account</button>
        </form>
      )}
    </div>
  );
}

export default SignUpPage;

import express, { Request, Response } from "express";
import axios from "axios";

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

const CMS_API_KEY = process.env.CMS_API_KEY;
const REDACTO_BASE_URL = process.env.REDACTO_BASE_URL || "https://api.redacto.io";
const ORG_UUID = process.env.ORG_UUID;
const WORKSPACE_UUID = process.env.WORKSPACE_UUID;

app.post("/api/login", async (req: Request, res: Response) => {
  const { email, password } = req.body;

  try {
    // 1. Authenticate user in your system
    const user = await authenticateUser(email, password);
    if (!user) {
      res.status(401).json({ error: "Invalid credentials" });
      return;
    }

    // 2. Generate tokens for the user
    const tokenResponse = await axios.post(
      `${REDACTO_BASE_URL}/consent/public/organisations/${ORG_UUID}/workspaces/${WORKSPACE_UUID}/tokens/generate`,
      { org_user_id: user.id },
      {
        headers: {
          "X-CMS-API-Key": CMS_API_KEY,
          "Content-Type": "application/json",
        },
      }
    );

    res.json({
      user: { id: user.id, email: user.email, name: user.name },
      token: tokenResponse.data.detail.token,
      refresh_token: tokenResponse.data.detail.refresh_token,
    });
  } catch (error) {
    console.error("Login error:", error);
    res.status(500).json({ error: "Login failed" });
  }
});

// Helper function (implement based on your auth system)
async function authenticateUser(email: string, password: string) {
  // Your authentication logic here
  // Returns user object or null if invalid
  return { id: "user_123", email, name: "John Doe" };
}

app.listen(3000, () => console.log("Server running on port 3000"));

import { RedactoNoticeConsent } from "@redacto.io/consent-sdk-react";
import { useState } from "react";

const NOTICE_UUID = process.env.NEXT_PUBLIC_NOTICE_UUID;
const REDACTO_BASE_URL = process.env.NEXT_PUBLIC_REDACTO_BASE_URL;

interface Tokens {
  token: string;
  refresh_token: string;
}

interface User {
  id: string;
  email: string;
  name: string;
}

function LoginPage() {
  const [tokens, setTokens] = useState<Tokens | null>(null);
  const [user, setUser] = useState<User | null>(null);
  const [showConsent, setShowConsent] = useState(false);

  const handleLogin = async (e: React.FormEvent<HTMLFormElement>) => {
    e.preventDefault();
    const formData = new FormData(e.currentTarget);

    const response = await fetch("/api/login", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        email: formData.get("email"),
        password: formData.get("password"),
      }),
    });

    if (!response.ok) {
      alert("Login failed");
      return;
    }

    const data = await response.json();
    setUser(data.user);
    setTokens({ token: data.token, refresh_token: data.refresh_token });
    setShowConsent(true);
  };

  const handleConsentComplete = () => {
    // Consent accepted or already valid
    setShowConsent(false);
    window.location.href = "/dashboard";
  };

  return (
    <div>
      <form onSubmit={handleLogin}>
        <h1>Log In</h1>
        <input name="email" type="email" placeholder="Email" required />
        <input name="password" type="password" placeholder="Password" required />
        <button type="submit">Log In</button>
      </form>

      {/* SDK checks consent status and shows modal only if needed */}
      {showConsent && tokens && (
        <RedactoNoticeConsent
          noticeId={NOTICE_UUID!}
          accessToken={tokens.token}
          refreshToken={tokens.refresh_token}
          baseUrl={REDACTO_BASE_URL}
          validateAgainst="required"
          onAccept={handleConsentComplete}
          onDecline={() => {
            // User declined - handle accordingly
            window.location.href = "/consent-required";
          }}
          onError={(error) => {
            // If error is because consent already exists, proceed
            console.error("Consent error:", error);
            handleConsentComplete();
          }}
        />
      )}
    </div>
  );
}

export default LoginPage;

import express, { Request, Response } from "express";
import axios from "axios";

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

const CMS_API_KEY = process.env.CMS_API_KEY;
const REDACTO_BASE_URL = process.env.REDACTO_BASE_URL || "https://api.redacto.io";
const ORG_UUID = process.env.ORG_UUID;
const WORKSPACE_UUID = process.env.WORKSPACE_UUID;

// Generate token for anonymous user
app.post("/api/consent/anonymous-token", async (req: Request, res: Response) => {
  const { anonymous_id } = req.body;

  if (!anonymous_id) {
    res.status(400).json({ error: "anonymous_id is required" });
    return;
  }

  try {
    const response = await axios.post(
      `${REDACTO_BASE_URL}/consent/public/organisations/${ORG_UUID}/workspaces/${WORKSPACE_UUID}/tokens/generate`,
      { org_user_id: anonymous_id },
      {
        headers: {
          "X-CMS-API-Key": CMS_API_KEY,
          "Content-Type": "application/json",
        },
      }
    );

    res.json({
      token: response.data.detail.token,
      refresh_token: response.data.detail.refresh_token,
    });
  } catch (error) {
    console.error("Error generating token:", error);
    res.status(500).json({ error: "Failed to generate token" });
  }
});

// Register user and link anonymous consent
app.post("/api/register-with-anonymous", async (req: Request, res: Response) => {
  const { email, password, name, anonymous_id } = req.body;

  try {
    // 1. Create user in your system
    const user = await createUser({ email, password, name });

    // 2. Create consent user in Redacto
    await axios.post(
      `${REDACTO_BASE_URL}/consent/organisations/${ORG_UUID}/workspaces/${WORKSPACE_UUID}/consent-ledger/consent-users/`,
      {
        org_user_id: user.id,
        primary_email: email,
        name: name,
      },
      {
        headers: {
          "X-CMS-API-Key": CMS_API_KEY,
          "Content-Type": "application/json",
        },
      }
    );

    // 3. Link anonymous user to the new user
    if (anonymous_id) {
      await axios.post(
        `${REDACTO_BASE_URL}/consent/organisations/${ORG_UUID}/workspaces/${WORKSPACE_UUID}/consent-ledger/consent-users/link-users`,
        {
          primary_org_user_id: user.id,
          alias_org_user_ids: [anonymous_id],
        },
        {
          headers: {
            "X-CMS-API-Key": CMS_API_KEY,
            "Content-Type": "application/json",
          },
        }
      );
    }

    // 4. Generate new tokens for the registered user
    const tokenResponse = await axios.post(
      `${REDACTO_BASE_URL}/consent/public/organisations/${ORG_UUID}/workspaces/${WORKSPACE_UUID}/tokens/generate`,
      { org_user_id: user.id, email: email },
      {
        headers: {
          "X-CMS-API-Key": CMS_API_KEY,
          "Content-Type": "application/json",
        },
      }
    );

    res.json({
      user: { id: user.id, email, name },
      token: tokenResponse.data.detail.token,
      refresh_token: tokenResponse.data.detail.refresh_token,
    });
  } catch (error) {
    console.error("Registration error:", error);
    res.status(500).json({ error: "Registration failed" });
  }
});

// Helper function
async function createUser(data: { email: string; password: string; name: string }) {
  return { id: `user_${Date.now()}`, ...data };
}

app.listen(3000, () => console.log("Server running on port 3000"));

import { RedactoNoticeConsentInline } from "@redacto.io/consent-sdk-react";
import { useState, useEffect } from "react";
import { v4 as uuidv4 } from "uuid";

const ORG_UUID = process.env.NEXT_PUBLIC_ORG_UUID;
const WORKSPACE_UUID = process.env.NEXT_PUBLIC_WORKSPACE_UUID;
const NOTICE_UUID = process.env.NEXT_PUBLIC_NOTICE_UUID;
const REDACTO_BASE_URL = process.env.NEXT_PUBLIC_REDACTO_BASE_URL;

interface Tokens {
  accessToken: string | undefined;
  refreshToken: string | undefined;
}

function LandingPage() {
  const [anonymousId, setAnonymousId] = useState("");
  const [tokens, setTokens] = useState<Tokens>({ accessToken: undefined, refreshToken: undefined });
  const [consentGiven, setConsentGiven] = useState(false);

  useEffect(() => {
    // Generate or retrieve anonymous ID
    let anonId = localStorage.getItem("anon_consent_id");
    if (!anonId) {
      anonId = `anon_${uuidv4()}`;
      localStorage.setItem("anon_consent_id", anonId);
    }
    setAnonymousId(anonId);
    fetchAnonymousToken(anonId);
  }, []);

  const fetchAnonymousToken = async (anonId: string) => {
    const response = await fetch("/api/consent/anonymous-token", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ anonymous_id: anonId }),
    });
    const data = await response.json();
    setTokens({ accessToken: data.token, refreshToken: data.refresh_token });
  };

  const handleRegister = async (e: React.FormEvent<HTMLFormElement>) => {
    e.preventDefault();
    const formData = new FormData(e.currentTarget);

    const response = await fetch("/api/register-with-anonymous", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        email: formData.get("email"),
        password: formData.get("password"),
        name: formData.get("name"),
        anonymous_id: anonymousId,
      }),
    });

    if (response.ok) {
      // Anonymous consent is now linked to the user
      localStorage.removeItem("anon_consent_id");
      window.location.href = "/dashboard";
    }
  };

  return (
    <div>
      <h1>Welcome!</h1>

      {/* Inline consent for anonymous users */}
      <RedactoNoticeConsentInline
        org_uuid={ORG_UUID!}
        workspace_uuid={WORKSPACE_UUID!}
        notice_uuid={NOTICE_UUID!}
        accessToken={tokens.accessToken}
        refreshToken={tokens.refreshToken}
        baseUrl={REDACTO_BASE_URL}
        onValidationChange={(valid) => setConsentGiven(valid)}
        onAccept={() => console.log("Anonymous consent recorded")}
        onError={(error) => console.error("Consent error:", error)}
      />

      {/* Show registration form after consent */}
      {consentGiven && (
        <form onSubmit={handleRegister}>
          <h2>Create an account to continue</h2>
          <input name="email" type="email" placeholder="Email" required />
          <input name="password" type="password" placeholder="Password" required />
          <input name="name" type="text" placeholder="Name" required />
          <button type="submit">Create Account</button>
        </form>
      )}
    </div>
  );
}

export default LandingPage;

import express, { Request, Response } from "express";
import axios, { AxiosError } from "axios";

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

const CMS_API_KEY = process.env.CMS_API_KEY;
const REDACTO_BASE_URL = process.env.REDACTO_BASE_URL || "https://api.redacto.io";
const ORG_UUID = process.env.ORG_UUID;
const WORKSPACE_UUID = process.env.WORKSPACE_UUID;

interface LinkResult {
  primary_user_uuid: string;
  linked: string[];
  already_linked: string[];
  not_found: string[];
  conflicts: Array<{
    org_user_id: string;
    existing_primary_org_user_id: string;
  }>;
}

// When user is identified across channels
app.post("/api/consolidate-user", async (req: Request, res: Response) => {
  const { user_id, email, phone } = req.body;

  try {
    // 1. Create the primary consent user with your system's ID
    try {
      await axios.post(
        `${REDACTO_BASE_URL}/consent/organisations/${ORG_UUID}/workspaces/${WORKSPACE_UUID}/consent-ledger/consent-users/`,
        {
          org_user_id: user_id,
          primary_email: email,
          primary_mobile: phone,
        },
        {
          headers: {
            "X-CMS-API-Key": CMS_API_KEY,
            "Content-Type": "application/json",
          },
        }
      );
    } catch (error) {
      const axiosError = error as AxiosError;
      // Handle 409 if user already exists - that's fine
      if (axiosError.response?.status !== 409) {
        throw error;
      }
    }

    // 2. Build list of potential alias identifiers
    // These are the org_user_ids that were created when consent was submitted
    const aliasIds: string[] = [];

    // When consent is submitted with just email, the email becomes the org_user_id
    if (email) {
      aliasIds.push(email);
    }

    // When consent is submitted with just phone, the phone becomes the org_user_id
    if (phone) {
      aliasIds.push(phone);
    }

    // 3. Link all aliases to the primary user
    let linkResult: LinkResult | null = null;
    if (aliasIds.length > 0) {
      const linkResponse = await axios.post(
        `${REDACTO_BASE_URL}/consent/organisations/${ORG_UUID}/workspaces/${WORKSPACE_UUID}/consent-ledger/consent-users/link-users`,
        {
          primary_org_user_id: user_id,
          alias_org_user_ids: aliasIds,
        },
        {
          headers: {
            "X-CMS-API-Key": CMS_API_KEY,
            "Content-Type": "application/json",
          },
        }
      );

      linkResult = linkResponse.data.detail;
      console.log("Link results:", linkResult);
    }

    res.json({
      success: true,
      link_result: linkResult,
    });
  } catch (error) {
    console.error("Consolidation error:", error);
    res.status(500).json({ error: "Failed to consolidate user" });
  }
});

app.listen(3000, () => console.log("Server running on port 3000"));

interface LinkResult {
  primary_user_uuid: string;
  linked: string[];
  already_linked: string[];
  not_found: string[];
  conflicts: Array<{
    org_user_id: string;
    existing_primary_org_user_id: string;
  }>;
}

async function handleLinkResults(result: LinkResult): Promise<void> {
  // Successfully linked
  if (result.linked.length > 0) {
    console.log(`Linked ${result.linked.length} users`);
  }

  // Already linked (idempotent, no action needed)
  if (result.already_linked.length > 0) {
    console.log(`${result.already_linked.length} already linked`);
  }

  // Not found - these users haven't given consent yet
  // (consent submission creates users, not token generation)
  if (result.not_found.length > 0) {
    console.log(`${result.not_found.length} not found - no consent submitted yet`);
    // Store for later linking when they do submit consent
    await storeForLaterLinking(result.not_found);
  }

  // Conflicts - already linked to another primary
  if (result.conflicts.length > 0) {
    // May need manual review or different resolution strategy
    for (const conflict of result.conflicts) {
      console.warn(
        `${conflict.org_user_id} already linked to ${conflict.existing_primary_org_user_id}`
      );
    }
  }
}

async function storeForLaterLinking(identifiers: string[]): Promise<void> {
  // Store identifiers to retry linking later
  // Implementation depends on your system
}

interface CRMCustomer {
  crm_id: string;
  email?: string;
  phone?: string;
  web_session_id?: string;
  app_device_id?: string;
}

// When CRM identifies a customer across touchpoints
async function syncCustomerConsent(crmCustomer: CRMCustomer): Promise<void> {
  const identifiers: string[] = [];

  // Collect all known identifiers that may have been used for consent
  if (crmCustomer.email) identifiers.push(crmCustomer.email);
  if (crmCustomer.phone) identifiers.push(crmCustomer.phone);
  if (crmCustomer.web_session_id) identifiers.push(crmCustomer.web_session_id);
  if (crmCustomer.app_device_id) identifiers.push(crmCustomer.app_device_id);

  // Create primary user with CRM ID
  await createConsentUser({
    org_user_id: crmCustomer.crm_id,
    primary_email: crmCustomer.email,
    primary_mobile: crmCustomer.phone,
    metadata: { source: "crm_sync" },
  });

  // Link all identifiers
  const result = await linkUsers({
    primary_org_user_id: crmCustomer.crm_id,
    alias_org_user_ids: identifiers,
  });

  // Handle results
  await handleLinkResults(result);

  // Now all consent from any channel is consolidated
}

// Helper functions (implement based on your setup)
async function createConsentUser(data: {
  org_user_id: string;
  primary_email?: string;
  primary_mobile?: string;
  metadata?: Record<string, unknown>;
}): Promise<void> {
  // Call Redacto API to create user
}

async function linkUsers(data: {
  primary_org_user_id: string;
  alias_org_user_ids: string[];
}): Promise<LinkResult> {
  // Call Redacto API to link users
  return {} as LinkResult;
}