@c15t/backend 0.0.1-rc.10

package/dist/db/adapters/drizzle.cjs

@@ -0,0 +1,1531 @@
+"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__, {
+    drizzleAdapter: ()=>drizzleAdapter
+});
+const external_drizzle_orm_namespaceObject = require("drizzle-orm");
+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 definition_getConsentTables = (options)=>{
+    const pluginSchema = options.plugins?.reduce((acc, plugin)=>{
+        const schema = plugin.schema;
+        if (!schema) return acc;
+        for (const [key, value] of Object.entries(schema))acc[key] = {
+            fields: {
+                ...acc[key]?.fields,
+                ...value.fields
+            },
+            entityName: 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())
+});
+require("superjson");
+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[]')
+});
+external_zod_namespaceObject.z.discriminatedUnion('type', [
+    stringFieldSchema,
+    numberFieldSchema,
+    booleanFieldSchema,
+    dateFieldSchema,
+    timezoneFieldSchema,
+    jsonFieldSchema,
+    stringArrayFieldSchema,
+    numberArrayFieldSchema
+]);
+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'
+};
+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 id_generator_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 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
+    };
+}
+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 logger_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)
+        ]));
+};
+logger_createLogger();
+require("kysely");
+function utils_applyDefaultValue(inputValue, field, operation) {
+    if ('update' === operation) return inputValue;
+    if (null == inputValue && field.defaultValue) {
+        if ('function' == typeof field.defaultValue) return field.defaultValue();
+        return field.defaultValue;
+    }
+    return inputValue;
+}
+const drizzle_adapter_rslib_entry_createEntityTransformer = (db, config, options)=>{
+    const schema = definition_getConsentTables(options);
+    function getField(model, field) {
+        if ('id' === field) return field;
+        const f = schema[model].fields[field];
+        return f.fieldName || field;
+    }
+    function getSchema(entityName) {
+        const schema = config.schema || db._.fullSchema;
+        if (!schema) throw new error_C15TError('The schema could not be found. Please ensure the schema is properly configured in the adapter.', {
+            code: codes_BASE_ERROR_CODES.DATABASE_CONNECTION_ERROR,
+            status: 500,
+            data: {
+                provider: config.provider
+            }
+        });
+        const model = getEntityName(entityName);
+        const schemaModel = schema[model];
+        if (!schemaModel) throw new error_C15TError(`The model "${model}" does not exist in the schema. Please verify the model name and ensure it is defined in your schema.`, {
+            code: codes_BASE_ERROR_CODES.DATABASE_QUERY_ERROR,
+            status: 404,
+            data: {
+                model,
+                availableModels: Object.keys(schema)
+            }
+        });
+        return schemaModel;
+    }
+    const getEntityName = (model)=>{
+        if (schema[model].entityName !== model) return schema[model].entityName;
+        if (config.usePlural) return `${model}s`;
+        return model;
+    };
+    function convertWhereClause(where, model) {
+        const schemaModel = getSchema(model);
+        if (!where) return [];
+        if (1 === where.length) {
+            const w = where[0];
+            if (!w) return [];
+            const field = getField(model, w.field);
+            if (!schemaModel[field]) throw new error_C15TError(`The field "${field}" does not exist in model "${model}". Please verify the field name and ensure it is defined in your schema.`, {
+                code: codes_BASE_ERROR_CODES.DATABASE_QUERY_ERROR,
+                status: 404,
+                data: {
+                    model,
+                    field,
+                    availableFields: Object.keys(schemaModel)
+                }
+            });
+            if ('in' === w.operator) {
+                if (!Array.isArray(w.value)) throw new error_C15TError(`The value for the field "${field}" must be an array when using the "in" operator.`, {
+                    code: codes_BASE_ERROR_CODES.BAD_REQUEST,
+                    status: 400,
+                    data: {
+                        field,
+                        operator: w.operator,
+                        expectedType: 'array',
+                        actualType: typeof w.value
+                    }
+                });
+                return [
+                    (0, external_drizzle_orm_namespaceObject.inArray)(schemaModel[field], w.value)
+                ];
+            }
+            if ('contains' === w.operator) return [
+                (0, external_drizzle_orm_namespaceObject.like)(schemaModel[field], `%${w.value}%`)
+            ];
+            if ('starts_with' === w.operator) return [
+                (0, external_drizzle_orm_namespaceObject.like)(schemaModel[field], `${w.value}%`)
+            ];
+            if ('ends_with' === w.operator) return [
+                (0, external_drizzle_orm_namespaceObject.like)(schemaModel[field], `%${w.value}`)
+            ];
+            return [
+                (0, external_drizzle_orm_namespaceObject.eq)(schemaModel[field], w.value)
+            ];
+        }
+        const andGroup = where.filter((w)=>'AND' === w.connector || !w.connector);
+        const orGroup = where.filter((w)=>'OR' === w.connector);
+        const andClause = (0, external_drizzle_orm_namespaceObject.and)(...andGroup.map((w)=>{
+            const field = getField(model, w.field);
+            if ('in' === w.operator) {
+                if (!Array.isArray(w.value)) throw new error_C15TError(`The value for the field "${field}" must be an array when using the "in" operator.`, {
+                    code: codes_BASE_ERROR_CODES.BAD_REQUEST,
+                    status: 400,
+                    data: {
+                        field,
+                        operator: w.operator,
+                        expectedType: 'array',
+                        actualType: typeof w.value
+                    }
+                });
+                return (0, external_drizzle_orm_namespaceObject.inArray)(schemaModel[field], w.value);
+            }
+            return (0, external_drizzle_orm_namespaceObject.eq)(schemaModel[field], w.value);
+        }));
+        const orClause = (0, external_drizzle_orm_namespaceObject.or)(...orGroup.map((w)=>{
+            const field = getField(model, w.field);
+            return (0, external_drizzle_orm_namespaceObject.eq)(schemaModel[field], w.value);
+        }));
+        const clause = [];
+        if (andGroup.length && andClause) clause.push(andClause);
+        if (orGroup.length && orClause) clause.push(orClause);
+        return clause;
+    }
+    const useDatabaseGeneratedId = options?.advanced?.generateId === false;
+    return {
+        getSchema,
+        transformInput (data, model, action) {
+            const transformedData = useDatabaseGeneratedId || 'update' === action ? {} : {
+                id: options.advanced?.generateId ? options.advanced.generateId({
+                    model
+                }) : data.id || id_generator_generateId(schema[model].entityPrefix)
+            };
+            const fields = schema[model].fields;
+            for(const field in fields)if (Object.hasOwn(fields, field)) {
+                const value = data[field];
+                if (void 0 === value && !fields[field].defaultValue) continue;
+                transformedData[fields[field].fieldName || field] = utils_applyDefaultValue(value, fields[field], action);
+            }
+            return transformedData;
+        },
+        transformOutput (data, model, select = []) {
+            if (!data) return null;
+            let transformedData = {};
+            if ((data.id || 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] = data[field.fieldName || key];
+            }
+            return transformedData;
+        },
+        convertWhereClause,
+        withReturning: async (model, builder, data, where)=>{
+            if ('mysql' !== config.provider) {
+                const c = await builder.returning();
+                return c[0];
+            }
+            await builder.execute();
+            const schemaModel = getSchema(model);
+            const builderVal = builder.config?.values;
+            if (where?.length) {
+                const clause = convertWhereClause(where, model);
+                const res = await db.select().from(schemaModel).where(...clause);
+                return res[0];
+            }
+            if (builderVal) {
+                const tId = builderVal[0]?.id.value;
+                const res = await db.select().from(schemaModel).where((0, external_drizzle_orm_namespaceObject.eq)(schemaModel.id, tId));
+                return res[0];
+            }
+            if (data.id) {
+                const res = await db.select().from(schemaModel).where((0, external_drizzle_orm_namespaceObject.eq)(schemaModel.id, data.id));
+                return res[0];
+            }
+        },
+        getField,
+        getEntityName
+    };
+};
+function checkMissingFields(schema, model, values) {
+    if (!schema) throw new error_C15TError('The schema could not be found. Please ensure the schema is properly configured in the adapter.', {
+        code: codes_BASE_ERROR_CODES.DATABASE_CONNECTION_ERROR,
+        status: 500
+    });
+    for(const key in values)if (!schema[key]) throw new error_C15TError(`The field "${key}" does not exist in the "${model}" schema. Please update your drizzle schema or re-generate using "npx @c15t/cli generate".`);
+}
+const drizzleAdapter = (db, config)=>(options)=>{
+        const { transformInput, transformOutput, convertWhereClause, getSchema, withReturning, getField, getEntityName } = drizzle_adapter_rslib_entry_createEntityTransformer(db, config, options);
+        return {
+            id: 'drizzle',
+            async create (data) {
+                const { model, data: values } = data;
+                const transformed = transformInput(values, model, 'create');
+                const schemaModel = getSchema(model);
+                checkMissingFields(schemaModel, getEntityName(model), transformed);
+                const builder = db.insert(schemaModel).values(transformed);
+                const returned = await withReturning(model, builder, transformed);
+                return transformOutput(returned, model);
+            },
+            async findOne (data) {
+                const { model, where, select } = data;
+                const schemaModel = getSchema(model);
+                const clause = convertWhereClause(where, model);
+                const res = await db.select().from(schemaModel).where(...clause);
+                if (!res.length) return null;
+                return transformOutput(res[0], model, select);
+            },
+            async findMany (data) {
+                const { model, where, sortBy, limit, offset } = data;
+                const schemaModel = getSchema(model);
+                const clause = where ? convertWhereClause(where, model) : [];
+                const sortFn = sortBy?.direction === 'desc' ? external_drizzle_orm_namespaceObject.desc : external_drizzle_orm_namespaceObject.asc;
+                const builder = db.select().from(schemaModel).limit(limit || 100).offset(offset || 0);
+                if (sortBy?.field) builder.orderBy(sortFn(schemaModel[getField(model, sortBy?.field)]));
+                const res = await builder.where(...clause);
+                return res.map((r)=>transformOutput(r, model));
+            },
+            async count (data) {
+                const { model, where } = data;
+                const schemaModel = getSchema(model);
+                const clause = where ? convertWhereClause(where, model) : [];
+                const res = await db.select({
+                    count: (0, external_drizzle_orm_namespaceObject.count)()
+                }).from(schemaModel).where(...clause);
+                return res[0].count;
+            },
+            async update (data) {
+                const { model, where, update } = data;
+                const schemaModel = getSchema(model);
+                const clause = convertWhereClause(where, model);
+                const transformed = transformInput(update, model, 'update');
+                const result = await db.update(schemaModel).set(transformed).where(clause).returning();
+                return result.length ? transformOutput(result[0], model) : null;
+            },
+            async updateMany (data) {
+                const { model, where, update: values } = data;
+                const schemaModel = getSchema(model);
+                const clause = convertWhereClause(where, model);
+                const transformed = transformInput(values, model, 'update');
+                const builder = db.update(schemaModel).set(transformed).where(...clause);
+                const res = await builder;
+                return res ? res.changes : 0;
+            },
+            async delete (data) {
+                const { model, where } = data;
+                const schemaModel = getSchema(model);
+                const clause = convertWhereClause(where, model);
+                const builder = db.delete(schemaModel).where(...clause);
+                await builder;
+            },
+            async deleteMany (data) {
+                const { model, where } = data;
+                const schemaModel = getSchema(model);
+                const clause = convertWhereClause(where, model);
+                const result = await db.delete(schemaModel).where(clause);
+                return result ? result.rowCount : 0;
+            },
+            async transaction (data) {
+                const { callback } = data;
+                return await db.transaction(async (tx)=>{
+                    const transactionAdapter = drizzleAdapter(tx, config)(options);
+                    return await callback(transactionAdapter);
+                });
+            },
+            options: config
+        };
+    };
+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
+});