@c15t/backend 0.0.1-rc.10

package/dist/api/routes/verify-consent.d.ts

@@ -0,0 +1,179 @@
+import { z } from 'zod';
+export interface VerifyConsentResponse {
+    success: boolean;
+    data: {
+        verified: boolean;
+        consentDetails: {
+            id: string;
+            givenAt: string;
+            policyVersion: string;
+            preferences: Record<string, string | null>;
+        } | null;
+        identifiedBy: string | null;
+        verificationResults: {
+            hasActiveConsent: boolean;
+            meetsPreferenceRequirements: boolean;
+            matchesPolicyVersion: boolean;
+        };
+    };
+}
+/**
+ * Endpoint for verifying if a subject has given consent.
+ *
+ * This endpoint allows checking if a subject has provided consent for a specific domain
+ * and verifies if the consent meets specific criteria (required preferences, policy version).
+ * Subjects can be identified by subjectId, externalId, or ipAddress.
+ *
+ * @endpoint GET /consent/verify
+ */
+export declare const verifyConsent: {
+    <C extends [import("better-call").InputContext<"/consent/verify", {
+        method: "GET";
+        query: z.ZodIntersection<z.ZodObject<{
+            domain: z.ZodString;
+            requiredPreferences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+            requireExactMatch: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            policyVersion: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            domain: string;
+            requireExactMatch: boolean;
+            requiredPreferences?: Record<string, string | null> | undefined;
+            policyVersion?: string | undefined;
+        }, {
+            domain: string;
+            requiredPreferences?: Record<string, string | null> | undefined;
+            requireExactMatch?: boolean | undefined;
+            policyVersion?: string | undefined;
+        }>, z.ZodEffects<z.ZodObject<{
+            subjectId: z.ZodOptional<z.ZodString>;
+            externalId: z.ZodOptional<z.ZodString>;
+            ipAddress: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            subjectId?: string | undefined;
+            ipAddress?: string | undefined;
+            externalId?: string | undefined;
+        }, {
+            subjectId?: string | undefined;
+            ipAddress?: string | undefined;
+            externalId?: string | undefined;
+        }>, {
+            subjectId?: string | undefined;
+            ipAddress?: string | undefined;
+            externalId?: string | undefined;
+        }, {
+            subjectId?: string | undefined;
+            ipAddress?: string | undefined;
+            externalId?: string | undefined;
+        }>>;
+    } & {
+        use: any[];
+    }>]>(...inputCtx: C): Promise<C extends [{
+        asResponse: true;
+    }] ? Response : C extends [{
+        returnHeaders: true;
+    }] ? {
+        headers: Headers;
+        response: {
+            success: boolean;
+            data: {
+                verified: boolean;
+                consentDetails: null;
+                identifiedBy: string | null;
+                verificationResults: {
+                    hasActiveConsent: boolean;
+                    meetsPreferenceRequirements: boolean;
+                    matchesPolicyVersion: boolean;
+                };
+            };
+        } | {
+            success: boolean;
+            data: {
+                verified: boolean;
+                consentDetails: {
+                    id: string;
+                    givenAt: string;
+                    policyVersion: string;
+                    preferences: {};
+                };
+                identifiedBy: string | null;
+                verificationResults: {
+                    hasActiveConsent: boolean;
+                    meetsPreferenceRequirements: boolean;
+                    matchesPolicyVersion: boolean;
+                };
+            };
+        };
+    } : {
+        success: boolean;
+        data: {
+            verified: boolean;
+            consentDetails: null;
+            identifiedBy: string | null;
+            verificationResults: {
+                hasActiveConsent: boolean;
+                meetsPreferenceRequirements: boolean;
+                matchesPolicyVersion: boolean;
+            };
+        };
+    } | {
+        success: boolean;
+        data: {
+            verified: boolean;
+            consentDetails: {
+                id: string;
+                givenAt: string;
+                policyVersion: string;
+                preferences: {};
+            };
+            identifiedBy: string | null;
+            verificationResults: {
+                hasActiveConsent: boolean;
+                meetsPreferenceRequirements: boolean;
+                matchesPolicyVersion: boolean;
+            };
+        };
+    }>;
+    options: {
+        method: "GET";
+        query: z.ZodIntersection<z.ZodObject<{
+            domain: z.ZodString;
+            requiredPreferences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+            requireExactMatch: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            policyVersion: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            domain: string;
+            requireExactMatch: boolean;
+            requiredPreferences?: Record<string, string | null> | undefined;
+            policyVersion?: string | undefined;
+        }, {
+            domain: string;
+            requiredPreferences?: Record<string, string | null> | undefined;
+            requireExactMatch?: boolean | undefined;
+            policyVersion?: string | undefined;
+        }>, z.ZodEffects<z.ZodObject<{
+            subjectId: z.ZodOptional<z.ZodString>;
+            externalId: z.ZodOptional<z.ZodString>;
+            ipAddress: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            subjectId?: string | undefined;
+            ipAddress?: string | undefined;
+            externalId?: string | undefined;
+        }, {
+            subjectId?: string | undefined;
+            ipAddress?: string | undefined;
+            externalId?: string | undefined;
+        }>, {
+            subjectId?: string | undefined;
+            ipAddress?: string | undefined;
+            externalId?: string | undefined;
+        }, {
+            subjectId?: string | undefined;
+            ipAddress?: string | undefined;
+            externalId?: string | undefined;
+        }>>;
+    } & {
+        use: any[];
+    };
+    path: "/consent/verify";
+};
+//# sourceMappingURL=verify-consent.d.ts.map

