@c15t/backend 1.8.0 → 2.0.0-rc.0

package/dist/contracts.js

@@ -1,636 +0,0 @@
-import { implement } from "@orpc/server";
-import { oc } from "@orpc/contract";
-import { z } from "zod";
-import base_x from "base-x";
-import "neverthrow";
-import { trace } from "@opentelemetry/api";
-import "@c15t/logger";
-const identifyUserSchema = z.object({
-    consentId: z.string(),
-    externalId: z.string(),
-    identityProvider: z.string().optional()
-});
-const identifyUserContract = oc.route({
-    method: 'PATCH',
-    path: '/consent/identify',
-    description: "Links a subject's external ID to a consent record by consent ID. This is used to identify a user across multiple devices and sessions.",
-    tags: [
-        'consent',
-        'cookie-banner'
-    ]
-}).errors({
-    CONSENT_NOT_FOUND: {
-        status: 404,
-        data: z.object({
-            consentId: z.string()
-        }),
-        error: 'Consent not found'
-    },
-    IDENTIFICATION_FAILED: {
-        status: 500,
-        data: z.object({
-            consentId: z.string()
-        }),
-        error: 'Failed to identify user'
-    }
-}).input(identifyUserSchema).output(z.object({
-    success: z.boolean()
-}));
-base_x('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
-const fieldConfigSchema = z.object({
-    required: z.boolean().prefault(true),
-    returned: z.boolean().prefault(true),
-    input: z.boolean().prefault(true),
-    defaultValue: z.any().optional(),
-    transform: z.object({
-        input: z.any().optional(),
-        output: z.any().optional()
-    }).optional(),
-    validator: z.any().optional(),
-    unique: z.boolean().optional(),
-    indexed: z.boolean().optional(),
-    sortable: z.boolean().prefault(true),
-    fieldName: z.string().optional(),
-    bigint: z.boolean().prefault(false)
-});
-const stringFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('string'),
-    minLength: z.number().optional(),
-    maxLength: z.number().optional(),
-    pattern: z.string().optional()
-});
-const numberFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('number'),
-    min: z.number().optional(),
-    max: z.number().optional()
-});
-const booleanFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('boolean')
-});
-const dateFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('date'),
-    minDate: z.date().optional(),
-    maxDate: z.date().optional(),
-    dateOnly: z.boolean().prefault(false),
-    format: z.record(z.string(), z.unknown()).optional()
-});
-const timezoneFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('timezone'),
-    validateTimezone: z.boolean().prefault(true),
-    suggestedValues: z.array(z.string()).optional(),
-    restrictToSuggestedValues: z.boolean().prefault(false)
-});
-const jsonFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('json'),
-    validateJson: z.boolean().prefault(true)
-});
-const stringArrayFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('string[]')
-});
-const numberArrayFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('number[]')
-});
-z.discriminatedUnion('type', [
-    stringFieldSchema,
-    numberFieldSchema,
-    booleanFieldSchema,
-    dateFieldSchema,
-    timezoneFieldSchema,
-    jsonFieldSchema,
-    stringArrayFieldSchema,
-    numberArrayFieldSchema
-]);
-Object.freeze({
-    NOT_FOUND: 'Resource not found',
-    BAD_REQUEST: 'Bad request',
-    CONFLICT: 'Conflict with current state',
-    MISSING_REQUIRED_PARAMETER: 'Missing required parameter',
-    UNAUTHORIZED: 'Unauthorized',
-    FORBIDDEN: 'Forbidden',
-    INTERNAL_SERVER_ERROR: 'Internal server error',
-    INITIALIZATION_FAILED: 'Initialization failed',
-    DATABASE_CONNECTION_ERROR: 'Database connection error',
-    DATABASE_QUERY_ERROR: 'Database query error',
-    INVALID_CONFIGURATION: 'Invalid configuration',
-    REQUEST_HANDLER_ERROR: 'Request handler error',
-    INVALID_REQUEST: 'Invalid request',
-    UNKNOWN_ERROR: 'Unknown error',
-    NETWORK_ERROR: 'Network error',
-    PLUGIN_INITIALIZATION_FAILED: 'Plugin initialization failed',
-    API_RETRIEVAL_ERROR: 'API retrieval error',
-    VALIDATION_ERROR: 'Validation error',
-    UNEXPECTED: 'Unexpected error'
-});
-Object.freeze({
-    VALIDATION: 'validation',
-    AUTHORIZATION: 'authorization',
-    STORAGE: 'storage',
-    NETWORK: 'network',
-    PLUGIN: 'plugin',
-    CONFIGURATION: 'configuration',
-    UNEXPECTED: 'unexpected'
-});
-trace.getTracer('@doubletie/results');
-z.object({
-    id: z.string(),
-    entityType: z.string(),
-    entityId: z.string(),
-    actionType: z.string(),
-    subjectId: z.string().optional(),
-    ipAddress: z.string().optional(),
-    userAgent: z.string().optional(),
-    changes: z.record(z.string(), z.unknown()).optional(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-    createdAt: z.date().prefault(()=>new Date())
-});
-z.object({
-    id: z.string(),
-    subjectId: z.string(),
-    domainId: z.string(),
-    purposeIds: z.array(z.string()),
-    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
-    policyId: z.string().optional(),
-    ipAddress: z.string().nullable().optional(),
-    userAgent: z.string().nullable().optional(),
-    status: z["enum"]([
-        'active',
-        'withdrawn',
-        'expired'
-    ]).prefault('active'),
-    withdrawalReason: z.string().nullable().optional(),
-    givenAt: z.date().prefault(()=>new Date()),
-    validUntil: z.date().nullable().optional(),
-    isActive: z.boolean().prefault(true)
-});
-const PolicyTypeSchema = z["enum"]([
-    'cookie_banner',
-    'privacy_policy',
-    'dpa',
-    'terms_and_conditions',
-    'marketing_communications',
-    'age_verification',
-    'other'
-]);
-z.object({
-    id: z.string(),
-    version: z.string(),
-    type: PolicyTypeSchema,
-    name: z.string(),
-    effectiveDate: z.date(),
-    expirationDate: z.date().nullable().optional(),
-    content: z.string(),
-    contentHash: z.string(),
-    isActive: z.boolean().prefault(true),
-    createdAt: z.date().prefault(()=>new Date()),
-    updatedAt: z.date().prefault(()=>new Date())
-});
-z.object({
-    id: z.string(),
-    code: z.string(),
-    name: z.string(),
-    description: z.string(),
-    isEssential: z.boolean().prefault(false),
-    dataCategory: z.string().nullish(),
-    legalBasis: z.string().nullish(),
-    isActive: z.boolean().prefault(true),
-    createdAt: z.date().prefault(()=>new Date()),
-    updatedAt: z.date().prefault(()=>new Date())
-});
-z.object({
-    id: z.string(),
-    subjectId: z.string(),
-    consentId: z.string().optional(),
-    actionType: z.string(),
-    details: z.record(z.string(), z.unknown()).optional(),
-    createdAt: z.date().prefault(()=>new Date()),
-    updatedAt: z.date().prefault(()=>new Date())
-});
-z.object({
-    id: z.string(),
-    name: z.string().min(1),
-    description: z.string().optional(),
-    allowedOrigins: z.array(z.string()).optional().prefault([]),
-    isVerified: z.boolean().prefault(true),
-    isActive: z.boolean().prefault(true),
-    createdAt: z.date().prefault(()=>new Date()),
-    updatedAt: z.date().prefault(()=>new Date())
-});
-z.object({
-    id: z.string(),
-    isIdentified: z.boolean().prefault(false),
-    externalId: z.string().nullable().optional(),
-    identityProvider: z.string().optional(),
-    lastIpAddress: z.string().optional(),
-    createdAt: z.date().prefault(()=>new Date()),
-    updatedAt: z.date().prefault(()=>new Date())
-});
-const baseConsentSchema = z.object({
-    subjectId: z.string().optional(),
-    externalSubjectId: z.string().optional(),
-    identityProvider: z.string().optional(),
-    domain: z.string(),
-    type: PolicyTypeSchema,
-    metadata: z.record(z.string(), z.unknown()).optional()
-});
-const cookieBannerSchema = baseConsentSchema.extend({
-    type: z.literal('cookie_banner'),
-    preferences: z.record(z.string(), z.boolean())
-});
-const policyBasedSchema = baseConsentSchema.extend({
-    type: z["enum"]([
-        'privacy_policy',
-        'dpa',
-        'terms_and_conditions'
-    ]),
-    policyId: z.string().optional(),
-    preferences: z.record(z.string(), z.boolean()).optional()
-});
-const otherConsentSchema = baseConsentSchema.extend({
-    type: z["enum"]([
-        'marketing_communications',
-        'age_verification',
-        'other'
-    ]),
-    preferences: z.record(z.string(), z.boolean()).optional()
-});
-const postConsentContract = oc.route({
-    method: 'POST',
-    path: '/consent/set',
-    description: `Records a user's consent preferences and creates necessary consent records.
-This endpoint handles various types of consent submissions:
-
-1. Cookie Banner Consent:
-   - Records granular cookie preferences
-   - Supports multiple consent purposes
-   - Creates audit trail for compliance
-
-2. Policy-Based Consent:
-   - Privacy Policy acceptance
-   - Data Processing Agreement (DPA) consent
-   - Terms and Conditions acceptance
-   - Links consent to specific policy versions
-
-3. Other Consent Types:
-   - Marketing communications preferences
-   - Age verification consent
-   - Custom consent types
-
-The endpoint performs the following operations:
-- Creates or retrieves subject records
-- Validates domain and policy information
-- Creates consent records with audit trails
-- Records consent purposes and preferences
-- Generates audit logs for compliance
-
-Use this endpoint to record user consent and maintain a compliant consent management system.`,
-    tags: [
-        'consent',
-        'cookie-banner'
-    ]
-}).errors({
-    INPUT_VALIDATION_FAILED: {
-        status: 422,
-        data: z.object({
-            formErrors: z.array(z.string()),
-            fieldErrors: z.record(z.string(), z.array(z.string()))
-        }),
-        error: 'Invalid input parameters'
-    },
-    SUBJECT_CREATION_FAILED: {
-        status: 400,
-        data: z.object({
-            subjectId: z.string().optional(),
-            externalSubjectId: z.string().optional()
-        }),
-        error: 'Failed to create or find subject'
-    },
-    DOMAIN_CREATION_FAILED: {
-        status: 500,
-        data: z.object({
-            domain: z.string()
-        }),
-        error: 'Failed to create or find domain'
-    },
-    POLICY_NOT_FOUND: {
-        status: 404,
-        data: z.object({
-            policyId: z.string(),
-            type: z.string()
-        }),
-        error: 'Policy not found'
-    },
-    POLICY_INACTIVE: {
-        status: 409,
-        data: z.object({
-            policyId: z.string(),
-            type: z.string()
-        }),
-        error: 'Policy is not active'
-    },
-    POLICY_CREATION_FAILED: {
-        status: 500,
-        data: z.object({
-            type: z.string()
-        }),
-        error: 'Failed to create or find policy'
-    },
-    PURPOSE_CREATION_FAILED: {
-        status: 500,
-        data: z.object({
-            purposeCode: z.string()
-        }),
-        error: 'Failed to create consent purpose'
-    },
-    CONSENT_CREATION_FAILED: {
-        status: 500,
-        data: z.object({
-            subjectId: z.string(),
-            domain: z.string()
-        }),
-        error: 'Failed to create consent record'
-    }
-}).input(z.discriminatedUnion('type', [
-    cookieBannerSchema,
-    policyBasedSchema,
-    otherConsentSchema
-])).output(z.object({
-    id: z.string(),
-    subjectId: z.string().optional(),
-    externalSubjectId: z.string().optional(),
-    domainId: z.string(),
-    domain: z.string(),
-    type: PolicyTypeSchema,
-    status: z.string(),
-    recordId: z.string(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-    givenAt: z.date()
-}));
-const branding = [
-    'c15t',
-    'consent',
-    'none'
-];
-const JurisdictionCodeSchema = z["enum"]([
-    'GDPR',
-    'CH',
-    'BR',
-    'PIPEDA',
-    'AU',
-    'APPI',
-    'PIPA',
-    'NONE'
-]);
-const JurisdictionInfoSchema = z.object({
-    code: JurisdictionCodeSchema,
-    message: z.string()
-});
-const TitleDescriptionSchema = z.object({
-    title: z.string(),
-    description: z.string()
-});
-const CompleteTranslationsSchema = z.object({
-    common: z.object({
-        acceptAll: z.string(),
-        rejectAll: z.string(),
-        customize: z.string(),
-        save: z.string()
-    }),
-    cookieBanner: TitleDescriptionSchema,
-    consentManagerDialog: TitleDescriptionSchema,
-    consentTypes: z.object({
-        experience: TitleDescriptionSchema,
-        functionality: TitleDescriptionSchema,
-        marketing: TitleDescriptionSchema,
-        measurement: TitleDescriptionSchema,
-        necessary: TitleDescriptionSchema
-    }),
-    frame: z.object({
-        title: z.string(),
-        actionButton: z.string()
-    }),
-    legalLinks: z.object({
-        privacyPolicy: z.string(),
-        termsOfService: z.string(),
-        cookiePolicy: z.string()
-    })
-});
-const PartialTranslationsSchema = z.object({
-    common: z.object({
-        acceptAll: z.string().optional(),
-        rejectAll: z.string().optional(),
-        customize: z.string().optional(),
-        save: z.string().optional()
-    }).partial(),
-    cookieBanner: TitleDescriptionSchema.partial(),
-    consentManagerDialog: TitleDescriptionSchema.partial(),
-    consentTypes: z.object({
-        experience: TitleDescriptionSchema.partial(),
-        functionality: TitleDescriptionSchema.partial(),
-        marketing: TitleDescriptionSchema.partial(),
-        measurement: TitleDescriptionSchema.partial(),
-        necessary: TitleDescriptionSchema.partial()
-    }).partial(),
-    frame: z.object({
-        title: z.string().optional(),
-        actionButton: z.string().optional()
-    }).partial().optional(),
-    legalLinks: z.object({
-        privacyPolicy: z.string().optional(),
-        termsOfService: z.string().optional(),
-        cookiePolicy: z.string().optional()
-    }).partial().optional()
-});
-const TranslationsSchema = z.union([
-    CompleteTranslationsSchema,
-    PartialTranslationsSchema
-]);
-const showConsentBannerContract = oc.route({
-    method: 'GET',
-    path: '/show-consent-banner',
-    description: `Determines if a user should see a consent banner based on their location and applicable privacy regulations.
-This endpoint performs the following checks:
-
-1. Detects the user's location using various header information:
-   - Cloudflare country headers
-   - Vercel IP country headers
-   - AWS CloudFront headers
-   - Custom country code headers
-
-2. Determines the applicable jurisdiction based on the location:
-   - GDPR (EU/EEA/UK)
-   - Swiss Data Protection Act
-   - LGPD (Brazil)
-   - PIPEDA (Canada)
-   - Australian Privacy Principles
-   - APPI (Japan)
-   - PIPA (South Korea)
-
-3. Returns detailed information about:
-   - Whether to show the consent banner
-   - The applicable jurisdiction and its requirements
-   - The user's detected location (country and region)
-
-Use this endpoint to implement geo-targeted consent banners and ensure compliance with regional privacy regulations.`,
-    tags: [
-        'cookie-banner'
-    ]
-}).output(z.object({
-    showConsentBanner: z.boolean(),
-    jurisdiction: JurisdictionInfoSchema,
-    location: z.object({
-        countryCode: z.string().nullable(),
-        regionCode: z.string().nullable()
-    }),
-    translations: z.object({
-        language: z.string(),
-        translations: TranslationsSchema
-    }),
-    branding: z["enum"](branding)
-}));
-const verifyConsentInputSchema = z.strictObject({
-    subjectId: z.string().optional(),
-    externalSubjectId: z.string().optional(),
-    domain: z.string(),
-    type: PolicyTypeSchema,
-    policyId: z.string().optional(),
-    preferences: z.array(z.string()).optional()
-});
-const verify_contract_consentSchema = z.looseObject({
-    id: z.string(),
-    purposeIds: z.array(z.string())
-});
-const verifyConsentContract = oc.route({
-    method: 'POST',
-    path: '/consent/verify',
-    description: `Verifies if a user has given valid consent for a specific policy and domain.
-This endpoint performs comprehensive consent verification by:
-
-1. Validating the subject's identity (using subjectId or externalSubjectId)
-2. Verifying the domain's existence and validity
-3. Checking if the specified policy exists and is active
-4. Validating that all required purposes have been consented to
-5. Ensuring the consent record is current and valid
-
-The endpoint supports different types of consent verification:
-- Cookie banner consent verification
-- Privacy policy consent verification
-- Terms and conditions verification
-- Marketing communications consent verification
-- Age verification
-- Custom consent types
-
-Use this endpoint to ensure compliance with privacy regulations and to verify user consent before processing personal data.`,
-    tags: [
-        'consent'
-    ]
-}).errors({
-    INPUT_VALIDATION_FAILED: {
-        status: 422,
-        data: z.object({
-            formErrors: z.array(z.string()),
-            fieldErrors: z.record(z.string(), z.array(z.string()).optional())
-        }),
-        error: 'Invalid input parameters'
-    },
-    SUBJECT_NOT_FOUND: {
-        status: 404,
-        data: z.object({
-            subjectId: z.string().optional(),
-            externalSubjectId: z.string().optional()
-        }),
-        error: 'Subject not found'
-    },
-    DOMAIN_NOT_FOUND: {
-        status: 404,
-        data: z.object({
-            domain: z.string()
-        }),
-        error: 'Domain not found'
-    },
-    POLICY_NOT_FOUND: {
-        status: 404,
-        data: z.object({
-            policyId: z.string(),
-            type: z.string()
-        }),
-        error: 'Policy not found or invalid'
-    },
-    PURPOSES_NOT_FOUND: {
-        status: 404,
-        data: z.object({
-            preferences: z.array(z.string()),
-            foundPurposes: z.array(z.string())
-        }),
-        error: 'Could not find all specified purposes'
-    },
-    COOKIE_BANNER_PREFERENCES_REQUIRED: {
-        status: 400,
-        data: z.object({
-            type: z.literal('cookie_banner')
-        }),
-        error: 'Preferences are required for cookie banner consent'
-    },
-    NO_CONSENT_FOUND: {
-        status: 404,
-        data: z.object({
-            policyId: z.string(),
-            subjectId: z.string(),
-            domainId: z.string()
-        }),
-        error: 'No consent found for the given policy'
-    }
-}).input(verifyConsentInputSchema).output(z.object({
-    isValid: z.boolean(),
-    reasons: z.array(z.string()).optional(),
-    consent: verify_contract_consentSchema.optional()
-}));
-const consentContracts = {
-    post: postConsentContract,
-    showBanner: showConsentBannerContract,
-    verify: verifyConsentContract,
-    identify: identifyUserContract
-};
-const statusContract = oc.route({
-    method: 'GET',
-    path: '/status',
-    description: `Returns the current operational status and health metrics of the service.
-This endpoint provides real-time information about:
-- Overall service status (ok/error)
-- Current API version
-- Server timestamp
-- Storage system status and availability
-- Client information (IP, User Agent, Region)
-
-Use this endpoint for health checks, monitoring, and service status verification.`,
-    tags: [
-        'meta'
-    ]
-}).output(z.object({
-    status: z["enum"]([
-        'ok',
-        'error'
-    ]),
-    version: z.string(),
-    timestamp: z.date(),
-    storage: z.object({
-        type: z.string(),
-        available: z.boolean()
-    }),
-    client: z.object({
-        ip: z.string().nullable(),
-        userAgent: z.string().nullable(),
-        region: z.object({
-            countryCode: z.string().nullable(),
-            regionCode: z.string().nullable()
-        })
-    })
-}));
-const metaContracts = {
-    status: statusContract
-};
-const contracts_config = {
-    consent: consentContracts,
-    meta: metaContracts
-};
-const os = implement(contracts_config);
-export { contracts_config as contracts, os };

package/dist/handlers/consent/identify.handler.d.ts

@@ -1,23 +0,0 @@
-export declare const identifyUser: import("@orpc/server").ImplementedProcedure<Record<never, never>, Record<never, never>, import("zod").ZodObject<{
-    consentId: import("zod").ZodString;
-    externalId: import("zod").ZodString;
-    identityProvider: import("zod").ZodOptional<import("zod").ZodString>;
-}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-    success: import("zod").ZodBoolean;
-}, import("zod/v4/core").$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
-    CONSENT_NOT_FOUND: {
-        status: number;
-        data: import("zod").ZodObject<{
-            consentId: import("zod").ZodString;
-        }, import("zod/v4/core").$strip>;
-        error: string;
-    };
-    IDENTIFICATION_FAILED: {
-        status: number;
-        data: import("zod").ZodObject<{
-            consentId: import("zod").ZodString;
-        }, import("zod/v4/core").$strip>;
-        error: string;
-    };
-}>, Record<never, never>>;
-//# sourceMappingURL=identify.handler.d.ts.map

package/dist/handlers/consent/identify.handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"identify.handler.d.ts","sourceRoot":"","sources":["../../../src/handlers/consent/identify.handler.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;yBA0KxB,CAAC"}

package/dist/handlers/consent/identify.handler.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=identify.handler.test.d.ts.map

package/dist/handlers/consent/identify.handler.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"identify.handler.test.d.ts","sourceRoot":"","sources":["../../../src/handlers/consent/identify.handler.test.ts"],"names":[],"mappings":""}