@dpdpguard/react-native 0.0.0

package/example/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@dpdpguard/react-native-example",
+  "version": "0.0.1",
+  "private": true,
+  "scripts": {
+    "android": "react-native run-android",
+    "ios": "react-native run-ios",
+    "start": "react-native start",
+    "build:android": "react-native build-android --extra-params \"--no-daemon --console=plain -PreactNativeArchitectures=arm64-v8a\"",
+    "build:ios": "react-native build-ios --mode Debug"
+  },
+  "dependencies": {
+    "react": "19.2.3",
+    "react-native": "0.85.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.2",
+    "@babel/preset-env": "^7.25.3",
+    "@babel/runtime": "^7.25.0",
+    "@react-native-community/cli": "20.1.0",
+    "@react-native-community/cli-platform-android": "20.1.0",
+    "@react-native-community/cli-platform-ios": "20.1.0",
+    "@react-native/babel-preset": "0.85.0",
+    "@react-native/jest-preset": "0.85.0",
+    "@react-native/metro-config": "0.85.0",
+    "@react-native/typescript-config": "0.85.0",
+    "@types/react": "^19.2.0",
+    "react-native-builder-bob": "^0.41.0",
+    "react-native-monorepo-config": "^0.4.0"
+  },
+  "engines": {
+    "node": ">= 22.11.0"
+  }
+}

package/example/react-native.config.js

@@ -0,0 +1,21 @@
+const path = require('path');
+const pkg = require('../package.json');
+
+module.exports = {
+  project: {
+    ios: {
+      automaticPodsInstallation: true,
+    },
+  },
+  dependencies: {
+    [pkg.name]: {
+      root: path.join(__dirname, '..'),
+      platforms: {
+        // Codegen script incorrectly fails without this
+        // So we explicitly specify the platforms with empty object
+        ios: {},
+        android: {},
+      },
+    },
+  },
+};

package/ios/ReactNative.h

@@ -0,0 +1,5 @@
+#import <ReactNativeSpec/ReactNativeSpec.h>
+
+@interface ReactNative : NSObject <NativeReactNativeSpec>
+
+@end

package/ios/ReactNative.mm

@@ -0,0 +1,21 @@
+#import "ReactNative.h"
+
+@implementation ReactNative
+- (NSNumber *)multiply:(double)a b:(double)b {
+    NSNumber *result = @(a * b);
+
+    return result;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeReactNativeSpecJSI>(params);
+}
+
++ (NSString *)moduleName
+{
+  return @"ReactNative";
+}
+
+@end

package/jest.config.js

@@ -0,0 +1,6 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['<rootDir>/src/**/*.test.ts'],
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@dpdpguard/react-native",
+  "version": "0.0.0",
+  "description": "DPDP Guard React Native SDK - bridge over the native Android/iOS consent engines",
+  "main": "src/index",
+  "scripts": {
+    "codegen": "node scripts/codegen.mjs",
+    "postinstall": "node scripts/codegen.mjs",
+    "test": "jest",
+    "typecheck": "tsc --noEmit"
+  },
+  "codegenConfig": {
+    "name": "ReactNativeSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.dpdpguard.reactnative"
+    }
+  },
+  "author": " <> ()",
+  "license": "MIT",
+  "homepage": "#readme",
+  "devDependencies": {
+    "@react-native/babel-preset": "0.85.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.20.1",
+    "@types/react": "^19.2.0",
+    "jest": "^29.7.0",
+    "react": "19.2.3",
+    "react-native": "0.85.0",
+    "ts-jest": "^29.4.11",
+    "typescript": "~5.8"
+  },
+  "create-react-native-library": {
+    "type": "turbo-module",
+    "languages": "kotlin-objc",
+    "tools": [
+      "eslint",
+      "jest",
+      "lefthook",
+      "release-it",
+      "vite"
+    ],
+    "version": "0.63.0"
+  },
+  "dependencies": {
+    "@dpdpguard/contract": "^0.2.0"
+  }
+}

