@c15t/backend 0.0.1-rc.10

package/.turbo/turbo-build.log

@@ -0,0 +1,11 @@
+
+
+> @c15t/backend@0.0.1-rc.10 build /Users/christopherburns/glados/k/c15t/packages/backend
+> rslib build
+
+  Rslib v0.5.3
+
+ready   built in 0.69 s (esm)
+ready   built in 0.69 s (cjs)
+start   Generating DTS... (esm)
+start   Generating DTS... (cjs)

package/.turbo/turbo-check-types.log

@@ -0,0 +1,5 @@
+
+
+> @c15t/backend@0.0.1-rc.10 check-types /Users/christopherburns/glados/k/c15t/packages/backend
+> tsc --noEmit
+

package/.turbo/turbo-fmt.log

@@ -0,0 +1,7 @@
+
+
+> @c15t/backend@0.0.1-rc.10 fmt /Users/christopherburns/glados/k/c15t/packages/backend
+> pnpm biome format --write . && biome check --formatter-enabled=false --linter-enabled=false --organize-imports-enabled=true --write
+
+Formatted 164 files in 40ms. No fixes applied.
+Checked 194 files in 32ms. Fixed 3 files.

package/.turbo/turbo-lint.log

@@ -0,0 +1,6 @@
+
+
+> @c15t/backend@0.0.1-rc.10 lint /Users/christopherburns/glados/k/c15t/packages/backend
+> pnpm biome lint ./src
+
+Checked 160 files in 59ms. No fixes applied.

package/.turbo/turbo-test.log