package/dist/api/routes/verify-consent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-consent.d.ts","sourceRoot":"","sources":["../../../src/api/routes/verify-consent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoCxB,MAAM,WAAW,qBAAqB;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE;QACL,QAAQ,EAAE,OAAO,CAAC;QAClB,cAAc,EAAE;YACf,EAAE,EAAE,MAAM,CAAC;YACX,OAAO,EAAE,MAAM,CAAC;YAChB,aAAa,EAAE,MAAM,CAAC;YACtB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;SAC3C,GAAG,IAAI,CAAC;QACT,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;QAC5B,mBAAmB,EAAE;YACpB,gBAAgB,EAAE,OAAO,CAAC;YAC1B,2BAA2B,EAAE,OAAO,CAAC;YACrC,oBAAoB,EAAE,OAAO,CAAC;SAC9B,CAAC;KACF,CAAC;CACF;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+MzB,CAAC"}

package/dist/api/routes/withdraw-consent.d.ts

@@ -0,0 +1,194 @@
+import { z } from 'zod';
+export interface WithdrawConsentResponse {
+    success: boolean;
+    data: {
+        withdrawalIds: string[];
+        consentIds: string[];
+        revokedAt: string;
+    };
+}
+/**
+ * Endpoint for withdrawing previously given consent.
+ *
+ * This endpoint allows clients to revoke a subject's consent by specifying either:
+ * 1. The specific consent ID to withdraw
+ * 2. The subject ID and domain to withdraw all active consents for that subject on that domain
+ * 3. The external subject ID and domain to withdraw all active consents for that subject on that domain
+ *
+ * @endpoint POST /consent/withdraw
+ */
+export declare const withdrawConsent: {
+    <C extends [import("better-call").InputContext<"/consent/withdraw", {
+        method: "POST";
+        body: z.ZodDiscriminatedUnion<"identifierType", [z.ZodObject<{
+            consentId: z.ZodString;
+            identifierType: z.ZodLiteral<"consentId">;
+            reason: z.ZodOptional<z.ZodString>;
+            method: z.ZodString;
+            actor: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            consentId: string;
+            method: string;
+            identifierType: "consentId";
+            metadata?: Record<string, any> | undefined;
+            reason?: string | undefined;
+            actor?: string | undefined;
+        }, {
+            consentId: string;
+            method: string;
+            identifierType: "consentId";
+            metadata?: Record<string, any> | undefined;
+            reason?: string | undefined;
+            actor?: string | undefined;
+        }>, z.ZodObject<{
+            subjectId: z.ZodString;
+            domain: z.ZodString;
+            identifierType: z.ZodLiteral<"subjectId">;
+            reason: z.ZodOptional<z.ZodString>;
+            method: z.ZodString;
+            actor: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            subjectId: string;
+            domain: string;
+            method: string;
+            identifierType: "subjectId";
+            metadata?: Record<string, any> | undefined;
+            reason?: string | undefined;
+            actor?: string | undefined;
+        }, {
+            subjectId: string;
+            domain: string;
+            method: string;
+            identifierType: "subjectId";
+            metadata?: Record<string, any> | undefined;
+            reason?: string | undefined;
+            actor?: string | undefined;
+        }>, z.ZodObject<{
+            externalId: z.ZodString;
+            domain: z.ZodString;
+            identifierType: z.ZodLiteral<"externalId">;
+            reason: z.ZodOptional<z.ZodString>;
+            method: z.ZodString;
+            actor: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            externalId: string;
+            domain: string;
+            method: string;
+            identifierType: "externalId";
+            metadata?: Record<string, any> | undefined;
+            reason?: string | undefined;
+            actor?: string | undefined;
+        }, {
+            externalId: string;
+            domain: string;
+            method: string;
+            identifierType: "externalId";
+            metadata?: Record<string, any> | undefined;
+            reason?: string | undefined;
+            actor?: string | undefined;
+        }>]>;
+    } & {
+        use: any[];
+    }>]>(...inputCtx: C): Promise<C extends [{
+        asResponse: true;
+    }] ? Response : C extends [{
+        returnHeaders: true;
+    }] ? {
+        headers: Headers;
+        response: {
+            success: boolean;
+            data: {
+                withdrawalIds: string[];
+                consentIds: string[];
+                revokedAt: string;
+            };
+        };
+    } : {
+        success: boolean;
+        data: {
+            withdrawalIds: string[];
+            consentIds: string[];
+            revokedAt: string;
+        };
+    }>;
+    options: {
+        method: "POST";
+        body: z.ZodDiscriminatedUnion<"identifierType", [z.ZodObject<{
+            consentId: z.ZodString;
+            identifierType: z.ZodLiteral<"consentId">;
+            reason: z.ZodOptional<z.ZodString>;
+            method: z.ZodString;
+            actor: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            consentId: string;
+            method: string;
+            identifierType: "consentId";
+            metadata?: Record<string, any> | undefined;
+            reason?: string | undefined;
+            actor?: string | undefined;
+        }, {
+            consentId: string;
+            method: string;
+            identifierType: "consentId";
+            metadata?: Record<string, any> | undefined;
+            reason?: string | undefined;
+            actor?: string | undefined;
+        }>, z.ZodObject<{
+            subjectId: z.ZodString;
+            domain: z.ZodString;
+            identifierType: z.ZodLiteral<"subjectId">;
+            reason: z.ZodOptional<z.ZodString>;
+            method: z.ZodString;
+            actor: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            subjectId: string;
+            domain: string;
+            method: string;
+            identifierType: "subjectId";
+            metadata?: Record<string, any> | undefined;
+            reason?: string | undefined;
+            actor?: string | undefined;
+        }, {
+            subjectId: string;
+            domain: string;
+            method: string;
+            identifierType: "subjectId";
+            metadata?: Record<string, any> | undefined;
+            reason?: string | undefined;
+            actor?: string | undefined;
+        }>, z.ZodObject<{
+            externalId: z.ZodString;
+            domain: z.ZodString;
+            identifierType: z.ZodLiteral<"externalId">;
+            reason: z.ZodOptional<z.ZodString>;
+            method: z.ZodString;
+            actor: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            externalId: string;
+            domain: string;
+            method: string;
+            identifierType: "externalId";
+            metadata?: Record<string, any> | undefined;
+            reason?: string | undefined;
+            actor?: string | undefined;
+        }, {
+            externalId: string;
+            domain: string;
+            method: string;
+            identifierType: "externalId";
+            metadata?: Record<string, any> | undefined;
+            reason?: string | undefined;
+            actor?: string | undefined;
+        }>]>;
+    } & {
+        use: any[];
+    };
+    path: "/consent/withdraw";
+};
+//# sourceMappingURL=withdraw-consent.d.ts.map

