@c15t/backend 0.0.1-rc.10

package/dist/db/adapters/kysely.cjs

@@ -0,0 +1,1551 @@
+"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__, {
+    kyselyAdapter: ()=>kysely_adapter_rslib_entry_kyselyAdapter
+});
+const external_superjson_namespaceObject = require("superjson");
+var external_superjson_default = /*#__PURE__*/ __webpack_require__.n(external_superjson_namespaceObject);
+const external_zod_namespaceObject = require("zod");
+const fieldConfigSchema = external_zod_namespaceObject.z.object({
+    required: external_zod_namespaceObject.z.boolean().default(true),
+    returned: external_zod_namespaceObject.z.boolean().default(true),
+    input: external_zod_namespaceObject.z.boolean().default(true),
+    defaultValue: external_zod_namespaceObject.z.union([
+        external_zod_namespaceObject.z.any(),
+        external_zod_namespaceObject.z["function"]().returns(external_zod_namespaceObject.z.any())
+    ]).optional(),
+    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)}`;
+}
+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 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())
+});
+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
+    };
+}
+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
+    };
+}
+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 kysely_adapter_rslib_entry_createEntityTransformer = (db, options, config)=>{
+    const schema = definition_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
+            }) : 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];
+                const fieldInfo = fields[field];
+                const fieldName = fieldInfo?.fieldName || field;
+                if (fieldInfo) transformedData[fieldName] = utils_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 kysely_adapter_rslib_entry_kyselyAdapter = (db, config)=>(opts)=>{
+        const { transformInput, withReturning, transformOutput, convertWhereClause, getEntityName, getField } = kysely_adapter_rslib_entry_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 = kysely_adapter_rslib_entry_kyselyAdapter(db, config)(opts);
+                    return await callback(regularAdapter);
+                }
+                try {
+                    return await db.transaction().execute(async (trx)=>{
+                        const transactionAdapter = kysely_adapter_rslib_entry_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 = kysely_adapter_rslib_entry_kyselyAdapter(db, config)(opts);
+                        return await callback(regularAdapter);
+                    }
+                    throw error;
+                }
+            },
+            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
+});