@c15t/backend 1.0.5 → 1.2.0-canary.0

package/dist/routes/status.d.ts

@@ -1,44 +0,0 @@
-/**
- * Response type for the status endpoint
- * @public
- */
-export interface StatusResponse {
-    status: 'ok' | 'error';
-    version: string;
-    timestamp: string;
-    storage: {
-        type: string;
-        available: boolean;
-    };
-}
-/**
- * Status endpoint that returns information about the c15t instance.
- *
- * This endpoint provides basic operational information about the c15t instance,
- * including its version, current timestamp, and storage adapter configuration.
- * It can be used for:
- * - Health checks to verify the API is operational
- * - Version verification
- * - Storage adapter verification
- * - Retrieving configuration information about the consent system
- *
- * The endpoint does not require authentication and is accessible via a GET request.
- *
- * @endpoint GET /status
- * @responseExample
- * ```json
- * {
- *   "status": "ok",
- *   "version": "1.0.0",
- *   "timestamp": "2023-04-01T12:34:56.789Z",
- *   "storage": {
- *     "type": "MemoryAdapter",
- *     "available": true
- *   }
- * }
- * ```
- */
-export declare const status: import("./types").Route & {
-    responseType: StatusResponse;
-};
-//# sourceMappingURL=status.d.ts.map

package/dist/routes/status.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/routes/status.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B,MAAM,EAAE,IAAI,GAAG,OAAO,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,OAAO,CAAC;KACnB,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,MAAM;;CAgBjB,CAAC"}

package/dist/routes/types.d.ts