@@ -0,0 +1,26 @@
+
+
+> @c15t/backend@0.0.1-rc.10 test /Users/christopherburns/glados/k/c15t/packages/backend
+> vitest
+
+[?25l
+ DEV  v3.0.8 /Users/christopherburns/glados/k/c15t/packages/backend
+
+[?2026h
+ ❯ src/api/routes/__tests__/status.test.ts [queued]
+
+ Test Files 0 passed (4)
+      Tests 0 passed (0)
+   Start at 13:42:20
+   Duration 204ms
+[?2026l[?2026h ✓ src/api/routes/__tests__/status.test.ts (2 tests) 16ms
+
+ ❯ src/api/routes/__tests__/consent.test.ts [queued]
+ ❯ src/core.test.ts [queued]
+ ❯ src/init.test.ts [queued]
+
+ Test Files 1 passed (4)
+      Tests 2 passed (2)
+   Start at 13:42:20
+   Duration 705ms
+[?2026l[?25h ELIFECYCLE  Test failed. See above for more details.

package/README-next.md

@@ -0,0 +1,223 @@
+# c15t Next.js Integration
+
+This guide shows how to integrate c15t into your Next.js application for consent management.
+
+## Quick Start
+
+Follow these steps to add c15t to your Next.js project:
+
+1. Install the c15t package:
+   ```bash
+   npm install @c15t/backend
+   # or
+   yarn add @c15t/backend
+   # or
+   pnpm add @c15t/backend
+   ```
+
+2. Create a shared c15t instance:
+   ```typescript
+   // lib/c15t.ts
+   import { c15tInstance } from '@c15t/backend';
+   import { memoryAdapter } from '@c15t/backend/storage/memory';
+   
+   export const C15TInstance = c15tInstance({
+     appName: 'My Next.js App',
+     trustedOrigins: ['http://localhost:3000'],
+     storage: memoryAdapter(), // Use a persistent adapter for production
+     consent: {
+       expiresIn: 60 * 60 * 24 * 365, // 1 year
+       updateAge: 60 * 60 * 24, // 24 hours
+     },
+   });
+   ```
+
+3. Create the API route handler:
+   ```typescript
+   // app/api/c15t/[...route]/route.ts
+   import { toNextJsHandler } from '@c15t/backend/integrations/next';
+   import { C15TInstance } from '@/lib/c15t';
+   
+   // Export all HTTP methods
+   export const { GET, POST, PUT, DELETE, OPTIONS } = toNextJsHandler(C15TInstance);
+   ```
+
+4. Create a React client for client components:
+   ```typescript
+   // lib/consent-client.ts
+   import { createConsentClient } from '@c15t/backend/integrations/react';
+   
+   export const consentClient = createConsentClient({
+     baseUrl: '/api/c15t',
+     refreshInterval: 60 * 1000, // Check every minute (optional)
+   });
+   
+   // Export hooks for use in components
+   export const { useConsent, useConditionalContent } = consentClient;
+   ```
+
+## Usage Examples
+
+### Client Components
+
+#### Consent Banner
+```tsx
+// components/ConsentBanner.tsx
+'use client';
+import { useConsent } from '@/lib/consent-client';
+
+export function ConsentBanner() {
+  const { isLoading, hasConsented, acceptAll, declineAll } = useConsent();
+  
+  if (isLoading || hasConsented) {
+    return null;
+  }
+  
+  return (
+    <div className="fixed bottom-0 left-0 right-0 bg-white p-4 shadow-lg">
+      <h3>Cookie Consent</h3>
+      <p>We use cookies to improve your experience.</p>
+      <div className="flex gap-2 mt-2">
+        <button onClick={() => acceptAll()}>Accept All</button>
+        <button onClick={() => declineAll()}>Decline All</button>
+      </div>
+    </div>
+  );
+}
+```
+
+#### Conditional Content
+```tsx
+// components/AnalyticsContent.tsx
+'use client';
+import { useConditionalContent } from '@/lib/consent-client';
+
+export function AnalyticsContent() {
+  const { isLoading, canShow } = useConditionalContent('analytics');
+  
+  if (isLoading) {
+    return <div>Loading...</div>;
+  }
+  
+  if (!canShow) {
+    return <div>Please accept analytics cookies to view this content.</div>;
+  }
+  
+  return <div>Analytics content visible!</div>;
+}
+```
+
+### Server Components and Actions
+
+#### Server Component with Consent Check
+```tsx
+// app/protected-content/page.tsx
+import { getServerConsent } from '@c15t/backend/integrations/server';
+import { headers } from 'next/headers';
+import { C15TInstance } from '@/lib/c15t';
+
+export default async function ProtectedPage() {
+  const consent = await getServerConsent(C15TInstance, { headers: headers() });
+  
+  if (!consent.consented) {
+    return (
+      <div>
+        <h1>Consent Required</h1>
+        <p>Please accept cookies to view this content.</p>
+      </div>
+    );
+  }
+  
+  // User has consented, show protected content
+  return (
+    <div>
+      <h1>Protected Content</h1>
+      <p>This content is only visible to users who have provided consent.</p>
+    </div>
+  );
+}
+```
+
+#### Server Action to Update Consent
+```tsx
+// app/actions.ts
+'use server'
+import { setServerConsent } from '@c15t/backend/integrations/server';
+import { cookies } from 'next/headers';
+import { C15TInstance } from '@/lib/c15t';
+
+export async function acceptAllCookies() {
+  return await setServerConsent(
+    C15TInstance,
+    { 
+      preferences: { analytics: true, marketing: true, preferences: true } 
+    },
+    { cookies: cookies() }
+  );
+}
+
+export async function rejectAllCookies() {
+  return await setServerConsent(
+    C15TInstance,
+    { 
+      preferences: { analytics: false, marketing: false, preferences: false } 
+    },
+    { cookies: cookies() }
+  );
+}
+```
+
+### Middleware for Consent Checking
+
+```typescript
+// middleware.ts
+import { NextResponse } from 'next/server';
+import { checkConsentCookie } from '@c15t/backend/integrations/next';
+
+export function middleware(request) {
+  // Check if user has provided consent
+  const hasConsent = checkConsentCookie(request);
+  
+  // For routes that require consent, redirect to consent page if not consented
+  if (!hasConsent && request.nextUrl.pathname.startsWith('/protected')) {
+    return NextResponse.redirect(new URL('/consent', request.url));
+  }
+  
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: ['/protected/:path*'],
+};
+```
+
+## Advanced Configuration
+
+### Custom Consent Preferences
+
+You can define custom consent categories beyond the standard ones:
+
+```typescript
+// lib/consent-client.ts
+import { createConsentClient } from '@c15t/backend/integrations/react';
+
+export const consentClient = createConsentClient({
+  defaultPreferences: {
+    analytics: true,
+    marketing: true,
+    preferences: true,
+    thirdParty: true, // Custom category
+    personalization: true, // Custom category
+  },
+});
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **API Route Not Found**: Make sure your route file is placed correctly at `app/api/c15t/[...route]/route.ts` or adjust your c15t configuration to match your route path.
+
+2. **Cookie Not Set**: Ensure your API calls include `credentials: 'same-origin'` to allow cookies to be set. For server actions, make sure you're using the `cookies()` helper.
+
+3. **CORS Issues**: If accessing the API from a different origin, configure the `trustedOrigins` in your c15t instance. 

package/README.md

@@ -0,0 +1,164 @@
+# 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
+
+```bash
+npm install @c15t/backend
+```
+
+### Basic Usage
+
+```typescript
+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
+
+```typescript
+// 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
+
+```typescript
+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
+
+```typescript
+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:
+
+```typescript
+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:
+
+```typescript
+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:
+
+```typescript
+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
+
+1. Fork the repository
+2. Create your feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a new Pull Request

package/dist/api/call.d.ts

@@ -0,0 +1,176 @@
+import type { C15TContext } from '../types';
+/**
+ * Middleware that provides access to the C15T context
+ *
+ * This middleware is used as a base for all endpoint handlers to provide
+ * access to the C15T context.
+ *
+ * @returns A Promise resolving to the C15T context
+ * @internal This is primarily meant for internal use by the C15T system
+ *
+ * @remarks
+ * This middleware serves as the foundation for context propagation throughout
+ * the consent management system. It's typically not used directly but is
+ * composed within other middleware and endpoint factories.
+ *
+ * @example
+ * ```typescript
+ * // This middleware is typically used internally by createAuthMiddleware and createAuthEndpoint
+ * const myMiddleware = createMiddleware.create({
+ *   use: [optionsMiddleware]
+ * });
+ * ```
+ */
+export declare const optionsMiddleware: <InputCtx extends import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>>(inputContext: InputCtx) => Promise<C15TContext>;
+/**
+ * Creates an authentication middleware with pre-configured context access
+ *
+ * This factory combines the options middleware with post-hook functionality,
+ * allowing handlers to modify responses by setting headers.
+ *
+ * @returns A configured middleware for authentication endpoints
+ * @throws May propagate errors from underlying middleware implementations
+ * @throws Errors from your middleware handler will be propagated unless explicitly caught
+ *
+ * @remarks
+ * The middleware created by this factory automatically receives the C15T context
+ * and manages response header manipulation. It's particularly useful for
+ * authentication, authorization, and other cross-cutting concerns.
+ *
+ * @example
+ * ```typescript
+ * // Create a custom authentication middleware
+ * const verifySubjectMiddleware = createAuthMiddleware(async (context) => {
+ *   const { subjectId } = context.params;
+ *
+ *   // Verify the subject exists
+ *   const subject = await getSubjectById(subjectId);
+ *   if (!subject) {
+ *     throw new APIError({
+ *       message: 'Subject not found',
+ *       status: 'NOT_FOUND'
+ *     });
+ *   }
+ *
+ *   // Add subject to context
+ *   return {
+ *     context: {
+ *       subject
+ *     }
+ *   };
+ * });
+ *
+ * // Apply the middleware to specific routes in router configuration
+ * router.use('/subjects/**', verifySubjectMiddleware);
+ * ```
+ */
+export declare const createAuthMiddleware: {
+    <Options extends import("better-call").MiddlewareOptions, R>(options: Options, handler: (ctx: import("better-call").MiddlewareContext<Options, {
+        returned?: unknown;
+        responseHeaders?: Headers;
+    } & import("../types").BaseC15TContext & Record<string, unknown>>) => Promise<R>): (inputContext: import("better-call").MiddlewareInputContext<Options>) => Promise<R>;
+    <Options extends import("better-call").MiddlewareOptions, R_1>(handler: (ctx: import("better-call").MiddlewareContext<Options, {
+        returned?: unknown;
+        responseHeaders?: Headers;
+    } & import("../types").BaseC15TContext & Record<string, unknown>>) => Promise<R_1>): (inputContext: import("better-call").MiddlewareInputContext<Options>) => Promise<R_1>;
+};
+/**
+ * Creates an authentication endpoint with pre-configured context access
+ *
+ * This factory provides a standardized way to create endpoints with access
+ * to the C15T context.
+ *
+ * @returns A configured endpoint creator for authentication endpoints
+ * @throws May propagate errors from endpoint handler implementations
+ * @throws Any uncaught errors in the endpoint handler will be propagated through the system
+ *
+ * @remarks
+ * Endpoints created with this factory are automatically configured with
+ * the C15T context, making them ideal for building consent management APIs.
+ * These endpoints can be used in route configurations or with the toEndpoints
+ * function for automatic API generation.
+ *
+ * @example
+ * ```typescript
+ * // Create a consent status endpoint
+ * export const getConsentStatus = createAuthEndpoint(async (context) => {
+ *   const { subjectId, domain } = context.params;
+ *
+ *   // Get consent status from storage
+ *   const status = await context.context.storage.getConsentStatus(subjectId, domain);
+ *
+ *   return {
+ *     subjectId,
+ *     domain,
+ *     hasConsented: status.consented,
+ *     purposes: status.purposes,
+ *     updatedAt: status.timestamp
+ *   };
+ * });
+ *
+ * // Create a consent update endpoint with error handling
+ * export const updateConsent = createAuthEndpoint(async (context) => {
+ *   const { subjectId, domain, purposes } = context.params;
+ *
+ *   try {
+ *     // Update consent status in storage
+ *     await context.context.storage.updateConsentStatus(subjectId, domain, {
+ *       consented: true,
+ *       purposes,
+ *       timestamp: new Date().toISOString()
+ *     });
+ *
+ *     return { success: true, subjectId, domain };
+ *   } catch (error) {
+ *     throw new APIError({
+ *       message: 'Failed to update consent status',
+ *       status: 'INTERNAL_SERVER_ERROR',
+ *       cause: error
+ *     });
+ *   }
+ * });
+ * ```
+ */
+export declare const createAuthEndpoint: <Path extends string, Opts extends import("better-call").EndpointOptions, R>(path: Path, options: Opts, handler: (ctx: import("better-call").EndpointContext<Path, Opts, import("../types").BaseC15TContext & Record<string, unknown>>) => Promise<R>) => {
+    <C extends import("better-call").HasRequiredKeys<import("better-call").InputContext<Path, Opts & {
+        use: any[];
+    }>> extends true ? [import("better-call").InputContext<Path, Opts & {
+        use: any[];
+    }>] : [(import("better-call").InputContext<Path, Opts & {
+        use: any[];
+    }> | undefined)?]>(...inputCtx: C): Promise<C extends [{
+        asResponse: true;
+    }] ? Response : C extends [{
+        returnHeaders: true;
+    }] ? {
+        headers: Headers;
+        response: R;
+    } : R>;
+    options: Opts & {
+        use: any[];
+    };
+    path: Path;
+};
+/**
+ * Type definition for a C15T endpoint handler
+ *
+ * Represents the function signature returned by createAuthEndpoint.
+ * Used for type checking when building API endpoints.
+ *
+ * @remarks
+ * This type is used extensively in the toEndpoints function and
+ * when defining route handlers for the consent management system.
+ */
+export type C15TEndpoint = ReturnType<typeof createAuthEndpoint>;
+/**
+ * Type definition for a C15T middleware handler
+ *
+ * Represents the function signature returned by createAuthMiddleware.
+ * Used for type checking when building middleware chains.
+ *
+ * @remarks
+ * This type is used when defining hooks and custom middleware
+ * for the consent management system pipeline.
+ */
+export type C15TMiddleware = ReturnType<typeof createAuthMiddleware>;
+//# sourceMappingURL=call.d.ts.map

package/dist/api/call.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call.d.ts","sourceRoot":"","sources":["../../src/api/call.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,0JAQ5B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,oBAAoB;;mBASlB,OAAO;0BACA,OAAO;;;mBADd,OAAO;0BACA,OAAO;;CAI3B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;CAE7B,CAAC;AAEH;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEjE;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC"}