package/scripts/codegen.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/**
+ * Regenerates src/generated/api-types.ts from the installed
+ * @dpdpguard/contract's openapi/v1.yaml. Run after every install/update of
+ * @dpdpguard/contract, or via `npm run codegen`.
+ *
+ * Uses `npx openapi-typescript` rather than a devDependency, matching
+ * dpdpguard-server-sdk's approach — keeps this repo's own TypeScript
+ * version free of a forced peer-dependency resolution.
+ */
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+const specPath = join(repoRoot, "node_modules", "@dpdpguard", "contract", "openapi", "v1.yaml");
+const outPath = join(repoRoot, "src", "generated", "api-types.ts");
+
+if (!existsSync(specPath)) {
+	console.error(`codegen: ${specPath} not found — is @dpdpguard/contract installed? Run npm install first.`);
+	process.exit(1);
+}
+
+const result = spawnSync(
+	"npx",
+	["--yes", "openapi-typescript@7", specPath, "-o", outPath],
+	{ stdio: "inherit", shell: process.platform === "win32" },
+);
+
+process.exit(result.status ?? 1);

package/src/NativeReactNative.ts

@@ -0,0 +1,7 @@
+import { TurboModuleRegistry, type TurboModule } from 'react-native';
+
+export interface Spec extends TurboModule {
+  multiply(a: number, b: number): number;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('ReactNative');

package/src/client.test.ts

@@ -0,0 +1,119 @@
+import { DpdpGuardClient } from "./client";
+import { DpdpGuardApiError } from "./errorCatalog";
+
+function jsonResponse(status: number, body: unknown): Response {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "Content-Type": "application/json" },
+	});
+}
+
+describe("DpdpGuardClient", () => {
+	test("getOrganization calls the public endpoint with no Authorization header", async () => {
+		const fetchImpl = jest
+			.fn()
+			.mockResolvedValue(
+				jsonResponse(200, { orgId: "org_1", name: "Acme", slug: "acme" }),
+			);
+		const client = new DpdpGuardClient({
+			baseUrl: "https://example.convex.site",
+			fetchImpl,
+		});
+
+		const org = await client.getOrganization("acme");
+
+		expect(org).toEqual({ orgId: "org_1", name: "Acme", slug: "acme" });
+		const [url, init] = fetchImpl.mock.calls[0];
+		expect(url).toBe("https://example.convex.site/api/v1/org/acme");
+		expect(init.headers.Authorization).toBeUndefined();
+	});
+
+	test("an authenticated call without setAccessToken() throws before hitting the network", async () => {
+		const fetchImpl = jest.fn();
+		const client = new DpdpGuardClient({
+			baseUrl: "https://example.convex.site",
+			fetchImpl,
+		});
+
+		await expect(client.listDsrRequests()).rejects.toThrow(/access token/i);
+		expect(fetchImpl).not.toHaveBeenCalled();
+	});
+
+	test("setAccessToken() makes subsequent authenticated calls use the new token", async () => {
+		const fetchImpl = jest.fn().mockResolvedValue(jsonResponse(200, { requests: [] }));
+		const client = new DpdpGuardClient({
+			baseUrl: "https://example.convex.site",
+			fetchImpl,
+		});
+
+		client.setAccessToken("token-from-my-backend");
+		await client.listDsrRequests();
+
+		const [, init] = fetchImpl.mock.calls[0];
+		expect(init.headers.Authorization).toBe("Bearer token-from-my-backend");
+	});
+
+	test("a constructor-supplied accessToken is used immediately", async () => {
+		const fetchImpl = jest.fn().mockResolvedValue(jsonResponse(200, { requests: [] }));
+		const client = new DpdpGuardClient({
+			baseUrl: "https://example.convex.site",
+			accessToken: "initial-token",
+			fetchImpl,
+		});
+
+		await client.listDsrRequests();
+
+		const [, init] = fetchImpl.mock.calls[0];
+		expect(init.headers.Authorization).toBe("Bearer initial-token");
+	});
+
+	test("a non-2xx response is thrown as a typed DpdpGuardApiError", async () => {
+		const fetchImpl = jest
+			.fn()
+			.mockImplementation(() =>
+				Promise.resolve(
+					jsonResponse(404, { code: "NOT_FOUND", error: "No such organization" }),
+				),
+			);
+		const client = new DpdpGuardClient({
+			baseUrl: "https://example.convex.site",
+			fetchImpl,
+		});
+
+		await expect(client.getOrganization("missing")).rejects.toMatchObject({
+			code: "NOT_FOUND",
+			status: 404,
+		});
+		await expect(client.getOrganization("missing")).rejects.toBeInstanceOf(
+			DpdpGuardApiError,
+		);
+	});
+
+	test("createDsrRequest forwards an Idempotency-Key header when provided", async () => {
+		const fetchImpl = jest.fn().mockResolvedValue(
+			jsonResponse(201, {
+				_id: "dsr_1",
+				organizationId: "org_1",
+				type: "erasure",
+			}),
+		);
+		const client = new DpdpGuardClient({
+			baseUrl: "https://example.convex.site",
+			accessToken: "token-abc",
+			fetchImpl,
+		});
+
+		await client.createDsrRequest(
+			{ organizationId: "org_1", type: "erasure" },
+			"idem-key-1",
+		);
+
+		const [, init] = fetchImpl.mock.calls[0];
+		expect(init.headers["Idempotency-Key"]).toBe("idem-key-1");
+	});
+
+	test("has no brokerToken method — mobile apps must never hold the service API key", () => {
+		const client = new DpdpGuardClient({ baseUrl: "https://example.convex.site" });
+		expect((client as unknown as Record<string, unknown>).brokerToken).toBeUndefined();
+	});
+});