@@ -1,7 +0,0 @@
-import type { EventHandler, RouterMethod } from 'h3';
-export type Route = {
-    path: string;
-    method: RouterMethod;
-    handler: EventHandler;
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/routes/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/routes/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,IAAI,CAAC;AAErD,MAAM,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,YAAY,CAAC;CACtB,CAAC"}

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

@@ -1,38 +0,0 @@
-import { z } from 'zod';
-interface Consent {
-    id: string;
-    purposeIds: string[];
-    [key: string]: unknown;
-}
-export interface VerifyConsentResponse {
-    isValid: boolean;
-    reasons?: string[];
-    consent?: Consent;
-}
-export declare const VerifyConsentRequestBody: z.ZodObject<{
-    subjectId: z.ZodOptional<z.ZodString>;
-    externalSubjectId: z.ZodOptional<z.ZodString>;
-    domain: z.ZodString;
-    type: z.ZodEnum<["cookie_banner", "privacy_policy", "dpa", "terms_and_conditions", "marketing_communications", "age_verification", "other"]>;
-    policyId: z.ZodOptional<z.ZodString>;
-    preferences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
-    domain: string;
-    subjectId?: string | undefined;
-    policyId?: string | undefined;
-    externalSubjectId?: string | undefined;
-    preferences?: string[] | undefined;
-}, {
-    type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
-    domain: string;
-    subjectId?: string | undefined;
-    policyId?: string | undefined;
-    externalSubjectId?: string | undefined;
-    preferences?: string[] | undefined;
-}>;
-export declare const verifyConsent: import("./types").Route & {
-    responseType: VerifyConsentResponse;
-};
-export {};
-//# sourceMappingURL=verify-consent.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"verify-consent.d.ts","sourceRoot":"","sources":["../../src/routes/verify-consent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,UAAU,OAAO;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,qBAAqB;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;EAOnC,CAAC;AAEH,eAAO,MAAM,aAAa;;CAyGxB,CAAC"}

package/src/docs/ADVANCED_JSON_HANDLING.md

@@ -1,99 +0,0 @@
-# Advanced JSON and Date Handling in C15T
-
-C15T provides intelligent, database-specific handling for JSON data and date/time values to ensure maximum compatibility and performance across different database systems. This document explains how data is stored and accessed in different database environments.
-
-## SuperJSON Integration
-
-C15T uses [SuperJSON](https://github.com/blitz-js/superjson) to enhance JSON serialization for complex JavaScript types that aren't natively supported by JSON, such as:
-
-- `Date` objects with timezone information
-- JavaScript `Map` and `Set` objects
-- `BigInt` values
-- `undefined` values
-- Custom class instances
-- And more
-
-## Database-Specific Behavior
-
-### PostgreSQL
-
-PostgreSQL has excellent native support for both JSON and timestamps with timezone:
-
-- **JSON fields**: Uses native JSONB type for most JSON data, with SuperJSON only applied when needed for complex JS types
-- **Date fields**: Uses native TIMESTAMPTZ which properly preserves timezone information
-- **Benefits**: Offers high performance and the ability to perform JSON path queries directly in the database
-
-### MySQL
-
-MySQL has native JSON support but more limited date/timezone handling:
-
-- **JSON fields**: Uses native JSON type with SuperJSON selectively applied for complex types
-- **Date fields**: Uses consistent timezone handling to ensure predictable behavior
-- **Benefits**: Provides good balance between native database features and JavaScript type support
-
-### SQLite
-
-SQLite has no native JSON or timezone-aware date types:
-
-- **JSON fields**: Always uses SuperJSON format stored as TEXT to preserve all JavaScript types
-- **Date fields**: Uses special handling to maintain timezone information
-- **Benefits**: Maintains complete JavaScript data structures even with SQLite's simpler type system
-
-## Implications for Your Application
-
-### Accessing Data Outside C15T
-
-When accessing data stored by C15T from outside the library (e.g., direct database queries), be aware:
-
-- **PostgreSQL data**: Most fields can be accessed directly without special handling
-- **MySQL data**: Complex values might be in SuperJSON format (look for `{"json":..., "meta":...}` structure)
-- **SQLite data**: All JSON and date fields will be in SuperJSON format and require parsing
-
-To parse SuperJSON data outside of C15T:
-
-```javascript
-// If using SuperJSON
-const data = superjson.parse(valueFromDatabase);
-
-// Without SuperJSON, you can manually extract the data
-const parsed = JSON.parse(valueFromDatabase);
-const actualData = parsed.json; // The actual data is in the 'json' property
-```
-
-### Best Practices
-
-1. **Use C15T's API** when possible to abstract away database differences
-2. **Document data format** if you expect other systems to access the database directly
-3. **Consider database requirements** when designing systems that need to use multiple database types
-4. **Test across databases** if your application needs to support multiple database types
-
-## Configuration
-
-The database-specific handling is applied automatically based on your database configuration when you initialize C15T.
-
-If needed, you can manually set the database type:
-
-```typescript
-import { setDatabaseType } from '@c15t/backend/db/core/fields/superjson-utils';
-
-// Must be called before using any field operations
-setDatabaseType('sqlite'); // or 'postgresql', 'mysql'
-```
-
-## Extending SuperJSON
-
-If you need to support additional custom types with SuperJSON, you can register them:
-
-```typescript
-import superjson from 'superjson';
-
-// Register a custom type
-superjson.registerCustom<MyCustomType, string>(
-  // isMyType check
-  (v) => v instanceof MyCustomType,
-  // serialize
-  (v) => v.toString(),
-  // deserialize
-  (v) => new MyCustomType(v)
-);
-``` 

package/src/docs/neverthrow.md

@@ -1,171 +0,0 @@
-# Using neverthrow in c15t
-
-## Overview
-
-The c15t library now supports a functional approach to error handling using the [neverthrow](https://github.com/supermacro/neverthrow) library. This approach provides several benefits:
-
-- More explicit error handling with the `Result` type
-- Better type safety and compile-time checks for error cases
-- Ability to chain operations with proper error propagation
-- No need for try/catch blocks or exception handling
-- Clearer and more predictable code flow
-
-This document explains how to use the neverthrow `Result` pattern with c15t.
-
-## Basic Concepts
-
-The core concept of neverthrow is the `Result` type, which represents either:
-
-- A successful operation (`Ok` variant) containing a value, or
-- A failed operation (`Err` variant) containing an error
-
-Instead of throwing exceptions, functions return a `Result` that must be handled explicitly.
-
-### Result vs Traditional Error Handling
-
-Traditional approach:
-```typescript
-try {
-  const context = await init(options);
-  // Use context...
-} catch (error) {
-  // Handle errors...
-}
-```
-
-neverthrow approach:
-```typescript
-const contextResult = await init(options);
-contextResult.match({
-  ok: (context) => {
-    // Use context...
-  },
-  err: (error) => {
-    // Handle errors...
-  }
-});
-```
-
-## Using c15t with neverthrow
-
-### Initialization
-
-The c15t library provides two versions of most core functions:
-
-1. Traditional functions that might throw exceptions (for backward compatibility)
-2. New functions with the `WithResult` suffix that return `Result` objects
-
-```typescript
-import { c15tWithResult } from '@c15t/backend';
-import { memoryAdapter } from '@c15t/backend/db/adapters/memory';
-
-// Create a c15t instance with Result-based error handling
-const c15tInstance = c15tWithResult({
-  secret: 'your-secret-key',
-  storage: memoryAdapter(),
-});
-
-// The context is now a ResultAsync
-c15tInstance.$context.match({
-  ok: (context) => {
-    console.log(`Initialized ${context.appName} successfully`);
-  },
-  err: (error) => {
-    console.error(`Initialization failed: ${error.message}`);
-  }
-});
-```
-
-### Request Handling
-
-The Result-based instance provides both traditional and Result-based handlers:
-
-```typescript
-// Traditional approach (might throw)
-app.use('/api/c15t', async (req, res) => {
-  try {
-    const response = await c15tInstance.handler(request);
-    // Handle response...
-  } catch (error) {
-    // Handle error...
-  }
-});
-
-// Result-based approach
-app.use('/api/c15t', async (req, res) => {
-  const requestResult = await c15tInstance.handlerWithResult(request);
-  
-  requestResult.match({
-    ok: (response) => {
-      // Handle successful response...
-    },
-    err: (error) => {
-      // Handle error with structured data...
-    }
-  });
-});
-```
-
-### Error Types
-
-All errors are instances of `C15TError` with properties:
-
-- `message`: Human-readable error message
-- `code`: Error code from `BASE_ERROR_CODES`
-- `status`: HTTP status code when applicable
-- `data`: Additional error data
-
-### Chaining Operations
-
-One of the major benefits of the neverthrow approach is the ability to chain operations with proper error handling:
-
-```typescript
-c15tInstance.$context
-  .andThen(context => {
-    // Use context to perform another operation
-    return c15tInstance.handlerWithResult(request);
-  })
-  .map(response => {
-    // Transform successful response
-    return response.json();
-  })
-  .mapErr(error => {
-    // Transform or enrich error
-    console.error(`Error: ${error.message}`);
-    return error;
-  });
-```
-
-### Combining with Promises
-
-You can convert between Results and Promises:
-
-```typescript
-import { toPromise, fromC15TPromise } from '@c15t/backend/utils';
-
-// Convert Result to Promise (might throw)
-const contextPromise = toPromise(c15tInstance.$context);
-
-// Convert Promise to Result
-const resultFromPromise = fromC15TPromise(somePromise);
-```
-
-## Complete Example
-
-See the complete example at `packages/c15t/src/examples/neverthrow-example.ts`.
-
-## Best Practices
-
-1. **Be explicit about errors**: Use the `match` method to handle both success and error cases explicitly.
-
-2. **Chain operations**: Use `andThen`, `map`, and `mapErr` to chain operations and transformations.
-
-3. **Type your errors**: Make use of error codes to handle specific error conditions.
-
-4. **Avoid mixing patterns**: Stick to either the Result pattern or traditional try/catch within a single function.
-
-5. **Convert at boundaries**: Use conversion utilities when interacting with code that doesn't use the Result pattern.
-
-## Backward Compatibility
-
-The c15t library maintains backward compatibility with the traditional error handling approach. You can continue using the existing API, or gradually migrate to the Result pattern. 

package/src/index.ts

@@ -1,34 +0,0 @@
-/**
- * c15t Consent Management System
- *
- * This is the main entry point for the c15t library, exporting all public APIs,
- * components, and types needed to implement consent management in your application.
- */
-
-//------------------------------------------------------------------------------
-// Core API
-//------------------------------------------------------------------------------
-export { c15tInstance, type C15TInstance } from './core';
-
-//------------------------------------------------------------------------------
-// Types
-//------------------------------------------------------------------------------
-export * as Types from './pkgs/types';
-
-export type {
-	C15TContext,
-	C15TOptions,
-	C15TPlugin,
-	InferPluginContexts,
-	ApiPathBase,
-	ApiPath,
-} from './types';
-
-// Export all the response types to make them available for client applications
-export type {
-	SetConsentResponse,
-	ShowConsentBannerResponse,
-	VerifyConsentResponse,
-	SetConsentRequestBody,
-	VerifyConsentRequestBody,
-} from './response-types';

package/src/init.test.ts

@@ -1,219 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import type { DatabaseConfiguration } from '~/pkgs/db-adapters/adapters/kysely-adapter/types';
-import { memoryAdapter } from '~/pkgs/db-adapters/adapters/memory-adapter';
-import type { C15TPlugin } from '~/types';
-import { init } from './init';
-
-describe('init', () => {
-	beforeEach(() => {
-		vi.unstubAllEnvs();
-	});
-
-	it('should initialize with basic config', async () => {
-		const result = await init({
-			baseURL: 'http://localhost:3000',
-			appName: 'c15t Consent Manager',
-			database: memoryAdapter({}),
-		});
-
-		expect(result.isOk()).toBe(true);
-		if (result.isOk()) {
-			const ctx = result.value;
-			expect(ctx.options.baseURL).toBe('http://localhost:3000');
-			expect(ctx.options.basePath).toBe('/api/c15t');
-			expect(ctx.appName).toBe('c15t Consent Manager');
-		}
-	});
-
-	it('should infer base URL from environment', async () => {
-		vi.stubEnv('C15T_URL', 'http://localhost:5147');
-
-		const result = await init({
-			database: memoryAdapter({}),
-		});
-
-		expect(result.isOk()).toBe(true);
-		if (result.isOk()) {
-			const ctx = result.value;
-			expect(ctx.options.baseURL).toBe('http://localhost:5147');
-		}
-
-		vi.unstubAllEnvs();
-	});
-
-	it('should respect custom base path', async () => {
-		const result = await init({
-			baseURL: 'http://localhost:3000',
-			basePath: '/custom-path',
-			database: memoryAdapter({}),
-		});
-
-		expect(result.isOk()).toBe(true);
-		if (result.isOk()) {
-			const ctx = result.value;
-			expect(ctx.options.basePath).toBe('/custom-path');
-		}
-	});
-
-	it('should initialize plugins', async () => {
-		const newBaseURL = 'http://test.test';
-		const result = await init({
-			baseURL: 'http://localhost:3000',
-			database: memoryAdapter({}),
-			plugins: [
-				{
-					id: 'test-plugin',
-					name: 'Test Plugin',
-					type: 'test',
-					init: () => ({
-						context: {
-							baseURL: newBaseURL,
-						},
-					}),
-				} as C15TPlugin,
-			],
-		});
-
-		expect(result.isOk()).toBe(true);
-		if (result.isOk()) {
-			const ctx = result.value;
-			expect(ctx.baseURL).toBe(newBaseURL);
-		}
-	});
-
-	it('should allow plugins to modify options', async () => {
-		const result = await init({
-			baseURL: 'http://localhost:3000',
-			database: memoryAdapter({}),
-			plugins: [
-				{
-					id: 'test-plugin',
-					name: 'Test Plugin',
-					type: 'test',
-					init: () => ({
-						options: {
-							baseURL: 'http://test.test',
-						},
-					}),
-				} as C15TPlugin,
-			],
-		});
-
-		expect(result.isOk()).toBe(true);
-		if (result.isOk()) {
-			const ctx = result.value;
-			expect(ctx.options.baseURL).toBe('http://test.test');
-		}
-	});
-
-	it('should handle plugin initialization errors', async () => {
-		const result = await init({
-			baseURL: 'http://localhost:3000',
-			database: memoryAdapter({}),
-			plugins: [
-				{
-					id: 'error-plugin',
-					name: 'Error Plugin',
-					type: 'test',
-					init: () => {
-						throw new Error('Plugin initialization failed');
-					},
-				} as C15TPlugin,
-			],
-		});
-
-		expect(result.isErr()).toBe(true);
-		if (result.isErr()) {
-			expect(result.error.message).toContain('Plugin initialization failed');
-		}
-	});
-
-	it('should handle storage adapter errors', async () => {
-		const result = await init({
-			baseURL: 'http://localhost:3000',
-			database: null as unknown as DatabaseConfiguration,
-		});
-
-		expect(result.isErr()).toBe(false);
-		if (result.isErr()) {
-			expect(result.error.message).toContain(
-				'Failed to initialize consent system'
-			);
-		}
-	});
-
-	it('should handle multiple plugins in sequence', async () => {
-		const result = await init({
-			baseURL: 'http://localhost:3000',
-			database: memoryAdapter({}),
-			plugins: [
-				{
-					id: 'plugin-1',
-					name: 'Plugin 1',
-					type: 'test',
-					init: () => ({
-						options: {
-							baseURL: 'http://plugin1.test',
-						},
-					}),
-				} as C15TPlugin,
-				{
-					id: 'plugin-2',
-					name: 'Plugin 2',
-					type: 'test',
-					init: () => ({
-						options: {
-							baseURL: 'http://plugin2.test',
-						},
-					}),
-				} as C15TPlugin,
-			],
-		});
-
-		expect(result.isOk()).toBe(true);
-		if (result.isOk()) {
-			const ctx = result.value;
-			expect(ctx.options.baseURL).toBe('http://plugin2.test');
-		}
-	});
-
-	it('should configure trusted origins', async () => {
-		const result = await init({
-			baseURL: 'http://localhost:3000',
-			database: memoryAdapter({}),
-			trustedOrigins: ['http://trusted.test', 'http://localhost:3000'],
-		});
-
-		expect(result.isOk()).toBe(true);
-		if (result.isOk()) {
-			const ctx = result.value;
-			expect(ctx.trustedOrigins).toContain('http://localhost:3000');
-			expect(ctx.trustedOrigins).toContain('http://trusted.test');
-		}
-	});
-
-	it('should handle plugin context modifications', async () => {
-		const result = await init({
-			baseURL: 'http://localhost:3000',
-			database: memoryAdapter({}),
-			plugins: [
-				{
-					id: 'context-plugin',
-					name: 'Context Plugin',
-					type: 'test',
-					init: () => ({
-						context: {
-							appName: 'Modified App Name',
-						},
-					}),
-				} as C15TPlugin,
-			],
-		});
-
-		expect(result.isOk()).toBe(true);
-		if (result.isOk()) {
-			const ctx = result.value;
-			expect(ctx.appName).toBe('Modified App Name');
-		}
-	});
-});