@c15t/backend 0.0.1-rc.10

package/dist/db/migration/index.cjs

@@ -0,0 +1,1613 @@
+"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__, {
+    getMigrations: ()=>getMigrations
+});
+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();
+const external_kysely_namespaceObject = require("kysely");
+function dialect_getDatabaseType(db) {
+    if (!db) return null;
+    if ('dialect' in db) return dialect_getDatabaseType(db.dialect);
+    if ('createDriver' in db) {
+        if (db instanceof external_kysely_namespaceObject.SqliteDialect) return 'sqlite';
+        if (db instanceof external_kysely_namespaceObject.MysqlDialect) return 'mysql';
+        if (db instanceof external_kysely_namespaceObject.PostgresDialect) return 'postgres';
+        if (db instanceof external_kysely_namespaceObject.MssqlDialect) return 'mssql';
+    }
+    if ('aggregate' in db) return 'sqlite';
+    if ('getConnection' in db) return 'mysql';
+    if ('connect' in db) return 'postgres';
+    return null;
+}
+const dialect_createKyselyAdapter = async (config)=>{
+    const db = config.database;
+    if (!db) return {
+        kysely: null,
+        databaseType: null
+    };
+    if ('db' in db) {
+        const kyselyConfig = db;
+        return {
+            kysely: kyselyConfig.db,
+            databaseType: kyselyConfig.type
+        };
+    }
+    if ('dialect' in db) {
+        const dialectConfig = db;
+        return {
+            kysely: new external_kysely_namespaceObject.Kysely({
+                dialect: dialectConfig.dialect
+            }),
+            databaseType: dialectConfig.type
+        };
+    }
+    let dialect;
+    const databaseType = dialect_getDatabaseType(db);
+    if ('createDriver' in db) dialect = db;
+    if ('aggregate' in db) dialect = new external_kysely_namespaceObject.SqliteDialect({
+        database: db
+    });
+    if ('getConnection' in db) dialect = new external_kysely_namespaceObject.MysqlDialect({
+        pool: db
+    });
+    if ('connect' in db) dialect = new external_kysely_namespaceObject.PostgresDialect({
+        pool: db
+    });
+    return {
+        kysely: dialect ? new external_kysely_namespaceObject.Kysely({
+            dialect
+        }) : null,
+        databaseType
+    };
+};
+const postgresMap = {
+    string: [
+        'character varying',
+        'text'
+    ],
+    number: [
+        'int4',
+        'integer',
+        'bigint',
+        'smallint',
+        'numeric',
+        'real',
+        'double precision'
+    ],
+    boolean: [
+        'bool',
+        'boolean'
+    ],
+    date: [
+        'timestamp',
+        'date'
+    ],
+    json: [
+        'json',
+        'jsonb'
+    ],
+    timezone: [
+        'text',
+        'character varying'
+    ]
+};
+const mysqlMap = {
+    string: [
+        'varchar(255)',
+        'varchar(36)',
+        'text'
+    ],
+    number: [
+        'integer',
+        'int',
+        'bigint',
+        'smallint',
+        'decimal',
+        'float',
+        'double'
+    ],
+    boolean: [
+        'boolean',
+        'tinyint'
+    ],
+    date: [
+        'timestamp',
+        'datetime',
+        'date'
+    ],
+    json: [
+        'json'
+    ],
+    timezone: [
+        'varchar(50)'
+    ]
+};
+const sqliteMap = {
+    string: [
+        'TEXT'
+    ],
+    number: [
+        'INTEGER',
+        'REAL'
+    ],
+    boolean: [
+        'INTEGER',
+        'BOOLEAN'
+    ],
+    date: [
+        'DATE',
+        'INTEGER'
+    ],
+    json: [
+        'TEXT'
+    ],
+    timezone: [
+        'TEXT'
+    ]
+};
+const mssqlMap = {
+    string: [
+        'text',
+        'varchar'
+    ],
+    number: [
+        'int',
+        'bigint',
+        'smallint',
+        'decimal',
+        'float(53)',
+        'float(24)'
+    ],
+    boolean: [
+        'bit',
+        'smallint'
+    ],
+    date: [
+        'datetime',
+        'date'
+    ],
+    json: [
+        'nvarchar(max)'
+    ],
+    timezone: [
+        'varchar',
+        'text'
+    ]
+};
+const map = {
+    postgres: postgresMap,
+    mysql: mysqlMap,
+    sqlite: sqliteMap,
+    mssql: mssqlMap
+};
+function getMySqlStringType(field) {
+    if (field.unique) return 'varchar(255)';
+    if (field.references) return 'varchar(36)';
+    return 'text';
+}
+function matchType(columnDataType, fieldType, dbType) {
+    if ('string[]' === fieldType || 'number[]' === fieldType) return columnDataType.toLowerCase().includes('json');
+    const types = map[dbType];
+    const type = Array.isArray(fieldType) ? types.string.map((t)=>t.toLowerCase()) : types[fieldType].map((t)=>t.toLowerCase());
+    const matches = type.includes(columnDataType.toLowerCase());
+    return matches;
+}
+function getType(field, dbType = 'sqlite') {
+    const type = field.type;
+    const typeMap = {
+        string: {
+            sqlite: 'text',
+            postgres: 'text',
+            mysql: getMySqlStringType(field),
+            mssql: getMySqlStringType(field)
+        },
+        boolean: {
+            sqlite: 'integer',
+            postgres: 'boolean',
+            mysql: 'boolean',
+            mssql: 'smallint'
+        },
+        number: {
+            sqlite: field.bigint ? 'bigint' : 'integer',
+            postgres: field.bigint ? 'bigint' : 'integer',
+            mysql: field.bigint ? 'bigint' : 'integer',
+            mssql: field.bigint ? 'bigint' : 'integer'
+        },
+        date: {
+            sqlite: 'date',
+            postgres: 'timestamp',
+            mysql: 'datetime',
+            mssql: 'datetime'
+        },
+        timezone: {
+            sqlite: 'text',
+            postgres: 'text',
+            mysql: 'varchar(50)',
+            mssql: 'nvarchar(50)'
+        },
+        json: {
+            sqlite: 'text',
+            postgres: 'jsonb',
+            mysql: 'json',
+            mssql: 'nvarchar(max)'
+        }
+    };
+    if ('sqlite' === dbType && ('string[]' === type || 'number[]' === type)) return 'text';
+    if ('string[]' === type || 'number[]' === type) switch(dbType){
+        case 'postgres':
+            return 'jsonb';
+        case 'mysql':
+        case 'mssql':
+            return 'json';
+        default:
+            return 'text';
+    }
+    if ('json' === type) return typeMap.json[dbType];
+    return typeMap[type][dbType];
+}
+function buildColumnAddMigrations(db, toBeAdded, dbType) {
+    const migrations = [];
+    for (const table of toBeAdded)for (const [fieldName, field] of Object.entries(table.fields)){
+        const type = getType(field, dbType);
+        const exec = db.schema.alterTable(table.table).addColumn(fieldName, type, (col)=>{
+            let column = false !== field.required ? col.notNull() : col;
+            if (field.references) column = column.references(`${field.references.model}.${field.references.field}`);
+            if (field.unique) column = column.unique();
+            return column;
+        });
+        migrations.push(exec);
+    }
+    return migrations;
+}
+function buildTableCreateMigrations(db, toBeCreated, dbType) {
+    const logger = logger_createLogger();
+    const migrations = [];
+    for (const table of toBeCreated){
+        const fieldNames = Object.keys(table.fields);
+        logger.info(`Creating table ${table.table} with fields: ${fieldNames.join(', ')}`);
+        if (fieldNames.includes('id')) logger.warn(`⚠️ Table ${table.table} already has an explicit 'id' field, which may conflict with the auto-generated primary key`);
+        for (const [fieldName, field] of Object.entries(table.fields))if ('id' === field.fieldName && 'id' !== fieldName) logger.error(`❌ ERROR: Table ${table.table} has field '${fieldName}' with fieldName 'id' - this will cause a duplicate column error`);
+        let dbT = db.schema.createTable(table.table).addColumn('id', 'mysql' === dbType || 'mssql' === dbType ? 'varchar(36)' : 'text', (col)=>col.primaryKey().notNull());
+        for (const [fieldName, field] of Object.entries(table.fields)){
+            const type = getType(field, dbType);
+            logger.info(`Adding column ${fieldName} (fieldName: ${field.fieldName || fieldName}) to table ${table.table}`);
+            dbT = dbT.addColumn(fieldName, type, (col)=>{
+                let column = false !== field.required ? col.notNull() : col;
+                if (field.references) column = column.references(`${field.references.model}.${field.references.field}`);
+                if (field.unique) column = column.unique();
+                return column;
+            });
+        }
+        const sqlDebug = dbT.compile().sql;
+        logger.info(`SQL for table ${table.table}:\n${sqlDebug}`);
+        migrations.push(dbT);
+    }
+    return migrations;
+}
+function createMigrationExecutors(migrations) {
+    const logger = logger_createLogger();
+    async function runMigrations() {
+        for (const migration of migrations)try {
+            await migration.execute();
+        } catch (error) {
+            const sql = migration.compile().sql;
+            logger.error(`Migration failed! SQL:\n${sql}`);
+            throw error;
+        }
+    }
+    async function compileMigrations() {
+        const compiled = migrations.map((m)=>m.compile().sql);
+        return `${compiled.join(';\n\n')};`;
+    }
+    return {
+        runMigrations,
+        compileMigrations
+    };
+}
+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);
+external_base_x_default()('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
+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
+    };
+}
+function getSchema(config) {
+    const entities = definition_getConsentTables(config);
+    const schema = {};
+    for (const [key, entity] of Object.entries(entities)){
+        if (!entity) continue;
+        const fields = entity.fields || {};
+        const processedFields = {};
+        for (const [fieldKey, field] of Object.entries(fields)){
+            if (!field) continue;
+            const fieldName = field.fieldName || fieldKey;
+            const typedField = field;
+            processedFields[fieldName] = typedField;
+            if (typedField && 'references' in typedField && typedField.references) {
+                const entityName = typedField.references.model;
+                const referencedEntity = entities[entityName];
+                if (referencedEntity) processedFields[fieldName] = {
+                    ...typedField,
+                    references: {
+                        model: referencedEntity.entityName,
+                        entity: referencedEntity.entityName,
+                        field: typedField.references.field,
+                        onDelete: typedField.references.onDelete
+                    }
+                };
+            }
+        }
+        const entityName = entity.entityName || key;
+        if (entityName in schema) {
+            const existingEntry = schema[entityName];
+            schema[entityName] = {
+                ...existingEntry,
+                order: existingEntry?.order ?? Number.POSITIVE_INFINITY,
+                fields: {
+                    ...existingEntry?.fields,
+                    ...processedFields
+                }
+            };
+        } else schema[entityName] = {
+            fields: processedFields,
+            order: entity.order ?? Number.POSITIVE_INFINITY
+        };
+    }
+    return schema;
+}
+function analyzeSchemaChanges(config, tableMetadata, dbType) {
+    const betterAuthSchema = getSchema(config);
+    const logger = logger_createLogger(config.logger);
+    const toBeCreated = [];
+    const toBeAdded = [];
+    for (const [key, value] of Object.entries(betterAuthSchema)){
+        const table = tableMetadata.find((t)=>t.name === key);
+        if (!table) {
+            handleNewTable(key, value, toBeCreated);
+            continue;
+        }
+        handleExistingTable(key, value, table, toBeAdded, dbType, logger);
+    }
+    return {
+        toBeCreated,
+        toBeAdded
+    };
+}
+function handleNewTable(tableName, value, toBeCreated) {
+    const tIndex = toBeCreated.findIndex((t)=>t.table === tableName);
+    const tableData = {
+        table: tableName,
+        fields: value.fields,
+        order: value.order || Number.POSITIVE_INFINITY
+    };
+    const insertIndex = toBeCreated.findIndex((t)=>(t.order || Number.POSITIVE_INFINITY) > tableData.order);
+    if (-1 === insertIndex) {
+        if (-1 === tIndex) toBeCreated.push(tableData);
+        else {
+            const existingTable = toBeCreated[tIndex];
+            if (existingTable) existingTable.fields = {
+                ...existingTable.fields,
+                ...value.fields
+            };
+        }
+    } else toBeCreated.splice(insertIndex, 0, tableData);
+}
+function handleExistingTable(tableName, value, table, toBeAdded, dbType, logger) {
+    const toBeAddedFields = {};
+    for (const [fieldName, field] of Object.entries(value.fields)){
+        const column = table.columns.find((c)=>c.name === fieldName);
+        if (!column) {
+            toBeAddedFields[fieldName] = field;
+            continue;
+        }
+        if (!matchType(column.dataType, field.type, dbType)) logger.warn(`Field ${fieldName} in table ${tableName} has a different type in the database. Expected ${field.type} but got ${column.dataType}.`);
+    }
+    if (Object.keys(toBeAddedFields).length > 0) toBeAdded.push({
+        table: tableName,
+        fields: toBeAddedFields,
+        order: value.order || Number.POSITIVE_INFINITY
+    });
+}
+async function getMigrations(config) {
+    const logger = logger_createLogger(config.logger);
+    let { kysely: db, databaseType: dbType } = await dialect_createKyselyAdapter(config);
+    if (!dbType) {
+        logger.warn('Could not determine database type, defaulting to sqlite. Please provide a type in the database options to avoid this.');
+        dbType = 'sqlite';
+    }
+    if (!db) {
+        logger.error("Only kysely adapter is supported for migrations. You can use `generate` command to generate the schema, if you're using a different adapter.");
+        process.exit(1);
+    }
+    const tableMetadata = await db.introspection.getTables();
+    const { toBeCreated, toBeAdded } = analyzeSchemaChanges(config, tableMetadata, dbType);
+    const columnMigrations = buildColumnAddMigrations(db, toBeAdded, dbType);
+    const tableMigrations = buildTableCreateMigrations(db, toBeCreated, dbType);
+    const migrations = [
+        ...columnMigrations,
+        ...tableMigrations
+    ];
+    const { runMigrations, compileMigrations } = createMigrationExecutors(migrations);
+    return {
+        toBeCreated,
+        toBeAdded,
+        runMigrations,
+        compileMigrations
+    };
+}
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});