@c15t/backend 1.5.0 → 1.6.0

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

@@ -106,32 +106,20 @@ function getDatabaseType() {
 }
 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'),
@@ -151,18 +139,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[]')
@@ -486,7 +474,27 @@ class error_class_DoubleTieError extends server_namespaceObject.ORPCError {
         return formattedMessage;
     }
 }
-const logger_namespaceObject = require("@doubletie/logger");
+function auditLogRegistry({ adapter, ...ctx }) {
+    const { createWithHooks } = getWithHooks(adapter, ctx);
+    return {
+        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;
+        }
+    };
+}
 const auditLogSchema = external_zod_namespaceObject.z.object({
     id: external_zod_namespaceObject.z.string(),
     entityType: external_zod_namespaceObject.z.string(),
@@ -495,9 +503,9 @@ const 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;
@@ -596,6 +604,129 @@ function getAuditLogTable(options, auditLogFields) {
         order: 5
     };
 }
+const logger_namespaceObject = require("@doubletie/logger");
+const 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.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 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: 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 PolicyTypeSchema = external_zod_namespaceObject.z["enum"]([
     'cookie_banner',
     'privacy_policy',
@@ -614,9 +745,9 @@ const consentPolicySchema = external_zod_namespaceObject.z.object({
     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())
+    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;
@@ -683,12 +814,12 @@ const 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;
@@ -757,9 +888,9 @@ const 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;
@@ -810,184 +941,62 @@ function getConsentRecordTable(options, recordFields) {
         order: 4
     };
 }
-const consentSchema = external_zod_namespaceObject.z.object({
+const domainSchema = 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)
+    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().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 getConsentTable(options, consentFields) {
-    const consentConfig = options.tables?.consent;
-    const subjectConfig = options.tables?.subject;
+function getDomainTable(options, domainFields) {
     const domainConfig = options.tables?.domain;
-    const policyConfig = options.tables?.consentPolicy;
     return {
-        entityName: consentConfig?.entityName || 'consent',
-        entityPrefix: consentConfig?.entityPrefix || 'cns',
-        schema: consentSchema,
+        entityName: domainConfig?.entityName || 'domain',
+        entityPrefix: domainConfig?.entityPrefix || 'dom',
+        schema: domainSchema,
         fields: {
-            subjectId: {
+            name: {
                 type: 'string',
                 required: true,
-                fieldName: consentConfig?.fields?.subjectId || 'subjectId',
-                references: {
-                    model: subjectConfig?.entityName || 'subject',
-                    field: 'id'
-                }
+                unique: true,
+                fieldName: domainConfig?.fields?.name || 'name'
             },
-            domainId: {
+            description: {
                 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'
+                fieldName: domainConfig?.fields?.description || "description"
             },
-            metadata: {
+            allowedOrigins: {
                 type: 'json',
+                defaultValue: ()=>[],
                 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'
+                fieldName: domainConfig?.fields?.allowedOrigins || 'allowedOrigins'
             },
-            status: {
-                type: 'string',
-                defaultValue: ()=>'active',
+            isVerified: {
+                type: 'boolean',
+                defaultValue: true,
                 required: true,
-                fieldName: consentConfig?.fields?.status || 'status'
+                fieldName: domainConfig?.fields?.isVerified || 'isVerified'
             },
-            withdrawalReason: {
-                type: 'string',
-                required: false,
-                fieldName: consentConfig?.fields?.withdrawalReason || 'withdrawalReason'
+            isActive: {
+                type: 'boolean',
+                defaultValue: true,
+                required: true,
+                fieldName: domainConfig?.fields?.isActive || 'isActive'
             },
-            givenAt: {
+            createdAt: {
                 type: 'date',
                 defaultValue: ()=>new Date(),
                 required: true,
-                fieldName: consentConfig?.fields?.givenAt || 'givenAt'
+                fieldName: domainConfig?.fields?.createdAt || 'createdAt'
             },
-            validUntil: {
+            updatedAt: {
                 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 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())
-});
-function getDomainTable(options, domainFields) {
-    const domainConfig = options.tables?.domain;
-    return {
-        entityName: domainConfig?.entityName || 'domain',
-        entityPrefix: domainConfig?.entityPrefix || 'dom',
-        schema: domainSchema,
-        fields: {
-            name: {
-                type: 'string',
-                required: true,
-                unique: true,
-                fieldName: domainConfig?.fields?.name || 'name'
-            },
-            description: {
-                type: 'string',
-                required: false,
-                fieldName: domainConfig?.fields?.description || "description"
-            },
-            allowedOrigins: {
-                type: 'json',
-                defaultValue: ()=>[],
-                required: false,
-                fieldName: domainConfig?.fields?.allowedOrigins || 'allowedOrigins'
-            },
-            isVerified: {
-                type: 'boolean',
-                defaultValue: true,
-                required: true,
-                fieldName: domainConfig?.fields?.isVerified || 'isVerified'
-            },
-            isActive: {
-                type: 'boolean',
-                defaultValue: true,
-                required: true,
-                fieldName: domainConfig?.fields?.isActive || 'isActive'
-            },
-            createdAt: {
-                type: 'date',
-                defaultValue: ()=>new Date(),
-                required: true,
-                fieldName: domainConfig?.fields?.createdAt || 'createdAt'
-            },
-            updatedAt: {
-                type: 'date',
-                required: false,
-                fieldName: domainConfig?.fields?.updatedAt || 'updatedAt'
+                fieldName: domainConfig?.fields?.updatedAt || 'updatedAt'
             },
             ...domainFields || {},
             ...domainConfig?.additionalFields || {}
@@ -997,12 +1006,12 @@ function getDomainTable(options, domainFields) {
 }
 const 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;
@@ -1099,157 +1108,6 @@ function validateEntityOutput(tableName, data, options) {
         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;
-        },
-        findSubjectByExternalId: async (externalId)=>{
-            const subject = await adapter.findOne({
-                model: 'subject',
-                where: [
-                    {
-                        field: 'externalId',
-                        value: externalId
-                    }
-                ]
-            });
-            return subject ? validateEntityOutput('subject', subject, ctx.options) : null;
-        }
-    };
-}
 function consentRegistry({ adapter, ...ctx }) {
     const { createWithHooks, updateWithHooks } = getWithHooks(adapter, ctx);
     const registry = {
@@ -1525,24 +1383,154 @@ 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 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 createdLog;
+            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;
         }
     };
 }