@c15t/backend 1.5.0 → 1.6.0

package/dist/core.cjs

@@ -33,6 +33,7 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    version: ()=>version,
     c15tInstance: ()=>c15tInstance
 });
 const logger_namespaceObject = require("@doubletie/logger");
@@ -224,6 +225,19 @@ class error_class_DoubleTieError extends server_namespaceObject.ORPCError {
         return formattedMessage;
     }
 }
+function createTelemetryOptions(appName = 'c15t', telemetryConfig) {
+    const serviceVersion = process.env.npm_package_version || '1.0.0';
+    const config = {
+        disabled: telemetryConfig?.disabled ?? false,
+        tracer: telemetryConfig?.tracer,
+        defaultAttributes: {
+            ...telemetryConfig?.defaultAttributes || {},
+            'service.name': String(appName),
+            'service.version': serviceVersion
+        }
+    };
+    return config;
+}
 function fail(message, options) {
     const error = new error_class_DoubleTieError(message, options);
     tracing_withSpan('create_error_result', async (span)=>{
@@ -274,32 +288,22 @@ function promiseToResult(promise, errorCode = error_codes_ERROR_CODES.UNKNOWN_ER
         return result;
     });
 }
-function createTelemetryOptions(appName = 'c15t', telemetryConfig) {
-    const serviceVersion = process.env.npm_package_version || '1.0.0';
-    const config = {
-        disabled: telemetryConfig?.disabled ?? false,
-        tracer: telemetryConfig?.tracer,
-        defaultAttributes: {
-            ...telemetryConfig?.defaultAttributes || {},
-            'service.name': String(appName),
-            'service.version': serviceVersion
-        }
-    };
-    return config;
-}
 const resources_namespaceObject = require("@opentelemetry/resources");
 const sdk_node_namespaceObject = require("@opentelemetry/sdk-node");
 const sdk_trace_base_namespaceObject = require("@opentelemetry/sdk-trace-base");
-function utils_applyDefaultValue(inputValue, field, operation) {
-    if ('update' === operation) return inputValue;
-    if (null == inputValue && field.defaultValue) {
-        if ('function' == typeof field.defaultValue) return field.defaultValue();
-        return field.defaultValue;
-    }
-    return inputValue;
+let globalLogger;
+function getLogger(options) {
+    if (!globalLogger) globalLogger = (0, logger_namespaceObject.createLogger)({
+        level: 'info',
+        appName: 'c15t',
+        ...options
+    });
+    return globalLogger;
+}
+function initLogger(options) {
+    globalLogger = (0, logger_namespaceObject.createLogger)(options);
+    return globalLogger;
 }
-const external_superjson_namespaceObject = require("superjson");
-var external_superjson_default = /*#__PURE__*/ __webpack_require__.n(external_superjson_namespaceObject);
 const COMMON_TIMEZONES = {
     UTC: 'UTC',
     GMT: 'GMT',
@@ -337,32 +341,20 @@ function id_generator_generateId(prefix) {
 }
 const external_zod_namespaceObject = require("zod");
 const fieldConfigSchema = external_zod_namespaceObject.z.object({
-    required: external_zod_namespaceObject.z.boolean().default(true),
-    returned: external_zod_namespaceObject.z.boolean().default(true),
-    input: external_zod_namespaceObject.z.boolean().default(true),
-    defaultValue: external_zod_namespaceObject.z.union([
-        external_zod_namespaceObject.z.any(),
-        external_zod_namespaceObject.z["function"]().returns(external_zod_namespaceObject.z.any())
-    ]).optional(),
+    required: external_zod_namespaceObject.z.boolean().prefault(true),
+    returned: external_zod_namespaceObject.z.boolean().prefault(true),
+    input: external_zod_namespaceObject.z.boolean().prefault(true),
+    defaultValue: external_zod_namespaceObject.z.any().optional(),
     transform: external_zod_namespaceObject.z.object({
-        input: external_zod_namespaceObject.z["function"]().args(external_zod_namespaceObject.z.any()).returns(external_zod_namespaceObject.z.union([
-            external_zod_namespaceObject.z.any(),
-            external_zod_namespaceObject.z.promise(external_zod_namespaceObject.z.any())
-        ])).optional(),
-        output: external_zod_namespaceObject.z["function"]().args(external_zod_namespaceObject.z.any()).returns(external_zod_namespaceObject.z.union([
-            external_zod_namespaceObject.z.any(),
-            external_zod_namespaceObject.z.promise(external_zod_namespaceObject.z.any())
-        ])).optional()
+        input: external_zod_namespaceObject.z.any().optional(),
+        output: external_zod_namespaceObject.z.any().optional()
     }).optional(),
-    validator: external_zod_namespaceObject.z["function"]().args(external_zod_namespaceObject.z.any()).returns(external_zod_namespaceObject.z.union([
-        external_zod_namespaceObject.z.string(),
-        external_zod_namespaceObject.z["null"]()
-    ])).optional(),
+    validator: external_zod_namespaceObject.z.any().optional(),
     unique: external_zod_namespaceObject.z.boolean().optional(),
     indexed: external_zod_namespaceObject.z.boolean().optional(),
-    sortable: external_zod_namespaceObject.z.boolean().default(true),
+    sortable: external_zod_namespaceObject.z.boolean().prefault(true),
     fieldName: external_zod_namespaceObject.z.string().optional(),
-    bigint: external_zod_namespaceObject.z.boolean().default(false)
+    bigint: external_zod_namespaceObject.z.boolean().prefault(false)
 });
 const stringFieldSchema = fieldConfigSchema.extend({
     type: external_zod_namespaceObject.z.literal('string'),
@@ -382,18 +374,18 @@ const dateFieldSchema = fieldConfigSchema.extend({
     type: external_zod_namespaceObject.z.literal('date'),
     minDate: external_zod_namespaceObject.z.date().optional(),
     maxDate: external_zod_namespaceObject.z.date().optional(),
-    dateOnly: external_zod_namespaceObject.z.boolean().default(false),
-    format: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional()
+    dateOnly: external_zod_namespaceObject.z.boolean().prefault(false),
+    format: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).optional()
 });
 const timezoneFieldSchema = fieldConfigSchema.extend({
     type: external_zod_namespaceObject.z.literal('timezone'),
-    validateTimezone: external_zod_namespaceObject.z.boolean().default(true),
+    validateTimezone: external_zod_namespaceObject.z.boolean().prefault(true),
     suggestedValues: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
-    restrictToSuggestedValues: external_zod_namespaceObject.z.boolean().default(false)
+    restrictToSuggestedValues: external_zod_namespaceObject.z.boolean().prefault(false)
 });
 const jsonFieldSchema = fieldConfigSchema.extend({
     type: external_zod_namespaceObject.z.literal('json'),
-    validateJson: external_zod_namespaceObject.z.boolean().default(true)
+    validateJson: external_zod_namespaceObject.z.boolean().prefault(true)
 });
 const stringArrayFieldSchema = fieldConfigSchema.extend({
     type: external_zod_namespaceObject.z.literal('string[]')
@@ -411,6 +403,125 @@ external_zod_namespaceObject.z.discriminatedUnion('type', [
     stringArrayFieldSchema,
     numberArrayFieldSchema
 ]);
+async function processHooks(data, model, operation, phase, hooks, context) {
+    let currentData = {
+        ...data
+    };
+    for (const hookSet of hooks){
+        const modelHooks = hookSet[model];
+        if (!modelHooks) continue;
+        const operationHooks = modelHooks[operation];
+        if (!operationHooks) continue;
+        const hookFn = operationHooks[phase];
+        if (hookFn) if ('before' === phase) {
+            const result = await hookFn(currentData, context);
+            if (result && 'object' == typeof result && 'kind' in result) switch(result.kind){
+                case 'abort':
+                    return null;
+                case 'transform':
+                    {
+                        const transformData = result.data;
+                        currentData = {
+                            ...currentData,
+                            ...transformData
+                        };
+                        break;
+                    }
+                default:
+                    break;
+            }
+        } else await hookFn(currentData, context);
+    }
+    return currentData;
+}
+async function processAfterHooksForMany(records, model, hooks, context) {
+    if (!records.length) return;
+    for (const record of records)await processHooks(record, model, 'update', 'after', hooks, context);
+}
+async function create_hooks_createWithHooks(adapter, ctx, props) {
+    const { data, model, customFn, context } = props;
+    const hooks = ctx.hooks || [];
+    const transformedData = await processHooks(data, model, 'create', 'before', hooks, context);
+    if (null === transformedData) return null;
+    let created = null;
+    if (customFn) {
+        created = await customFn.fn(transformedData);
+        if (!customFn.executeMainFn && created) return created;
+    }
+    if (!created) created = await adapter.create({
+        model: model,
+        data: transformedData
+    });
+    if (created) await processHooks(created, model, 'create', 'after', hooks, context);
+    return created;
+}
+async function update_hooks_updateWithHooks(adapter, ctx, props) {
+    const { data, where, model, customFn, context } = props;
+    const hooks = ctx.hooks || [];
+    const transformedData = await processHooks(data, model, 'update', 'before', hooks, context);
+    if (null === transformedData) return null;
+    let updated = null;
+    if (customFn) {
+        const result = await customFn.fn(transformedData);
+        updated = result;
+        if (!customFn.executeMainFn && updated) return updated;
+    }
+    if (!updated) updated = await adapter.update({
+        model: model,
+        update: transformedData,
+        where
+    });
+    if (updated) await processHooks(updated, model, 'update', 'after', hooks, context);
+    return updated;
+}
+async function executeCustomFunction(data, customFn) {
+    if (!customFn) return {
+        result: null,
+        shouldContinue: true
+    };
+    const result = await customFn.fn(data);
+    const shouldContinue = !result || !!customFn.executeMainFn;
+    return {
+        result,
+        shouldContinue
+    };
+}
+function processUpdateManyResult(result) {
+    if (Array.isArray(result)) return result;
+    if ('number' == typeof result && result > 0) return [];
+    return null;
+}
+async function updateManyWithHooks(adapter, ctx, props) {
+    const { data, where, model, customFn, context } = props;
+    const hooks = ctx.hooks || [];
+    const transformedData = await processHooks(data, model, 'update', 'before', hooks, context);
+    if (null === transformedData) return null;
+    const { result: customResult, shouldContinue } = await executeCustomFunction(transformedData, customFn);
+    if (customResult && !shouldContinue) return customResult;
+    let updated = customResult;
+    if (!updated) {
+        const adapterResult = await adapter.updateMany({
+            model: model,
+            update: transformedData,
+            where
+        });
+        updated = processUpdateManyResult(adapterResult);
+    }
+    if (updated && updated.length > 0) await processAfterHooksForMany(updated, model, hooks, context);
+    return updated;
+}
+function getWithHooks(adapter, ctx) {
+    return {
+        createWithHooks: ({ data, model, customFn, context })=>create_hooks_createWithHooks(adapter, ctx, {
+                data,
+                model,
+                customFn,
+                context
+            }),
+        updateWithHooks: (props)=>update_hooks_updateWithHooks(adapter, ctx, props),
+        updateManyWithHooks: (props)=>updateManyWithHooks(adapter, ctx, props)
+    };
+}
 const schema_auditLogSchema = external_zod_namespaceObject.z.object({
     id: external_zod_namespaceObject.z.string(),
     entityType: external_zod_namespaceObject.z.string(),
@@ -419,9 +530,9 @@ const schema_auditLogSchema = external_zod_namespaceObject.z.object({
     subjectId: external_zod_namespaceObject.z.string().optional(),
     ipAddress: external_zod_namespaceObject.z.string().optional(),
     userAgent: external_zod_namespaceObject.z.string().optional(),
-    changes: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional(),
-    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional(),
-    createdAt: external_zod_namespaceObject.z.date().default(()=>new Date())
+    changes: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).optional(),
+    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).optional(),
+    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
 });
 function getAuditLogTable(options, auditLogFields) {
     const auditLogConfig = options.tables?.auditLog;
@@ -520,66 +631,188 @@ function getAuditLogTable(options, auditLogFields) {
         order: 5
     };
 }
-const PolicyTypeSchema = external_zod_namespaceObject.z["enum"]([
-    'cookie_banner',
-    'privacy_policy',
-    'dpa',
-    'terms_and_conditions',
-    'marketing_communications',
-    'age_verification',
-    'other'
-]);
-const schema_consentPolicySchema = external_zod_namespaceObject.z.object({
+const schema_consentSchema = external_zod_namespaceObject.z.object({
     id: external_zod_namespaceObject.z.string(),
-    version: external_zod_namespaceObject.z.string(),
-    type: PolicyTypeSchema,
-    name: external_zod_namespaceObject.z.string(),
-    effectiveDate: external_zod_namespaceObject.z.date(),
-    expirationDate: external_zod_namespaceObject.z.date().nullable().optional(),
-    content: external_zod_namespaceObject.z.string(),
-    contentHash: external_zod_namespaceObject.z.string(),
-    isActive: external_zod_namespaceObject.z.boolean().default(true),
-    createdAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
-    updatedAt: external_zod_namespaceObject.z.date().default(()=>new Date())
+    subjectId: external_zod_namespaceObject.z.string(),
+    domainId: external_zod_namespaceObject.z.string(),
+    purposeIds: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
+    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).nullable().optional(),
+    policyId: external_zod_namespaceObject.z.string().optional(),
+    ipAddress: external_zod_namespaceObject.z.string().nullable().optional(),
+    userAgent: external_zod_namespaceObject.z.string().nullable().optional(),
+    status: external_zod_namespaceObject.z["enum"]([
+        'active',
+        'withdrawn',
+        'expired'
+    ]).prefault('active'),
+    withdrawalReason: external_zod_namespaceObject.z.string().nullable().optional(),
+    givenAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
+    validUntil: external_zod_namespaceObject.z.date().nullable().optional(),
+    isActive: external_zod_namespaceObject.z.boolean().prefault(true)
 });
-function getConsentPolicyTable(options, policyFields) {
-    const consentPolicyConfig = options.tables?.consentPolicy;
+function getConsentTable(options, consentFields) {
+    const consentConfig = options.tables?.consent;
+    const subjectConfig = options.tables?.subject;
+    const domainConfig = options.tables?.domain;
+    const policyConfig = options.tables?.consentPolicy;
     return {
-        entityName: consentPolicyConfig?.entityName || 'consentPolicy',
-        entityPrefix: consentPolicyConfig?.entityPrefix || 'pol',
-        schema: schema_consentPolicySchema,
+        entityName: consentConfig?.entityName || 'consent',
+        entityPrefix: consentConfig?.entityPrefix || 'cns',
+        schema: schema_consentSchema,
         fields: {
-            version: {
-                type: 'string',
-                required: true,
-                fieldName: consentPolicyConfig?.fields?.version || 'version'
-            },
-            type: {
+            subjectId: {
                 type: 'string',
                 required: true,
-                fieldName: consentPolicyConfig?.fields?.type || 'type'
+                fieldName: consentConfig?.fields?.subjectId || 'subjectId',
+                references: {
+                    model: subjectConfig?.entityName || 'subject',
+                    field: 'id'
+                }
             },
-            name: {
+            domainId: {
                 type: 'string',
                 required: true,
-                fieldName: consentPolicyConfig?.fields?.name || 'name'
+                fieldName: consentConfig?.fields?.domainId || 'domainId',
+                references: {
+                    model: domainConfig?.entityName || 'domain',
+                    field: 'id'
+                }
             },
-            effectiveDate: {
-                type: 'date',
-                required: true,
-                fieldName: consentPolicyConfig?.fields?.effectiveDate || 'effectiveDate'
+            purposeIds: {
+                type: 'json',
+                required: false,
+                fieldName: consentConfig?.fields?.purposeIds || 'purposeIds'
             },
-            expirationDate: {
-                type: 'date',
+            metadata: {
+                type: 'json',
                 required: false,
-                fieldName: consentPolicyConfig?.fields?.expirationDate || 'expirationDate'
+                fieldName: consentConfig?.fields?.metadata || 'metadata'
             },
-            content: {
+            policyId: {
                 type: 'string',
-                required: true,
-                fieldName: consentPolicyConfig?.fields?.content || 'content'
+                required: false,
+                fieldName: consentConfig?.fields?.policyId || 'policyId',
+                references: {
+                    model: policyConfig?.entityName || 'consentPolicy',
+                    field: 'id'
+                }
             },
-            contentHash: {
+            ipAddress: {
+                type: 'string',
+                required: false,
+                fieldName: consentConfig?.fields?.ipAddress || 'ipAddress'
+            },
+            userAgent: {
+                type: 'string',
+                required: false,
+                fieldName: consentConfig?.fields?.userAgent || 'userAgent'
+            },
+            status: {
+                type: 'string',
+                defaultValue: ()=>'active',
+                required: true,
+                fieldName: consentConfig?.fields?.status || 'status'
+            },
+            withdrawalReason: {
+                type: 'string',
+                required: false,
+                fieldName: consentConfig?.fields?.withdrawalReason || 'withdrawalReason'
+            },
+            givenAt: {
+                type: 'date',
+                defaultValue: ()=>new Date(),
+                required: true,
+                fieldName: consentConfig?.fields?.givenAt || 'givenAt'
+            },
+            validUntil: {
+                type: 'date',
+                required: false,
+                fieldName: consentConfig?.fields?.validUntil || 'validUntil',
+                transform: {
+                    input: (val, data)=>{
+                        if (val) return val;
+                        const expiresIn = consentConfig?.expiresIn || 31536000;
+                        const givenAt = data.givenAt instanceof Date ? data.givenAt : new Date();
+                        if (expiresIn > 0) {
+                            const validUntil = new Date(givenAt);
+                            validUntil.setSeconds(validUntil.getSeconds() + expiresIn);
+                            return validUntil;
+                        }
+                    }
+                }
+            },
+            isActive: {
+                type: 'boolean',
+                defaultValue: true,
+                required: true,
+                fieldName: consentConfig?.fields?.isActive || 'isActive'
+            },
+            ...consentFields || {},
+            ...consentConfig?.additionalFields || {}
+        },
+        order: 3
+    };
+}
+const PolicyTypeSchema = external_zod_namespaceObject.z["enum"]([
+    'cookie_banner',
+    'privacy_policy',
+    'dpa',
+    'terms_and_conditions',
+    'marketing_communications',
+    'age_verification',
+    'other'
+]);
+const schema_consentPolicySchema = external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    version: external_zod_namespaceObject.z.string(),
+    type: PolicyTypeSchema,
+    name: external_zod_namespaceObject.z.string(),
+    effectiveDate: external_zod_namespaceObject.z.date(),
+    expirationDate: external_zod_namespaceObject.z.date().nullable().optional(),
+    content: external_zod_namespaceObject.z.string(),
+    contentHash: external_zod_namespaceObject.z.string(),
+    isActive: external_zod_namespaceObject.z.boolean().prefault(true),
+    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
+    updatedAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
+});
+function getConsentPolicyTable(options, policyFields) {
+    const consentPolicyConfig = options.tables?.consentPolicy;
+    return {
+        entityName: consentPolicyConfig?.entityName || 'consentPolicy',
+        entityPrefix: consentPolicyConfig?.entityPrefix || 'pol',
+        schema: schema_consentPolicySchema,
+        fields: {
+            version: {
+                type: 'string',
+                required: true,
+                fieldName: consentPolicyConfig?.fields?.version || 'version'
+            },
+            type: {
+                type: 'string',
+                required: true,
+                fieldName: consentPolicyConfig?.fields?.type || 'type'
+            },
+            name: {
+                type: 'string',
+                required: true,
+                fieldName: consentPolicyConfig?.fields?.name || 'name'
+            },
+            effectiveDate: {
+                type: 'date',
+                required: true,
+                fieldName: consentPolicyConfig?.fields?.effectiveDate || 'effectiveDate'
+            },
+            expirationDate: {
+                type: 'date',
+                required: false,
+                fieldName: consentPolicyConfig?.fields?.expirationDate || 'expirationDate'
+            },
+            content: {
+                type: 'string',
+                required: true,
+                fieldName: consentPolicyConfig?.fields?.content || 'content'
+            },
+            contentHash: {
                 type: 'string',
                 required: true,
                 fieldName: consentPolicyConfig?.fields?.contentHash || 'contentHash'
@@ -607,12 +840,12 @@ const schema_purposeSchema = external_zod_namespaceObject.z.object({
     code: external_zod_namespaceObject.z.string(),
     name: external_zod_namespaceObject.z.string(),
     description: external_zod_namespaceObject.z.string(),
-    isEssential: external_zod_namespaceObject.z.boolean().default(false),
+    isEssential: external_zod_namespaceObject.z.boolean().prefault(false),
     dataCategory: external_zod_namespaceObject.z.string().nullish(),
     legalBasis: external_zod_namespaceObject.z.string().nullish(),
-    isActive: external_zod_namespaceObject.z.boolean().default(true),
-    createdAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
-    updatedAt: external_zod_namespaceObject.z.date().default(()=>new Date())
+    isActive: external_zod_namespaceObject.z.boolean().prefault(true),
+    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
+    updatedAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
 });
 function getPurposeTable(options, purposeFields) {
     const purposeConfig = options.tables?.consentPurpose;
@@ -681,9 +914,9 @@ const schema_consentRecordSchema = external_zod_namespaceObject.z.object({
     subjectId: external_zod_namespaceObject.z.string(),
     consentId: external_zod_namespaceObject.z.string().optional(),
     actionType: external_zod_namespaceObject.z.string(),
-    details: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional(),
-    createdAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
-    updatedAt: external_zod_namespaceObject.z.date().default(()=>new Date())
+    details: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).optional(),
+    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
+    updatedAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
 });
 function getConsentRecordTable(options, recordFields) {
     const recordConfig = options.tables?.record;
@@ -734,137 +967,15 @@ function getConsentRecordTable(options, recordFields) {
         order: 4
     };
 }
-const schema_consentSchema = external_zod_namespaceObject.z.object({
-    id: external_zod_namespaceObject.z.string(),
-    subjectId: external_zod_namespaceObject.z.string(),
-    domainId: external_zod_namespaceObject.z.string(),
-    purposeIds: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
-    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).nullable().optional(),
-    policyId: external_zod_namespaceObject.z.string().optional(),
-    ipAddress: external_zod_namespaceObject.z.string().nullable().optional(),
-    userAgent: external_zod_namespaceObject.z.string().nullable().optional(),
-    status: external_zod_namespaceObject.z["enum"]([
-        'active',
-        'withdrawn',
-        'expired'
-    ]).default('active'),
-    withdrawalReason: external_zod_namespaceObject.z.string().nullable().optional(),
-    givenAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
-    validUntil: external_zod_namespaceObject.z.date().nullable().optional(),
-    isActive: external_zod_namespaceObject.z.boolean().default(true)
-});
-function getConsentTable(options, consentFields) {
-    const consentConfig = options.tables?.consent;
-    const subjectConfig = options.tables?.subject;
-    const domainConfig = options.tables?.domain;
-    const policyConfig = options.tables?.consentPolicy;
-    return {
-        entityName: consentConfig?.entityName || 'consent',
-        entityPrefix: consentConfig?.entityPrefix || 'cns',
-        schema: schema_consentSchema,
-        fields: {
-            subjectId: {
-                type: 'string',
-                required: true,
-                fieldName: consentConfig?.fields?.subjectId || 'subjectId',
-                references: {
-                    model: subjectConfig?.entityName || 'subject',
-                    field: 'id'
-                }
-            },
-            domainId: {
-                type: 'string',
-                required: true,
-                fieldName: consentConfig?.fields?.domainId || 'domainId',
-                references: {
-                    model: domainConfig?.entityName || 'domain',
-                    field: 'id'
-                }
-            },
-            purposeIds: {
-                type: 'json',
-                required: false,
-                fieldName: consentConfig?.fields?.purposeIds || 'purposeIds'
-            },
-            metadata: {
-                type: 'json',
-                required: false,
-                fieldName: consentConfig?.fields?.metadata || 'metadata'
-            },
-            policyId: {
-                type: 'string',
-                required: false,
-                fieldName: consentConfig?.fields?.policyId || 'policyId',
-                references: {
-                    model: policyConfig?.entityName || 'consentPolicy',
-                    field: 'id'
-                }
-            },
-            ipAddress: {
-                type: 'string',
-                required: false,
-                fieldName: consentConfig?.fields?.ipAddress || 'ipAddress'
-            },
-            userAgent: {
-                type: 'string',
-                required: false,
-                fieldName: consentConfig?.fields?.userAgent || 'userAgent'
-            },
-            status: {
-                type: 'string',
-                defaultValue: ()=>'active',
-                required: true,
-                fieldName: consentConfig?.fields?.status || 'status'
-            },
-            withdrawalReason: {
-                type: 'string',
-                required: false,
-                fieldName: consentConfig?.fields?.withdrawalReason || 'withdrawalReason'
-            },
-            givenAt: {
-                type: 'date',
-                defaultValue: ()=>new Date(),
-                required: true,
-                fieldName: consentConfig?.fields?.givenAt || 'givenAt'
-            },
-            validUntil: {
-                type: 'date',
-                required: false,
-                fieldName: consentConfig?.fields?.validUntil || 'validUntil',
-                transform: {
-                    input: (val, data)=>{
-                        if (val) return val;
-                        const expiresIn = consentConfig?.expiresIn || 31536000;
-                        const givenAt = data.givenAt instanceof Date ? data.givenAt : new Date();
-                        if (expiresIn > 0) {
-                            const validUntil = new Date(givenAt);
-                            validUntil.setSeconds(validUntil.getSeconds() + expiresIn);
-                            return validUntil;
-                        }
-                    }
-                }
-            },
-            isActive: {
-                type: 'boolean',
-                defaultValue: true,
-                required: true,
-                fieldName: consentConfig?.fields?.isActive || 'isActive'
-            },
-            ...consentFields || {},
-            ...consentConfig?.additionalFields || {}
-        },
-        order: 3
-    };
-}
 const schema_domainSchema = external_zod_namespaceObject.z.object({
     id: external_zod_namespaceObject.z.string(),
     name: external_zod_namespaceObject.z.string().min(1),
     description: external_zod_namespaceObject.z.string().optional(),
-    allowedOrigins: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional().default([]),
-    isVerified: external_zod_namespaceObject.z.boolean().default(true),
-    isActive: external_zod_namespaceObject.z.boolean().default(true),
-    createdAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
-    updatedAt: external_zod_namespaceObject.z.date().default(()=>new Date())
+    allowedOrigins: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional().prefault([]),
+    isVerified: external_zod_namespaceObject.z.boolean().prefault(true),
+    isActive: external_zod_namespaceObject.z.boolean().prefault(true),
+    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
+    updatedAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
 });
 function getDomainTable(options, domainFields) {
     const domainConfig = options.tables?.domain;
@@ -921,12 +1032,12 @@ function getDomainTable(options, domainFields) {
 }
 const schema_subjectSchema = external_zod_namespaceObject.z.object({
     id: external_zod_namespaceObject.z.string(),
-    isIdentified: external_zod_namespaceObject.z.boolean().default(false),
+    isIdentified: external_zod_namespaceObject.z.boolean().prefault(false),
     externalId: external_zod_namespaceObject.z.string().nullable().optional(),
     identityProvider: external_zod_namespaceObject.z.string().optional(),
     lastIpAddress: external_zod_namespaceObject.z.string().optional(),
-    createdAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
-    updatedAt: external_zod_namespaceObject.z.date().default(()=>new Date())
+    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
+    updatedAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
 });
 function getSubjectTable(options, subjectFields) {
     const subjectConfig = options.tables?.subject;
@@ -966,213 +1077,62 @@ function getSubjectTable(options, subjectFields) {
                 type: 'date',
                 defaultValue: ()=>new Date(),
                 required: true,
-                fieldName: subjectConfig?.fields?.updatedAt || 'updatedAt'
-            },
-            subjectTimezone: {
-                type: 'timezone',
-                required: false,
-                defaultValue: COMMON_TIMEZONES.UTC,
-                fieldName: subjectConfig?.fields?.subjectTimezone || 'subjectTimezone'
-            },
-            ...subjectFields || {},
-            ...subjectConfig?.additionalFields || {}
-        },
-        order: 1
-    };
-}
-const definition_getConsentTables = (options)=>{
-    const pluginSchema = options.plugins?.reduce((acc, plugin)=>{
-        const schema = plugin.schema;
-        if (!schema) return acc;
-        for (const [key, value] of Object.entries(schema))acc[key] = {
-            fields: {
-                ...acc[key]?.fields,
-                ...value.fields
-            },
-            entityName: key
-        };
-        return acc;
-    }, {});
-    const { subject, consentPurpose, consentPolicy, domain, geoLocation, consent, consentPurposeJunction, record, consentGeoLocation, consentWithdrawal, auditLog, ...pluginTables } = pluginSchema || {};
-    return {
-        subject: getSubjectTable(options, subject?.fields),
-        consentPurpose: getPurposeTable(options, consentPurpose?.fields),
-        consentPolicy: getConsentPolicyTable(options, consentPolicy?.fields),
-        domain: getDomainTable(options, domain?.fields),
-        consent: getConsentTable(options, consent?.fields),
-        consentRecord: getConsentRecordTable(options, record?.fields),
-        auditLog: getAuditLogTable(options, auditLog?.fields),
-        ...pluginTables
-    };
-};
-function validateEntityOutput(tableName, data, options) {
-    const tables = definition_getConsentTables(options);
-    const table = tables[tableName];
-    if (!table) throw new Error(`Table ${tableName} not found`);
-    const processedData = {
-        ...data
-    };
-    for (const [field, def] of Object.entries(table.fields))if ('date' === def.type && 'string' == typeof processedData[field]) processedData[field] = new Date(processedData[field]);
-    try {
-        return table.schema.parse(processedData);
-    } catch (error) {
-        if (error instanceof external_zod_namespaceObject.ZodError) logger_namespaceObject.logger.error(`[validateEntityOutput] Validation failed for table ${String(tableName)}`, {
-            table,
-            issues: error.issues
-        });
-        throw error;
-    }
-}
-function subjectRegistry({ adapter, ...ctx }) {
-    const { createWithHooks } = getWithHooks(adapter, ctx);
-    return {
-        createSubject: async (subject, context)=>{
-            const createdSubject = await createWithHooks({
-                data: {
-                    createdAt: new Date(),
-                    updatedAt: new Date(),
-                    ...subject
-                },
-                model: 'subject',
-                customFn: void 0,
-                context
-            });
-            return createdSubject ? validateEntityOutput('subject', createdSubject, ctx.options) : null;
-        },
-        findOrCreateSubject: async function({ subjectId, externalSubjectId, ipAddress = 'unknown', context }) {
-            if (subjectId && externalSubjectId) {
-                const [subjectById, subjectByExternalId] = await Promise.all([
-                    this.findSubjectById(subjectId),
-                    this.findSubjectByExternalId(externalSubjectId)
-                ]);
-                if (!subjectById || !subjectByExternalId) {
-                    ctx.logger?.error('Subject validation failed: One or both subjects not found', {
-                        providedSubjectId: subjectId,
-                        providedExternalId: externalSubjectId,
-                        subjectByIdFound: !!subjectById,
-                        subjectByExternalIdFound: !!subjectByExternalId
-                    });
-                    throw new error_class_DoubleTieError('The specified subject could not be found. Please verify the subject identifiers and try again.', {
-                        code: error_codes_ERROR_CODES.NOT_FOUND,
-                        status: 404,
-                        meta: {
-                            providedSubjectId: subjectId,
-                            providedExternalId: externalSubjectId
-                        }
-                    });
-                }
-                if (subjectById.id !== subjectByExternalId.id) {
-                    ctx.logger?.warn('Subject validation failed: IDs do not match the same subject', {
-                        providedSubjectId: subjectId,
-                        providedExternalId: externalSubjectId,
-                        subjectByIdId: subjectById.id,
-                        subjectByExternalIdId: subjectByExternalId.id
-                    });
-                    throw new error_class_DoubleTieError('The provided subjectId and externalSubjectId do not match the same subject. Please ensure both identifiers refer to the same subject.', {
-                        code: error_codes_ERROR_CODES.CONFLICT,
-                        status: 409,
-                        meta: {
-                            providedSubjectId: subjectId,
-                            providedExternalId: externalSubjectId,
-                            subjectByIdId: subjectById.id,
-                            subjectByExternalIdId: subjectByExternalId.id
-                        }
-                    });
-                }
-                return subjectById;
-            }
-            if (subjectId) {
-                const subject = await this.findSubjectById(subjectId);
-                if (subject) return subject;
-                throw new error_class_DoubleTieError('Subject not found by subjectId', {
-                    code: error_codes_ERROR_CODES.NOT_FOUND,
-                    status: 404
-                });
-            }
-            if (externalSubjectId) try {
-                const subject = await this.findSubjectByExternalId(externalSubjectId);
-                if (subject) {
-                    ctx.logger?.debug('Found existing subject by external ID', {
-                        externalSubjectId
-                    });
-                    return subject;
-                }
-                ctx.logger?.info('Creating new subject with external ID', {
-                    externalSubjectId
-                });
-                return await this.createSubject({
-                    externalId: externalSubjectId,
-                    identityProvider: 'external',
-                    lastIpAddress: ipAddress,
-                    isIdentified: true
-                }, context);
-            } catch (error) {
-                if (error instanceof Error && error.message.includes('unique constraint')) {
-                    ctx.logger?.info('Handling duplicate key violation for external ID', {
-                        externalSubjectId
-                    });
-                    const subject = await this.findSubjectByExternalId(externalSubjectId);
-                    if (subject) return subject;
-                }
-                ctx.logger?.error('Failed to create or find subject with external ID', {
-                    externalSubjectId,
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                });
-                throw new error_class_DoubleTieError('Failed to create or find subject with external ID', {
-                    code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                    status: 500,
-                    meta: {
-                        error: error instanceof Error ? error.message : 'Unknown error'
-                    }
-                });
-            }
-            try {
-                ctx.logger?.info('Creating new anonymous subject');
-                return await this.createSubject({
-                    externalId: null,
-                    identityProvider: 'anonymous',
-                    lastIpAddress: ipAddress,
-                    isIdentified: false
-                }, context);
-            } catch (error) {
-                ctx.logger?.error('Failed to create anonymous subject', {
-                    ipAddress,
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                });
-                throw new error_class_DoubleTieError('Failed to create anonymous subject', {
-                    code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                    status: 500,
-                    meta: {
-                        error: error instanceof Error ? error.message : 'Unknown error'
-                    }
-                });
-            }
-        },
-        findSubjectById: async (subjectId)=>{
-            const subject = await adapter.findOne({
-                model: 'subject',
-                where: [
-                    {
-                        field: 'id',
-                        value: subjectId
-                    }
-                ]
-            });
-            return subject ? validateEntityOutput('subject', subject, ctx.options) : null;
+                fieldName: subjectConfig?.fields?.updatedAt || 'updatedAt'
+            },
+            subjectTimezone: {
+                type: 'timezone',
+                required: false,
+                defaultValue: COMMON_TIMEZONES.UTC,
+                fieldName: subjectConfig?.fields?.subjectTimezone || 'subjectTimezone'
+            },
+            ...subjectFields || {},
+            ...subjectConfig?.additionalFields || {}
         },
-        findSubjectByExternalId: async (externalId)=>{
-            const subject = await adapter.findOne({
-                model: 'subject',
-                where: [
-                    {
-                        field: 'externalId',
-                        value: externalId
-                    }
-                ]
-            });
-            return subject ? validateEntityOutput('subject', subject, ctx.options) : null;
-        }
+        order: 1
+    };
+}
+const definition_getConsentTables = (options)=>{
+    const pluginSchema = options.plugins?.reduce((acc, plugin)=>{
+        const schema = plugin.schema;
+        if (!schema) return acc;
+        for (const [key, value] of Object.entries(schema))acc[key] = {
+            fields: {
+                ...acc[key]?.fields,
+                ...value.fields
+            },
+            entityName: key
+        };
+        return acc;
+    }, {});
+    const { subject, consentPurpose, consentPolicy, domain, geoLocation, consent, consentPurposeJunction, record, consentGeoLocation, consentWithdrawal, auditLog, ...pluginTables } = pluginSchema || {};
+    return {
+        subject: getSubjectTable(options, subject?.fields),
+        consentPurpose: getPurposeTable(options, consentPurpose?.fields),
+        consentPolicy: getConsentPolicyTable(options, consentPolicy?.fields),
+        domain: getDomainTable(options, domain?.fields),
+        consent: getConsentTable(options, consent?.fields),
+        consentRecord: getConsentRecordTable(options, record?.fields),
+        auditLog: getAuditLogTable(options, auditLog?.fields),
+        ...pluginTables
     };
+};
+function validateEntityOutput(tableName, data, options) {
+    const tables = definition_getConsentTables(options);
+    const table = tables[tableName];
+    if (!table) throw new Error(`Table ${tableName} not found`);
+    const processedData = {
+        ...data
+    };
+    for (const [field, def] of Object.entries(table.fields))if ('date' === def.type && 'string' == typeof processedData[field]) processedData[field] = new Date(processedData[field]);
+    try {
+        return table.schema.parse(processedData);
+    } catch (error) {
+        if (error instanceof external_zod_namespaceObject.ZodError) logger_namespaceObject.logger.error(`[validateEntityOutput] Validation failed for table ${String(tableName)}`, {
+            table,
+            issues: error.issues
+        });
+        throw error;
+    }
 }
 function consentRegistry({ adapter, ...ctx }) {
     const { createWithHooks, updateWithHooks } = getWithHooks(adapter, ctx);
@@ -1449,146 +1409,236 @@ function domainRegistry({ adapter, ...ctx }) {
     };
     return registry;
 }
-function auditLogRegistry({ adapter, ...ctx }) {
+function subjectRegistry({ adapter, ...ctx }) {
     const { createWithHooks } = getWithHooks(adapter, ctx);
     return {
-        createAuditLog: async (auditLog, context)=>{
-            const createdLog = await createWithHooks({
+        createSubject: async (subject, context)=>{
+            const createdSubject = await createWithHooks({
                 data: {
                     createdAt: new Date(),
-                    ...auditLog
+                    updatedAt: new Date(),
+                    ...subject
                 },
-                model: 'auditLog',
+                model: 'subject',
                 customFn: void 0,
                 context
             });
-            if (!createdLog) throw new error_class_DoubleTieError('Failed to create audit log - operation returned null', {
-                code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                status: 500
-            });
-            return createdLog;
-        }
-    };
-}
-async function processHooks(data, model, operation, phase, hooks, context) {
-    let currentData = {
-        ...data
-    };
-    for (const hookSet of hooks){
-        const modelHooks = hookSet[model];
-        if (!modelHooks) continue;
-        const operationHooks = modelHooks[operation];
-        if (!operationHooks) continue;
-        const hookFn = operationHooks[phase];
-        if (hookFn) if ('before' === phase) {
-            const result = await hookFn(currentData, context);
-            if (result && 'object' == typeof result && 'kind' in result) switch(result.kind){
-                case 'abort':
-                    return null;
-                case 'transform':
-                    {
-                        const transformData = result.data;
-                        currentData = {
-                            ...currentData,
-                            ...transformData
-                        };
-                        break;
+            return createdSubject ? validateEntityOutput('subject', createdSubject, ctx.options) : null;
+        },
+        findOrCreateSubject: async function({ subjectId, externalSubjectId, ipAddress = 'unknown', context }) {
+            if (subjectId && externalSubjectId) {
+                const [subjectById, subjectByExternalId] = await Promise.all([
+                    this.findSubjectById(subjectId),
+                    this.findSubjectByExternalId(externalSubjectId)
+                ]);
+                if (!subjectById || !subjectByExternalId) {
+                    ctx.logger?.error('Subject validation failed: One or both subjects not found', {
+                        providedSubjectId: subjectId,
+                        providedExternalId: externalSubjectId,
+                        subjectByIdFound: !!subjectById,
+                        subjectByExternalIdFound: !!subjectByExternalId
+                    });
+                    throw new error_class_DoubleTieError('The specified subject could not be found. Please verify the subject identifiers and try again.', {
+                        code: error_codes_ERROR_CODES.NOT_FOUND,
+                        status: 404,
+                        meta: {
+                            providedSubjectId: subjectId,
+                            providedExternalId: externalSubjectId
+                        }
+                    });
+                }
+                if (subjectById.id !== subjectByExternalId.id) {
+                    ctx.logger?.warn('Subject validation failed: IDs do not match the same subject', {
+                        providedSubjectId: subjectId,
+                        providedExternalId: externalSubjectId,
+                        subjectByIdId: subjectById.id,
+                        subjectByExternalIdId: subjectByExternalId.id
+                    });
+                    throw new error_class_DoubleTieError('The provided subjectId and externalSubjectId do not match the same subject. Please ensure both identifiers refer to the same subject.', {
+                        code: error_codes_ERROR_CODES.CONFLICT,
+                        status: 409,
+                        meta: {
+                            providedSubjectId: subjectId,
+                            providedExternalId: externalSubjectId,
+                            subjectByIdId: subjectById.id,
+                            subjectByExternalIdId: subjectByExternalId.id
+                        }
+                    });
+                }
+                return subjectById;
+            }
+            if (subjectId) {
+                const subject = await this.findSubjectById(subjectId);
+                if (subject) return subject;
+                throw new error_class_DoubleTieError('Subject not found by subjectId', {
+                    code: error_codes_ERROR_CODES.NOT_FOUND,
+                    status: 404
+                });
+            }
+            if (externalSubjectId) try {
+                const subject = await this.findSubjectByExternalId(externalSubjectId);
+                if (subject) {
+                    ctx.logger?.debug('Found existing subject by external ID', {
+                        externalSubjectId
+                    });
+                    return subject;
+                }
+                ctx.logger?.info('Creating new subject with external ID', {
+                    externalSubjectId
+                });
+                return await this.createSubject({
+                    externalId: externalSubjectId,
+                    identityProvider: 'external',
+                    lastIpAddress: ipAddress,
+                    isIdentified: true
+                }, context);
+            } catch (error) {
+                if (error instanceof Error && error.message.includes('unique constraint')) {
+                    ctx.logger?.info('Handling duplicate key violation for external ID', {
+                        externalSubjectId
+                    });
+                    const subject = await this.findSubjectByExternalId(externalSubjectId);
+                    if (subject) return subject;
+                }
+                ctx.logger?.error('Failed to create or find subject with external ID', {
+                    externalSubjectId,
+                    error: error instanceof Error ? error.message : 'Unknown error'
+                });
+                throw new error_class_DoubleTieError('Failed to create or find subject with external ID', {
+                    code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
+                    status: 500,
+                    meta: {
+                        error: error instanceof Error ? error.message : 'Unknown error'
                     }
-                default:
-                    break;
+                });
             }
-        } else await hookFn(currentData, context);
-    }
-    return currentData;
-}
-async function processAfterHooksForMany(records, model, hooks, context) {
-    if (!records.length) return;
-    for (const record of records)await processHooks(record, model, 'update', 'after', hooks, context);
-}
-async function create_hooks_createWithHooks(adapter, ctx, props) {
-    const { data, model, customFn, context } = props;
-    const hooks = ctx.hooks || [];
-    const transformedData = await processHooks(data, model, 'create', 'before', hooks, context);
-    if (null === transformedData) return null;
-    let created = null;
-    if (customFn) {
-        created = await customFn.fn(transformedData);
-        if (!customFn.executeMainFn && created) return created;
-    }
-    if (!created) created = await adapter.create({
-        model: model,
-        data: transformedData
-    });
-    if (created) await processHooks(created, model, 'create', 'after', hooks, context);
-    return created;
-}
-async function update_hooks_updateWithHooks(adapter, ctx, props) {
-    const { data, where, model, customFn, context } = props;
-    const hooks = ctx.hooks || [];
-    const transformedData = await processHooks(data, model, 'update', 'before', hooks, context);
-    if (null === transformedData) return null;
-    let updated = null;
-    if (customFn) {
-        const result = await customFn.fn(transformedData);
-        updated = result;
-        if (!customFn.executeMainFn && updated) return updated;
-    }
-    if (!updated) updated = await adapter.update({
-        model: model,
-        update: transformedData,
-        where
-    });
-    if (updated) await processHooks(updated, model, 'update', 'after', hooks, context);
-    return updated;
-}
-async function executeCustomFunction(data, customFn) {
-    if (!customFn) return {
-        result: null,
-        shouldContinue: true
+            try {
+                ctx.logger?.info('Creating new anonymous subject');
+                return await this.createSubject({
+                    externalId: null,
+                    identityProvider: 'anonymous',
+                    lastIpAddress: ipAddress,
+                    isIdentified: false
+                }, context);
+            } catch (error) {
+                ctx.logger?.error('Failed to create anonymous subject', {
+                    ipAddress,
+                    error: error instanceof Error ? error.message : 'Unknown error'
+                });
+                throw new error_class_DoubleTieError('Failed to create anonymous subject', {
+                    code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
+                    status: 500,
+                    meta: {
+                        error: error instanceof Error ? error.message : 'Unknown error'
+                    }
+                });
+            }
+        },
+        findSubjectById: async (subjectId)=>{
+            const subject = await adapter.findOne({
+                model: 'subject',
+                where: [
+                    {
+                        field: 'id',
+                        value: subjectId
+                    }
+                ]
+            });
+            return subject ? validateEntityOutput('subject', subject, ctx.options) : null;
+        },
+        findSubjectByExternalId: async (externalId)=>{
+            const subject = await adapter.findOne({
+                model: 'subject',
+                where: [
+                    {
+                        field: 'externalId',
+                        value: externalId
+                    }
+                ]
+            });
+            return subject ? validateEntityOutput('subject', subject, ctx.options) : null;
+        }
     };
-    const result = await customFn.fn(data);
-    const shouldContinue = !result || !!customFn.executeMainFn;
+}
+function auditLogRegistry({ adapter, ...ctx }) {
+    const { createWithHooks } = getWithHooks(adapter, ctx);
     return {
-        result,
-        shouldContinue
+        createAuditLog: async (auditLog, context)=>{
+            const createdLog = await createWithHooks({
+                data: {
+                    createdAt: new Date(),
+                    ...auditLog
+                },
+                model: 'auditLog',
+                customFn: void 0,
+                context
+            });
+            if (!createdLog) throw new error_class_DoubleTieError('Failed to create audit log - operation returned null', {
+                code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
+                status: 500
+            });
+            return createdLog;
+        }
     };
 }
-function processUpdateManyResult(result) {
-    if (Array.isArray(result)) return result;
-    if ('number' == typeof result && result > 0) return [];
+const external_kysely_namespaceObject = require("kysely");
+function getDatabaseType(db) {
+    if (!db) return null;
+    if ('dialect' in db) return getDatabaseType(db.dialect);
+    if (db && 'object' == typeof db && 'createDriver' in db) {
+        if (db instanceof external_kysely_namespaceObject.SqliteDialect) return 'sqlite';
+        if (db instanceof external_kysely_namespaceObject.MysqlDialect) return 'mysql';
+        if (db instanceof external_kysely_namespaceObject.PostgresDialect) return 'postgres';
+        if (db instanceof external_kysely_namespaceObject.MssqlDialect) return 'mssql';
+    }
+    if (db && 'object' == typeof db && 'aggregate' in db) return 'sqlite';
+    if (db && 'object' == typeof db && 'getConnection' in db) return 'mysql';
+    if (db && 'object' == typeof db && 'connect' in db) return 'postgres';
     return null;
 }
-async function updateManyWithHooks(adapter, ctx, props) {
-    const { data, where, model, customFn, context } = props;
-    const hooks = ctx.hooks || [];
-    const transformedData = await processHooks(data, model, 'update', 'before', hooks, context);
-    if (null === transformedData) return null;
-    const { result: customResult, shouldContinue } = await executeCustomFunction(transformedData, customFn);
-    if (customResult && !shouldContinue) return customResult;
-    let updated = customResult;
-    if (!updated) {
-        const adapterResult = await adapter.updateMany({
-            model: model,
-            update: transformedData,
-            where
-        });
-        updated = processUpdateManyResult(adapterResult);
+const createKyselyAdapter = async (config)=>{
+    const db = config.database;
+    if (!db) return {
+        kysely: null,
+        databaseType: null
+    };
+    if (db && 'object' == typeof db && 'db' in db) {
+        const kyselyConfig = db;
+        return {
+            kysely: kyselyConfig.db,
+            databaseType: kyselyConfig.type
+        };
     }
-    if (updated && updated.length > 0) await processAfterHooksForMany(updated, model, hooks, context);
-    return updated;
-}
-function getWithHooks(adapter, ctx) {
-    return {
-        createWithHooks: ({ data, model, customFn, context })=>create_hooks_createWithHooks(adapter, ctx, {
-                data,
-                model,
-                customFn,
-                context
+    if (db && 'object' == typeof db && 'dialect' in db) {
+        const dialectConfig = db;
+        return {
+            kysely: new external_kysely_namespaceObject.Kysely({
+                dialect: dialectConfig.dialect
             }),
-        updateWithHooks: (props)=>update_hooks_updateWithHooks(adapter, ctx, props),
-        updateManyWithHooks: (props)=>updateManyWithHooks(adapter, ctx, props)
+            databaseType: dialectConfig.type
+        };
+    }
+    let dialect;
+    const databaseType = getDatabaseType(db);
+    if (db && 'object' == typeof db && 'createDriver' in db) dialect = db;
+    if (db && 'object' == typeof db && 'aggregate' in db) dialect = new external_kysely_namespaceObject.SqliteDialect({
+        database: db
+    });
+    if (db && 'object' == typeof db && 'getConnection' in db) dialect = new external_kysely_namespaceObject.MysqlDialect({
+        pool: db
+    });
+    if (db && 'object' == typeof db && 'connect' in db) dialect = new external_kysely_namespaceObject.PostgresDialect({
+        pool: db
+    });
+    return {
+        kysely: dialect ? new external_kysely_namespaceObject.Kysely({
+            dialect
+        }) : null,
+        databaseType
     };
-}
+};
+const external_superjson_namespaceObject = require("superjson");
+var external_superjson_default = /*#__PURE__*/ __webpack_require__.n(external_superjson_namespaceObject);
 const createEntityTransformer = (db, options, config)=>{
     const schema = definition_getConsentTables(options);
     function getField(model, field) {
@@ -1927,62 +1977,14 @@ const kyselyAdapter = (db, config)=>(opts)=>{
             options: config
         };
     };
-const external_kysely_namespaceObject = require("kysely");
-function getDatabaseType(db) {
-    if (!db) return null;
-    if ('dialect' in db) return getDatabaseType(db.dialect);
-    if (db && 'object' == typeof db && 'createDriver' in db) {
-        if (db instanceof external_kysely_namespaceObject.SqliteDialect) return 'sqlite';
-        if (db instanceof external_kysely_namespaceObject.MysqlDialect) return 'mysql';
-        if (db instanceof external_kysely_namespaceObject.PostgresDialect) return 'postgres';
-        if (db instanceof external_kysely_namespaceObject.MssqlDialect) return 'mssql';
+function utils_applyDefaultValue(inputValue, field, operation) {
+    if ('update' === operation) return inputValue;
+    if (null == inputValue && field.defaultValue) {
+        if ('function' == typeof field.defaultValue) return field.defaultValue();
+        return field.defaultValue;
     }
-    if (db && 'object' == typeof db && 'aggregate' in db) return 'sqlite';
-    if (db && 'object' == typeof db && 'getConnection' in db) return 'mysql';
-    if (db && 'object' == typeof db && 'connect' in db) return 'postgres';
-    return null;
+    return inputValue;
 }
-const createKyselyAdapter = async (config)=>{
-    const db = config.database;
-    if (!db) return {
-        kysely: null,
-        databaseType: null
-    };
-    if (db && 'object' == typeof db && 'db' in db) {
-        const kyselyConfig = db;
-        return {
-            kysely: kyselyConfig.db,
-            databaseType: kyselyConfig.type
-        };
-    }
-    if (db && 'object' == typeof db && 'dialect' in db) {
-        const dialectConfig = db;
-        return {
-            kysely: new external_kysely_namespaceObject.Kysely({
-                dialect: dialectConfig.dialect
-            }),
-            databaseType: dialectConfig.type
-        };
-    }
-    let dialect;
-    const databaseType = getDatabaseType(db);
-    if (db && 'object' == typeof db && 'createDriver' in db) dialect = db;
-    if (db && 'object' == typeof db && 'aggregate' in db) dialect = new external_kysely_namespaceObject.SqliteDialect({
-        database: db
-    });
-    if (db && 'object' == typeof db && 'getConnection' in db) dialect = new external_kysely_namespaceObject.MysqlDialect({
-        pool: db
-    });
-    if (db && 'object' == typeof db && 'connect' in db) dialect = new external_kysely_namespaceObject.PostgresDialect({
-        pool: db
-    });
-    return {
-        kysely: dialect ? new external_kysely_namespaceObject.Kysely({
-            dialect
-        }) : null,
-        databaseType
-    };
-};
 const memory_adapter_createEntityTransformer = (options)=>{
     const schema = definition_getConsentTables(options);
     function getField(model, field) {
@@ -2163,20 +2165,6 @@ const memoryAdapter = (db)=>(options)=>{
             }
         };
     };
-require("drizzle-orm");
-let globalLogger;
-function getLogger(options) {
-    if (!globalLogger) globalLogger = (0, logger_namespaceObject.createLogger)({
-        level: 'info',
-        appName: 'c15t',
-        ...options
-    });
-    return globalLogger;
-}
-function initLogger(options) {
-    globalLogger = (0, logger_namespaceObject.createLogger)(options);
-    return globalLogger;
-}
 async function getAdapter(options) {
     const logger = getLogger({
         appName: options.appName ?? 'c15t',
@@ -2201,6 +2189,7 @@ async function getAdapter(options) {
         type: databaseType || 'sqlite'
     })(options);
 }
+require("drizzle-orm");
 const env = 'undefined' != typeof process ? process.env : {};
 'undefined' != typeof process && process.env.NODE_ENV;
 function toBoolean(val) {
@@ -2235,7 +2224,7 @@ function getBaseURL(url, path) {
     if (fromEnv) return withPath(fromEnv, path);
 }
 var package_namespaceObject = {
-    i8: "1.5.0"
+    i8: "1.6.0"
 };
 const createRegistry = (ctx)=>({
         ...auditLogRegistry(ctx),
@@ -2267,7 +2256,7 @@ const init = async (options)=>{
                 logger.info('Telemetry is disabled by configuration');
                 telemetryInitialized = false;
             } else {
-                const resource = new resources_namespaceObject.Resource({
+                const resource = (0, resources_namespaceObject.resourceFromAttributes)({
                     'service.name': String(appName),
                     'service.version': String(package_namespaceObject.i8 || '1.0.0'),
                     ...telemetryOptions?.defaultAttributes || {}
@@ -2515,7 +2504,7 @@ const processCors = (request, context, trustedOrigins)=>{
     }
     return context;
 };
-const version = '1.5.0';
+const version = '1.6.0';
 const createOpenAPIConfig = (options)=>{
     const basePath = options.basePath || '';
     return {
@@ -2550,11 +2539,11 @@ const baseConsentSchema = external_zod_namespaceObject.z.object({
     externalSubjectId: external_zod_namespaceObject.z.string().optional(),
     domain: external_zod_namespaceObject.z.string(),
     type: PolicyTypeSchema,
-    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional()
+    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).optional()
 });
 const cookieBannerSchema = baseConsentSchema.extend({
     type: external_zod_namespaceObject.z.literal('cookie_banner'),
-    preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.boolean())
+    preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.boolean())
 });
 const policyBasedSchema = baseConsentSchema.extend({
     type: external_zod_namespaceObject.z["enum"]([
@@ -2563,7 +2552,7 @@ const policyBasedSchema = baseConsentSchema.extend({
         'terms_and_conditions'
     ]),
     policyId: external_zod_namespaceObject.z.string().optional(),
-    preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.boolean()).optional()
+    preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.boolean()).optional()
 });
 const otherConsentSchema = baseConsentSchema.extend({
     type: external_zod_namespaceObject.z["enum"]([
@@ -2571,7 +2560,7 @@ const otherConsentSchema = baseConsentSchema.extend({
         'age_verification',
         'other'
     ]),
-    preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.boolean()).optional()
+    preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.boolean()).optional()
 });
 const postConsentContract = contract_namespaceObject.oc.route({
     method: 'POST',
@@ -2610,64 +2599,64 @@ Use this endpoint to record user consent and maintain a compliant consent manage
 }).errors({
     INPUT_VALIDATION_FAILED: {
         status: 422,
-        message: 'Invalid input parameters',
         data: external_zod_namespaceObject.z.object({
             formErrors: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
             fieldErrors: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()))
-        })
+        }),
+        error: 'Invalid input parameters'
     },
     SUBJECT_CREATION_FAILED: {
         status: 400,
-        message: 'Failed to create or find subject',
         data: external_zod_namespaceObject.z.object({
             subjectId: external_zod_namespaceObject.z.string().optional(),
             externalSubjectId: external_zod_namespaceObject.z.string().optional()
-        })
+        }),
+        error: 'Failed to create or find subject'
     },
     DOMAIN_CREATION_FAILED: {
         status: 500,
-        message: 'Failed to create or find domain',
         data: external_zod_namespaceObject.z.object({
             domain: external_zod_namespaceObject.z.string()
-        })
+        }),
+        error: 'Failed to create or find domain'
     },
     POLICY_NOT_FOUND: {
         status: 404,
-        message: 'Policy not found',
         data: external_zod_namespaceObject.z.object({
             policyId: external_zod_namespaceObject.z.string(),
             type: external_zod_namespaceObject.z.string()
-        })
+        }),
+        error: 'Policy not found'
     },
     POLICY_INACTIVE: {
         status: 409,
-        message: 'Policy is not active',
         data: external_zod_namespaceObject.z.object({
             policyId: external_zod_namespaceObject.z.string(),
             type: external_zod_namespaceObject.z.string()
-        })
+        }),
+        error: 'Policy is not active'
     },
     POLICY_CREATION_FAILED: {
         status: 500,
-        message: 'Failed to create or find policy',
         data: external_zod_namespaceObject.z.object({
             type: external_zod_namespaceObject.z.string()
-        })
+        }),
+        error: 'Failed to create or find policy'
     },
     PURPOSE_CREATION_FAILED: {
         status: 500,
-        message: 'Failed to create consent purpose',
         data: external_zod_namespaceObject.z.object({
             purposeCode: external_zod_namespaceObject.z.string()
-        })
+        }),
+        error: 'Failed to create consent purpose'
     },
     CONSENT_CREATION_FAILED: {
         status: 500,
-        message: 'Failed to create consent record',
         data: external_zod_namespaceObject.z.object({
             subjectId: external_zod_namespaceObject.z.string(),
             domain: external_zod_namespaceObject.z.string()
-        })
+        }),
+        error: 'Failed to create consent record'
     }
 }).input(external_zod_namespaceObject.z.discriminatedUnion('type', [
     cookieBannerSchema,
@@ -2682,9 +2671,14 @@ Use this endpoint to record user consent and maintain a compliant consent manage
     type: PolicyTypeSchema,
     status: external_zod_namespaceObject.z.string(),
     recordId: external_zod_namespaceObject.z.string(),
-    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional(),
+    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).optional(),
     givenAt: external_zod_namespaceObject.z.date()
 }));
+const types_branding = [
+    'c15t',
+    'consent',
+    'none'
+];
 const JurisdictionMessages = {
     GDPR: 'GDPR or equivalent regulations require a cookie banner.',
     CH: 'Switzerland requires similar data protection measures.',
@@ -2770,20 +2764,21 @@ Use this endpoint to implement geo-targeted consent banners and ensure complianc
     translations: external_zod_namespaceObject.z.object({
         language: external_zod_namespaceObject.z.string(),
         translations: TranslationsSchema
-    })
+    }),
+    branding: external_zod_namespaceObject.z["enum"](types_branding)
 }));
-const verifyConsentInputSchema = external_zod_namespaceObject.z.object({
+const verifyConsentInputSchema = external_zod_namespaceObject.z.strictObject({
     subjectId: external_zod_namespaceObject.z.string().optional(),
     externalSubjectId: external_zod_namespaceObject.z.string().optional(),
     domain: external_zod_namespaceObject.z.string(),
     type: PolicyTypeSchema,
     policyId: external_zod_namespaceObject.z.string().optional(),
     preferences: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional()
-}).strict();
-const verify_contract_consentSchema = external_zod_namespaceObject.z.object({
+});
+const verify_contract_consentSchema = external_zod_namespaceObject.z.looseObject({
     id: external_zod_namespaceObject.z.string(),
     purposeIds: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string())
-}).passthrough();
+});
 const verifyConsentContract = contract_namespaceObject.oc.route({
     method: 'POST',
     path: '/consent/verify',
@@ -2811,58 +2806,58 @@ Use this endpoint to ensure compliance with privacy regulations and to verify us
 }).errors({
     INPUT_VALIDATION_FAILED: {
         status: 422,
-        message: 'Invalid input parameters',
         data: external_zod_namespaceObject.z.object({
             formErrors: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
             fieldErrors: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional())
-        })
+        }),
+        error: 'Invalid input parameters'
     },
     SUBJECT_NOT_FOUND: {
         status: 404,
-        message: 'Subject not found',
         data: external_zod_namespaceObject.z.object({
             subjectId: external_zod_namespaceObject.z.string().optional(),
             externalSubjectId: external_zod_namespaceObject.z.string().optional()
-        })
+        }),
+        error: 'Subject not found'
     },
     DOMAIN_NOT_FOUND: {
         status: 404,
-        message: 'Domain not found',
         data: external_zod_namespaceObject.z.object({
             domain: external_zod_namespaceObject.z.string()
-        })
+        }),
+        error: 'Domain not found'
     },
     POLICY_NOT_FOUND: {
         status: 404,
-        message: 'Policy not found or invalid',
         data: external_zod_namespaceObject.z.object({
             policyId: external_zod_namespaceObject.z.string(),
             type: external_zod_namespaceObject.z.string()
-        })
+        }),
+        error: 'Policy not found or invalid'
     },
     PURPOSES_NOT_FOUND: {
         status: 404,
-        message: 'Could not find all specified purposes',
         data: external_zod_namespaceObject.z.object({
             preferences: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
             foundPurposes: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string())
-        })
+        }),
+        error: 'Could not find all specified purposes'
     },
     COOKIE_BANNER_PREFERENCES_REQUIRED: {
         status: 400,
-        message: 'Preferences are required for cookie banner consent',
         data: external_zod_namespaceObject.z.object({
             type: external_zod_namespaceObject.z.literal('cookie_banner')
-        })
+        }),
+        error: 'Preferences are required for cookie banner consent'
     },
     NO_CONSENT_FOUND: {
         status: 404,
-        message: 'No consent found for the given policy',
         data: external_zod_namespaceObject.z.object({
             policyId: external_zod_namespaceObject.z.string(),
             subjectId: external_zod_namespaceObject.z.string(),
             domainId: external_zod_namespaceObject.z.string()
-        })
+        }),
+        error: 'No consent found for the given policy'
     }
 }).input(verifyConsentInputSchema).output(external_zod_namespaceObject.z.object({
     isValid: external_zod_namespaceObject.z.boolean(),
@@ -3227,11 +3222,11 @@ function getTranslations(acceptLanguage, customTranslations) {
     };
 }
 function getHeaders(headers) {
-    if (!headers) throw new server_namespaceObject.ORPCError('LOCATION_DETECTION_FAILED', {
-        data: {
-            reason: 'No headers found in request context'
-        }
-    });
+    if (!headers) return {
+        countryCode: null,
+        regionCode: null,
+        acceptLanguage: null
+    };
     const normalizeHeader = (value)=>{
         if (!value) return null;
         return Array.isArray(value) ? value[0] ?? null : value;
@@ -3245,17 +3240,18 @@ function getHeaders(headers) {
         acceptLanguage
     };
 }
-function buildResponse({ shouldShowBanner, jurisdiction, location, acceptLanguage, customTranslations }) {
+function buildResponse({ shouldShowBanner, jurisdiction, location, acceptLanguage, customTranslations, branding = 'c15t' }) {
     return {
         showConsentBanner: shouldShowBanner,
         jurisdiction,
         location,
-        translations: getTranslations(acceptLanguage, customTranslations)
+        translations: getTranslations(acceptLanguage, customTranslations),
+        branding
     };
 }
 const handler_showConsentBanner = os.consent.showBanner.handler(({ context })=>{
     const typedContext = context;
-    const { customTranslations, disableGeoLocation } = typedContext.options.advanced ?? {};
+    const { customTranslations, disableGeoLocation, branding } = typedContext.options.advanced ?? {};
     const { countryCode, regionCode, acceptLanguage } = getHeaders(typedContext.headers);
     if (disableGeoLocation) return buildResponse({
         shouldShowBanner: true,
@@ -3268,7 +3264,8 @@ const handler_showConsentBanner = os.consent.showBanner.handler(({ context })=>{
             regionCode: null
         },
         acceptLanguage,
-        customTranslations
+        customTranslations,
+        branding
     });
     const { showConsentBanner, jurisdictionCode, message } = checkJurisdiction(countryCode);
     return buildResponse({
@@ -3282,7 +3279,8 @@ const handler_showConsentBanner = os.consent.showBanner.handler(({ context })=>{
             regionCode
         },
         acceptLanguage,
-        customTranslations
+        customTranslations,
+        branding
     });
 });
 const verifyConsent = os.consent.verify.handler(async ({ input, context })=>{
@@ -3824,8 +3822,10 @@ const c15tInstance = (options)=>{
     };
 };
 exports.c15tInstance = __webpack_exports__.c15tInstance;
+exports.version = __webpack_exports__.version;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "c15tInstance"
+    "c15tInstance",
+    "version"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true