Package Exports

@c15t/backend
@c15t/backend/integrations
@c15t/backend/integrations/next
@c15t/backend/pkgs/data-model
@c15t/backend/pkgs/data-model/fields
@c15t/backend/pkgs/data-model/schema
@c15t/backend/pkgs/db-adapters
@c15t/backend/pkgs/db-adapters/adapters/drizzle-adapter
@c15t/backend/pkgs/db-adapters/adapters/kysely-adapter
@c15t/backend/pkgs/db-adapters/adapters/memory-adapter
@c15t/backend/pkgs/db-adapters/adapters/prisma-adapter
@c15t/backend/pkgs/logger
@c15t/backend/pkgs/migrations
@c15t/backend/pkgs/results
@c15t/backend/pkgs/types
@c15t/backend/schema

Readme

C15T Backend

A robust consent management system backend that provides flexible database adapters, comprehensive audit logging, and a powerful plugin system.

Features

Database Adapters

Memory Adapter: In-memory storage for development and testing
Kysely Adapter: Type-safe SQL query builder with support for multiple databases
Prisma Adapter: Integration with Prisma ORM
Drizzle Adapter: Integration with Drizzle ORM

Core Functionality

Consent Management: Track and manage user consent preferences
Audit Logging: Comprehensive logging of all consent-related actions
Geo-location Support: Track user locations for compliance
Domain Management: Handle multiple domains and subdomains
Policy Management: Version and manage consent policies

API Endpoints

/api/c15t/status: System status and configuration
/api/c15t/consent: Consent management endpoints
/api/c15t/policy: Policy management endpoints
/api/c15t/audit: Audit log access
/api/c15t/domain: Domain management
/api/c15t/geo-location: Geo-location tracking

Getting Started

Installation

npm install @c15t/backend

Basic Usage

import { c15tInstance } from '@c15t/backend';
import { memoryAdapter } from '@c15t/backend/db/adapters/memory';

const instance = c15tInstance({
  baseURL: 'http://localhost:3000',
  database: memoryAdapter({}),
});

// Handle requests
const response = await instance.handler(request);

Database Configuration

// Using Kysely adapter
import { kyselyAdapter } from '@c15t/backend/db/adapters/kysely';

const instance = c15tInstance({
  baseURL: 'http://localhost:3000',
  database: kyselyAdapter({
    dialect: 'postgres',
    connection: {
      host: 'localhost',
      port: 5432,
      database: 'c15t',
      user: 'postgres',
      password: 'password',
    },
  }),
});

Plugin System

const customPlugin = {
  id: 'custom-plugin',
  name: 'Custom Plugin',
  type: 'test',
  init: () => ({
    context: {
      customField: 'value',
    },
  }),
  onRequest: async (request, ctx) => {
    // Modify request
    return { request: modifiedRequest };
  },
  onResponse: async (response, ctx) => {
    // Modify response
    return { response: modifiedResponse };
  },
};

const instance = c15tInstance({
  baseURL: 'http://localhost:3000',
  database: memoryAdapter({}),
  plugins: [customPlugin],
});

API Documentation

Core Instance

interface C15TInstance {
  options: C15TOptions;
  $context: Promise<Result<C15TContext, C15TError>>;
  handler: (request: Request) => Promise<Result<Response, C15TError>>;
  getApi: () => Promise<Result<Record<string, unknown>, C15TError>>;
}

Database Adapters

Each adapter provides a consistent interface for database operations:

interface DatabaseAdapter {
  create: <T extends Record<string, unknown>>(table: string, data: T) => Promise<T>;
  find: <T extends Record<string, unknown>>(table: string, query: Query) => Promise<T[]>;
  update: <T extends Record<string, unknown>>(table: string, query: Query, data: Partial<T>) => Promise<T>;
  delete: (table: string, query: Query) => Promise<void>;
}

Plugin System

Plugins can extend the system's functionality:

interface C15TPlugin {
  id: string;
  name: string;
  type: string;
  init?: () => Promise<{ context: Record<string, unknown> }>;
  onRequest?: (request: Request, ctx: C15TContext) => Promise<{ request: Request } | { response: Response } | undefined>;
  onResponse?: (response: Response, ctx: C15TContext) => Promise<{ response: Response } | undefined>;
}

Error Handling

The system uses a Result type for error handling:

type Result<T, E> = { isOk: true; value: T } | { isOk: false; error: E };

Security Features

Origin validation for CORS
Request validation
Audit logging
Secure ID generation
Input sanitization

Contributing

Fork the repository
Create your feature branch
Commit your changes
Push to the branch
Create a new Pull Request