package/src/client.ts

@@ -0,0 +1,203 @@
+import { DpdpGuardApiError } from "./errorCatalog";
+import type { components } from "./generated/api-types";
+
+type OrgSummary = components["schemas"]["OrgSummary"];
+type Notice = components["schemas"]["Notice"];
+type DsrRequest = components["schemas"]["DsrRequest"];
+type Grievance = components["schemas"]["Grievance"];
+type Nomination = components["schemas"]["Nomination"];
+
+export interface DpdpGuardClientOptions {
+	/** e.g. "https://trustworthy-alligator-303.convex.site" */
+	baseUrl: string;
+	/**
+	 * A brokered principal access token (ADR-004 D1/D2), obtained from your
+	 * own app backend — this client deliberately has no `brokerToken()`
+	 * method or API-key option. Minting a token requires a service API key
+	 * (convex/apiKeys.ts), which must never ship inside a mobile app
+	 * bundle; brokering stays server-side.
+	 */
+	accessToken?: string;
+	/** Override for testing; defaults to the global `fetch` (RN provides one natively). */
+	fetchImpl?: typeof fetch;
+}
+
+type AuthMode = "none" | "bearer";
+
+interface RequestOptions {
+	body?: unknown;
+	auth?: AuthMode;
+	headers?: Record<string, string>;
+}
+
+/**
+ * Thin typed client over DPDP Guard's public `/api/v1` (spec §4.2), for use
+ * from a React Native app. Wraps the openapi-typescript-generated
+ * request/response shapes (src/generated/api-types.ts) in ergonomic
+ * methods, and maps every non-2xx response to a {@link DpdpGuardApiError}
+ * keyed by the ADR-002 error catalog's `code`.
+ */
+export class DpdpGuardClient {
+	private readonly baseUrl: string;
+	private accessToken: string | undefined;
+	private readonly fetchImpl: typeof fetch;
+
+	constructor(options: DpdpGuardClientOptions) {
+		this.baseUrl = options.baseUrl.replace(/\/$/, "");
+		this.accessToken = options.accessToken;
+		this.fetchImpl = options.fetchImpl ?? fetch;
+	}
+
+	/** Set/replace the brokered principal access token (e.g. after your backend re-brokers on expiry). */
+	setAccessToken(token: string): void {
+		this.accessToken = token;
+	}
+
+	private async request<T>(
+		method: string,
+		path: string,
+		options: RequestOptions = {},
+	): Promise<T> {
+		const auth = options.auth ?? "bearer";
+		const headers: Record<string, string> = {
+			"Content-Type": "application/json",
+			...options.headers,
+		};
+
+		if (auth === "bearer") {
+			if (!this.accessToken) {
+				throw new Error(
+					"DpdpGuardClient: this call requires an access token — call setAccessToken() with a token from your own backend first.",
+				);
+			}
+			headers.Authorization = `Bearer ${this.accessToken}`;
+		}
+
+		const init: RequestInit = { method, headers };
+		if (options.body !== undefined) {
+			init.body = JSON.stringify(options.body);
+		}
+		const response = await this.fetchImpl(`${this.baseUrl}${path}`, init);
+
+		const text = await response.text();
+		const json: unknown = text.length > 0 ? JSON.parse(text) : undefined;
+
+		if (!response.ok) {
+			const code =
+				json && typeof json === "object" && "code" in json
+					? String((json as { code: unknown }).code)
+					: "VALIDATION_ERROR";
+			const message =
+				json && typeof json === "object" && "error" in json
+					? String((json as { error: unknown }).error)
+					: `Request failed with status ${response.status}`;
+			throw new DpdpGuardApiError(code, message, response.status);
+		}
+
+		return json as T;
+	}
+
+	// --- Public reads (no auth) ---
+
+	getOrganization(slug: string): Promise<OrgSummary> {
+		return this.request("GET", `/api/v1/org/${encodeURIComponent(slug)}`, {
+			auth: "none",
+		});
+	}
+
+	getNotices(orgId: string): Promise<{ notices: Notice[] }> {
+		return this.request(
+			"GET",
+			`/api/v1/org/${encodeURIComponent(orgId)}/notices`,
+			{ auth: "none" },
+		);
+	}
+
+	getNotice(noticeId: string): Promise<Notice> {
+		return this.request(
+			"GET",
+			`/api/v1/notices/${encodeURIComponent(noticeId)}`,
+			{ auth: "none" },
+		);
+	}
+
+	getBannerConfig(
+		orgId: string,
+		scope?: { domain?: string; appId?: string },
+	): Promise<{ bannerSettings?: Record<string, never>; configVersion: number }> {
+		const query = new URLSearchParams();
+		if (scope?.domain) query.set("domain", scope.domain);
+		if (scope?.appId) query.set("appId", scope.appId);
+		const qs = query.toString();
+		return this.request(
+			"GET",
+			`/api/v1/org/${encodeURIComponent(orgId)}/banner-config${qs ? `?${qs}` : ""}`,
+			{ auth: "none" },
+		);
+	}
+
+	// --- Anonymous → known-user reconciliation (ADR-004 D3) ---
+
+	linkAnonymousConsent(
+		anonymousId: string,
+	): Promise<{
+		linkedCount: number;
+		needsReconsent: { noticeId: string; purpose: string }[];
+	}> {
+		return this.request("POST", "/api/v1/link-anonymous-consent", {
+			body: { anonymousId },
+		});
+	}
+
+	// --- DSR (spec §4.2) ---
+
+	listDsrRequests(): Promise<{ requests: DsrRequest[] }> {
+		return this.request("GET", "/api/v1/dsr");
+	}
+
+	createDsrRequest(
+		input: {
+			organizationId: string;
+			type: "summary" | "processors" | "correction" | "erasure";
+			details?: string;
+		},
+		idempotencyKey?: string,
+	): Promise<DsrRequest> {
+		const options: RequestOptions = { body: input };
+		if (idempotencyKey !== undefined) {
+			options.headers = { "Idempotency-Key": idempotencyKey };
+		}
+		return this.request("POST", "/api/v1/dsr", options);
+	}
+
+	// --- Grievances (spec §4.2) ---
+
+	listGrievances(): Promise<{ grievances: Grievance[] }> {
+		return this.request("GET", "/api/v1/grievances");
+	}
+
+	createGrievance(input: {
+		organizationId: string;
+		subject: string;
+		description: string;
+	}): Promise<Grievance> {
+		return this.request("POST", "/api/v1/grievances", { body: input });
+	}
+
+	// --- Nomination (spec §4.2) ---
+
+	getNomination(): Promise<Nomination | null> {
+		return this.request("GET", "/api/v1/nomination");
+	}
+
+	upsertNomination(input: {
+		nomineeName: string;
+		nomineeContact: string;
+	}): Promise<Nomination> {
+		return this.request("PUT", "/api/v1/nomination", { body: input });
+	}
+
+	revokeNomination(): Promise<{ revoked: boolean }> {
+		return this.request("DELETE", "/api/v1/nomination");
+	}
+}

