@c15t/backend 0.0.1-rc.10

package/dist/db/index.cjs

@@ -0,0 +1,2458 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    booleanField: ()=>booleanField,
+    getConsentTables: ()=>getConsentTables,
+    numberField: ()=>numberField,
+    numberArrayField: ()=>numberArrayField,
+    parseEntityOutputData: ()=>parseEntityOutputData,
+    stringArrayField: ()=>stringArrayField,
+    parseInputData: ()=>parseInputData,
+    dateField: ()=>dateField,
+    getAllFields: ()=>getAllFields,
+    getMigrations: ()=>getMigrations,
+    getAdapter: ()=>getAdapter,
+    stringField: ()=>stringField
+});
+const 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: value.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),
+        consentPurposeJunction: getPurposeJunctionTable(options, consentPurposeJunction?.fields),
+        consentRecord: getConsentRecordTable(options, record?.fields),
+        consentGeoLocation: getConsentGeoLocationTable(options, consentGeoLocation?.fields),
+        consentWithdrawal: getConsentWithdrawalTable(options, consentWithdrawal?.fields),
+        auditLog: getAuditLogTable(options, auditLog?.fields),
+        geoLocation: getGeoLocationTable(options, geoLocation?.fields),
+        ...pluginTables
+    };
+};
+const external_zod_namespaceObject = require("zod");
+const auditLogSchema = external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    entityType: external_zod_namespaceObject.z.string(),
+    entityId: external_zod_namespaceObject.z.string(),
+    actionType: external_zod_namespaceObject.z.string(),
+    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())
+});
+const external_superjson_namespaceObject = require("superjson");
+var external_superjson_default = /*#__PURE__*/ __webpack_require__.n(external_superjson_namespaceObject);
+const currentDatabaseType = 'unknown';
+function getDatabaseType() {
+    return currentDatabaseType;
+}
+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(),
+    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()
+    }).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(),
+    unique: external_zod_namespaceObject.z.boolean().optional(),
+    indexed: external_zod_namespaceObject.z.boolean().optional(),
+    sortable: external_zod_namespaceObject.z.boolean().default(true),
+    fieldName: external_zod_namespaceObject.z.string().optional(),
+    bigint: external_zod_namespaceObject.z.boolean().default(false)
+});
+const stringFieldSchema = fieldConfigSchema.extend({
+    type: external_zod_namespaceObject.z.literal('string'),
+    minLength: external_zod_namespaceObject.z.number().optional(),
+    maxLength: external_zod_namespaceObject.z.number().optional(),
+    pattern: external_zod_namespaceObject.z.string().optional()
+});
+const numberFieldSchema = fieldConfigSchema.extend({
+    type: external_zod_namespaceObject.z.literal('number'),
+    min: external_zod_namespaceObject.z.number().optional(),
+    max: external_zod_namespaceObject.z.number().optional()
+});
+const booleanFieldSchema = fieldConfigSchema.extend({
+    type: external_zod_namespaceObject.z.literal('boolean')
+});
+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()
+});
+const timezoneFieldSchema = fieldConfigSchema.extend({
+    type: external_zod_namespaceObject.z.literal('timezone'),
+    validateTimezone: external_zod_namespaceObject.z.boolean().default(true),
+    suggestedValues: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
+    restrictToSuggestedValues: external_zod_namespaceObject.z.boolean().default(false)
+});
+const jsonFieldSchema = fieldConfigSchema.extend({
+    type: external_zod_namespaceObject.z.literal('json'),
+    validateJson: external_zod_namespaceObject.z.boolean().default(true)
+});
+const stringArrayFieldSchema = fieldConfigSchema.extend({
+    type: external_zod_namespaceObject.z.literal('string[]')
+});
+const numberArrayFieldSchema = fieldConfigSchema.extend({
+    type: external_zod_namespaceObject.z.literal('number[]')
+});
+const fieldSchema = external_zod_namespaceObject.z.discriminatedUnion('type', [
+    stringFieldSchema,
+    numberFieldSchema,
+    booleanFieldSchema,
+    dateFieldSchema,
+    timezoneFieldSchema,
+    jsonFieldSchema,
+    stringArrayFieldSchema,
+    numberArrayFieldSchema
+]);
+function validateField(field) {
+    return fieldSchema.parse(field);
+}
+const COMMON_TIMEZONES = {
+    UTC: 'UTC',
+    GMT: 'GMT',
+    EASTERN: 'America/New_York',
+    CENTRAL: 'America/Chicago',
+    MOUNTAIN: 'America/Denver',
+    PACIFIC: 'America/Los_Angeles',
+    LONDON: 'Europe/London',
+    PARIS: 'Europe/Paris',
+    BERLIN: 'Europe/Berlin',
+    TOKYO: 'Asia/Tokyo',
+    SHANGHAI: 'Asia/Shanghai',
+    SINGAPORE: 'Asia/Singapore',
+    SYDNEY: 'Australia/Sydney',
+    SAO_PAULO: 'America/Sao_Paulo'
+};
+function createField(type, config) {
+    const fieldConfig = {
+        type,
+        required: true,
+        returned: true,
+        input: true,
+        sortable: true,
+        bigint: false,
+        ...config
+    };
+    return validateField(fieldConfig);
+}
+function stringField(config = {}) {
+    return createField('string', config);
+}
+function numberField(config = {}) {
+    return createField('number', config);
+}
+function booleanField(config = {}) {
+    return createField('boolean', config);
+}
+function dateField(config = {}) {
+    const { transform = {}, minDate, maxDate, dateOnly = false, format, validator, ...restConfig } = config;
+    const originalInputTransform = transform.input;
+    const originalOutputTransform = transform.output;
+    const dbType = getDatabaseType();
+    const inputTransform = async (value)=>{
+        let transformedValue = value;
+        if (originalInputTransform) transformedValue = await originalInputTransform(value);
+        if (dateOnly && transformedValue instanceof Date) {
+            const dateOnlyValue = new Date(transformedValue);
+            dateOnlyValue.setHours(0, 0, 0, 0);
+            transformedValue = dateOnlyValue;
+        }
+        if ('sqlite' === dbType) return external_superjson_default().stringify({
+            date: transformedValue
+        });
+        return transformedValue;
+    };
+    const outputTransform = async (value)=>{
+        let parsedValue = value;
+        if ('sqlite' === dbType && 'string' == typeof value && value.includes('"date"')) try {
+            const parsed = external_superjson_default().parse(value);
+            parsedValue = parsed.date;
+        } catch  {}
+        if (originalOutputTransform && parsedValue instanceof Date) return await originalOutputTransform(parsedValue);
+        if (!originalOutputTransform && format && parsedValue instanceof Date) return new Date(new Intl.DateTimeFormat(void 0, format).format(parsedValue));
+        return parsedValue;
+    };
+    let dateValidator = validator;
+    if ((minDate || maxDate) && !dateValidator) dateValidator = (value)=>{
+        if (!(value instanceof Date)) return 'Value must be a Date object';
+        if (minDate && value < minDate) return `Date must not be earlier than ${minDate.toISOString()}`;
+        if (maxDate && value > maxDate) return `Date must not be later than ${maxDate.toISOString()}`;
+        return null;
+    };
+    else if ((minDate || maxDate) && dateValidator && 'function' == typeof dateValidator) {
+        const originalValidator = dateValidator;
+        dateValidator = (value)=>{
+            if (!(value instanceof Date)) return 'Value must be a Date object';
+            if (minDate && value < minDate) return `Date must not be earlier than ${minDate.toISOString()}`;
+            if (maxDate && value > maxDate) return `Date must not be later than ${maxDate.toISOString()}`;
+            return originalValidator(value);
+        };
+    }
+    return createField('date', {
+        ...restConfig,
+        transform: {
+            input: inputTransform,
+            output: outputTransform
+        },
+        validator: dateValidator
+    });
+}
+function stringArrayField(config = {}) {
+    return createField('string[]', config);
+}
+function numberArrayField(config = {}) {
+    return createField('number[]', config);
+}
+const external_base_x_namespaceObject = require("base-x");
+var external_base_x_default = /*#__PURE__*/ __webpack_require__.n(external_base_x_namespaceObject);
+const b58 = external_base_x_default()('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
+function generateId(prefix) {
+    const buf = crypto.getRandomValues(new Uint8Array(20));
+    const EPOCH_TIMESTAMP = 1700000000000;
+    const t = Date.now() - EPOCH_TIMESTAMP;
+    const high = Math.floor(t / 0x100000000);
+    const low = t >>> 0;
+    buf[0] = high >>> 24 & 255;
+    buf[1] = high >>> 16 & 255;
+    buf[2] = high >>> 8 & 255;
+    buf[3] = 255 & high;
+    buf[4] = low >>> 24 & 255;
+    buf[5] = low >>> 16 & 255;
+    buf[6] = low >>> 8 & 255;
+    buf[7] = 255 & low;
+    return `${prefix}_${b58.encode(buf)}`;
+}
+function getAuditLogTable(options, auditLogFields) {
+    const auditLogConfig = options.tables?.auditLog;
+    const subjectConfig = options.tables?.subject;
+    return {
+        entityName: auditLogConfig?.entityName || 'auditLog',
+        entityPrefix: auditLogConfig?.entityPrefix || 'log',
+        schema: auditLogSchema,
+        fields: {
+            entityType: {
+                type: 'string',
+                required: true,
+                fieldName: auditLogConfig?.fields?.entityType || 'entityType'
+            },
+            entityId: {
+                type: 'string',
+                required: true,
+                fieldName: auditLogConfig?.fields?.entityId || 'entityId'
+            },
+            actionType: {
+                type: 'string',
+                required: true,
+                fieldName: auditLogConfig?.fields?.actionType || 'actionType'
+            },
+            subjectId: {
+                type: 'string',
+                required: false,
+                fieldName: auditLogConfig?.fields?.subjectId || 'subjectId',
+                references: {
+                    model: subjectConfig?.entityName || 'subject',
+                    field: 'id'
+                }
+            },
+            ipAddress: {
+                type: 'string',
+                required: false,
+                fieldName: auditLogConfig?.fields?.ipAddress || 'ipAddress'
+            },
+            userAgent: {
+                type: 'string',
+                required: false,
+                fieldName: auditLogConfig?.fields?.userAgent || 'userAgent'
+            },
+            changes: {
+                type: 'json',
+                required: false,
+                fieldName: auditLogConfig?.fields?.changes || 'changes'
+            },
+            metadata: {
+                type: 'json',
+                required: false,
+                fieldName: auditLogConfig?.fields?.metadata || 'metadata'
+            },
+            createdAt: {
+                type: 'date',
+                defaultValue: ()=>new Date(),
+                required: true,
+                fieldName: auditLogConfig?.fields?.createdAt || 'createdAt'
+            },
+            eventTimezone: {
+                type: 'timezone',
+                required: true,
+                defaultValue: COMMON_TIMEZONES.UTC,
+                fieldName: auditLogConfig?.fields?.eventTimezone || 'eventTimezone'
+            },
+            ...auditLogFields || {},
+            ...auditLogConfig?.additionalFields || {}
+        },
+        indexes: [
+            {
+                name: 'entity_index',
+                fields: [
+                    'entityType',
+                    'entityId'
+                ]
+            },
+            {
+                name: 'action_type_index',
+                fields: [
+                    'actionType'
+                ]
+            },
+            {
+                name: 'subject_id_index',
+                fields: [
+                    'subjectId'
+                ]
+            },
+            {
+                name: 'created_at_index',
+                fields: [
+                    'createdAt'
+                ]
+            }
+        ],
+        order: 5
+    };
+}
+const consentGeoLocationSchema = external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    consentId: external_zod_namespaceObject.z.string(),
+    ip: external_zod_namespaceObject.z.string().ip(),
+    country: external_zod_namespaceObject.z.string().optional(),
+    region: external_zod_namespaceObject.z.string().optional(),
+    city: external_zod_namespaceObject.z.string().optional(),
+    latitude: external_zod_namespaceObject.z.number().min(-90).max(90).optional(),
+    longitude: external_zod_namespaceObject.z.number().min(-180).max(180).optional(),
+    timezone: external_zod_namespaceObject.z.string().regex(/^[A-Za-z_]+\/[A-Za-z_]+$/).optional(),
+    createdAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
+    updatedAt: external_zod_namespaceObject.z.date().default(()=>new Date())
+});
+function getConsentGeoLocationTable(options, geoLocationFields) {
+    const consentGeoLocationConfig = options.tables?.consentGeoLocation;
+    const consentConfig = options.tables?.consent;
+    return {
+        entityName: consentGeoLocationConfig?.entityName || 'consentGeoLocation',
+        entityPrefix: consentGeoLocationConfig?.entityPrefix || 'cgl',
+        schema: consentGeoLocationSchema,
+        fields: {
+            consentId: {
+                type: 'string',
+                required: true,
+                fieldName: consentGeoLocationConfig?.fields?.consentId || 'consentId',
+                references: {
+                    model: consentConfig?.entityName || 'consent',
+                    field: 'id'
+                }
+            },
+            ip: {
+                type: 'string',
+                required: true,
+                fieldName: consentGeoLocationConfig?.fields?.ip || 'ip'
+            },
+            country: {
+                type: 'string',
+                required: false,
+                fieldName: consentGeoLocationConfig?.fields?.country || 'country'
+            },
+            region: {
+                type: 'string',
+                required: false,
+                fieldName: consentGeoLocationConfig?.fields?.region || 'region'
+            },
+            city: {
+                type: 'string',
+                required: false,
+                fieldName: consentGeoLocationConfig?.fields?.city || 'city'
+            },
+            latitude: {
+                type: 'number',
+                required: false,
+                fieldName: consentGeoLocationConfig?.fields?.latitude || 'latitude'
+            },
+            longitude: {
+                type: 'number',
+                required: false,
+                fieldName: consentGeoLocationConfig?.fields?.longitude || 'longitude'
+            },
+            timezone: {
+                type: 'string',
+                required: false,
+                fieldName: consentGeoLocationConfig?.fields?.timezone || 'timezone'
+            },
+            createdAt: {
+                type: 'date',
+                defaultValue: ()=>new Date(),
+                required: true,
+                fieldName: consentGeoLocationConfig?.fields?.createdAt || 'createdAt'
+            },
+            ...geoLocationFields || {},
+            ...consentGeoLocationConfig?.additionalFields || {}
+        },
+        indexes: [
+            {
+                name: 'consent_id_index',
+                fields: [
+                    'consentId'
+                ]
+            },
+            {
+                name: 'country_index',
+                fields: [
+                    'country'
+                ]
+            },
+            {
+                name: 'created_at_index',
+                fields: [
+                    'createdAt'
+                ]
+            }
+        ],
+        order: 4
+    };
+}
+require("node:crypto");
+const consentPolicySchema = external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    version: external_zod_namespaceObject.z.string(),
+    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())
+});
+function getConsentPolicyTable(options, policyFields) {
+    const consentPolicyConfig = options.tables?.consentPolicy;
+    return {
+        entityName: consentPolicyConfig?.entityName || 'consentPolicy',
+        entityPrefix: consentPolicyConfig?.entityPrefix || 'pol',
+        schema: consentPolicySchema,
+        fields: {
+            version: {
+                type: 'string',
+                required: true,
+                fieldName: consentPolicyConfig?.fields?.version || 'version'
+            },
+            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'
+            },
+            isActive: {
+                type: 'boolean',
+                defaultValue: true,
+                required: true,
+                fieldName: consentPolicyConfig?.fields?.isActive || 'isActive'
+            },
+            createdAt: {
+                type: 'date',
+                defaultValue: ()=>new Date(),
+                required: true,
+                fieldName: consentPolicyConfig?.fields?.createdAt || 'createdAt'
+            },
+            ...policyFields || {},
+            ...consentPolicyConfig?.additionalFields || {}
+        },
+        order: 2
+    };
+}
+const consentPurposeJunctionSchema = external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    consentId: external_zod_namespaceObject.z.string(),
+    consentPurposeId: external_zod_namespaceObject.z.string(),
+    status: external_zod_namespaceObject.z["enum"]([
+        'active',
+        'withdrawn'
+    ], {
+        errorMap: ()=>({
+                message: "Status must be either 'active' or 'withdrawn'"
+            })
+    }).default('active'),
+    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.union([
+        external_zod_namespaceObject.z.string(),
+        external_zod_namespaceObject.z.number(),
+        external_zod_namespaceObject.z.boolean()
+    ])).optional(),
+    createdAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
+    updatedAt: external_zod_namespaceObject.z.date().default(()=>new Date())
+});
+function getPurposeJunctionTable(options, junctionFields) {
+    const purposeJunctionConfig = options.tables?.consentPurposeJunction;
+    const consentConfig = options.tables?.consent;
+    const purposeConfig = options.tables?.consentPurpose;
+    return {
+        entityName: purposeJunctionConfig?.entityName || 'consentPurposeJunction',
+        entityPrefix: purposeJunctionConfig?.entityPrefix || 'pjx',
+        schema: consentPurposeJunctionSchema,
+        fields: {
+            consentId: {
+                type: 'string',
+                required: true,
+                fieldName: purposeJunctionConfig?.fields?.consentId || 'consentId',
+                references: {
+                    model: consentConfig?.entityName || 'consent',
+                    field: 'id'
+                }
+            },
+            purposeId: {
+                type: 'string',
+                required: true,
+                fieldName: purposeJunctionConfig?.fields?.purposeId || 'purposeId',
+                references: {
+                    model: purposeConfig?.entityName || 'consentPurpose',
+                    field: 'id'
+                }
+            },
+            status: {
+                type: 'string',
+                defaultValue: ()=>'active',
+                required: true,
+                fieldName: purposeJunctionConfig?.fields?.status || 'status'
+            },
+            metadata: {
+                type: 'json',
+                required: false,
+                fieldName: purposeJunctionConfig?.fields?.metadata || 'metadata'
+            },
+            createdAt: {
+                type: 'date',
+                defaultValue: ()=>new Date(),
+                required: true,
+                fieldName: purposeJunctionConfig?.fields?.createdAt || 'createdAt'
+            },
+            updatedAt: {
+                type: 'date',
+                required: false,
+                fieldName: purposeJunctionConfig?.fields?.updatedAt || 'updatedAt'
+            },
+            ...junctionFields || {},
+            ...purposeJunctionConfig?.additionalFields || {}
+        },
+        uniqueConstraints: [
+            {
+                name: 'unique_consent_purpose',
+                fields: [
+                    'consentId',
+                    'purposeId'
+                ]
+            }
+        ],
+        order: 4
+    };
+}
+const purposeSchema = external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    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),
+    dataCategory: external_zod_namespaceObject.z.string().optional(),
+    legalBasis: external_zod_namespaceObject.z.string().optional(),
+    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 getPurposeTable(options, purposeFields) {
+    const purposeConfig = options.tables?.consentPurpose;
+    return {
+        entityName: purposeConfig?.entityName || 'consentPurpose',
+        entityPrefix: purposeConfig?.entityPrefix || 'pur',
+        schema: purposeSchema,
+        fields: {
+            code: {
+                type: 'string',
+                required: true,
+                fieldName: purposeConfig?.fields?.code || 'code'
+            },
+            name: {
+                type: 'string',
+                required: true,
+                fieldName: purposeConfig?.fields?.name || 'name'
+            },
+            description: {
+                type: 'string',
+                required: true,
+                fieldName: purposeConfig?.fields?.description || "description"
+            },
+            isEssential: {
+                type: 'boolean',
+                defaultValue: ()=>false,
+                required: true,
+                fieldName: purposeConfig?.fields?.isEssential || 'isEssential'
+            },
+            dataCategory: {
+                type: 'string',
+                required: false,
+                fieldName: purposeConfig?.fields?.dataCategory || 'dataCategory'
+            },
+            legalBasis: {
+                type: 'string',
+                required: false,
+                fieldName: purposeConfig?.fields?.legalBasis || 'legalBasis'
+            },
+            isActive: {
+                type: 'boolean',
+                defaultValue: true,
+                required: true,
+                fieldName: purposeConfig?.fields?.isActive || 'isActive'
+            },
+            createdAt: {
+                type: 'date',
+                defaultValue: ()=>new Date(),
+                required: true,
+                fieldName: purposeConfig?.fields?.createdAt || 'createdAt'
+            },
+            updatedAt: {
+                type: 'date',
+                defaultValue: ()=>new Date(),
+                required: true,
+                fieldName: purposeConfig?.fields?.updatedAt || 'updatedAt'
+            },
+            ...purposeFields || {},
+            ...purposeConfig?.additionalFields || {}
+        },
+        order: 1
+    };
+}
+const consentRecordSchema = external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    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())
+});
+function getConsentRecordTable(options, recordFields) {
+    const recordConfig = options.tables?.record;
+    const subjectConfig = options.tables?.subject;
+    const consentConfig = options.tables?.consent;
+    return {
+        entityName: recordConfig?.entityName || 'consentRecord',
+        entityPrefix: recordConfig?.entityPrefix || 'rec',
+        schema: consentRecordSchema,
+        fields: {
+            subjectId: {
+                type: 'string',
+                required: true,
+                fieldName: recordConfig?.fields?.subjectId || 'subjectId',
+                references: {
+                    model: subjectConfig?.entityName || 'subject',
+                    field: 'id'
+                }
+            },
+            consentId: {
+                type: 'string',
+                required: false,
+                fieldName: recordConfig?.fields?.consentId || 'consentId',
+                references: {
+                    model: consentConfig?.entityName || 'consent',
+                    field: 'id'
+                }
+            },
+            actionType: {
+                type: 'string',
+                required: true,
+                fieldName: recordConfig?.fields?.actionType || 'actionType'
+            },
+            details: {
+                type: 'json',
+                required: false,
+                fieldName: recordConfig?.fields?.details || 'details'
+            },
+            createdAt: {
+                type: 'date',
+                defaultValue: ()=>new Date(),
+                required: true,
+                fieldName: recordConfig?.fields?.createdAt || 'createdAt'
+            },
+            ...recordFields || {},
+            ...recordConfig?.additionalFields || {}
+        },
+        order: 4
+    };
+}
+const consentWithdrawalSchema = external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    consentId: external_zod_namespaceObject.z.string(),
+    subjectId: external_zod_namespaceObject.z.string(),
+    withdrawalReason: external_zod_namespaceObject.z.string().optional(),
+    withdrawalMethod: external_zod_namespaceObject.z["enum"]([
+        'subject-initiated',
+        'automatic-expiry',
+        'admin',
+        'api',
+        'other'
+    ]).default('subject-initiated'),
+    ipAddress: external_zod_namespaceObject.z.string().optional(),
+    userAgent: external_zod_namespaceObject.z.string().optional(),
+    metadata: 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())
+});
+function getConsentWithdrawalTable(options, withdrawalFields) {
+    const consentWithdrawalConfig = options.tables?.consentWithdrawal;
+    const consentConfig = options.tables?.consent;
+    const subjectConfig = options.tables?.subject;
+    return {
+        entityName: consentWithdrawalConfig?.entityName || 'consentWithdrawal',
+        entityPrefix: consentWithdrawalConfig?.entityPrefix || 'wdr',
+        schema: consentWithdrawalSchema,
+        fields: {
+            consentId: {
+                type: 'string',
+                required: true,
+                fieldName: consentWithdrawalConfig?.fields?.consentId || 'consentId',
+                references: {
+                    model: consentConfig?.entityName || 'consent',
+                    field: 'id'
+                }
+            },
+            subjectId: {
+                type: 'string',
+                required: true,
+                fieldName: consentWithdrawalConfig?.fields?.subjectId || 'subjectId',
+                references: {
+                    model: subjectConfig?.entityName || 'subject',
+                    field: 'id'
+                }
+            },
+            withdrawalReason: {
+                type: 'string',
+                required: false,
+                fieldName: consentWithdrawalConfig?.fields?.withdrawalReason || 'withdrawalReason'
+            },
+            withdrawalMethod: {
+                type: 'string',
+                defaultValue: ()=>'subject-initiated',
+                required: true,
+                fieldName: consentWithdrawalConfig?.fields?.withdrawalMethod || 'withdrawalMethod'
+            },
+            ipAddress: {
+                type: 'string',
+                required: false,
+                fieldName: consentWithdrawalConfig?.fields?.ipAddress || 'ipAddress'
+            },
+            userAgent: {
+                type: 'string',
+                required: false,
+                fieldName: consentWithdrawalConfig?.fields?.userAgent || 'userAgent'
+            },
+            metadata: {
+                type: 'json',
+                required: false,
+                fieldName: consentWithdrawalConfig?.fields?.metadata || 'metadata'
+            },
+            createdAt: {
+                type: 'date',
+                defaultValue: ()=>new Date(),
+                required: true,
+                fieldName: consentWithdrawalConfig?.fields?.createdAt || 'createdAt'
+            },
+            ...withdrawalFields || {},
+            ...consentWithdrawalConfig?.additionalFields || {}
+        },
+        uniqueConstraints: consentWithdrawalConfig?.preventMultipleWithdrawals !== false ? [
+            {
+                name: 'unique_consent_withdrawal',
+                fields: [
+                    'consentId'
+                ]
+            }
+        ] : [],
+        indexes: [
+            {
+                name: 'subject_id_index',
+                fields: [
+                    'subjectId'
+                ]
+            },
+            {
+                name: 'created_at_index',
+                fields: [
+                    'createdAt'
+                ]
+            }
+        ],
+        order: 4
+    };
+}
+const consentHistorySchema = external_zod_namespaceObject.z.object({
+    actionType: external_zod_namespaceObject.z["enum"]([
+        'given',
+        'withdrawn',
+        'updated',
+        'expired'
+    ]),
+    timestamp: external_zod_namespaceObject.z.date(),
+    details: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional(),
+    previousState: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional(),
+    newState: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional()
+});
+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.unknown()).optional(),
+    policyId: external_zod_namespaceObject.z.string().optional(),
+    ipAddress: external_zod_namespaceObject.z.string().optional(),
+    userAgent: external_zod_namespaceObject.z.string().optional(),
+    status: external_zod_namespaceObject.z["enum"]([
+        'active',
+        'withdrawn',
+        'expired'
+    ]).default('active'),
+    withdrawalReason: external_zod_namespaceObject.z.string().optional(),
+    givenAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
+    validUntil: external_zod_namespaceObject.z.date().optional(),
+    isActive: external_zod_namespaceObject.z.boolean().default(true),
+    history: external_zod_namespaceObject.z.array(consentHistorySchema).default([])
+});
+function getConsentTable(options, consentFields) {
+    const consentConfig = options.tables?.consent;
+    const subjectConfig = options.tables?.subject;
+    const domainConfig = options.tables?.domain;
+    const policyConfig = options.tables?.consentPolicy;
+    const purposeConfig = options.tables?.consentPurpose;
+    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',
+                references: {
+                    model: purposeConfig?.entityName || 'consentPurpose',
+                    field: 'id',
+                    type: 'array'
+                }
+            },
+            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 codes_BASE_ERROR_CODES = {
+    NOT_FOUND: 'Resource not found',
+    BAD_REQUEST: 'Bad request',
+    CONFLICT: 'Conflict with current state',
+    CONSENT_NOT_FOUND: 'Consent not found',
+    CONSENT_EXPIRED: 'Consent has expired',
+    FAILED_TO_CREATE_CONSENT: 'Failed to create consent',
+    FAILED_TO_UPDATE_CONSENT: 'Failed to update consent',
+    FAILED_TO_GET_CONSENT: 'Failed to get consent',
+    FAILED_TO_CREATE_PURPOSE: 'Failed to create consentPurpose',
+    PURPOSE_NOT_FOUND: 'Consent Purpose not found',
+    INVALID_CONFIGURATION: 'Invalid configuration',
+    MISSING_REQUIRED_PARAMETER: 'Missing required parameter',
+    UNAUTHORIZED: 'Unauthorized',
+    FORBIDDEN: 'Forbidden',
+    INTERNAL_SERVER_ERROR: 'Internal server error',
+    INITIALIZATION_FAILED: 'Initialization failed',
+    PLUGIN_INITIALIZATION_FAILED: 'Plugin initialization failed',
+    DATABASE_CONNECTION_ERROR: 'Database connection error',
+    DATABASE_QUERY_ERROR: 'Database query error',
+    REQUEST_HANDLER_ERROR: 'Request handler error',
+    API_RETRIEVAL_ERROR: 'API retrieval error',
+    INVALID_REQUEST: 'Invalid request',
+    UNKNOWN_ERROR: 'Unknown error'
+};
+class error_C15TError extends Error {
+    code;
+    status;
+    data;
+    category;
+    constructor(message, options){
+        super(message);
+        this.name = 'C15TError';
+        if (options) {
+            this.code = options.code;
+            this.status = options.status;
+            this.data = options.data;
+            this.category = options.category;
+        }
+        Object.setPrototypeOf(this, error_C15TError.prototype);
+    }
+    static fromResponse(response, data) {
+        let message = `HTTP error ${response.status}`;
+        let code;
+        let errorData;
+        if (data && 'object' == typeof data && null !== data) {
+            const errorObj = data;
+            if ('string' == typeof errorObj.message) message = errorObj.message;
+            if ('string' == typeof errorObj.code) {
+                const isKnownCode = Object.values(codes_BASE_ERROR_CODES).includes(errorObj.code);
+                if (isKnownCode) code = errorObj.code;
+            }
+            if ('object' == typeof errorObj.data && null !== errorObj.data) errorData = errorObj.data;
+        }
+        return new error_C15TError(message, {
+            code,
+            status: response.status,
+            data: errorData
+        });
+    }
+    static isC15TError(error) {
+        return error instanceof error_C15TError;
+    }
+}
+require("neverthrow");
+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'
+            },
+            ...domainFields || {},
+            ...domainConfig?.additionalFields || {}
+        },
+        order: 1
+    };
+}
+const geoLocationSchema = external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    countryCode: external_zod_namespaceObject.z.string().length(2).toUpperCase(),
+    countryName: external_zod_namespaceObject.z.string(),
+    regionCode: external_zod_namespaceObject.z.string().optional(),
+    regionName: external_zod_namespaceObject.z.string().optional(),
+    regulatoryZones: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z["enum"]([
+        'GDPR',
+        'CCPA',
+        'CPRA',
+        'LGPD',
+        'PIPEDA'
+    ])).optional(),
+    createdAt: external_zod_namespaceObject.z.date().default(()=>new Date())
+});
+function getGeoLocationTable(options, geoLocationFields) {
+    const geoLocationConfig = options.tables?.geoLocation;
+    return {
+        entityName: geoLocationConfig?.entityName || 'geoLocation',
+        entityPrefix: geoLocationConfig?.entityPrefix || 'geo',
+        schema: geoLocationSchema,
+        fields: {
+            countryCode: {
+                type: 'string',
+                required: true,
+                fieldName: geoLocationConfig?.fields?.countryCode || 'countryCode'
+            },
+            countryName: {
+                type: 'string',
+                required: true,
+                fieldName: geoLocationConfig?.fields?.countryName || 'countryName'
+            },
+            regionCode: {
+                type: 'string',
+                required: false,
+                fieldName: geoLocationConfig?.fields?.regionCode || 'regionCode'
+            },
+            regionName: {
+                type: 'string',
+                required: false,
+                fieldName: geoLocationConfig?.fields?.regionName || 'regionName'
+            },
+            regulatoryZones: {
+                type: 'json',
+                required: false,
+                fieldName: geoLocationConfig?.fields?.regulatoryZones || 'regulatoryZones',
+                transformer: {
+                    input: (value)=>JSON.stringify(value),
+                    output: (value)=>{
+                        try {
+                            return JSON.parse(value);
+                        } catch  {
+                            return [];
+                        }
+                    }
+                }
+            },
+            createdAt: {
+                type: 'date',
+                defaultValue: ()=>new Date(),
+                required: true,
+                fieldName: geoLocationConfig?.fields?.createdAt || 'createdAt'
+            },
+            ...geoLocationFields || {},
+            ...geoLocationConfig?.additionalFields || {}
+        },
+        indexes: [
+            {
+                name: 'country_code_index',
+                fields: [
+                    'countryCode'
+                ]
+            },
+            {
+                name: 'region_code_index',
+                fields: [
+                    'regionCode'
+                ]
+            },
+            {
+                name: 'created_at_index',
+                fields: [
+                    'createdAt'
+                ]
+            }
+        ],
+        order: 1
+    };
+}
+const subjectSchema = external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    isIdentified: external_zod_namespaceObject.z.boolean().default(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())
+});
+function getSubjectTable(options, subjectFields) {
+    const subjectConfig = options.tables?.subject;
+    return {
+        entityName: subjectConfig?.entityName || 'subject',
+        entityPrefix: subjectConfig?.entityPrefix || 'sub',
+        schema: subjectSchema,
+        fields: {
+            isIdentified: {
+                type: 'boolean',
+                defaultValue: ()=>false,
+                required: true,
+                fieldName: subjectConfig?.fields?.isIdentified || 'isIdentified'
+            },
+            externalId: {
+                type: 'string',
+                required: false,
+                fieldName: subjectConfig?.fields?.externalId || 'externalId'
+            },
+            identityProvider: {
+                type: 'string',
+                required: false,
+                fieldName: subjectConfig?.fields?.identityProvider || 'identityProvider'
+            },
+            lastIpAddress: {
+                type: 'string',
+                required: false,
+                fieldName: subjectConfig?.fields?.lastIpAddress || 'lastIpAddress'
+            },
+            createdAt: {
+                type: 'date',
+                defaultValue: ()=>new Date(),
+                required: true,
+                fieldName: subjectConfig?.fields?.createdAt || 'createdAt'
+            },
+            updatedAt: {
+                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
+    };
+}
+function parseEntityOutputData(data, schema) {
+    const fields = schema.fields;
+    const parsedData = {};
+    for(const key in data)if (Object.hasOwn(data, key)) {
+        const field = fields[key];
+        if (!field) {
+            parsedData[key] = data[key];
+            continue;
+        }
+        if (false === field.returned) continue;
+        parsedData[key] = data[key];
+    }
+    return parsedData;
+}
+function getAllFields(options, table, conflictResolution = {
+    strategy: 'error'
+}) {
+    const schema = {};
+    const fieldOrigins = new Map();
+    const addFields = (fields, source)=>{
+        for (const [key, field] of Object.entries(fields)){
+            if (schema[key]) {
+                const origins = fieldOrigins.get(key) || [];
+                origins.push(source);
+                fieldOrigins.set(key, origins);
+                if ('error' === conflictResolution.strategy) throw new error_C15TError('A field conflict was detected in the schema. Multiple definitions exist for the same field.', {
+                    code: codes_BASE_ERROR_CODES.CONFLICT,
+                    status: 500,
+                    data: {
+                        field: key,
+                        table,
+                        definedIn: origins.join(', ')
+                    }
+                });
+                if ('warn' === conflictResolution.strategy && conflictResolution.onWarning) conflictResolution.onWarning(`Field conflict detected for '${key}' in table '${table}'. Using last definition from ${source}.`);
+            }
+            schema[key] = field;
+        }
+    };
+    if (options.tables && table in options.tables) {
+        const tableConfig = options.tables[table];
+        if (tableConfig?.additionalFields) addFields(tableConfig.additionalFields, 'table configuration');
+    }
+    for (const plugin of options.plugins || []){
+        const pluginSchema = plugin.schema;
+        if (pluginSchema?.[table]) addFields(pluginSchema[table].fields, `plugin: ${plugin.name || 'unnamed'}`);
+    }
+    return schema;
+}
+function parseInputData(data, schema, extraFieldsConfig = {
+    strategy: 'error'
+}) {
+    const action = schema.action || 'create';
+    const fields = schema.fields;
+    const parsedData = {};
+    const extraFields = new Set();
+    for(const key in fields)if (Object.hasOwn(fields, key)) {
+        if (key in data) {
+            if (fields[key]?.input === false) {
+                if (fields[key]?.defaultValue) parsedData[key] = fields[key]?.defaultValue;
+                continue;
+            }
+            function isLegacyValidator(validator) {
+                return 'object' == typeof validator && null !== validator && 'input' in validator;
+            }
+            if (fields[key]?.validator && isLegacyValidator(fields[key]?.validator) && fields[key]?.validator.input && void 0 !== data[key]) {
+                parsedData[key] = fields[key]?.validator.input.parse(data[key]);
+                continue;
+            }
+            if (fields[key]?.transform?.input && void 0 !== data[key]) {
+                const inputValue = data[key];
+                parsedData[key] = fields[key]?.transform?.input(inputValue);
+                continue;
+            }
+            parsedData[key] = data[key];
+            continue;
+        }
+        if (fields[key]?.defaultValue && 'create' === action) {
+            parsedData[key] = fields[key]?.defaultValue;
+            continue;
+        }
+        if (fields[key]?.required && 'create' === action) throw new error_C15TError('Missing required field', {
+            code: codes_BASE_ERROR_CODES.BAD_REQUEST,
+            status: 400,
+            data: {
+                message: `${key} is required`
+            }
+        });
+    }
+    for(const key in data)if (Object.hasOwn(data, key) && !(key in fields)) extraFields.add(key);
+    if (extraFields.size > 0) {
+        const allowedFields = new Set(extraFieldsConfig.allowedExtraFields || []);
+        const unallowedFields = Array.from(extraFields).filter((field)=>!allowedFields.has(field));
+        if (unallowedFields.length > 0) switch(extraFieldsConfig.strategy){
+            case 'error':
+                throw new error_C15TError('Unexpected fields found', {
+                    code: codes_BASE_ERROR_CODES.BAD_REQUEST,
+                    status: 400,
+                    data: {
+                        message: `Unexpected fields found: ${unallowedFields.join(', ')}`
+                    }
+                });
+            case 'warn':
+                if (extraFieldsConfig.onWarning) extraFieldsConfig.onWarning(`Unexpected fields found: ${unallowedFields.join(', ')}`);
+                for (const key of extraFields)parsedData[key] = data[key];
+                break;
+            case 'silent':
+                for (const key of extraFields)parsedData[key] = data[key];
+                break;
+            case 'drop':
+                break;
+            default:
+                throw new error_C15TError('Unexpected fields found', {
+                    code: codes_BASE_ERROR_CODES.BAD_REQUEST,
+                    status: 400,
+                    data: {
+                        message: `Unexpected fields found: ${unallowedFields.join(', ')}`
+                    }
+                });
+        }
+        else for (const key of extraFields)parsedData[key] = data[key];
+    }
+    return parsedData;
+}
+const levels = [
+    'info',
+    'success',
+    'warn',
+    'error',
+    'debug'
+];
+function shouldPublishLog(currentLogLevel, logLevel) {
+    return levels.indexOf(logLevel) <= levels.indexOf(currentLogLevel);
+}
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    underscore: '\x1b[4m',
+    blink: '\x1b[5m',
+    reverse: '\x1b[7m',
+    hidden: '\x1b[8m',
+    fg: {
+        black: '\x1b[30m',
+        red: '\x1b[31m',
+        green: '\x1b[32m',
+        yellow: '\x1b[33m',
+        blue: '\x1b[34m',
+        magenta: '\x1b[35m',
+        cyan: '\x1b[36m',
+        white: '\x1b[37m'
+    },
+    bg: {
+        black: '\x1b[40m',
+        red: '\x1b[41m',
+        green: '\x1b[42m',
+        yellow: '\x1b[43m',
+        blue: '\x1b[44m',
+        magenta: '\x1b[45m',
+        cyan: '\x1b[46m',
+        white: '\x1b[47m'
+    }
+};
+const levelColors = {
+    info: colors.fg.blue,
+    success: colors.fg.green,
+    warn: colors.fg.yellow,
+    error: colors.fg.red,
+    debug: colors.fg.magenta
+};
+const formatMessage = (level, message)=>{
+    const timestamp = new Date().toISOString();
+    return `${colors.dim}${timestamp}${colors.reset} ${levelColors[level]}${level.toUpperCase()}${colors.reset} ${colors.bright}[c15t]:${colors.reset} ${message}`;
+};
+const createLogger = (options)=>{
+    const enabled = options?.disabled !== true;
+    const logLevel = options?.level ?? 'error';
+    const LogFunc = (level, message, args = [])=>{
+        if (!enabled || !shouldPublishLog(logLevel, level)) return;
+        const formattedMessage = formatMessage(level, message);
+        if (!options || 'function' != typeof options.log) {
+            if ('error' === level) console.error(formattedMessage, ...args);
+            else if ('warn' === level) console.warn(formattedMessage, ...args);
+            else if ('info' === level) console.log(formattedMessage, ...args);
+            else if ('debug' === level) console.debug(formattedMessage, ...args);
+            else if ('success' === level) console.log(formattedMessage, ...args);
+            return;
+        }
+        options.log('success' === level ? 'info' : level, message, ...args);
+    };
+    return Object.fromEntries(levels.map((level)=>[
+            level,
+            (...[message, ...args])=>LogFunc(level, message, args)
+        ]));
+};
+createLogger();
+const external_kysely_namespaceObject = require("kysely");
+function dialect_getDatabaseType(db) {
+    if (!db) return null;
+    if ('dialect' in db) return dialect_getDatabaseType(db.dialect);
+    if ('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 ('aggregate' in db) return 'sqlite';
+    if ('getConnection' in db) return 'mysql';
+    if ('connect' in db) return 'postgres';
+    return null;
+}
+const createKyselyAdapter = async (config)=>{
+    const db = config.database;
+    if (!db) return {
+        kysely: null,
+        databaseType: null
+    };
+    if ('db' in db) {
+        const kyselyConfig = db;
+        return {
+            kysely: kyselyConfig.db,
+            databaseType: kyselyConfig.type
+        };
+    }
+    if ('dialect' in db) {
+        const dialectConfig = db;
+        return {
+            kysely: new external_kysely_namespaceObject.Kysely({
+                dialect: dialectConfig.dialect
+            }),
+            databaseType: dialectConfig.type
+        };
+    }
+    let dialect;
+    const databaseType = dialect_getDatabaseType(db);
+    if ('createDriver' in db) dialect = db;
+    if ('aggregate' in db) dialect = new external_kysely_namespaceObject.SqliteDialect({
+        database: db
+    });
+    if ('getConnection' in db) dialect = new external_kysely_namespaceObject.MysqlDialect({
+        pool: db
+    });
+    if ('connect' in db) dialect = new external_kysely_namespaceObject.PostgresDialect({
+        pool: db
+    });
+    return {
+        kysely: dialect ? new external_kysely_namespaceObject.Kysely({
+            dialect
+        }) : null,
+        databaseType
+    };
+};
+const postgresMap = {
+    string: [
+        'character varying',
+        'text'
+    ],
+    number: [
+        'int4',
+        'integer',
+        'bigint',
+        'smallint',
+        'numeric',
+        'real',
+        'double precision'
+    ],
+    boolean: [
+        'bool',
+        'boolean'
+    ],
+    date: [
+        'timestamp',
+        'date'
+    ],
+    json: [
+        'json',
+        'jsonb'
+    ],
+    timezone: [
+        'text',
+        'character varying'
+    ]
+};
+const mysqlMap = {
+    string: [
+        'varchar(255)',
+        'varchar(36)',
+        'text'
+    ],
+    number: [
+        'integer',
+        'int',
+        'bigint',
+        'smallint',
+        'decimal',
+        'float',
+        'double'
+    ],
+    boolean: [
+        'boolean',
+        'tinyint'
+    ],
+    date: [
+        'timestamp',
+        'datetime',
+        'date'
+    ],
+    json: [
+        'json'
+    ],
+    timezone: [
+        'varchar(50)'
+    ]
+};
+const sqliteMap = {
+    string: [
+        'TEXT'
+    ],
+    number: [
+        'INTEGER',
+        'REAL'
+    ],
+    boolean: [
+        'INTEGER',
+        'BOOLEAN'
+    ],
+    date: [
+        'DATE',
+        'INTEGER'
+    ],
+    json: [
+        'TEXT'
+    ],
+    timezone: [
+        'TEXT'
+    ]
+};
+const mssqlMap = {
+    string: [
+        'text',
+        'varchar'
+    ],
+    number: [
+        'int',
+        'bigint',
+        'smallint',
+        'decimal',
+        'float(53)',
+        'float(24)'
+    ],
+    boolean: [
+        'bit',
+        'smallint'
+    ],
+    date: [
+        'datetime',
+        'date'
+    ],
+    json: [
+        'nvarchar(max)'
+    ],
+    timezone: [
+        'varchar',
+        'text'
+    ]
+};
+const map = {
+    postgres: postgresMap,
+    mysql: mysqlMap,
+    sqlite: sqliteMap,
+    mssql: mssqlMap
+};
+function getMySqlStringType(field) {
+    if (field.unique) return 'varchar(255)';
+    if (field.references) return 'varchar(36)';
+    return 'text';
+}
+function matchType(columnDataType, fieldType, dbType) {
+    if ('string[]' === fieldType || 'number[]' === fieldType) return columnDataType.toLowerCase().includes('json');
+    const types = map[dbType];
+    const type = Array.isArray(fieldType) ? types.string.map((t)=>t.toLowerCase()) : types[fieldType].map((t)=>t.toLowerCase());
+    const matches = type.includes(columnDataType.toLowerCase());
+    return matches;
+}
+function getType(field, dbType = 'sqlite') {
+    const type = field.type;
+    const typeMap = {
+        string: {
+            sqlite: 'text',
+            postgres: 'text',
+            mysql: getMySqlStringType(field),
+            mssql: getMySqlStringType(field)
+        },
+        boolean: {
+            sqlite: 'integer',
+            postgres: 'boolean',
+            mysql: 'boolean',
+            mssql: 'smallint'
+        },
+        number: {
+            sqlite: field.bigint ? 'bigint' : 'integer',
+            postgres: field.bigint ? 'bigint' : 'integer',
+            mysql: field.bigint ? 'bigint' : 'integer',
+            mssql: field.bigint ? 'bigint' : 'integer'
+        },
+        date: {
+            sqlite: 'date',
+            postgres: 'timestamp',
+            mysql: 'datetime',
+            mssql: 'datetime'
+        },
+        timezone: {
+            sqlite: 'text',
+            postgres: 'text',
+            mysql: 'varchar(50)',
+            mssql: 'nvarchar(50)'
+        },
+        json: {
+            sqlite: 'text',
+            postgres: 'jsonb',
+            mysql: 'json',
+            mssql: 'nvarchar(max)'
+        }
+    };
+    if ('sqlite' === dbType && ('string[]' === type || 'number[]' === type)) return 'text';
+    if ('string[]' === type || 'number[]' === type) switch(dbType){
+        case 'postgres':
+            return 'jsonb';
+        case 'mysql':
+        case 'mssql':
+            return 'json';
+        default:
+            return 'text';
+    }
+    if ('json' === type) return typeMap.json[dbType];
+    return typeMap[type][dbType];
+}
+function buildColumnAddMigrations(db, toBeAdded, dbType) {
+    const migrations = [];
+    for (const table of toBeAdded)for (const [fieldName, field] of Object.entries(table.fields)){
+        const type = getType(field, dbType);
+        const exec = db.schema.alterTable(table.table).addColumn(fieldName, type, (col)=>{
+            let column = false !== field.required ? col.notNull() : col;
+            if (field.references) column = column.references(`${field.references.model}.${field.references.field}`);
+            if (field.unique) column = column.unique();
+            return column;
+        });
+        migrations.push(exec);
+    }
+    return migrations;
+}
+function buildTableCreateMigrations(db, toBeCreated, dbType) {
+    const logger = createLogger();
+    const migrations = [];
+    for (const table of toBeCreated){
+        const fieldNames = Object.keys(table.fields);
+        logger.info(`Creating table ${table.table} with fields: ${fieldNames.join(', ')}`);
+        if (fieldNames.includes('id')) logger.warn(`⚠️ Table ${table.table} already has an explicit 'id' field, which may conflict with the auto-generated primary key`);
+        for (const [fieldName, field] of Object.entries(table.fields))if ('id' === field.fieldName && 'id' !== fieldName) logger.error(`❌ ERROR: Table ${table.table} has field '${fieldName}' with fieldName 'id' - this will cause a duplicate column error`);
+        let dbT = db.schema.createTable(table.table).addColumn('id', 'mysql' === dbType || 'mssql' === dbType ? 'varchar(36)' : 'text', (col)=>col.primaryKey().notNull());
+        for (const [fieldName, field] of Object.entries(table.fields)){
+            const type = getType(field, dbType);
+            logger.info(`Adding column ${fieldName} (fieldName: ${field.fieldName || fieldName}) to table ${table.table}`);
+            dbT = dbT.addColumn(fieldName, type, (col)=>{
+                let column = false !== field.required ? col.notNull() : col;
+                if (field.references) column = column.references(`${field.references.model}.${field.references.field}`);
+                if (field.unique) column = column.unique();
+                return column;
+            });
+        }
+        const sqlDebug = dbT.compile().sql;
+        logger.info(`SQL for table ${table.table}:\n${sqlDebug}`);
+        migrations.push(dbT);
+    }
+    return migrations;
+}
+function createMigrationExecutors(migrations) {
+    const logger = createLogger();
+    async function runMigrations() {
+        for (const migration of migrations)try {
+            await migration.execute();
+        } catch (error) {
+            const sql = migration.compile().sql;
+            logger.error(`Migration failed! SQL:\n${sql}`);
+            throw error;
+        }
+    }
+    async function compileMigrations() {
+        const compiled = migrations.map((m)=>m.compile().sql);
+        return `${compiled.join(';\n\n')};`;
+    }
+    return {
+        runMigrations,
+        compileMigrations
+    };
+}
+function 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;
+}
+const createEntityTransformer = (db, options, config)=>{
+    const schema = getConsentTables(options);
+    function getField(model, field) {
+        if ('id' === field) return field;
+        const modelFields = schema[model]?.fields;
+        const f = modelFields ? modelFields[field] : void 0;
+        if (!f) console.log('Field not found', model, field);
+        return f?.fieldName || field;
+    }
+    function transformValueToDB(value, model, field) {
+        if ('id' === field) return value;
+        const { type = 'sqlite' } = config || {};
+        const modelFields = schema[model]?.fields;
+        const f = modelFields ? modelFields[field] : void 0;
+        if (f?.type === 'boolean' && ('sqlite' === type || 'mssql' === type) && null != value) return value ? 1 : 0;
+        if (f?.type === 'date' && value && value instanceof Date) return 'sqlite' === type ? value.toISOString() : value;
+        if (f?.type === 'json' && null != value) {
+            if ('postgres' === type || 'mysql' === type) return value;
+            return external_superjson_default().stringify(value);
+        }
+        return value;
+    }
+    function transformValueFromDB(value, model, field) {
+        const { type = 'sqlite' } = config || {};
+        const modelFields = schema[model]?.fields;
+        const f = modelFields ? modelFields[field] : void 0;
+        if (f?.type === 'boolean' && ('sqlite' === type || 'mssql' === type) && null !== value) return 1 === value;
+        if (f?.type === 'date' && value) return new Date(value);
+        if (f?.type === 'json' && null != value) {
+            if (('postgres' === type || 'mysql' === type) && 'object' == typeof value) return value;
+            if ('string' == typeof value) try {
+                return external_superjson_default().parse(value);
+            } catch  {
+                try {
+                    return JSON.parse(value);
+                } catch  {}
+            }
+        }
+        return value;
+    }
+    function getEntityName(model) {
+        return schema[model].entityName;
+    }
+    return {
+        transformInput (data, model, action) {
+            const transformedData = {};
+            if ('create' === action) transformedData.id = data.id || (options.advanced?.generateId ? options.advanced.generateId({
+                model
+            }) : generateId(schema[model].entityPrefix));
+            const fields = schema[model].fields;
+            for(const field in fields)if (Object.hasOwn(fields, field)) {
+                const value = data[field];
+                const fieldInfo = fields[field];
+                const fieldName = fieldInfo?.fieldName || field;
+                if (fieldInfo) transformedData[fieldName] = applyDefaultValue(transformValueToDB(value, model, field), fieldInfo, action);
+            }
+            return transformedData;
+        },
+        transformOutput (data, model, select = []) {
+            if (!data) return null;
+            const transformedData = {};
+            if (data.id && (0 === select.length || select.includes('id'))) transformedData.id = data.id;
+            const tableSchema = schema[model]?.fields;
+            for(const key in tableSchema){
+                if (select.length && !select.includes(key)) continue;
+                const field = tableSchema[key];
+                if (field) transformedData[key] = transformValueFromDB(data[field.fieldName || key], model, key);
+            }
+            return transformedData;
+        },
+        convertWhereClause (model, whereConditions) {
+            if (!whereConditions || 0 === whereConditions.length) return {
+                and: null,
+                or: null
+            };
+            const conditions = {
+                and: [],
+                or: []
+            };
+            for (const condition of whereConditions){
+                let { field: _field, value, operator = '=', connector = 'AND' } = condition;
+                const fieldString = getField(model, _field);
+                value = transformValueToDB(value, model, _field);
+                const expr = (eb)=>{
+                    const dbField = fieldString;
+                    if ('in' === operator.toLowerCase()) return eb(dbField, 'in', Array.isArray(value) ? value : [
+                        value
+                    ]);
+                    if ('contains' === operator) return eb(dbField, 'like', `%${value}%`);
+                    if ('starts_with' === operator) return eb(dbField, 'like', `${value}%`);
+                    if ('ends_with' === operator) return eb(dbField, 'like', `%${value}`);
+                    if ('ilike' === operator) {
+                        const lowerField = eb.fn('lower', [
+                            dbField
+                        ]);
+                        const lowerValue = eb.fn('lower', [
+                            eb.val(value?.toString())
+                        ]);
+                        return eb(lowerField, 'like', lowerValue);
+                    }
+                    if ('eq' === operator) return eb(dbField, '=', value);
+                    if ('ne' === operator) return eb(dbField, '<>', value);
+                    if ('gt' === operator) return eb(dbField, '>', value);
+                    if ('gte' === operator) return eb(dbField, '>=', value);
+                    if ('lt' === operator) return eb(dbField, '<', value);
+                    if ('lte' === operator) return eb(dbField, '<=', value);
+                    return eb(dbField, operator, value);
+                };
+                if ('OR' === connector) conditions.or.push(expr);
+                else conditions.and.push(expr);
+            }
+            return {
+                and: conditions.and.length ? conditions.and : null,
+                or: conditions.or.length ? conditions.or : null
+            };
+        },
+        async withReturning (values, builder, model, where) {
+            let res = null;
+            if (config?.type === 'mysql') {
+                await builder.execute();
+                const whereCondition = where[0];
+                const field = values.id ? 'id' : whereCondition?.field ?? 'id';
+                const value = values[field] ?? whereCondition?.value;
+                const fieldString = getField(model, field);
+                res = await db.selectFrom(getEntityName(model)).selectAll().where((eb)=>eb(fieldString, '=', value)).executeTakeFirst();
+                return res;
+            }
+            if (config?.type === 'mssql') {
+                res = await builder.outputAll('inserted').executeTakeFirst();
+                return res;
+            }
+            res = await builder.returningAll().executeTakeFirst();
+            return res;
+        },
+        getEntityName,
+        getField
+    };
+};
+const kyselyAdapter = (db, config)=>(opts)=>{
+        const { transformInput, withReturning, transformOutput, convertWhereClause, getEntityName, getField } = createEntityTransformer(db, opts, config);
+        return {
+            id: 'kysely',
+            async create (data) {
+                const { model, data: values, select } = data;
+                const transformed = transformInput(values, model, 'create');
+                const tableName = getEntityName(model);
+                const builder = db.insertInto(tableName).values(transformed);
+                const result = await withReturning(transformed, builder, model, []);
+                const output = transformOutput(result, model, select);
+                return output;
+            },
+            async findOne (data) {
+                const { model, where, select } = data;
+                const whereArray = Array.isArray(where) ? where : [
+                    where
+                ];
+                const { and, or } = convertWhereClause(model, whereArray);
+                const tableName = getEntityName(model);
+                let query = db.selectFrom(tableName).selectAll();
+                if (and) query = query.where((eb)=>{
+                    const conditions = and.map((expr)=>expr(eb));
+                    return eb.and(conditions);
+                });
+                if (or) query = query.where((eb)=>{
+                    const conditions = or.map((expr)=>expr(eb));
+                    return eb.or(conditions);
+                });
+                const res = await query.executeTakeFirst();
+                if (!res) return null;
+                return transformOutput(res, model, select);
+            },
+            async findMany (data) {
+                const { model, where, limit, offset, sortBy } = data;
+                const whereArray = where ? Array.isArray(where) ? where : [
+                    where
+                ] : void 0;
+                const { and, or } = convertWhereClause(model, whereArray);
+                const tableName = getEntityName(model);
+                let query = db.selectFrom(tableName);
+                if (and) query = query.where((eb)=>{
+                    const conditions = and.map((expr)=>expr(eb));
+                    return eb.and(conditions);
+                });
+                if (or) query = query.where((eb)=>{
+                    const conditions = or.map((expr)=>expr(eb));
+                    return eb.or(conditions);
+                });
+                if (config?.type === 'mssql') {
+                    if (!offset) query = query.top(limit || 100);
+                } else query = query.limit(limit || 100);
+                if (sortBy) {
+                    const sortFieldString = getField(model, sortBy.field);
+                    query = query.orderBy(sortFieldString, sortBy.direction);
+                }
+                if (offset) {
+                    if (config?.type === 'mssql') {
+                        if (!sortBy) query = query.orderBy('id');
+                        query = query.offset(offset).fetch(limit || 100);
+                    } else query = query.offset(offset);
+                }
+                const res = await query.selectAll().execute();
+                if (!res) return [];
+                return res.map((r)=>transformOutput(r, model));
+            },
+            async update (data) {
+                const { model, where, update: values } = data;
+                const whereArray = Array.isArray(where) ? where : [
+                    where
+                ];
+                const { and, or } = convertWhereClause(model, whereArray);
+                const transformedData = transformInput(values, model, 'update');
+                const tableName = getEntityName(model);
+                let query = db.updateTable(tableName).set(transformedData);
+                if (and) query = query.where((eb)=>{
+                    const conditions = and.map((expr)=>expr(eb));
+                    return eb.and(conditions);
+                });
+                if (or) query = query.where((eb)=>{
+                    const conditions = or.map((expr)=>expr(eb));
+                    return eb.or(conditions);
+                });
+                const result = await withReturning(transformedData, query, model, whereArray);
+                return transformOutput(result, model);
+            },
+            async updateMany (data) {
+                const { model, where, update: values } = data;
+                const whereArray = Array.isArray(where) ? where : [
+                    where
+                ];
+                const { and, or } = convertWhereClause(model, whereArray);
+                const transformedData = transformInput(values, model, 'update');
+                const tableName = getEntityName(model);
+                let query = db.updateTable(tableName).set(transformedData);
+                if (and) query = query.where((eb)=>{
+                    const conditions = and.map((expr)=>expr(eb));
+                    return eb.and(conditions);
+                });
+                if (or) query = query.where((eb)=>{
+                    const conditions = or.map((expr)=>expr(eb));
+                    return eb.or(conditions);
+                });
+                await query.execute();
+                let selectQuery = db.selectFrom(tableName).selectAll();
+                if (and) selectQuery = selectQuery.where((eb)=>{
+                    const conditions = and.map((expr)=>expr(eb));
+                    return eb.and(conditions);
+                });
+                if (or) selectQuery = selectQuery.where((eb)=>{
+                    const conditions = or.map((expr)=>expr(eb));
+                    return eb.or(conditions);
+                });
+                const fetchedResults = await selectQuery.execute();
+                if (!fetchedResults || 0 === fetchedResults.length) return [];
+                return fetchedResults.map((record)=>transformOutput(record, model));
+            },
+            async count (data) {
+                const { model, where } = data;
+                const whereArray = where ? Array.isArray(where) ? where : [
+                    where
+                ] : void 0;
+                const { and, or } = convertWhereClause(model, whereArray);
+                const tableName = getEntityName(model);
+                let query = db.selectFrom(tableName).select((eb)=>eb.fn.count('id').as('count'));
+                if (and) query = query.where((eb)=>{
+                    const conditions = and.map((expr)=>expr(eb));
+                    return eb.and(conditions);
+                });
+                if (or) query = query.where((eb)=>{
+                    const conditions = or.map((expr)=>expr(eb));
+                    return eb.or(conditions);
+                });
+                const res = await query.execute();
+                const count = res[0]?.count;
+                return 'number' == typeof count ? count : 0;
+            },
+            async delete (data) {
+                const { model, where } = data;
+                const whereArray = Array.isArray(where) ? where : [
+                    where
+                ];
+                const { and, or } = convertWhereClause(model, whereArray);
+                const tableName = getEntityName(model);
+                let query = db.deleteFrom(tableName);
+                if (and) query = query.where((eb)=>{
+                    const conditions = and.map((expr)=>expr(eb));
+                    return eb.and(conditions);
+                });
+                if (or) query = query.where((eb)=>{
+                    const conditions = or.map((expr)=>expr(eb));
+                    return eb.or(conditions);
+                });
+                await query.execute();
+            },
+            async deleteMany (data) {
+                const { model, where } = data;
+                const whereArray = Array.isArray(where) ? where : [
+                    where
+                ];
+                const { and, or } = convertWhereClause(model, whereArray);
+                const tableName = getEntityName(model);
+                let query = db.deleteFrom(tableName);
+                if (and) query = query.where((eb)=>{
+                    const conditions = and.map((expr)=>expr(eb));
+                    return eb.and(conditions);
+                });
+                if (or) query = query.where((eb)=>{
+                    const conditions = or.map((expr)=>expr(eb));
+                    return eb.or(conditions);
+                });
+                const result = await query.execute();
+                const count = result.length;
+                return count;
+            },
+            async transaction (data) {
+                const { callback } = data;
+                if (opts.advanced?.disableTransactions) {
+                    const regularAdapter = kyselyAdapter(db, config)(opts);
+                    return await callback(regularAdapter);
+                }
+                try {
+                    return await db.transaction().execute(async (trx)=>{
+                        const transactionAdapter = kyselyAdapter(trx, config)(opts);
+                        return await callback(transactionAdapter);
+                    });
+                } catch (error) {
+                    if (error instanceof Error && (error.message.includes('transactions are not supported') || error.message.toLowerCase().includes('no transaction support'))) {
+                        console.warn("Warning: Database transaction failed. If your database does not support transactions, you can disable this warning by setting opts.advanced.disableTransactions to true.");
+                        const regularAdapter = kyselyAdapter(db, config)(opts);
+                        return await callback(regularAdapter);
+                    }
+                    throw error;
+                }
+            },
+            options: config
+        };
+    };
+const memory_adapter_createEntityTransformer = (options)=>{
+    const schema = getConsentTables(options);
+    function getField(model, field) {
+        if ('id' === field) return field;
+        const modelFields = schema[model]?.fields;
+        const f = modelFields ? modelFields[field] : void 0;
+        return f?.fieldName || field;
+    }
+    return {
+        transformInput (data, model, action) {
+            const transformedData = 'update' === action ? {} : {
+                id: options.advanced?.generateId ? options.advanced.generateId({
+                    model
+                }) : data.id || generateId(schema[model].entityPrefix)
+            };
+            const fields = schema[model].fields;
+            for(const field in fields)if (Object.hasOwn(fields, field)) {
+                const value = data[field];
+                const fieldInfo = fields[field];
+                if (void 0 === value && !fieldInfo?.defaultValue) continue;
+                const fieldName = fieldInfo?.fieldName || field;
+                transformedData[fieldName] = applyDefaultValue(value, fieldInfo, action);
+            }
+            return transformedData;
+        },
+        transformOutput (data, model, select = []) {
+            if (!data) return null;
+            const transformedData = {};
+            const hasId = data.id || data._id;
+            if (hasId && (0 === select.length || select.includes('id'))) transformedData.id = data.id;
+            const tableSchema = schema[model].fields;
+            for(const key in tableSchema){
+                if (select.length && !select.includes(key)) continue;
+                const field = tableSchema[key];
+                if (field) transformedData[key] = data[field.fieldName || key];
+            }
+            return transformedData;
+        },
+        convertWhereClause (where, table, model) {
+            return table.filter((record)=>where.every((clause)=>{
+                    const { field: _field, value, operator = '=' } = clause;
+                    const field = getField(model, _field);
+                    if ('in' === operator) {
+                        if (!Array.isArray(value)) throw new Error('Value must be an array');
+                        return value.includes(record[field]);
+                    }
+                    if ('contains' === operator) {
+                        const fieldValue = record[field];
+                        return 'string' == typeof fieldValue && fieldValue.includes(value);
+                    }
+                    if ('starts_with' === operator) {
+                        const fieldValue = record[field];
+                        return 'string' == typeof fieldValue && fieldValue.startsWith(value);
+                    }
+                    if ('ends_with' === operator) {
+                        const fieldValue = record[field];
+                        return 'string' == typeof fieldValue && fieldValue.endsWith(value);
+                    }
+                    if ('eq' === operator) return record[field] === value;
+                    if ('ne' === operator) return record[field] !== value;
+                    return record[field] === value;
+                }));
+        },
+        getField
+    };
+};
+const memoryAdapter = (db)=>(options)=>{
+        const { transformInput, transformOutput, convertWhereClause, getField } = memory_adapter_createEntityTransformer(options);
+        return {
+            id: 'memory',
+            async create (data) {
+                const { model, data: values, select } = data;
+                const transformed = transformInput(values, model, 'create');
+                if (!db[model]) db[model] = [];
+                db[model].push(transformed);
+                return transformOutput(transformed, model, select);
+            },
+            async findOne (data) {
+                const { model, where, select } = data;
+                const table = db[model] || [];
+                const whereArray = Array.isArray(where) ? where : [
+                    where
+                ];
+                const res = convertWhereClause(whereArray, table, model);
+                const record = res[0] || null;
+                return transformOutput(record, model, select);
+            },
+            async findMany (data) {
+                const { model, where, sortBy, limit, offset } = data;
+                let table = db[model] || [];
+                if (where) {
+                    const whereArray = Array.isArray(where) ? where : [
+                        where
+                    ];
+                    table = convertWhereClause(whereArray, table, model);
+                }
+                if (sortBy) {
+                    const field = getField(model, sortBy.field);
+                    table = [
+                        ...table
+                    ].sort((a, b)=>{
+                        if ('asc' === sortBy.direction) return a[field] > b[field] ? 1 : -1;
+                        return a[field] < b[field] ? 1 : -1;
+                    });
+                }
+                let result = table;
+                if (void 0 !== offset) result = result.slice(offset);
+                if (void 0 !== limit) result = result.slice(0, limit);
+                return result.map((record)=>transformOutput(record, model));
+            },
+            async count (data) {
+                const { model, where } = data;
+                const table = db[model] || [];
+                if (!where) return table.length;
+                const whereArray = Array.isArray(where) ? where : [
+                    where
+                ];
+                const filtered = convertWhereClause(whereArray, table, model);
+                return filtered.length;
+            },
+            async update (data) {
+                const { model, where, update: values } = data;
+                const table = db[model] || [];
+                const whereArray = Array.isArray(where) ? where : [
+                    where
+                ];
+                const res = convertWhereClause(whereArray, table, model);
+                for (const record of res)Object.assign(record, transformInput(values, model, 'update'));
+                return transformOutput(res[0] || null, model);
+            },
+            async updateMany (data) {
+                const { model, where, update: values } = data;
+                const table = db[model] || [];
+                const whereArray = Array.isArray(where) ? where : [
+                    where
+                ];
+                const res = convertWhereClause(whereArray, table, model);
+                for (const record of res)Object.assign(record, transformInput(values, model, 'update'));
+                return res.map((record)=>transformOutput(record, model));
+            },
+            async delete (data) {
+                const { model, where } = data;
+                const table = db[model] || [];
+                const whereArray = Array.isArray(where) ? where : [
+                    where
+                ];
+                const res = convertWhereClause(whereArray, table, model);
+                db[model] = table.filter((record)=>!res.includes(record));
+            },
+            async deleteMany (data) {
+                const { model, where } = data;
+                const table = db[model] || [];
+                const whereArray = Array.isArray(where) ? where : [
+                    where
+                ];
+                const res = convertWhereClause(whereArray, table, model);
+                let count = 0;
+                db[model] = table.filter((record)=>{
+                    if (res.includes(record)) {
+                        count++;
+                        return false;
+                    }
+                    return true;
+                });
+                return count;
+            },
+            async transaction (data) {
+                const { callback } = data;
+                const tempDb = {};
+                for(const key in db)if (Object.hasOwn(db, key)) tempDb[key] = JSON.parse(JSON.stringify(db[key]));
+                const transactionAdapter = memoryAdapter(tempDb)(options);
+                const result = await callback(transactionAdapter);
+                for(const key in tempDb)if (Object.hasOwn(tempDb, key)) db[key] = tempDb[key];
+                return result;
+            }
+        };
+    };
+async function getAdapter(options) {
+    const logger = createLogger();
+    if (!options.database) {
+        const tables = getConsentTables(options);
+        const memoryDB = Object.keys(tables).reduce((acc, key)=>{
+            acc[key] = [];
+            return acc;
+        }, {});
+        logger.warn('No database configuration provided. Using memory adapter in development');
+        return memoryAdapter(memoryDB)(options);
+    }
+    if ('function' == typeof options.database) return options.database(options);
+    const { kysely, databaseType } = await createKyselyAdapter(options);
+    if (!kysely) throw new error_C15TError('Failed to initialize database adapter', {
+        code: codes_BASE_ERROR_CODES.INTERNAL_SERVER_ERROR,
+        status: 500
+    });
+    return kyselyAdapter(kysely, {
+        type: databaseType || 'sqlite'
+    })(options);
+}
+function getSchema(config) {
+    const entities = getConsentTables(config);
+    const schema = {};
+    for (const [key, entity] of Object.entries(entities)){
+        if (!entity) continue;
+        const fields = entity.fields || {};
+        const processedFields = {};
+        for (const [fieldKey, field] of Object.entries(fields)){
+            if (!field) continue;
+            const fieldName = field.fieldName || fieldKey;
+            const typedField = field;
+            processedFields[fieldName] = typedField;
+            if (typedField && 'references' in typedField && typedField.references) {
+                const entityName = typedField.references.model;
+                const referencedEntity = entities[entityName];
+                if (referencedEntity) processedFields[fieldName] = {
+                    ...typedField,
+                    references: {
+                        model: referencedEntity.entityName,
+                        entity: referencedEntity.entityName,
+                        field: typedField.references.field,
+                        onDelete: typedField.references.onDelete
+                    }
+                };
+            }
+        }
+        const entityName = entity.entityName || key;
+        if (entityName in schema) {
+            const existingEntry = schema[entityName];
+            schema[entityName] = {
+                ...existingEntry,
+                order: existingEntry?.order ?? Number.POSITIVE_INFINITY,
+                fields: {
+                    ...existingEntry?.fields,
+                    ...processedFields
+                }
+            };
+        } else schema[entityName] = {
+            fields: processedFields,
+            order: entity.order ?? Number.POSITIVE_INFINITY
+        };
+    }
+    return schema;
+}
+function analyzeSchemaChanges(config, tableMetadata, dbType) {
+    const betterAuthSchema = getSchema(config);
+    const logger = createLogger(config.logger);
+    const toBeCreated = [];
+    const toBeAdded = [];
+    for (const [key, value] of Object.entries(betterAuthSchema)){
+        const table = tableMetadata.find((t)=>t.name === key);
+        if (!table) {
+            handleNewTable(key, value, toBeCreated);
+            continue;
+        }
+        handleExistingTable(key, value, table, toBeAdded, dbType, logger);
+    }
+    return {
+        toBeCreated,
+        toBeAdded
+    };
+}
+function handleNewTable(tableName, value, toBeCreated) {
+    const tIndex = toBeCreated.findIndex((t)=>t.table === tableName);
+    const tableData = {
+        table: tableName,
+        fields: value.fields,
+        order: value.order || Number.POSITIVE_INFINITY
+    };
+    const insertIndex = toBeCreated.findIndex((t)=>(t.order || Number.POSITIVE_INFINITY) > tableData.order);
+    if (-1 === insertIndex) {
+        if (-1 === tIndex) toBeCreated.push(tableData);
+        else {
+            const existingTable = toBeCreated[tIndex];
+            if (existingTable) existingTable.fields = {
+                ...existingTable.fields,
+                ...value.fields
+            };
+        }
+    } else toBeCreated.splice(insertIndex, 0, tableData);
+}
+function handleExistingTable(tableName, value, table, toBeAdded, dbType, logger) {
+    const toBeAddedFields = {};
+    for (const [fieldName, field] of Object.entries(value.fields)){
+        const column = table.columns.find((c)=>c.name === fieldName);
+        if (!column) {
+            toBeAddedFields[fieldName] = field;
+            continue;
+        }
+        if (!matchType(column.dataType, field.type, dbType)) logger.warn(`Field ${fieldName} in table ${tableName} has a different type in the database. Expected ${field.type} but got ${column.dataType}.`);
+    }
+    if (Object.keys(toBeAddedFields).length > 0) toBeAdded.push({
+        table: tableName,
+        fields: toBeAddedFields,
+        order: value.order || Number.POSITIVE_INFINITY
+    });
+}
+async function getMigrations(config) {
+    const logger = createLogger(config.logger);
+    let { kysely: db, databaseType: dbType } = await createKyselyAdapter(config);
+    if (!dbType) {
+        logger.warn('Could not determine database type, defaulting to sqlite. Please provide a type in the database options to avoid this.');
+        dbType = 'sqlite';
+    }
+    if (!db) {
+        logger.error("Only kysely adapter is supported for migrations. You can use `generate` command to generate the schema, if you're using a different adapter.");
+        process.exit(1);
+    }
+    const tableMetadata = await db.introspection.getTables();
+    const { toBeCreated, toBeAdded } = analyzeSchemaChanges(config, tableMetadata, dbType);
+    const columnMigrations = buildColumnAddMigrations(db, toBeAdded, dbType);
+    const tableMigrations = buildTableCreateMigrations(db, toBeCreated, dbType);
+    const migrations = [
+        ...columnMigrations,
+        ...tableMigrations
+    ];
+    const { runMigrations, compileMigrations } = createMigrationExecutors(migrations);
+    return {
+        toBeCreated,
+        toBeAdded,
+        runMigrations,
+        compileMigrations
+    };
+}
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});