package/dist/api/routes/withdraw-consent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withdraw-consent.d.ts","sourceRoot":"","sources":["../../../src/api/routes/withdraw-consent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA4CxB,MAAM,WAAW,uBAAuB;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE;QACL,aAAa,EAAE,MAAM,EAAE,CAAC;QACxB,UAAU,EAAE,MAAM,EAAE,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;KAClB,CAAC;CACF;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqO3B,CAAC"}

package/dist/api/to-endpoints.d.ts

@@ -0,0 +1,35 @@
+import type { C15TContext } from '../types';
+import type { C15TEndpoint } from './call';
+/**
+ * Converts a map of endpoint definitions to callable API functions
+ *
+ * This function transforms raw endpoint definitions into API handlers that
+ * properly manage context, execute hooks, and handle responses.
+ *
+ * @remarks
+ * The generated API handlers maintain the path and options from the original
+ * endpoints while adding hook processing, error handling, and response formatting.
+ *
+ * @typeParam EndpointMap - Record type mapping endpoint names to their handler functions
+ * @param endpoints - Map of endpoint definitions to convert
+ * @param ctx - The C15T context or promise that will resolve to context
+ * @returns A record of API functions matching the endpoint definitions
+ * @throws Will re-throw any errors not instanceof APIError that occur during endpoint execution
+ *
+ * @example
+ * ```typescript
+ * const api = toEndpoints({
+ *   getSubject: createAuthEndpoint(async (ctx) => {
+ *     return { name: "Subject" };
+ *   }),
+ *   updateSubject: createAuthEndpoint(async (ctx) => {
+ *     // Process update logic
+ *   })
+ * }, contextPromise);
+ *
+ * // Later use the API
+ * const subject = await api.getSubject({ params: { id: "sub_x1pftyoufsm7xgo1kv" } });
+ * ```
+ */
+export declare function toEndpoints<EndpointMap extends Record<string, C15TEndpoint>>(endpoints: EndpointMap, ctx: C15TContext | Promise<C15TContext>): EndpointMap;
+//# sourceMappingURL=to-endpoints.d.ts.map