package/src/consentGate.test.ts

@@ -0,0 +1,17 @@
+import { hasConsent } from "./consentGate";
+
+describe("hasConsent", () => {
+	test("true when a matching purpose has no withdrawnAt", () => {
+		expect(hasConsent([{ purpose: "Analytics" }], "Analytics")).toBe(true);
+	});
+
+	test("false when the matching purpose was withdrawn", () => {
+		expect(
+			hasConsent([{ purpose: "Analytics", withdrawnAt: 123 }], "Analytics"),
+		).toBe(false);
+	});
+
+	test("false when no record matches the purpose", () => {
+		expect(hasConsent([{ purpose: "Marketing" }], "Analytics")).toBe(false);
+	});
+});

package/src/consentGate.ts

@@ -0,0 +1,14 @@
+/**
+ * Pure helper for gating a feature/tracker on an existing consent decision —
+ * e.g. `if (!hasConsent(consents, "Analytics")) return;` before firing an
+ * analytics event.
+ */
+export interface ConsentRecord {
+	purpose: string;
+	/** Present when the decision was withdrawn; absent/undefined means still active. */
+	withdrawnAt?: number | null;
+}
+
+export function hasConsent(consents: ConsentRecord[], purpose: string): boolean {
+	return consents.some((c) => c.purpose === purpose && c.withdrawnAt == null);
+}

