@c15t/backend 1.2.0-canary.9 → 1.2.0

package/dist/core.cjs

@@ -1212,10 +1212,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
@@ -1277,42 +1286,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))
+                        });
+                    }
                 }
             })
     };
@@ -2215,7 +2233,9 @@ function getBaseURL(url, path) {
     const fromEnv = env.C15T_URL || env.NEXT_PUBLIC_C15T_URL || env.PUBLIC_C15T_URL || env.NUXT_PUBLIC_C15T_URL || env.NUXT_PUBLIC_AUTH_URL || ('/' !== env.BASE_URL ? env.BASE_URL : void 0);
     if (fromEnv) return withPath(fromEnv, path);
 }
-var package_namespaceObject = JSON.parse('{"i8":"1.2.0-canary.9"}');
+var package_namespaceObject = {
+    i8: "1.2.0"
+};
 const createRegistry = (ctx)=>({
         ...auditLogRegistry(ctx),
         ...consentRegistry(ctx),
@@ -2494,12 +2514,15 @@ const processCors = (request, context, trustedOrigins)=>{
     }
     return context;
 };
-const createOpenAPIConfig = (options)=>({
+const createOpenAPIConfig = (options)=>{
+    const basePath = options.basePath || '';
+    return {
         enabled: true,
-        specPath: '/spec.json',
-        docsPath: '/docs',
+        specPath: `${basePath}/spec.json`,
+        docsPath: `${basePath}/docs`,
         ...options.openapi || {}
-    });
+    };
+};
 const createDefaultOpenAPIOptions = (options)=>({
         info: {
             title: options.appName || 'c15t API',
@@ -2508,7 +2531,7 @@ const createDefaultOpenAPIOptions = (options)=>({
         },
         servers: [
             {
-                url: '/'
+                url: options.basePath || '/'
             }
         ],
         security: [
@@ -3614,11 +3637,26 @@ const c15tInstance = (options)=>{
         processCors(request, orpcContext, options.trustedOrigins);
         processTelemetry(request, orpcContext);
         const handlerContext = orpcContext;
+        orpcContext.logger.debug?.('Handling prefix', {
+            prefix: options.basePath || '/'
+        });
         const { matched, response } = await rpcHandler.handle(request, {
-            prefix: options.baseURL || '/',
+            prefix: options.basePath || '/',
             context: handlerContext
         });
-        if (matched && response) return response;
+        if (matched && response) {
+            orpcContext.logger.debug('Handler matched', {
+                request,
+                matched,
+                response
+            });
+            return response;
+        }
+        orpcContext.logger.debug('No handler matched', {
+            request,
+            matched,
+            response
+        });
         return new Response('Not Found', {
             status: 404
         });
@@ -3637,6 +3675,15 @@ const c15tInstance = (options)=>{
             const ctxResult = await contextPromise;
             if (!ctxResult.isOk()) throw ctxResult.error;
             const ctx = ctxResult.value;
+            const basePath = options.basePath || options.baseURL || '/';
+            (0, logger_namespaceObject.createLogger)(options.logger)?.debug?.('[c15t] Using basePath/baseURL', {
+                basePath
+            });
+            (0, logger_namespaceObject.createLogger)(options.logger)?.debug?.('[c15t] Routing request', {
+                method: request.method,
+                url: request.url,
+                prefix: basePath
+            });
             return await handleApiRequest(request, ctx);
         } catch (error) {
             const logger = options.logger ? (0, logger_namespaceObject.createLogger)(options.logger) : console;

package/dist/core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAUpE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,YAAY,CAAC,WAAW,SAAS,UAAU,EAAE,GAAG,UAAU,EAAE;IAC5E;;;;;;;;;;;;;;;OAeG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IAEjD;;OAEG;IACH,OAAO,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;IAElC;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAE/B;;OAEG;IACH,MAAM,EAAE,OAAO,MAAM,CAAC;IAEtB;;;;OAIG;IACH,cAAc,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAEvD;;;;OAIG;IACH,SAAS,EAAE,MAAM,MAAM,CAAC;CACxB;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,WAAW,SAAS,UAAU,EAAE,GAAG,UAAU,EAAE,EAC3E,SAAS,WAAW,CAAC,WAAW,CAAC;;;mBAiQI,OAAO;oBAAP,OAAO;mBAAP,OAAO;qBAAP,OAAO;sBAAP,OAAO;uBAAP,OAAO;oBAAP,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA7CZ,OAAO,KAAG,OAAO,CAAC,QAAQ,CAAC;CAyG3D,CAAC;AAEF,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC;AACrD,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAUpE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,YAAY,CAAC,WAAW,SAAS,UAAU,EAAE,GAAG,UAAU,EAAE;IAC5E;;;;;;;;;;;;;;;OAeG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IAEjD;;OAEG;IACH,OAAO,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;IAElC;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAE/B;;OAEG;IACH,MAAM,EAAE,OAAO,MAAM,CAAC;IAEtB;;;;OAIG;IACH,cAAc,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAEvD;;;;OAIG;IACH,SAAS,EAAE,MAAM,MAAM,CAAC;CACxB;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,WAAW,SAAS,UAAU,EAAE,GAAG,UAAU,EAAE,EAC3E,SAAS,WAAW,CAAC,WAAW,CAAC;;;mBA6RI,OAAO;oBAAP,OAAO;mBAAP,OAAO;qBAAP,OAAO;sBAAP,OAAO;uBAAP,OAAO;oBAAP,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA1DZ,OAAO,KAAG,OAAO,CAAC,QAAQ,CAAC;CAsH3D,CAAC;AAEF,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC;AACrD,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC"}

package/dist/core.js

@@ -1178,10 +1178,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
@@ -1243,42 +1252,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))
+                        });
+                    }
                 }
             })
     };