package/dist/api/to-endpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-endpoints.d.ts","sourceRoot":"","sources":["../../src/api/to-endpoints.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,SAAS,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,QAAQ,CAAC;AAgB3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,WAAW,CAAC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC3E,SAAS,EAAE,WAAW,EACtB,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,GAwIzB,WAAW,CACzB"}

package/dist/client/index.cjs

@@ -0,0 +1,139 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    c15tClient: ()=>c15tClient,
+    createConsentClient: ()=>createConsentClient
+});
+class c15tClient {
+    baseURL;
+    headers;
+    customFetch;
+    constructor(options){
+        this.baseURL = options.baseURL.endsWith('/') ? options.baseURL.slice(0, -1) : options.baseURL;
+        this.headers = {
+            'Content-Type': 'application/json',
+            ...options.headers
+        };
+        this.customFetch = options.fetchOptions?.customFetchImpl;
+    }
+    async fetcher(path, options = {}) {
+        try {
+            const url = new URL(path, this.baseURL);
+            if (options.query) {
+                for (const [key, value] of Object.entries(options.query))if (void 0 !== value) {
+                    if (Array.isArray(value)) for (const v of value)url.searchParams.append(key, String(v));
+                    else url.searchParams.append(key, String(value));
+                }
+            }
+            const fetchOptions = {
+                method: options.method || 'GET',
+                headers: {
+                    ...this.headers,
+                    ...options.headers
+                }
+            };
+            if (options.body && 'GET' !== fetchOptions.method) fetchOptions.body = JSON.stringify(options.body);
+            const fetchImpl = this.customFetch || fetch;
+            const response = await fetchImpl(url.toString(), fetchOptions);
+            let data = null;
+            let error = null;
+            if (204 !== response.status) try {
+                data = await response.json();
+            } catch (err) {
+                if (response.ok) data = null;
+                else error = new Error(`Failed to parse response: ${err.message}`);
+            }
+            const context = {
+                data,
+                response,
+                error: error ? {
+                    message: error.message,
+                    status: response.status
+                } : null,
+                ok: response.ok
+            };
+            if (response.ok) {
+                if (options.onSuccess) await options.onSuccess(context);
+            } else {
+                if (options.onError) await options.onError(context);
+                if (options.throw) {
+                    const error = new Error(`Request failed with status ${response.status}`);
+                    Object.assign(error, {
+                        status: response.status,
+                        data
+                    });
+                    throw error;
+                }
+            }
+            return context;
+        } catch (error) {
+            if (options.onError) {
+                const errorObj = error;
+                const context = {
+                    data: null,
+                    error: {
+                        message: errorObj.message || 'Request failed',
+                        status: error.status || 500,
+                        code: error.code
+                    },
+                    ok: false,
+                    response: null
+                };
+                await options.onError(context);
+                if (options.throw) throw error;
+                return context;
+            }
+            if (options.throw) throw error;
+            return {
+                data: null,
+                error: {
+                    message: error.message || 'Request failed',
+                    status: error.status || 500,
+                    code: error.code
+                },
+                ok: false,
+                response: null
+            };
+        }
+    }
+    async listPurposes(options) {
+        return this.fetcher('/list-purposes', {
+            method: 'GET',
+            ...options
+        });
+    }
+    async $fetch(path, options) {
+        return this.fetcher(path, options);
+    }
+}
+function createConsentClient(options) {
+    return new c15tClient(options);
+}
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});