package/src/errorCatalog.test.ts

@@ -0,0 +1,19 @@
+import { ERROR_CATALOG } from "./errorCatalog";
+
+describe("ERROR_CATALOG", () => {
+	test("loads all 10 codes from the installed @dpdpguard/contract package", () => {
+		const codes = ERROR_CATALOG.map((entry) => entry.code);
+		expect(codes).toEqual([
+			"MINOR_TRACKING_BLOCKED",
+			"NOTICE_NOT_PUBLISHED",
+			"ALREADY_CONSENTED",
+			"NOT_ASSOCIATED_WITH_ORG",
+			"INVALID_STATUS_TRANSITION",
+			"SDK_VERSION_UNSUPPORTED",
+			"NOT_FOUND",
+			"UNAUTHORIZED",
+			"RATE_LIMITED",
+			"VALIDATION_ERROR",
+		]);
+	});
+});

package/src/errorCatalog.ts

@@ -0,0 +1,39 @@
+import errorCatalog from "@dpdpguard/contract/conformance/error-catalog.json";
+
+/**
+ * ADR-002 D2's typed error-code enum, loaded from the installed
+ * @dpdpguard/contract package via a static JSON import (Metro and
+ * TypeScript's resolveJsonModule both support this directly — unlike the
+ * Node server SDK, there's no CommonJS `require()` trick needed here).
+ */
+export interface ErrorCatalogEntry {
+	code: string;
+	description: string;
+}
+
+export const ERROR_CATALOG: ErrorCatalogEntry[] = errorCatalog.codes;
+
+export type ApiErrorCode =
+	| "MINOR_TRACKING_BLOCKED"
+	| "NOTICE_NOT_PUBLISHED"
+	| "ALREADY_CONSENTED"
+	| "NOT_ASSOCIATED_WITH_ORG"
+	| "INVALID_STATUS_TRANSITION"
+	| "SDK_VERSION_UNSUPPORTED"
+	| "NOT_FOUND"
+	| "UNAUTHORIZED"
+	| "RATE_LIMITED"
+	| "VALIDATION_ERROR";
+
+/** Thrown by {@link DpdpGuardClient} for any non-2xx `/api/v1` response. */
+export class DpdpGuardApiError extends Error {
+	readonly code: ApiErrorCode | string;
+	readonly status: number;
+
+	constructor(code: ApiErrorCode | string, message: string, status: number) {
+		super(message);
+		this.name = "DpdpGuardApiError";
+		this.code = code;
+		this.status = status;
+	}
+}

package/src/index.tsx

@@ -0,0 +1,8 @@
+export { multiply } from './multiply';
+
+export { DpdpGuardClient } from './client';
+export type { DpdpGuardClientOptions } from './client';
+export { DpdpGuardApiError, ERROR_CATALOG } from './errorCatalog';
+export type { ApiErrorCode, ErrorCatalogEntry } from './errorCatalog';
+export { hasConsent } from './consentGate';
+export type { ConsentRecord } from './consentGate';

package/src/multiply.native.tsx

@@ -0,0 +1,5 @@
+import ReactNative from './NativeReactNative';
+
+export function multiply(a: number, b: number): number {
+  return ReactNative.multiply(a, b);
+}

package/src/multiply.tsx

@@ -0,0 +1,3 @@
+export function multiply(a: number, b: number): number {
+  return a * b;
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "lib": ["es2020"],
+    "jsx": "react-native",
+    "strict": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "lib",
+    "rootDir": "src"
+  },
+  "include": ["src"],
+  "exclude": ["src/**/*.test.ts", "src/generated", "lib"]
+}