@c15t/backend 1.2.0-canary.9 → 1.2.0

package/dist/pkgs/data-model/schema/index.cjs

@@ -1256,10 +1256,19 @@ function consentRegistry({ adapter, ...ctx }) {
 }
 async function generatePolicyPlaceholder(name, date) {
     const content = `[PLACEHOLDER] This is an automatically generated version of the ${name} policy.\n\nThis placeholder content should be replaced with actual policy terms before being presented to users.\n\nGenerated on: ${date.toISOString()}`;
-    const encoder = new TextEncoder();
-    const data = encoder.encode(content);
-    const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-    const contentHash = Array.from(new Uint8Array(hashBuffer)).map((b)=>b.toString(16).padStart(2, '0')).join('');
+    let contentHash;
+    try {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(content);
+        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+        contentHash = Array.from(new Uint8Array(hashBuffer)).map((b)=>b.toString(16).padStart(2, '0')).join('');
+    } catch (error) {
+        throw new error_class_DoubleTieError('Failed to generate policy content hash', {
+            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
+            status: 500,
+            cause: error instanceof Error ? error : new Error(String(error))
+        });
+    }
     return {
         content,
         contentHash
@@ -1321,42 +1330,51 @@ function policyRegistry({ adapter, ...ctx }) {
         },
         findOrCreatePolicy: async (type)=>await adapter.transaction({
                 callback: async (txAdapter)=>{
-                    const now = new Date();
-                    const txRegistry = policyRegistry({
-                        adapter: txAdapter,
-                        ...ctx
-                    });
-                    const rawLatestPolicy = await txAdapter.findOne({
-                        model: 'consentPolicy',
-                        where: [
-                            {
-                                field: 'isActive',
-                                value: true
-                            },
-                            {
-                                field: 'type',
-                                value: type
+                    try {
+                        const now = new Date();
+                        const txRegistry = policyRegistry({
+                            adapter: txAdapter,
+                            ...ctx
+                        });
+                        const rawLatestPolicy = await txAdapter.findOne({
+                            model: 'consentPolicy',
+                            where: [
+                                {
+                                    field: 'isActive',
+                                    value: true
+                                },
+                                {
+                                    field: 'type',
+                                    value: type
+                                }
+                            ],
+                            sortBy: {
+                                field: 'effectiveDate',
+                                direction: 'desc'
                             }
-                        ],
-                        sortBy: {
-                            field: 'effectiveDate',
-                            direction: 'desc'
-                        }
-                    });
-                    const latestPolicy = rawLatestPolicy ? validateEntityOutput('consentPolicy', rawLatestPolicy, ctx.options) : null;
-                    if (latestPolicy) return latestPolicy;
-                    const { content: defaultContent, contentHash } = await generatePolicyPlaceholder(type, now);
-                    return txRegistry.createConsentPolicy({
-                        version: '1.0.0',
-                        type,
-                        name: type,
-                        effectiveDate: now,
-                        content: defaultContent,
-                        contentHash,
-                        isActive: true,
-                        updatedAt: now,
-                        expirationDate: null
-                    });
+                        });
+                        const latestPolicy = rawLatestPolicy ? validateEntityOutput('consentPolicy', rawLatestPolicy, ctx.options) : null;
+                        if (latestPolicy) return latestPolicy;
+                        const { content: defaultContent, contentHash } = await generatePolicyPlaceholder(type, now);
+                        return txRegistry.createConsentPolicy({
+                            version: '1.0.0',
+                            type,
+                            name: type,
+                            effectiveDate: now,
+                            content: defaultContent,
+                            contentHash,
+                            isActive: true,
+                            updatedAt: now,
+                            expirationDate: null
+                        });
+                    } catch (error) {
+                        ctx.logger.error('Error in findOrCreatePolicy transaction:', error);
+                        throw new error_class_DoubleTieError('Failed to find or create policy', {
+                            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
+                            status: 500,
+                            cause: error instanceof Error ? error : new Error(String(error))
+                        });
+                    }
                 }
             })
     };

package/dist/pkgs/data-model/schema/index.js

@@ -1198,10 +1198,19 @@ function consentRegistry({ adapter, ...ctx }) {
 }
 async function generatePolicyPlaceholder(name, date) {
     const content = `[PLACEHOLDER] This is an automatically generated version of the ${name} policy.\n\nThis placeholder content should be replaced with actual policy terms before being presented to users.\n\nGenerated on: ${date.toISOString()}`;
-    const encoder = new TextEncoder();
-    const data = encoder.encode(content);
-    const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-    const contentHash = Array.from(new Uint8Array(hashBuffer)).map((b)=>b.toString(16).padStart(2, '0')).join('');
+    let contentHash;
+    try {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(content);
+        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+        contentHash = Array.from(new Uint8Array(hashBuffer)).map((b)=>b.toString(16).padStart(2, '0')).join('');
+    } catch (error) {
+        throw new error_class_DoubleTieError('Failed to generate policy content hash', {
+            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
+            status: 500,
+            cause: error instanceof Error ? error : new Error(String(error))
+        });
+    }
     return {
         content,
         contentHash
@@ -1263,42 +1272,51 @@ function policyRegistry({ adapter, ...ctx }) {
         },
         findOrCreatePolicy: async (type)=>await adapter.transaction({
                 callback: async (txAdapter)=>{
-                    const now = new Date();
-                    const txRegistry = policyRegistry({
-                        adapter: txAdapter,
-                        ...ctx
-                    });
-                    const rawLatestPolicy = await txAdapter.findOne({
-                        model: 'consentPolicy',
-                        where: [
-                            {
-                                field: 'isActive',
-                                value: true
-                            },
-                            {
-                                field: 'type',
-                                value: type
+                    try {
+                        const now = new Date();
+                        const txRegistry = policyRegistry({
+                            adapter: txAdapter,
+                            ...ctx
+                        });
+                        const rawLatestPolicy = await txAdapter.findOne({
+                            model: 'consentPolicy',
+                            where: [
+                                {
+                                    field: 'isActive',
+                                    value: true
+                                },
+                                {
+                                    field: 'type',
+                                    value: type
+                                }
+                            ],
+                            sortBy: {
+                                field: 'effectiveDate',
+                                direction: 'desc'
                             }
-                        ],
-                        sortBy: {
-                            field: 'effectiveDate',
-                            direction: 'desc'
-                        }
-                    });
-                    const latestPolicy = rawLatestPolicy ? validateEntityOutput('consentPolicy', rawLatestPolicy, ctx.options) : null;
-                    if (latestPolicy) return latestPolicy;
-                    const { content: defaultContent, contentHash } = await generatePolicyPlaceholder(type, now);
-                    return txRegistry.createConsentPolicy({
-                        version: '1.0.0',
-                        type,
-                        name: type,
-                        effectiveDate: now,
-                        content: defaultContent,
-                        contentHash,
-                        isActive: true,
-                        updatedAt: now,
-                        expirationDate: null
-                    });
+                        });
+                        const latestPolicy = rawLatestPolicy ? validateEntityOutput('consentPolicy', rawLatestPolicy, ctx.options) : null;
+                        if (latestPolicy) return latestPolicy;
+                        const { content: defaultContent, contentHash } = await generatePolicyPlaceholder(type, now);
+                        return txRegistry.createConsentPolicy({
+                            version: '1.0.0',
+                            type,
+                            name: type,
+                            effectiveDate: now,
+                            content: defaultContent,
+                            contentHash,
+                            isActive: true,
+                            updatedAt: now,
+                            expirationDate: null
+                        });
+                    } catch (error) {
+                        ctx.logger.error('Error in findOrCreatePolicy transaction:', error);
+                        throw new error_class_DoubleTieError('Failed to find or create policy', {
+                            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
+                            status: 500,
+                            cause: error instanceof Error ? error : new Error(String(error))
+                        });
+                    }
                 }
             })
     };

package/dist/router.cjs

@@ -1167,7 +1167,9 @@ const consentHandlers = {
     showBanner: show_banner_handler_showConsentBanner,
     verify: verifyConsent
 };
-var package_namespaceObject = JSON.parse('{"i8":"1.2.0-canary.9"}');
+var package_namespaceObject = {
+    i8: "1.2.0"
+};
 const statusHandler = os.meta.status.handler(({ context })=>{
     const typedContext = context;
     const headers = typedContext.headers;

package/dist/router.js

@@ -1129,7 +1129,9 @@ const consentHandlers = {
     showBanner: show_banner_handler_showConsentBanner,
     verify: verifyConsent
 };
-var package_namespaceObject = JSON.parse('{"i8":"1.2.0-canary.9"}');
+var package_namespaceObject = {
+    i8: "1.2.0"
+};
 const statusHandler = os.meta.status.handler(({ context })=>{
     const typedContext = context;
     const headers = typedContext.headers;

package/dist/schema/consent-policy/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/schema/consent-policy/registry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAI5E,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAoC1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,cAAc,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,EAAE,EAAE,eAAe;IAGjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;kCAEM,IAAI,CAAC,aAAa,EAAE,IAAI,GAAG,WAAW,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,YAC9D,sBAAsB;;;;;;;;;;;;;IAwBjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;4BAEM;QACP,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,eAAe,CAAC,EAAE,OAAO,CAAC;KAC1B;;;;;;;;;;;;;IAuCF;;;;;;;;;;;;;;;;;;;;;;OAsBG;sCACqC,MAAM;;;;;;;;;;;;;IAe9C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;+BAC8B,UAAU;;;;;;;;;;;;;EA2D5C"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/schema/consent-policy/registry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE5E,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAgD1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,cAAc,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,EAAE,EAAE,eAAe;IAGjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;kCAEM,IAAI,CAAC,aAAa,EAAE,IAAI,GAAG,WAAW,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,YAC9D,sBAAsB;;;;;;;;;;;;;IAwBjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;4BAEM;QACP,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,eAAe,CAAC,EAAE,OAAO,CAAC;KAC1B;;;;;;;;;;;;;IAuCF;;;;;;;;;;;;;;;;;;;;;;OAsBG;sCACqC,MAAM;;;;;;;;;;;;;IAe9C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;+BAC8B,UAAU;;;;;;;;;;;;;EAuE5C"}

package/dist/schema/create-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-registry.d.ts","sourceRoot":"","sources":["../../src/schema/create-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAWpD,eAAO,MAAM,cAAc,GAAI,KAAK,eAAe;;;;;;;;;;;iBAUmtE,CAAC;yBAA8B,CAAC;iBAAsB,CAAC;eAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAAuuH,CAAC;eAAqB,CAAC;uBAA6B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAD7mM,CAAC"}
+{"version":3,"file":"create-registry.d.ts","sourceRoot":"","sources":["../../src/schema/create-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAWpD,eAAO,MAAM,cAAc,GAAI,KAAK,eAAe;;;;;;;;;;;iBAUmtE,CAAC;yBAA8B,CAAC;iBAAsB,CAAC;eAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAA+jI,CAAC;eAAqB,CAAC;uBAA6B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CADr8M,CAAC"}

package/dist/schema/index.cjs

@@ -1139,10 +1139,19 @@ function consentRegistry({ adapter, ...ctx }) {
 }
 async function generatePolicyPlaceholder(name, date) {
     const content = `[PLACEHOLDER] This is an automatically generated version of the ${name} policy.\n\nThis placeholder content should be replaced with actual policy terms before being presented to users.\n\nGenerated on: ${date.toISOString()}`;
-    const encoder = new TextEncoder();
-    const data = encoder.encode(content);
-    const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-    const contentHash = Array.from(new Uint8Array(hashBuffer)).map((b)=>b.toString(16).padStart(2, '0')).join('');
+    let contentHash;
+    try {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(content);
+        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+        contentHash = Array.from(new Uint8Array(hashBuffer)).map((b)=>b.toString(16).padStart(2, '0')).join('');
+    } catch (error) {
+        throw new error_class_DoubleTieError('Failed to generate policy content hash', {
+            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
+            status: 500,
+            cause: error instanceof Error ? error : new Error(String(error))
+        });
+    }
     return {
         content,
         contentHash
@@ -1204,42 +1213,51 @@ function policyRegistry({ adapter, ...ctx }) {
         },
         findOrCreatePolicy: async (type)=>await adapter.transaction({
                 callback: async (txAdapter)=>{
-                    const now = new Date();
-                    const txRegistry = policyRegistry({
-                        adapter: txAdapter,
-                        ...ctx
-                    });
-                    const rawLatestPolicy = await txAdapter.findOne({
-                        model: 'consentPolicy',
-                        where: [
-                            {
-                                field: 'isActive',
-                                value: true
-                            },
-                            {
-                                field: 'type',
-                                value: type
+                    try {
+                        const now = new Date();
+                        const txRegistry = policyRegistry({
+                            adapter: txAdapter,
+                            ...ctx
+                        });
+                        const rawLatestPolicy = await txAdapter.findOne({
+                            model: 'consentPolicy',
+                            where: [
+                                {
+                                    field: 'isActive',
+                                    value: true
+                                },
+                                {
+                                    field: 'type',
+                                    value: type
+                                }
+                            ],
+                            sortBy: {
+                                field: 'effectiveDate',
+                                direction: 'desc'
                             }
-                        ],
-                        sortBy: {
-                            field: 'effectiveDate',
-                            direction: 'desc'
-                        }
-                    });
-                    const latestPolicy = rawLatestPolicy ? validateEntityOutput('consentPolicy', rawLatestPolicy, ctx.options) : null;
-                    if (latestPolicy) return latestPolicy;
-                    const { content: defaultContent, contentHash } = await generatePolicyPlaceholder(type, now);
-                    return txRegistry.createConsentPolicy({
-                        version: '1.0.0',
-                        type,
-                        name: type,
-                        effectiveDate: now,
-                        content: defaultContent,
-                        contentHash,
-                        isActive: true,
-                        updatedAt: now,
-                        expirationDate: null
-                    });
+                        });
+                        const latestPolicy = rawLatestPolicy ? validateEntityOutput('consentPolicy', rawLatestPolicy, ctx.options) : null;
+                        if (latestPolicy) return latestPolicy;
+                        const { content: defaultContent, contentHash } = await generatePolicyPlaceholder(type, now);
+                        return txRegistry.createConsentPolicy({
+                            version: '1.0.0',
+                            type,
+                            name: type,
+                            effectiveDate: now,
+                            content: defaultContent,
+                            contentHash,
+                            isActive: true,
+                            updatedAt: now,
+                            expirationDate: null
+                        });
+                    } catch (error) {
+                        ctx.logger.error('Error in findOrCreatePolicy transaction:', error);
+                        throw new error_class_DoubleTieError('Failed to find or create policy', {
+                            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
+                            status: 500,
+                            cause: error instanceof Error ? error : new Error(String(error))
+                        });
+                    }
                 }
             })
     };

package/dist/schema/index.js

@@ -1079,10 +1079,19 @@ function consentRegistry({ adapter, ...ctx }) {
 }
 async function generatePolicyPlaceholder(name, date) {
     const content = `[PLACEHOLDER] This is an automatically generated version of the ${name} policy.\n\nThis placeholder content should be replaced with actual policy terms before being presented to users.\n\nGenerated on: ${date.toISOString()}`;
-    const encoder = new TextEncoder();
-    const data = encoder.encode(content);
-    const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-    const contentHash = Array.from(new Uint8Array(hashBuffer)).map((b)=>b.toString(16).padStart(2, '0')).join('');
+    let contentHash;
+    try {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(content);
+        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+        contentHash = Array.from(new Uint8Array(hashBuffer)).map((b)=>b.toString(16).padStart(2, '0')).join('');
+    } catch (error) {
+        throw new error_class_DoubleTieError('Failed to generate policy content hash', {
+            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
+            status: 500,
+            cause: error instanceof Error ? error : new Error(String(error))
+        });
+    }
     return {
         content,
         contentHash
@@ -1144,42 +1153,51 @@ function policyRegistry({ adapter, ...ctx }) {
         },
         findOrCreatePolicy: async (type)=>await adapter.transaction({
                 callback: async (txAdapter)=>{
-                    const now = new Date();
-                    const txRegistry = policyRegistry({
-                        adapter: txAdapter,
-                        ...ctx
-                    });
-                    const rawLatestPolicy = await txAdapter.findOne({
-                        model: 'consentPolicy',
-                        where: [
-                            {
-                                field: 'isActive',
-                                value: true
-                            },
-                            {
-                                field: 'type',
-                                value: type
+                    try {
+                        const now = new Date();
+                        const txRegistry = policyRegistry({
+                            adapter: txAdapter,
+                            ...ctx
+                        });
+                        const rawLatestPolicy = await txAdapter.findOne({
+                            model: 'consentPolicy',
+                            where: [
+                                {
+                                    field: 'isActive',
+                                    value: true
+                                },
+                                {
+                                    field: 'type',
+                                    value: type
+                                }
+                            ],
+                            sortBy: {
+                                field: 'effectiveDate',
+                                direction: 'desc'
                             }
-                        ],
-                        sortBy: {
-                            field: 'effectiveDate',
-                            direction: 'desc'
-                        }
-                    });
-                    const latestPolicy = rawLatestPolicy ? validateEntityOutput('consentPolicy', rawLatestPolicy, ctx.options) : null;
-                    if (latestPolicy) return latestPolicy;
-                    const { content: defaultContent, contentHash } = await generatePolicyPlaceholder(type, now);
-                    return txRegistry.createConsentPolicy({
-                        version: '1.0.0',
-                        type,
-                        name: type,
-                        effectiveDate: now,
-                        content: defaultContent,
-                        contentHash,
-                        isActive: true,
-                        updatedAt: now,
-                        expirationDate: null
-                    });
+                        });
+                        const latestPolicy = rawLatestPolicy ? validateEntityOutput('consentPolicy', rawLatestPolicy, ctx.options) : null;
+                        if (latestPolicy) return latestPolicy;
+                        const { content: defaultContent, contentHash } = await generatePolicyPlaceholder(type, now);
+                        return txRegistry.createConsentPolicy({
+                            version: '1.0.0',
+                            type,
+                            name: type,
+                            effectiveDate: now,
+                            content: defaultContent,
+                            contentHash,
+                            isActive: true,
+                            updatedAt: now,
+                            expirationDate: null
+                        });
+                    } catch (error) {
+                        ctx.logger.error('Error in findOrCreatePolicy transaction:', error);
+                        throw new error_class_DoubleTieError('Failed to find or create policy', {
+                            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
+                            status: 500,
+                            cause: error instanceof Error ? error : new Error(String(error))
+                        });
+                    }
                 }
             })
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c15t/backend",
-  "version": "1.2.0-canary.9",
+  "version": "1.2.0",
   "license": "GPL-3.0-only",
   "type": "module",
   "exports": {
@@ -19,6 +19,11 @@
       "import": "./dist/schema/index.js",
       "require": "./dist/schema/index.cjs"
     },
+    "./contracts": {
+      "types": "./dist/contracts/index.d.ts",
+      "import": "./dist/contracts.js",
+      "require": "./dist/contracts.cjs"
+    },
     "./pkgs/data-model/fields": {
       "types": "./dist/pkgs/data-model/fields/index.d.ts",
       "import": "./dist/pkgs/data-model/fields/index.js",
@@ -117,7 +122,7 @@
     "build": "rslib build",
     "check-types": "tsc --noEmit",
     "dev": "rslib build --watch",
-    "fmt": "pnpm biome format --write . && biome check --formatter-enabled=false --linter-enabled=false --organize-imports-enabled=true --write",
+    "fmt": "pnpm biome format --write . && pnpm biome check --formatter-enabled=false --linter-enabled=false --organize-imports-enabled=true --write",
     "knip": "knip",
     "lint": "pnpm biome lint ./src",
     "start": "node dist/server.cjs",

package/rslib.config.ts

@@ -62,6 +62,7 @@ export default defineConfig({
 		entry: {
 			core: ['./src/core.ts'],
 			router: ['./src/router.ts'],
+			contracts: ['./src/contracts/index.ts'],
 			'schema/index': ['./src/schema/index.ts'],
 			'pkgs/data-model/fields/index': ['./src/pkgs/data-model/fields/index.ts'],
 			'pkgs/data-model/index': ['./src/pkgs/data-model/index.ts'],

package/src/__tests__/server.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from 'vitest';
+import { type C15TOptions, c15tInstance } from '../core';
+
+const mockOptions: C15TOptions = {
+	appName: 'Consent.io Dashboard',
+	basePath: '/api/c15t',
+	trustedOrigins: [
+		'localhost',
+		'vercel.app',
+		'consent.io',
+		'https://test.consent.io',
+	],
+	cors: true,
+	advanced: {
+		cors: {
+			allowHeaders: ['content-type', 'x-request-id'],
+		},
+	},
+	logger: {
+		level: 'debug',
+	},
+};
+
+const createTestRequest = (
+	path = '/api/c15t/status',
+	method = 'GET',
+	headers?: Record<string, string>
+) => {
+	return new Request(`http://localhost${path}`, {
+		method,
+		headers: {
+			'content-type': 'application/json',
+			...(headers || {}),
+		},
+	});
+};
+
+describe('C15T /status endpoint', () => {
+	it('GET /api/c15t/status returns 200 and status payload', async () => {
+		const c15t = c15tInstance(mockOptions);
+		const request = createTestRequest();
+		const response = await c15t.handler(request);
+		expect(response.status).toBe(200);
+		const data = await response.json();
+		expect(data).toHaveProperty('status');
+	});
+
+	it('responds correctly to requests from allowed origins', async () => {
+		const c15t = c15tInstance(mockOptions);
+		const request = createTestRequest(undefined, undefined, {
+			origin: 'https://test.consent.io',
+		});
+		const response = await c15t.handler(request);
+		expect(response.status).toBe(200);
+		expect(response.headers.get('access-control-allow-origin')).toBe(
+			'https://test.consent.io'
+		);
+	});
+
+	it('rejects requests from disallowed origins', async () => {
+		const c15t = c15tInstance(mockOptions);
+		const request = createTestRequest(undefined, undefined, {
+			origin: 'https://malicious-site.com',
+		});
+		const response = await c15t.handler(request);
+		expect(response.headers.get('access-control-allow-origin')).toBeNull();
+	});
+
+	it('handles preflight requests correctly', async () => {
+		const c15t = c15tInstance(mockOptions);
+		const request = createTestRequest(undefined, 'OPTIONS', {
+			origin: 'https://test.consent.io',
+			'access-control-request-method': 'GET',
+		});
+		const response = await c15t.handler(request);
+		expect(response.status).toBe(204);
+		expect(response.headers.get('access-control-allow-origin')).toBe(
+			'https://test.consent.io'
+		);
+		expect(response.headers.get('access-control-allow-headers')).toContain(
+			'Content-Type, Authorization, x-request-id'
+		);
+	});
+});
+
+describe('C15T /docs endpoint', () => {
+	it('GET /api/c15t/docs returns 200 and HTML', async () => {
+		const c15t = c15tInstance(mockOptions);
+		const request = createTestRequest('/api/c15t/docs');
+		const response = await c15t.handler(request);
+		expect(response.status).toBe(200);
+		const text = await response.text();
+		expect(text).toContain('<!doctype html>');
+		expect(response.headers.get('content-type')).toContain('text/html');
+	});
+});

package/src/contracts/index.ts

@@ -12,6 +12,8 @@ const config = {
 	meta: metaContracts,
 };
 
+export { config as contracts };
+
 export const os = implement(config);
 
 export type ContractsOutputs = InferContractRouterOutputs<typeof config>;