@c15t/backend 0.0.1-rc.10

package/dist/client/types.d.ts

@@ -0,0 +1,431 @@
+/**
+ * Configuration options for initializing a c15t client.
+ *
+ * This interface defines the required and optional parameters for creating
+ * a client that can interact with the c15t consent management API.
+ *
+ * @example
+ * ```typescript
+ * // Basic client configuration
+ * const options: c15tClientOptions = {
+ *   baseURL: 'https://api.example.com/consent',
+ *   headers: {
+ *     'X-API-Key': 'your-api-key',
+ *     'Authorization': 'Bearer token'
+ *   }
+ * };
+ *
+ * // Advanced configuration with plugins and custom fetch
+ * const advancedOptions: c15tClientOptions = {
+ *   baseURL: 'https://api.example.com/consent',
+ *   headers: {
+ *     'X-API-Key': 'your-api-key',
+ *     'Authorization': 'Bearer token'
+ *   },
+ *   fetchOptions: {
+ *     customFetchImpl: nodeFetch // Use node-fetch in Node.js environments
+ *   },
+ *   plugins: [
+ *     analyticsPlugin({ trackConsent: true }),
+ *     geoPlugin({ defaultJurisdiction: 'us-ca' })
+ *   ]
+ * };
+ * ```
+ */
+export interface c15tClientOptions {
+    /**
+     * Base URL for API endpoints.
+     *
+     * The URL should point to the root of the c15t API without a trailing slash.
+     * All endpoint paths will be appended to this base URL.
+     *
+     * @example 'https://api.example.com/consent'
+     */
+    baseURL: string;
+    /**
+     * Default request headers to include with all API requests.
+     *
+     * Common headers include API keys, authorization tokens, and content type.
+     * These headers will be included in every request made by the client.
+     *
+     * @example { 'X-API-Key': 'your-api-key', 'Authorization': 'Bearer token' }
+     */
+    headers?: Record<string, string>;
+    /**
+     * Additional configuration options for the fetch implementation.
+     *
+     * These options control the behavior of the underlying HTTP client.
+     */
+    fetchOptions?: {
+        /**
+         * Custom fetch implementation to use instead of the global fetch.
+         *
+         * This can be useful for environments without a native fetch,
+         * or for using a fetch implementation with additional features.
+         *
+         * @example
+         * ```typescript
+         * import nodeFetch from 'node-fetch';
+         *
+         * const options = {
+         *   fetchOptions: {
+         *     customFetchImpl: nodeFetch
+         *   }
+         * };
+         * ```
+         */
+        customFetchImpl?: typeof fetch;
+    };
+    /**
+     * Client plugins to extend the core client functionality.
+     *
+     * Plugins can add additional methods and features to the client,
+     * such as analytics tracking, geo-location services, etc.
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *   plugins: [
+     *     analyticsPlugin({
+     *       trackConsentChanges: true,
+     *       eventPrefix: 'consent_'
+     *     }),
+     *     geoPlugin({
+     *       defaultJurisdiction: 'us-ca',
+     *       cacheResults: true
+     *     })
+     *   ]
+     * };
+     * ```
+     */
+    plugins?: c15tClientPlugin[];
+}
+/**
+ * Request configuration options for API requests.
+ *
+ * This interface defines the options that can be provided when making
+ * HTTP requests to the c15t API endpoints.
+ *
+ * @typeParam ResponseType - The expected response data type
+ *
+ * @example
+ * ```typescript
+ * // Basic GET request options
+ * const getOptions: FetchOptions<SubjectConsent> = {
+ *   method: 'GET',
+ *   query: { subjectId: 'sub_x1pftyoufsm7xgo1kv' }
+ * };
+ *
+ * // POST request with error handling
+ * const postOptions: FetchOptions<UpdateResult> = {
+ *   method: 'POST',
+ *   body: { preferences: { analytics: true } },
+ *   throw: true,
+ *   onError: ({ error }) => {
+ *     console.error(`Error ${error.status}: ${error.message}`);
+ *   }
+ * };
+ * ```
+ */
+export interface FetchOptions<ResponseType = unknown> {
+    /**
+     * HTTP method for the request.
+     *
+     * Defaults to 'GET' if not specified.
+     */
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    /**
+     * Request body to send with the request.
+     *
+     * For non-GET requests, this data will be serialized as JSON
+     * and sent in the request body.
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *   body: {
+     *     preferences: { analytics: true, marketing: false },
+     *     timestamp: new Date().toISOString()
+     *   }
+     * };
+     * ```
+     */
+    body?: Record<string, unknown>;
+    /**
+     * Query parameters to include in the request URL.
+     *
+     * These parameters will be appended to the URL as query string parameters.
+     * Array values will result in multiple query parameters with the same name.
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *   query: {
+     *     subjectId: 'sub_x1pftyoufsm7xgo1kv',
+     *     purposes: ['pur_uvrr67my07m7xj2bta', 'pur_vv76m0rtb2dm7xj59gt'], // Results in ?purposes=analytics&purposes=marketing
+     *     includeHistory: true
+     *   }
+     * };
+     * ```
+     */
+    query?: Record<string, string | number | boolean | string[] | undefined>;
+    /**
+     * Custom headers to include with this specific request.
+     *
+     * These headers will be merged with the default headers
+     * configured for the client.
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *   headers: {
+     *     'X-Request-ID': generateRequestId(),
+     *     'Cache-Control': 'no-cache'
+     *   }
+     * };
+     * ```
+     */
+    headers?: Record<string, string>;
+    /**
+     * Whether to throw an error when the response is not successful.
+     *
+     * If true, the client will throw an error for non-2xx responses
+     * instead of returning a response context with the error.
+     *
+     * @default false
+     *
+     * @example
+     * ```typescript
+     * // This will throw an error if the request fails
+     * try {
+     *   const result = await client.$fetch('/important-endpoint', {
+     *     throw: true
+     *   });
+     *   // Only runs if request was successful
+     *   processResult(result.data);
+     * } catch (error) {
+     *   handleError(error);
+     * }
+     * ```
+     */
+    throw?: boolean;
+    /**
+     * Callback function to execute on successful response.
+     *
+     * This function will be called when the request completes successfully
+     * with a 2xx status code.
+     *
+     * @param context The response context containing the result data
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *   onSuccess: ({ data }) => {
+     *     console.log('Request succeeded:', data);
+     *     updateUI(data);
+     *   }
+     * };
+     * ```
+     */
+    onSuccess?: (context: ResponseContext<ResponseType>) => void | Promise<void>;
+    /**
+     * Callback function to execute on error response.
+     *
+     * This function will be called when the request fails with a non-2xx
+     * status code or when an exception occurs during the request.
+     *
+     * @param context The response context containing the error details
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *   onError: ({ error }) => {
+     *     console.error(`Request failed (${error.status}):`, error.message);
+     *     showErrorNotification(error.message);
+     *   }
+     * };
+     * ```
+     */
+    onError?: (context: ResponseContext<ResponseType>) => void | Promise<void>;
+    /**
+     * Additional fetch options to include in the request.
+     *
+     * These options will be passed directly to the fetch implementation.
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *   fetchOptions: {
+     *     credentials: 'include', // Send cookies with cross-origin requests
+     *     mode: 'cors',
+     *     cache: 'no-cache'
+     *   }
+     * };
+     * ```
+     */
+    fetchOptions?: RequestInit;
+}
+/**
+ * Response context returned from API requests.
+ *
+ * This interface contains the complete information about an API response,
+ * including the data, response object, and any error information.
+ *
+ * @typeParam ResponseType - The expected response data type
+ *
+ * @example
+ * ```typescript
+ * // Processing a response context
+ * const response: ResponseContext<SubjectData> = await client.$fetch('/subject/123');
+ *
+ * if (response.ok) {
+ *   // Handle successful response
+ *   console.log('Subject data:', response.data);
+ *   // Access headers if needed
+ *   const etag = response.response?.headers.get('ETag');
+ * } else {
+ *   // Handle error response
+ *   console.error(`Error ${response.error?.status}: ${response.error?.message}`);
+ *   if (response.error?.status === 404) {
+ *     console.log('Subject not found');
+ *   }
+ * }
+ * ```
+ */
+export interface ResponseContext<ResponseType = unknown> {
+    /**
+     * Response data returned by the API.
+     *
+     * For successful requests, this will contain the parsed JSON response.
+     * For failed requests or non-JSON responses, this will be null.
+     */
+    data: ResponseType | null;
+    /**
+     * Original fetch Response object.
+     *
+     * This contains the raw response information, such as status, headers, etc.
+     * For network errors or other exceptions, this may be null.
+     */
+    response: Response | null;
+    /**
+     * Error information if the request failed.
+     *
+     * This will be null for successful requests (2xx status codes).
+     * For failed requests, this contains the error details.
+     */
+    error: {
+        /**
+         * Error message describing what went wrong
+         */
+        message: string;
+        /**
+         * HTTP status code or custom error code
+         */
+        status: number;
+        /**
+         * Optional error code for more specific error identification
+         */
+        code?: string;
+    } | null;
+    /**
+     * Whether the request was successful.
+     *
+     * True for successful requests (2xx status codes), false otherwise.
+     */
+    ok: boolean;
+}
+/**
+ * Client plugin interface for extending the c15t client functionality.
+ *
+ * Plugins can add additional methods and features to the client,
+ * such as analytics tracking, geo-location services, etc.
+ *
+ * @example
+ * ```typescript
+ * // Defining a custom plugin
+ * const analyticsPlugin = (options = {}): c15tClientPlugin => ({
+ *   id: 'analytics',
+ *
+ *   init: (client) => {
+ *     console.log('Analytics plugin initialized');
+ *   },
+ *
+ *   methods: {
+ *     trackEvent: async (eventName, properties) => {
+ *       // Implementation logic
+ *       return { success: true };
+ *     },
+ *
+ *     getAnalyticsConsent: async () => {
+ *       // Get analytics-specific consent
+ *       return { allowed: true };
+ *     }
+ *   }
+ * });
+ *
+ * // Using the plugin
+ * const client = createConsentClient({
+ *   baseURL: 'https://api.example.com',
+ *   plugins: [analyticsPlugin({ trackPageviews: true })]
+ * });
+ *
+ * // Now you can use the plugin methods
+ * client.trackEvent('button_click', { buttonId: 'submit' });
+ * ```
+ */
+export interface c15tClientPlugin {
+    /**
+     * Unique plugin identifier.
+     *
+     * This ID should be unique across all plugins to avoid conflicts.
+     */
+    id: string;
+    /**
+     * Plugin initialization function.
+     *
+     * This function is called when the plugin is registered with the client.
+     * It can be used to set up the plugin and perform any necessary initialization.
+     *
+     * @param client The c15t client instance this plugin is being initialized with
+     */
+    init?: (client: c15tClient) => void;
+    /**
+     * Extensions to client methods.
+     *
+     * These methods will be added to the client instance, allowing plugins
+     * to extend the client's functionality with additional methods.
+     */
+    methods?: Record<string, (...args: unknown[]) => unknown>;
+    /**
+     * Type inference for the server-side plugin implementation.
+     *
+     * This is used for type checking to ensure the client plugin is compatible
+     * with the server-side plugin implementation.
+     *
+     * @internal This property is primarily for TypeScript type checking
+     */
+    $InferServerPlugin?: Record<string, unknown>;
+}
+/**
+ * Interface for c15t client instance.
+ * This is used for the plugin init type to avoid circular references.
+ *
+ * @internal This interface is primarily used internally for type definitions
+ */
+export interface c15tClient {
+    /**
+     * Makes a custom API request to any endpoint.
+     *
+     * @typeParam ResponseType - The expected response data type
+     * @param path - The API endpoint path
+     * @param options - Request configuration options
+     * @returns Response context containing the requested data if successful
+     */
+    $fetch<ResponseType>(path: string, options?: FetchOptions<ResponseType>): Promise<ResponseContext<ResponseType>>;
+    /**
+     * Index signature to allow dynamic access to properties.
+     * This enables plugins to add methods to the client.
+     */
+    [key: string]: unknown;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/client/types.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,WAAW,iBAAiB;IACjC;;;;;;;OAOG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC;;;;OAIG;IACH,YAAY,CAAC,EAAE;QACd;;;;;;;;;;;;;;;;WAgBG;QACH,eAAe,CAAC,EAAE,OAAO,KAAK,CAAC;KAC/B,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,YAAY,CAAC,YAAY,GAAG,OAAO;IACnD;;;;OAIG;IACH,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC;IAErD;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE/B;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC;IAEzE;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,CAAC,YAAY,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE7E;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,CAAC,YAAY,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3E;;;;;;;;;;;;;;;OAeG;IACH,YAAY,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,eAAe,CAAC,YAAY,GAAG,OAAO;IACtD;;;;;OAKG;IACH,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IAE1B;;;;;OAKG;IACH,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAE1B;;;;;OAKG;IACH,KAAK,EAAE;QACN;;WAEG;QACH,OAAO,EAAE,MAAM,CAAC;QAEhB;;WAEG;QACH,MAAM,EAAE,MAAM,CAAC;QAEf;;WAEG;QACH,IAAI,CAAC,EAAE,MAAM,CAAC;KACd,GAAG,IAAI,CAAC;IAET;;;;OAIG;IACH,EAAE,EAAE,OAAO,CAAC;CACZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,WAAW,gBAAgB;IAChC;;;;OAIG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;IAEpC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAC;IAE1D;;;;;;;OAOG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC7C;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IAC1B;;;;;;;OAOG;IACH,MAAM,CAAC,YAAY,EAClB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,YAAY,CAAC,YAAY,CAAC,GAClC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC;IAE1C;;;OAGG;IACH,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB"}

package/dist/core.d.ts

@@ -0,0 +1,124 @@
+import { router } from './api/index';
+import type { C15TResult, C15TResultAsync } from './error/results';
+import type { C15TContext, C15TOptions, C15TPlugin, FilterActions } from './types';
+/**
+ * Interface representing a configured c15t consent management instance.
+ *
+ * @typeParam PluginTypes - Array of plugin types used in this instance
+ *
+ * @remarks
+ * The C15TInstance provides the main interface for interacting with the consent
+ * management system. It includes methods for handling requests, accessing API
+ * endpoints, and managing the system's configuration.
+ *
+ * All asynchronous operations return {@link C15TResultAsync} types for
+ * consistent error handling across the system.
+ *
+ * @example
+ * ```typescript
+ * const instance: C15TInstance = c15tInstance({
+ *   secret: 'your-secret',
+ *   storage: memoryAdapter()
+ * });
+ *
+ * // Handle an incoming request
+ * const response = await instance.handler(request);
+ * ```
+ */
+export interface C15TInstance<PluginTypes extends C15TPlugin[] = C15TPlugin[]> {
+    /**
+     * Processes incoming HTTP requests and routes them to appropriate handlers.
+     *
+     * @param request - The incoming web request
+     * @returns A Promise resolving to a Result containing the HTTP response
+     *
+     * @throws Never - All errors are captured in the Result type
+     *
+     * @example
+     * ```typescript
+     * const result = await instance.handler(request);
+     * result.match(
+     *   response => sendResponse(response),
+     *   error => handleError(error)
+     * );
+     * ```
+     */
+    handler: (request: Request) => Promise<C15TResultAsync<Response>>;
+    /**
+     * Retrieves available API endpoints and their configurations.
+     *
+     * @returns A Promise resolving to a Result containing the available API endpoints
+     *
+     * @throws Never - All errors are captured in the Result type
+     *
+     * @example
+     * ```typescript
+     * const endpoints = await instance.getApi();
+     * endpoints.map(
+     *   apis => console.log('Available endpoints:', apis),
+     *   error => console.error('Failed to get endpoints:', error)
+     * );
+     * ```
+     */
+    getApi: () => Promise<C15TResultAsync<FilterActions<ReturnType<typeof router>['endpoints']>>>;
+    /**
+     * The configuration options used for this instance.
+     */
+    options: C15TOptions<PluginTypes>;
+    /**
+     * Access to the underlying context as a Result type.
+     *
+     * @remarks
+     * The context is wrapped in a Result type to ensure error handling
+     * consistency. Access should be handled using Result pattern methods.
+     */
+    $context: Promise<C15TResult<C15TContext>>;
+}
+/**
+ * Creates a new c15t consent management instance.
+ *
+ * @typeParam PluginTypes - Array of plugin types to be used in this instance
+ * @typeParam ConfigOptions - Configuration options extending the base C15TOptions
+ *
+ * @param options - Configuration options for the consent management system
+ * @returns A configured C15TInstance ready for use
+ *
+ * @remarks
+ * This is the main factory function for creating c15t instances. It initializes
+ * the consent management system with the provided configuration and sets up all
+ * necessary components including:
+ *
+ * - Database adapters
+ * - Plugin system
+ * - Request handlers
+ * - API endpoints
+ * - CORS configuration
+ *
+ * All async operations use the Result pattern for error handling, ensuring
+ * that errors are handled consistently throughout the system.
+ *
+ * @example
+ * Basic initialization:
+ * ```typescript
+ * import { c15tInstance } from '@c15t/backend';
+ *
+ * const manager = c15tInstance({
+ *   secret: process.env.SECRET_KEY,
+ *   storage: memoryAdapter()
+ * });
+ * ```
+ *
+ * @example
+ * Advanced initialization with type parameters:
+ * ```typescript
+ * type MyPlugins = [typeof geoPlugin, typeof analyticsPlugin];
+ *
+ * const c15t = c15tInstance<MyPlugins>({
+ *   secret: process.env.SECRET_KEY,
+ *   storage: kyselyAdapter(db),
+ *   plugins: [geoPlugin(), analyticsPlugin()]
+ * });
+ * ```
+ */
+export declare const c15tInstance: <PluginTypes extends C15TPlugin[] = C15TPlugin[], ConfigOptions extends C15TOptions<PluginTypes> = C15TOptions<PluginTypes>>(options: ConfigOptions) => C15TInstance<PluginTypes>;
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEnE,OAAO,KAAK,EACX,WAAW,EACX,WAAW,EACX,UAAU,EACV,aAAa,EACb,MAAM,SAAS,CAAC;AAGjB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,WAAW,YAAY,CAAC,WAAW,SAAS,UAAU,EAAE,GAAG,UAAU,EAAE;IAC5E;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC;IAElE;;;;;;;;;;;;;;;OAeG;IACH,MAAM,EAAE,MAAM,OAAO,CACpB,eAAe,CAAC,aAAa,CAAC,UAAU,CAAC,OAAO,MAAM,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CACtE,CAAC;IAEF;;OAEG;IACH,OAAO,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;IAElC;;;;;;OAMG;IACH,QAAQ,EAAE,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,YAAY,GACxB,WAAW,SAAS,UAAU,EAAE,GAAG,UAAU,EAAE,EAC/C,aAAa,SAAS,WAAW,CAAC,WAAW,CAAC,GAAG,WAAW,CAAC,WAAW,CAAC,EAEzE,SAAS,aAAa,KACpB,YAAY,CAAC,WAAW,CA4H1B,CAAC"}

package/dist/core.test.d.ts

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

package/dist/core.test.d.ts.map

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

package/dist/db/adapters/drizzle-adapter/drizzle-adapter.d.ts

@@ -0,0 +1,122 @@
+import type { C15TOptions } from '../../../types';
+/**
+ * Database interface for Drizzle ORM integration
+ *
+ * This generic interface represents a Drizzle ORM database connection.
+ * It allows the adapter to work with different Drizzle providers.
+ *
+ * @remarks
+ * The interface uses an index signature to allow for dynamic access to
+ * the database's properties and methods.
+ */
+export interface DB {
+    [key: string]: unknown;
+}
+/**
+ * Configuration options for the Drizzle adapter
+ *
+ * @example
+ * ```typescript
+ * // Basic Drizzle adapter configuration
+ * const config: DrizzleAdapterConfig = {
+ *   provider: 'pg', // PostgreSQL
+ *   usePlural: true // Use plural table names
+ * };
+ *
+ * // Configuration with explicit schema
+ * const configWithSchema: DrizzleAdapterConfig = {
+ *   provider: 'mysql',
+ *   schema: {
+ *     subjects: subjects, // Drizzle schema objects
+ *     consents: consents,
+ *     purposes: purposes
+ *   }
+ * };
+ * ```
+ */
+export interface DrizzleAdapterConfig {
+    /**
+     * The schema object that defines the tables and fields
+     *
+     * @remarks
+     * If not provided, the adapter will attempt to use `db._.fullSchema`
+     */
+    schema?: Record<string, unknown>;
+    /**
+     * The database provider
+     *
+     * @remarks
+     * Different providers have different SQL dialects and features
+     */
+    provider: 'pg' | 'mysql' | 'sqlite';
+    /**
+     * If the table names in the schema are plural
+     * set this to true. For example, if the schema
+     * has an object with a key "subjects" instead of "subject"
+     *
+     * @default false
+     */
+    usePlural?: boolean;
+}
+/**
+ * Creates a C15T adapter for Drizzle ORM
+ *
+ * This factory function creates an adapter that allows C15T to use Drizzle ORM
+ * as its database layer. It supports PostgreSQL, MySQL, and SQLite.
+ *
+ * @param db - The Drizzle database instance
+ * @param config - Configuration options for the Drizzle adapter
+ * @returns A C15T adapter factory function
+ *
+ * @example
+ * ```typescript
+ * import { drizzle } from 'drizzle-orm/postgres-js';
+ * import postgres from 'postgres';
+ * import { drizzleAdapter } from '@c15t/db/adapters/drizzle';
+ * import * as schema from './schema';
+ * import { c15tInstance } from '@c15t/backend';
+ *
+ * // Create a Postgres connection
+ * const connection = postgres('postgresql://user:password@localhost:5432/db');
+ * const db = drizzle(connection, { schema });
+ *
+ * // Create the C15T instance with Drizzle adapter
+ * const c15t = c15tInstance({
+ *   storage: drizzleAdapter(db, {
+ *     provider: 'pg',
+ *     schema, // Pass your Drizzle schema
+ *     usePlural: true
+ *   }),
+ *   // Other C15T options...
+ *   secret: process.env.SECRET
+ * });
+ *
+ * // Use in your application
+ * export default c15tInstance.handler;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with MySQL
+ * import { drizzle } from 'drizzle-orm/mysql2';
+ * import mysql from 'mysql2/promise';
+ * import { c15tInstance } from '@c15t/backend';
+ *
+ * const connection = await mysql.createConnection({
+ *   host: 'localhost',
+ *   user: 'root',
+ *   database: 'c15t'
+ * });
+ *
+ * const db = drizzle(connection);
+ *
+ * const c15t = c15tInstance({
+ *   storage: drizzleAdapter(db, {
+ *     provider: 'mysql'
+ *   }),
+ *   secret: process.env.SECRET
+ * });
+ * ```
+ */
+export declare const drizzleAdapter: (db: DB, config: DrizzleAdapterConfig) => (options: C15TOptions) => Adapter;
+//# sourceMappingURL=drizzle-adapter.d.ts.map

package/dist/db/adapters/drizzle-adapter/drizzle-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle-adapter.d.ts","sourceRoot":"","sources":["../../../../src/db/adapters/drizzle-adapter/drizzle-adapter.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAW,WAAW,EAAS,MAAM,SAAS,CAAC;AAO3D;;;;;;;;;GASG;AACH,MAAM,WAAW,EAAE;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB;AA+VD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,oBAAoB;IACpC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEjC;;;;;OAKG;IACH,QAAQ,EAAE,IAAI,GAAG,OAAO,GAAG,QAAQ,CAAC;IAEpC;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAkCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,eAAO,MAAM,cAAc,GACzB,IAAI,EAAE,EAAE,QAAQ,oBAAoB,MAAM,SAAS,WAAW,YAwL9D,CAAC"}

package/dist/db/adapters/drizzle-adapter/index.d.ts

@@ -0,0 +1,2 @@
+export * from './drizzle-adapter';
+//# sourceMappingURL=index.d.ts.map