@@ -2179,7 +2197,9 @@ function getBaseURL(url, path) {
     const fromEnv = env.C15T_URL || env.NEXT_PUBLIC_C15T_URL || env.PUBLIC_C15T_URL || env.NUXT_PUBLIC_C15T_URL || env.NUXT_PUBLIC_AUTH_URL || ('/' !== env.BASE_URL ? env.BASE_URL : void 0);
     if (fromEnv) return withPath(fromEnv, path);
 }
-var package_namespaceObject = JSON.parse('{"i8":"1.2.0-canary.9"}');
+var package_namespaceObject = {
+    i8: "1.2.0"
+};
 const createRegistry = (ctx)=>({
         ...auditLogRegistry(ctx),
         ...consentRegistry(ctx),
@@ -2458,12 +2478,15 @@ const processCors = (request, context, trustedOrigins)=>{
     }
     return context;
 };
-const createOpenAPIConfig = (options)=>({
+const createOpenAPIConfig = (options)=>{
+    const basePath = options.basePath || '';
+    return {
         enabled: true,
-        specPath: '/spec.json',
-        docsPath: '/docs',
+        specPath: `${basePath}/spec.json`,
+        docsPath: `${basePath}/docs`,
         ...options.openapi || {}
-    });
+    };
+};
 const createDefaultOpenAPIOptions = (options)=>({
         info: {
             title: options.appName || 'c15t API',
@@ -2472,7 +2495,7 @@ const createDefaultOpenAPIOptions = (options)=>({
         },
         servers: [
             {
-                url: '/'
+                url: options.basePath || '/'
             }
         ],
         security: [
@@ -3575,11 +3598,26 @@ const c15tInstance = (options)=>{
         processCors(request, orpcContext, options.trustedOrigins);
         processTelemetry(request, orpcContext);
         const handlerContext = orpcContext;
+        orpcContext.logger.debug?.('Handling prefix', {
+            prefix: options.basePath || '/'
+        });
         const { matched, response } = await rpcHandler.handle(request, {
-            prefix: options.baseURL || '/',
+            prefix: options.basePath || '/',
             context: handlerContext
         });
-        if (matched && response) return response;
+        if (matched && response) {
+            orpcContext.logger.debug('Handler matched', {
+                request,
+                matched,
+                response
+            });
+            return response;
+        }
+        orpcContext.logger.debug('No handler matched', {
+            request,
+            matched,
+            response
+        });
         return new Response('Not Found', {
             status: 404
         });
@@ -3598,6 +3636,15 @@ const c15tInstance = (options)=>{
             const ctxResult = await contextPromise;
             if (!ctxResult.isOk()) throw ctxResult.error;
             const ctx = ctxResult.value;
+            const basePath = options.basePath || options.baseURL || '/';
+            (0, __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__.createLogger)(options.logger)?.debug?.('[c15t] Using basePath/baseURL', {
+                basePath
+            });
+            (0, __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__.createLogger)(options.logger)?.debug?.('[c15t] Routing request', {
+                method: request.method,
+                url: request.url,
+                prefix: basePath
+            });
             return await handleApiRequest(request, ctx);
         } catch (error) {
             const logger = options.logger ? (0, __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__.createLogger)(options.logger) : console;

package/dist/middleware/openapi/config.d.ts

@@ -19,7 +19,7 @@ export declare const createDefaultOpenAPIOptions: (options: C15TOptions) => {
         description: string;
     };
     servers: {
-        url: string;
+        url: {};
     }[];
     security: {
         bearerAuth: never[];

package/dist/middleware/openapi/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/middleware/openapi/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,WAAW;;;;;;CAKtD,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,2BAA2B,GAAI,SAAS,WAAW;;;;;;;;;;;;CAQ9D,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/middleware/openapi/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,WAAW;;;;;;CAQvD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,2BAA2B,GAAI,SAAS,WAAW;;;;;;;;;;;;CAQ9D,CAAC"}

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

@@ -1289,10 +1289,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
@@ -1354,42 +1363,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/index.js

@@ -1221,10 +1221,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
@@ -1286,42 +1295,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))
+                        });
+                    }
                 }
             })
     };