@c15t/backend 1.0.0 → 1.1.0-canary.0

package/src/pkgs/results/types.ts

@@ -1,4 +1,4 @@
-import type { H3Error } from 'h3';
+import type { ORPCError } from '@orpc/server';
 import type { Result, ResultAsync } from 'neverthrow';
 
 /**
@@ -46,17 +46,13 @@ export type ErrorMessageType = string;
  *
  * @remarks
  * This interface defines the public API of the DoubleTieError class.
- * It extends the H3Error class with additional properties and methods
+ * It extends the ORPCError class with additional properties and methods
  * specific to the DoubleTie error handling system.
  *
  * @see DoubleTieErrorOptions for the options used to construct a DoubleTieError
  */
 export interface DoubleTieError
-	extends H3Error<{
-		code: ErrorMessageType;
-		category?: ErrorCategory;
-		meta?: Record<string, unknown>;
-	}> {
+	extends ORPCError<string, Record<string, unknown>> {
 	/**
 	 * Error code identifying the error type
 	 */
@@ -72,6 +68,11 @@ export interface DoubleTieError
 	 */
 	readonly meta: Record<string, unknown>;
 
+	/**
+	 * HTTP status code for the error
+	 */
+	readonly statusCode: number;
+
 	/**
 	 * Creates a new error instance with additional metadata
 	 */

package/src/pkgs/types/context.ts

@@ -1,7 +1,6 @@
-import type { H3Event } from 'h3';
+import type { createLogger } from '@doubletie/logger';
 import type { DatabaseHook, EntityName } from '~/pkgs/data-model';
 import type { Adapter } from '~/pkgs/db-adapters/types';
-import type { createLogger } from '~/pkgs/logger';
 import type { createRegistry } from '~/schema/create-registry';
 import type { getConsentTables } from '~/schema/definition';
 import type { DoubleTieOptions } from './options';
@@ -12,7 +11,12 @@ import type { DoubleTieOptions } from './options';
  * This type extends the standard endpoint context with additional properties
  * specific to DoubleTie hooks, allowing hooks to access the complete DoubleTie context.
  */
-export type HookEndpointContext = H3Event & {
+export type HookEndpointContext = {
+	/**
+	 * The request object
+	 */
+	request: Request;
+
 	/**
 	 * The DoubleTie context with possible hook-specific extensions
 	 */
@@ -35,7 +39,12 @@ export type HookEndpointContext = H3Event & {
  * A simplified context type for endpoint handlers that don't need
  * access to input-specific context properties.
  */
-export type GenericEndpointContext = H3Event & {
+export type GenericEndpointContext = {
+	/**
+	 * The request object
+	 */
+	request: Request;
+
 	/**
 	 * The DoubleTie application context
 	 */
@@ -112,11 +121,6 @@ export interface BaseDoubleTieContext {
 	 */
 	baseURL: string;
 
-	/**
-	 * Secret key used for signing cookies and tokens
-	 */
-	secret: string;
-
 	/**
 	 * Logger instance for recording events and errors
 	 */
@@ -154,6 +158,11 @@ export interface BaseDoubleTieContext {
 	 * User agent of the client
 	 */
 	userAgent?: string | null;
+
+	/**
+	 * Headers of the request
+	 */
+	headers?: Headers;
 }
 
 /**

package/src/pkgs/types/endpoints.ts

@@ -1,5 +1,3 @@
-import type { H3Event } from 'h3';
-
 export interface EndpointOptions {
 	/**
 	 * Whether authentication is required for this endpoint
@@ -12,12 +10,12 @@ export interface EndpointOptions {
 	middleware?: EndpointMiddleware[];
 }
 
-export type EndpointMiddleware = (event: H3Event) => Promise<void>;
+export type EndpointMiddleware = (request: Request) => Promise<void>;
 
-export type EndpointHandler = (event: H3Event) => Promise<unknown>;
+export type EndpointHandler = (request: Request) => Promise<unknown>;
 
 /**
- * Native H3 endpoint interface
+ * Native endpoint interface
  */
 export interface Endpoint {
 	/**

package/src/pkgs/types/options.ts

@@ -1,11 +1,10 @@
 import type { DatabaseHook } from '~/pkgs/data-model';
 import type { DatabaseConfiguration } from '~/pkgs/db-adapters/adapters/kysely-adapter/types';
 
+import type { LoggerOptions } from '@doubletie/logger';
 import type { Tracer } from '@opentelemetry/api';
-import type { H3Event } from 'h3';
 // Import table configuration types from the schema module
 import type { TablesConfig } from '~/schema/types';
-import type { LoggerOptions } from '../logger';
 import type { DoubleTiePlugin } from './plugins';
 
 /**
@@ -22,7 +21,6 @@ import type { DoubleTiePlugin } from './plugins';
  * // Basic configuration
  * const options: DoubleTieOptions = {
  *   appName: "My App",
- *   secret: process.env.SECRET_KEY,
  *   baseURL: "https://example.com",
  *   trustedOrigins: ["https://example.com"]
  * };
@@ -229,6 +227,6 @@ export interface DoubleTieOptions {
  * Middleware function for processing API requests
  */
 export type DoubleTieMiddleware = (
-	event: H3Event,
+	request: Request,
 	next: () => Promise<unknown>
 ) => Promise<unknown>;

package/src/pkgs/types/plugins.ts

@@ -1,4 +1,3 @@
-import type { H3Event } from 'h3';
 import type { Migration } from 'kysely';
 import type { Field } from '~/pkgs/data-model';
 import type { DoubleTieContext, HookEndpointContext } from './context';
@@ -75,12 +74,12 @@ export interface DoubleTiePlugin {
 	/**
 	 * Handler for intercepting and potentially modifying incoming requests
 	 */
-	onRequest?: (event: H3Event, ctx: DoubleTieContext) => Promise<unknown>;
+	onRequest?: (request: Request, ctx: DoubleTieContext) => Promise<unknown>;
 
 	/**
 	 * Handler for intercepting and potentially modifying outgoing responses
 	 */
-	onResponse?: (event: H3Event, ctx: DoubleTieContext) => Promise<unknown>;
+	onResponse?: (response: Response, ctx: DoubleTieContext) => Promise<unknown>;
 
 	/**
 	 * Request lifecycle hooks for executing code before or after endpoint handling

package/src/pkgs/utils/index.ts

@@ -1,2 +1,3 @@
 export { env, isProduction, isTest } from './env';
 export { getBaseURL } from './url';
+export * from './logger';

package/src/pkgs/utils/logger.ts

@@ -0,0 +1,38 @@
+import {
+	type LoggerOptions,
+	createLogger as createDTLogger,
+} from '@doubletie/logger';
+
+let globalLogger: ReturnType<typeof createDTLogger>;
+
+/**
+ * Gets or creates a global logger instance
+ *
+ * @param options - Optional logger configuration options
+ * @returns The global logger instance
+ */
+export function getLogger(
+	options?: LoggerOptions
+): ReturnType<typeof createDTLogger> {
+	if (!globalLogger) {
+		globalLogger = createDTLogger({
+			level: 'info',
+			appName: 'c15t',
+			...options,
+		});
+	}
+	return globalLogger;
+}
+
+/**
+ * Initializes the global logger with specific options
+ *
+ * @param options - Logger configuration options
+ * @returns The initialized global logger instance
+ */
+export function initLogger(
+	options: LoggerOptions
+): ReturnType<typeof createDTLogger> {
+	globalLogger = createDTLogger(options);
+	return globalLogger;
+}

package/src/router.ts

@@ -0,0 +1,8 @@
+import { os } from './contracts';
+import { consentHandlers } from './handlers/consent';
+import { metaHandlers } from './handlers/meta';
+
+export const router = os.router({
+	consent: consentHandlers,
+	meta: metaHandlers,
+});

package/src/schema/audit-log/table.ts

@@ -9,7 +9,7 @@ import { auditLogSchema } from './schema';
  * and any additional fields from plugins or configuration. The resulting schema is used
  * for database migrations, schema validation, and query building.
  *
- * @param options - C15T configuration options that may contain audit log table customizations
+ * @param options - c15t configuration options that may contain audit log table customizations
  * @param auditLogFields - Additional fields from plugins to include in the audit log table
  * @returns A complete table schema definition with fields, model name, and metadata
  *

package/src/schema/consent/table.ts

@@ -8,7 +8,7 @@ import { consentSchema } from './schema';
  * and any additional fields from plugins or configuration. The resulting schema is used
  * for database migrations, schema validation, and query building.
  *
- * @param options - C15T configuration options that may contain consent table customizations
+ * @param options - c15t configuration options that may contain consent table customizations
  * @param consentFields - Additional fields from plugins to include in the consent table
  * @returns A complete table schema definition with fields, model name, and metadata
  *

package/src/schema/consent-policy/table.ts

@@ -9,7 +9,7 @@ import { consentPolicySchema } from './schema';
  * and any additional fields from plugins or configuration. The resulting schema is used
  * for database migrations, schema validation, and query building.
  *
- * @param options - C15T configuration options that may contain policy table customizations
+ * @param options - c15t configuration options that may contain policy table customizations
  * @param policyFields - Additional fields from plugins to include in the policy table
  * @returns A complete table schema definition with fields, model name, and metadata
  *

package/src/schema/consent-purpose/table.ts

@@ -9,7 +9,7 @@ import { purposeSchema } from './schema';
  * and any additional fields from plugins or configuration. The resulting schema is used
  * for database migrations, schema validation, and query building.
  *
- * @param options - C15T configuration options that may contain consentPurpose table customizations
+ * @param options - c15t configuration options that may contain consentPurpose table customizations
  * @param purposeFields - Additional fields from plugins to include in the consentPurpose table
  * @returns A complete table schema definition with fields, model name, and metadata
  *

package/src/schema/consent-record/table.ts

@@ -9,7 +9,7 @@ import { consentRecordSchema } from './schema';
  * and any additional fields from plugins or configuration. The resulting schema is used
  * for database migrations, schema validation, and query building.
  *
- * @param options - C15T configuration options that may contain consent record table customizations
+ * @param options - c15t configuration options that may contain consent record table customizations
  * @param recordFields - Additional fields from plugins to include in the consent record table
  * @returns A complete table schema definition with fields, model name, and metadata
  *

package/src/schema/definition.ts

@@ -1,6 +1,6 @@
-import { ZodError } from 'node_modules/zod/lib/ZodError';
+import { logger } from '@doubletie/logger';
+import { ZodError } from 'zod';
 import type { Field, PluginSchema } from '~/pkgs/data-model';
-import { logger } from '~/pkgs/logger';
 import type { C15TOptions } from '~/types';
 import { getAuditLogTable } from './audit-log/table';
 import { getConsentPolicyTable } from './consent-policy/table';

package/src/schema/domain/table.ts

@@ -9,7 +9,7 @@ import { domainSchema } from './schema';
  * and any additional fields from plugins or configuration. The resulting schema is used
  * for database migrations, schema validation, and query building.
  *
- * @param options - C15T configuration options that may contain domain table customizations
+ * @param options - c15t configuration options that may contain domain table customizations
  * @param domainFields - Additional fields from plugins to include in the domain table
  * @returns A complete table schema definition with fields, model name, and metadata
  *

package/src/schema/subject/table.ts

@@ -9,7 +9,7 @@ import { subjectSchema } from './schema';
  * and any additional fields from plugins or configuration. The resulting schema is used
  * for database migrations, schema validation, and query building.
  *
- * @param options - C15T configuration options that may contain subject table customizations
+ * @param options - c15t configuration options that may contain subject table customizations
  * @param subjectFields - Additional fields from plugins to include in the subject table
  * @returns A complete table schema definition with fields, model name, and metadata
  *

package/src/server.ts

@@ -0,0 +1,130 @@
+import { createServer } from 'node:http';
+import { c15tInstance } from './core';
+import { DoubleTieError } from './pkgs/results';
+import { getLogger } from './pkgs/utils/logger';
+
+// Use the centralized logger
+const logger = getLogger({
+	level: 'info',
+	// appName: 'c15t-server'
+});
+
+// Create the c15t instance with our configuration
+const instance = c15tInstance({
+	advanced: {
+		cors: {
+			allowedOrigins: ['*'], // Allow all origins for development
+		},
+	},
+	// Add OpenAPI configuration
+	openapi: {
+		enabled: true, // Set to true to enable docs
+		// Additional OpenAPI options can be added here
+	},
+	// Add logger
+	logger: {
+		level: 'info',
+	},
+});
+
+// Create HTTP server
+const server = createServer(async (req, res) => {
+	// Convert Node.js request to Web Request
+	const url = new URL(req.url || '/', `http://${req.headers.host}`);
+	const headers = new Headers();
+
+	// Convert Node.js headers to Headers object
+	for (const [key, value] of Object.entries(req.headers)) {
+		if (value) {
+			headers.set(key, Array.isArray(value) ? value.join(', ') : value);
+		}
+	}
+
+	// Create a Request object compatible with oRPC
+	const request = new Request(url.toString(), {
+		method: req.method || 'GET',
+		headers,
+		// Handle request body for POST/PUT/PATCH requests
+		...(req.method !== 'GET' &&
+			req.method !== 'HEAD' && {
+				body: req,
+			}),
+	});
+
+	try {
+		// Use c15tInstance handler to process the request
+		// It will automatically handle OpenAPI spec and docs UI
+		const response = await instance.handler(request);
+
+		// Convert Web API Response to Node.js response
+		res.writeHead(
+			response.status,
+			response.statusText,
+			Object.fromEntries(response.headers.entries())
+		);
+
+		// Handle different response types
+		if (response.body) {
+			// Stream the response body
+			const reader = response.body.getReader();
+			const processChunk = async () => {
+				try {
+					const { done, value } = await reader.read();
+					if (done) {
+						res.end();
+						return;
+					}
+
+					// Check if response already ended
+					if (!res.writableEnded) {
+						const canContinue = res.write(value);
+						if (canContinue) {
+							processChunk();
+						} else {
+							// If the buffer is full, wait for the drain event
+							res.once('drain', processChunk);
+						}
+					}
+				} catch (err) {
+					logger.error('Error while streaming response:', err);
+					if (!res.writableEnded) {
+						res.end();
+					}
+				}
+			};
+			processChunk();
+		} else {
+			res.end();
+		}
+	} catch (error) {
+		logger.error('Error handling request:', error);
+
+		// Return a proper error response based on the error type
+		if (error instanceof DoubleTieError) {
+			res.writeHead(error.statusCode, { 'Content-Type': 'application/json' });
+			res.end(
+				JSON.stringify({
+					code: error.code,
+					message: error.message,
+					data: error.meta,
+				})
+			);
+		} else {
+			// Generic error handler
+			res.writeHead(500, { 'Content-Type': 'application/json' });
+			res.end(
+				JSON.stringify({
+					error: 'Internal Server Error',
+					message: error instanceof Error ? error.message : String(error),
+				})
+			);
+		}
+	}
+});
+
+// Start the server
+const PORT = process.env.PORT ? Number.parseInt(process.env.PORT, 10) : 3000;
+server.listen(PORT, () => {
+	logger.info(`c15t server is running at http://localhost:${PORT}`);
+	logger.info(`API documentation available at http://localhost:${PORT}/docs`);
+});