@c15t/cli 0.0.1-rc.13 → 0.0.1-rc.15

package/dist/index.mjs

@@ -1,141 +1,127 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import fs$1, { existsSync } from 'node:fs';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { getAdapter } from '@c15t/backend/pkgs/db-adapters';
-import chalk from 'chalk';
-import prompts from 'prompts';
-import yoctoSpinner from 'yocto-spinner';
-import { z } from 'zod';
-import { createLogger } from '@c15t/backend/pkgs/logger';
-import { getConsentTables } from '@c15t/backend/schema';
-import { getMigrations } from '@c15t/backend/pkgs/migrations';
-import { produceSchema } from '@mrleebo/prisma-ast';
-import babelPresetReact from '@babel/preset-react';
-import babelPresetTypescript from '@babel/preset-typescript';
-import { DoubleTieError } from '@c15t/backend/pkgs/results';
-import { loadConfig } from 'c12';
-import 'dotenv/config';
-import Crypto from 'node:crypto';
-import fs$2 from 'fs-extra';
-
-const logger = createLogger({
-  level: "info",
-  appName: "c15t"
+import * as __WEBPACK_EXTERNAL_MODULE_commander__ from "commander";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__ from "node:fs/promises";
+import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_db_adapters_cee37d0f__ from "@c15t/backend/pkgs/db-adapters";
+import * as __WEBPACK_EXTERNAL_MODULE_chalk__ from "chalk";
+import * as __WEBPACK_EXTERNAL_MODULE_prompts__ from "prompts";
+import * as __WEBPACK_EXTERNAL_MODULE_yocto_spinner_579f0326__ from "yocto-spinner";
+import * as __WEBPACK_EXTERNAL_MODULE_zod__ from "zod";
+import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_logger_44a195c6__ from "@c15t/backend/pkgs/logger";
+import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_schema_4fae43f5__ from "@c15t/backend/schema";
+import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_migrations_80b6e3bd__ from "@c15t/backend/pkgs/migrations";
+import * as __WEBPACK_EXTERNAL_MODULE__mrleebo_prisma_ast_c5b328aa__ from "@mrleebo/prisma-ast";
+import * as __WEBPACK_EXTERNAL_MODULE__babel_preset_react_76cf724d__ from "@babel/preset-react";
+import * as __WEBPACK_EXTERNAL_MODULE__babel_preset_typescript_a7789c85__ from "@babel/preset-typescript";
+import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__ from "@c15t/backend/pkgs/results";
+import * as __WEBPACK_EXTERNAL_MODULE_c12__ from "c12";
+import "dotenv/config";
+import * as __WEBPACK_EXTERNAL_MODULE_node_crypto_9ba42079__ from "node:crypto";
+import * as __WEBPACK_EXTERNAL_MODULE_fs_extra_ce68a66b__ from "fs-extra";
+const logger = (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_logger_44a195c6__.createLogger)({
+    level: 'info',
+    appName: 'c15t'
 });
-
+const utils_logger = logger;
 function convertToSnakeCase(str) {
-  if (str === void 0 || str === null) {
-    return "";
-  }
-  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+    if (null == str) return '';
+    return str.replace(/[A-Z]/g, (letter)=>`_${letter.toLowerCase()}`);
 }
-const generateDrizzleSchema = async ({
-  options,
-  file,
-  adapter
-}) => {
-  const tables = getConsentTables(options);
-  const filePath = file || "./auth-schema.ts";
-  const databaseType = adapter.options?.provider;
-  const usePlural = adapter.options?.usePlural;
-  const timestampAndBoolean = databaseType !== "sqlite" ? "timestamp, boolean" : "";
-  const int = databaseType === "mysql" ? "int" : "integer";
-  const hasBigint = Object.values(tables).some(
-    (table) => Object.values(table.fields).some(
-      (field) => "bigint" in field && field.bigint
-    )
-  );
-  const bigint = databaseType !== "sqlite" ? "bigint" : "";
-  const text = databaseType === "mysql" ? "varchar, text" : "text";
-  const jsonType = ["mysql", "pg"].includes(databaseType || "") ? ", json" : "";
-  let code = `import { ${databaseType}Table, ${text}, ${int}${hasBigint ? `, ${bigint}` : ""}, ${timestampAndBoolean}${jsonType} } from "drizzle-orm/${databaseType}-core";`;
-  const fileExist = existsSync(filePath);
-  let isFirstTable = true;
-  for (const table in tables) {
-    if (Object.prototype.hasOwnProperty.call(tables, table)) {
-      let getMySQLStringType = function(field, name) {
-        if (field.unique) {
-          return `varchar('${name}', { length: 255 })`;
-        }
-        if (field.references) {
-          return `varchar('${name}', { length: 36 })`;
-        }
-        return `text('${name}')`;
-      }, getType = function(fieldName, field) {
-        const snakeCaseName = convertToSnakeCase(fieldName);
-        const type = field.type;
-        const typeMap = {
-          string: {
-            sqlite: `text('${snakeCaseName}')`,
-            pg: `text('${snakeCaseName}')`,
-            mysql: getMySQLStringType(field, snakeCaseName)
-          },
-          boolean: {
-            sqlite: `integer('${snakeCaseName}', { mode: 'boolean' })`,
-            pg: `boolean('${snakeCaseName}')`,
-            mysql: `boolean('${snakeCaseName}')`
-          },
-          number: {
-            sqlite: `integer('${snakeCaseName}')`,
-            pg: "bigint" in field && field.bigint ? `bigint('${snakeCaseName}', { mode: 'number' })` : `integer('${snakeCaseName}')`,
-            mysql: "bigint" in field && field.bigint ? `bigint('${snakeCaseName}', { mode: 'number' })` : `int('${snakeCaseName}')`
-          },
-          date: {
-            sqlite: `integer('${snakeCaseName}', { mode: 'timestamp' })`,
-            pg: `timestamp('${snakeCaseName}')`,
-            mysql: `timestamp('${snakeCaseName}')`
-          },
-          // Add JSON type support
-          json: {
-            sqlite: `text('${snakeCaseName}')`,
-            // SQLite uses TEXT for JSON
-            pg: `json('${snakeCaseName}')`,
-            // PostgreSQL native JSON
-            mysql: `json('${snakeCaseName}')`
-            // MySQL native JSON
-          }
-        };
-        if (!typeMap[type]) {
-          return `text('${snakeCaseName}')`;
+const generateDrizzleSchema = async ({ options, file, adapter })=>{
+    const tables = (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_schema_4fae43f5__.getConsentTables)(options);
+    const filePath = file || './auth-schema.ts';
+    const databaseType = adapter.options?.provider;
+    const usePlural = adapter.options?.usePlural;
+    const timestampAndBoolean = 'sqlite' !== databaseType ? 'timestamp, boolean' : '';
+    const int = 'mysql' === databaseType ? 'int' : 'integer';
+    const hasBigint = Object.values(tables).some((table)=>Object.values(table.fields).some((field)=>'bigint' in field && field.bigint));
+    const bigint = 'sqlite' !== databaseType ? 'bigint' : '';
+    const text = 'mysql' === databaseType ? 'varchar, text' : 'text';
+    const jsonType = [
+        'mysql',
+        'pg'
+    ].includes(databaseType || '') ? ', json' : '';
+    let code = `import { ${databaseType}Table, ${text}, ${int}${hasBigint ? `, ${bigint}` : ''}, ${timestampAndBoolean}${jsonType} } from "drizzle-orm/${databaseType}-core";`;
+    const fileExist = (0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(filePath);
+    let isFirstTable = true;
+    for(const table in tables)if (Object.prototype.hasOwnProperty.call(tables, table)) {
+        const tableDefinition = tables[table];
+        if (!tableDefinition) continue;
+        let modelName = usePlural ? `${tableDefinition.modelName}s` : tableDefinition.modelName;
+        if (!modelName) modelName = table;
+        const fields = tableDefinition.fields;
+        function getMySQLStringType(field, name) {
+            if (field.unique) return `varchar('${name}', { length: 255 })`;
+            if (field.references) return `varchar('${name}', { length: 36 })`;
+            return `text('${name}')`;
         }
-        const dbType = databaseType && ["sqlite", "pg", "mysql"].includes(databaseType) ? databaseType : "sqlite";
-        return typeMap[type][dbType];
-      };
-      let modelName = usePlural ? `${tables[table].modelName}s` : tables[table].modelName;
-      if (!modelName) {
-        modelName = table;
-      }
-      const fields = tables[table].fields;
-      const id = databaseType === "mysql" ? `varchar("id", { length: 36 }).primaryKey()` : `text("id").primaryKey()`;
-      const tableNameForSQL = convertToSnakeCase(modelName);
-      if (isFirstTable) {
-        code += "\n\n";
-        isFirstTable = false;
-      } else {
-        code += "\n\n";
-      }
-      const schema = `export const ${modelName} = ${databaseType}Table("${tableNameForSQL}", {
-  id: ${id},
-${Object.keys(fields).map((field) => {
-        if (Object.prototype.hasOwnProperty.call(fields, field)) {
-          const attr = fields[field];
-          return `  ${field}: ${getType(field, attr)}${attr.required ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${attr.references ? `.references(()=> ${usePlural ? `${attr.references.model}s` : attr.references.model}.${attr.references.field}, { onDelete: 'cascade' })` : ""}`;
+        function getType(fieldName, field) {
+            const snakeCaseName = convertToSnakeCase(fieldName);
+            const type = field.type;
+            const typeMap = {
+                string: {
+                    sqlite: `text('${snakeCaseName}')`,
+                    pg: `text('${snakeCaseName}')`,
+                    mysql: getMySQLStringType(field, snakeCaseName)
+                },
+                boolean: {
+                    sqlite: `integer('${snakeCaseName}', { mode: 'boolean' })`,
+                    pg: `boolean('${snakeCaseName}')`,
+                    mysql: `boolean('${snakeCaseName}')`
+                },
+                number: {
+                    sqlite: `integer('${snakeCaseName}')`,
+                    pg: 'bigint' in field && field.bigint ? `bigint('${snakeCaseName}', { mode: 'number' })` : `integer('${snakeCaseName}')`,
+                    mysql: 'bigint' in field && field.bigint ? `bigint('${snakeCaseName}', { mode: 'number' })` : `int('${snakeCaseName}')`
+                },
+                date: {
+                    sqlite: `integer('${snakeCaseName}', { mode: 'timestamp' })`,
+                    pg: `timestamp('${snakeCaseName}')`,
+                    mysql: `timestamp('${snakeCaseName}')`
+                },
+                json: {
+                    sqlite: `text('${snakeCaseName}')`,
+                    pg: `json('${snakeCaseName}')`,
+                    mysql: `json('${snakeCaseName}')`
+                }
+            };
+            if (!typeMap[type]) return `text('${snakeCaseName}')`;
+            const dbType = databaseType && [
+                'sqlite',
+                'pg',
+                'mysql'
+            ].includes(databaseType) ? databaseType : 'sqlite';
+            return typeMap[type][dbType];
         }
-        return "";
-      }).filter(Boolean).join(",\n")}
-});`;
-      code += schema;
+        const id = 'mysql' === databaseType ? 'varchar("id", { length: 36 }).primaryKey()' : 'text("id").primaryKey()';
+        const tableNameForSQL = convertToSnakeCase(modelName);
+        if (isFirstTable) {
+            code += '\n\n';
+            isFirstTable = false;
+        } else code += '\n\n';
+        const fieldDefinitions = Object.keys(fields).map((field)=>{
+            if (Object.prototype.hasOwnProperty.call(fields, field)) {
+                const attr = fields[field];
+                if (!attr) return '';
+                return `  ${field}: ${getType(field, attr)}${attr.required ? '.notNull()' : ''}${attr.unique ? '.unique()' : ''}${attr.references ? `.references(()=> ${usePlural ? `${attr.references.model}s` : attr.references.model}.${attr.references.field}, { onDelete: 'cascade' })` : ''}`;
+            }
+            return '';
+        }).filter(Boolean).join(',\n');
+        const schema = [
+            `export const ${modelName} = ${databaseType}Table("${tableNameForSQL}", {`,
+            `  id: ${id},`,
+            fieldDefinitions,
+            '});'
+        ].join('\n');
+        code += schema;
     }
-  }
-  return {
-    code,
-    fileName: filePath,
-    overwrite: fileExist
-  };
+    return {
+        code: code,
+        fileName: filePath,
+        overwrite: fileExist
+    };
 };
-
 const CREATE_TABLE_REGEX = /create\s+table\s+"([^"]+)"\s+\((.*)\)/i;
 const CREATE_INDEX_REGEX = /create\s+index\s+"?([^"\s]+)"?\s+on\s+"?([^"\s]+)"?/i;
 const NOT_NULL_REGEX = /\bnot null\b/gi;
@@ -159,59 +145,45 @@ const BOOLEAN_FIELD_REGEX = /("is[A-Z][a-zA-Z0-9]*")\s+integer/g;
 const DATE_FIELD_REGEX = /("(?:created|updated|expires)At")\s+date/gi;
 const TEXT_FIELD_REGEX = /("(?:name|code|description|id)")\s+text/gi;
 const JSON_FIELD_REGEX = /("(?:metadata|config|data|settings|options|preferences|attributes)")\s+text/gi;
-function formatSQL(sql, databaseType = "sqlite", options) {
-  const dbType = databaseType === "pg" ? "postgresql" : databaseType;
-  const statements = sql.split(";").filter((stmt) => stmt.trim());
-  const rollbackStatements = [];
-  const formattedStatements = statements.map((statement) => {
-    const trimmedStmt = statement.trim().toLowerCase();
-    if (trimmedStmt.startsWith("create table")) {
-      const match = statement.match(CREATE_TABLE_REGEX);
-      if (match) {
-        const [_, tableName, columnsStr] = match;
-        rollbackStatements.unshift(`DROP TABLE IF EXISTS "${tableName}"`);
-        const columns = columnsStr.split(",").map((col) => col.trim());
-        const formattedColumns = columns.map((col) => {
-          let formattedCol = col.replace(NOT_NULL_REGEX, "NOT NULL").replace(PRIMARY_KEY_REGEX, "PRIMARY KEY").replace(REFERENCES_REGEX, "REFERENCES").replace(UNIQUE_REGEX, "UNIQUE");
-          if (dbType === "postgresql") {
-            formattedCol = formattedCol.replace(BOOLEAN_FIELD_REGEX, "$1 boolean").replace(DATE_FIELD_REGEX, "$1 timestamp with time zone").replace(TEXT_FIELD_REGEX, "$1 varchar(255)").replace(JSON_FIELD_REGEX, "$1 jsonb");
-          } else if (dbType === "mysql") {
-            formattedCol = formattedCol.replace(BOOLEAN_FIELD_REGEX, "$1 TINYINT(1)").replace(DATE_FIELD_REGEX, "$1 DATETIME").replace(TEXT_FIELD_REGEX, "$1 VARCHAR(255)").replace(JSON_FIELD_REGEX, "$1 JSON");
-          } else if (dbType === "sqlite") {
-            formattedCol = formattedCol.replace(
-              JSON_FIELD_REGEX,
-              "$1 text -- stored as JSON"
-            );
-          }
-          return formattedCol;
-        }).map((col) => `  ${col}`).join(",\n");
-        return `CREATE TABLE IF NOT EXISTS "${tableName}" (
-${formattedColumns}
-);`;
-      }
-    }
-    if (trimmedStmt.startsWith("create index")) {
-      const indexMatch = statement.match(CREATE_INDEX_REGEX);
-      if (indexMatch) {
-        const [_, indexName] = indexMatch;
-        rollbackStatements.unshift(`DROP INDEX IF EXISTS "${indexName}"`);
-        return `CREATE INDEX IF NOT EXISTS "${indexName}" ${statement.substring(statement.toLowerCase().indexOf("on")).trim()};`;
-      }
-    }
-    return `${statement.trim().replace(CREATE_TABLE_KEYWORD_REGEX, "CREATE TABLE").replace(CREATE_INDEX_KEYWORD_REGEX, "CREATE INDEX").replace(ALTER_TABLE_REGEX, "ALTER TABLE").replace(INSERT_INTO_REGEX, "INSERT INTO").replace(UPDATE_REGEX, "UPDATE").replace(DELETE_FROM_REGEX, "DELETE FROM").replace(SELECT_REGEX, "SELECT").replace(FROM_REGEX, "FROM").replace(WHERE_REGEX, "WHERE").replace(JOIN_REGEX, "JOIN").replace(ON_REGEX, "ON").replace(AND_REGEX, "AND").replace(OR_REGEX, "OR")};`;
-  }).join("\n\n");
-  const useTransactions = dbType !== "d1";
-  let transactionStart = "";
-  if (useTransactions) {
-    if (dbType === "mysql") {
-      transactionStart = "START TRANSACTION;";
-    } else {
-      transactionStart = "BEGIN;";
-    }
-  }
-  const transactionEnd = useTransactions ? "COMMIT;" : "";
-  const timestamp = options?.timestamp || (/* @__PURE__ */ new Date()).toISOString();
-  return `-- Migration generated by C15T (${timestamp})
+function formatSQL(sql, databaseType = 'sqlite', options) {
+    const dbType = 'pg' === databaseType ? 'postgresql' : databaseType;
+    const statements = sql.split(';').filter((stmt)=>stmt.trim());
+    const rollbackStatements = [];
+    const formattedStatements = statements.map((statement)=>{
+        const trimmedStmt = statement.trim().toLowerCase();
+        if (trimmedStmt.startsWith('create table')) {
+            const match = statement.match(CREATE_TABLE_REGEX);
+            if (match) {
+                const [_, tableName, columnsStr] = match;
+                if (!columnsStr) return `${statement.trim()};`;
+                rollbackStatements.unshift(`DROP TABLE IF EXISTS "${tableName}"`);
+                const columns = columnsStr.split(',').map((col)=>col.trim());
+                const formattedColumns = columns.map((col)=>{
+                    let formattedCol = col.replace(NOT_NULL_REGEX, 'NOT NULL').replace(PRIMARY_KEY_REGEX, 'PRIMARY KEY').replace(REFERENCES_REGEX, 'REFERENCES').replace(UNIQUE_REGEX, 'UNIQUE');
+                    if ('postgresql' === dbType) formattedCol = formattedCol.replace(BOOLEAN_FIELD_REGEX, '$1 boolean').replace(DATE_FIELD_REGEX, '$1 timestamp with time zone').replace(TEXT_FIELD_REGEX, '$1 varchar(255)').replace(JSON_FIELD_REGEX, '$1 jsonb');
+                    else if ('mysql' === dbType) formattedCol = formattedCol.replace(BOOLEAN_FIELD_REGEX, '$1 TINYINT(1)').replace(DATE_FIELD_REGEX, '$1 DATETIME').replace(TEXT_FIELD_REGEX, '$1 VARCHAR(255)').replace(JSON_FIELD_REGEX, '$1 JSON');
+                    else if ('sqlite' === dbType) formattedCol = formattedCol.replace(JSON_FIELD_REGEX, '$1 text -- stored as JSON');
+                    return formattedCol;
+                }).map((col)=>`  ${col}`).join(',\n');
+                return `CREATE TABLE IF NOT EXISTS "${tableName}" (\n${formattedColumns}\n);`;
+            }
+        }
+        if (trimmedStmt.startsWith('create index')) {
+            const indexMatch = statement.match(CREATE_INDEX_REGEX);
+            if (indexMatch) {
+                const [_, indexName] = indexMatch;
+                rollbackStatements.unshift(`DROP INDEX IF EXISTS "${indexName}"`);
+                return `CREATE INDEX IF NOT EXISTS "${indexName}" ${statement.substring(statement.toLowerCase().indexOf('on')).trim()};`;
+            }
+        }
+        return `${statement.trim().replace(CREATE_TABLE_KEYWORD_REGEX, 'CREATE TABLE').replace(CREATE_INDEX_KEYWORD_REGEX, 'CREATE INDEX').replace(ALTER_TABLE_REGEX, 'ALTER TABLE').replace(INSERT_INTO_REGEX, 'INSERT INTO').replace(UPDATE_REGEX, 'UPDATE').replace(DELETE_FROM_REGEX, 'DELETE FROM').replace(SELECT_REGEX, 'SELECT').replace(FROM_REGEX, 'FROM').replace(WHERE_REGEX, 'WHERE').replace(JOIN_REGEX, 'JOIN').replace(ON_REGEX, 'ON').replace(AND_REGEX, 'AND').replace(OR_REGEX, 'OR')};`;
+    }).join('\n\n');
+    const useTransactions = 'd1' !== dbType;
+    let transactionStart = '';
+    if (useTransactions) transactionStart = 'mysql' === dbType ? 'START TRANSACTION;' : 'BEGIN;';
+    const transactionEnd = useTransactions ? 'COMMIT;' : '';
+    const timestamp = options?.timestamp || new Date().toISOString();
+    return `-- Migration generated by C15T (${timestamp})
 -- Database type: ${dbType}
 -- Description: Automatically generated schema migration
 -- 
@@ -228,609 +200,453 @@ ${transactionEnd}
 /*
 ${transactionStart}
 
-${rollbackStatements.join(";\n\n")};
-
+${rollbackStatements.join(';\n\n')};\n
 ${transactionEnd}
 */`;
 }
-const generateMigrations = async ({
-  options,
-  file,
-  adapter
-}) => {
-  const { compileMigrations } = await getMigrations(options);
-  const migrations = await compileMigrations();
-  let databaseType = "sqlite";
-  if (adapter?.options?.provider) {
-    databaseType = adapter.options.provider;
-  } else if (options.database && "options" in options.database && options.database.options && typeof options.database.options === "object" && "provider" in options.database.options) {
-    databaseType = options.database.options.provider;
-  }
-  const isTest = process.env.NODE_ENV === "test" || file?.includes("test");
-  const testTimestamp = options?._testTimestamp;
-  const formatOptions = {
-    timestamp: testTimestamp || (isTest ? "2023-01-01T00:00:00.000Z" : void 0)
-  };
-  const formattedMigrations = formatSQL(
-    migrations,
-    databaseType,
-    formatOptions
-  );
-  const generatedFileName = file || `./c15t_migrations/${Date.now()}_create_tables.sql`;
-  return {
-    code: formattedMigrations,
-    fileName: generatedFileName
-  };
+const generateMigrations = async ({ options, file, adapter })=>{
+    const { compileMigrations } = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_migrations_80b6e3bd__.getMigrations)(options);
+    const migrations = await compileMigrations();
+    let databaseType = 'sqlite';
+    if (adapter?.options?.provider) databaseType = adapter.options.provider;
+    else {
+        const dbOptions = options.database?.options;
+        if (dbOptions?.provider) databaseType = dbOptions.provider;
+    }
+    const isTest = 'test' === process.env.NODE_ENV || file?.includes('test');
+    const testTimestamp = options?._testTimestamp;
+    const formatOptions = {
+        timestamp: testTimestamp || (isTest ? '2023-01-01T00:00:00.000Z' : void 0)
+    };
+    const formattedMigrations = formatSQL(migrations, databaseType, formatOptions);
+    const generatedFileName = file || `./c15t_migrations/${Date.now()}_create_tables.sql`;
+    return {
+        code: formattedMigrations,
+        fileName: generatedFileName
+    };
 };
-
 function capitalizeFirstLetter(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
+    return str.charAt(0).toUpperCase() + str.slice(1);
 }
-
-const generatePrismaSchema = async ({
-  adapter,
-  options,
-  file
-}) => {
-  const provider = adapter.options?.provider || "postgresql";
-  const tables = getConsentTables(options);
-  const filePath = file || "./prisma/schema.prisma";
-  const schemaPrismaExist = existsSync(path.join(process.cwd(), filePath));
-  let schemaPrisma = "";
-  if (schemaPrismaExist) {
-    schemaPrisma = await fs.readFile(
-      path.join(process.cwd(), filePath),
-      "utf-8"
-    );
-  } else {
-    schemaPrisma = getNewPrisma(provider);
-  }
-  const manyToManyRelations = /* @__PURE__ */ new Map();
-  for (const table in tables) {
-    if (Object.hasOwn(tables, table)) {
-      const fields = tables[table]?.fields;
-      for (const field in fields) {
-        if (Object.hasOwn(fields, field)) {
-          const attr = fields[field];
-          if (attr?.references) {
-            const referencedModel = capitalizeFirstLetter(
-              attr.references.model
-            );
-            if (!manyToManyRelations.has(referencedModel)) {
-              manyToManyRelations.set(referencedModel, /* @__PURE__ */ new Set());
+const generatePrismaSchema = async ({ adapter, options, file })=>{
+    const provider = adapter.options?.provider || 'postgresql';
+    const tables = (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_schema_4fae43f5__.getConsentTables)(options);
+    const filePath = file || './prisma/schema.prisma';
+    const schemaPrismaExist = (0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(process.cwd(), filePath));
+    let schemaPrisma = '';
+    schemaPrisma = schemaPrismaExist ? await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].readFile(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(process.cwd(), filePath), 'utf-8') : getNewPrisma(provider);
+    const manyToManyRelations = new Map();
+    for(const table in tables)if (Object.hasOwn(tables, table)) {
+        const fields = tables[table]?.fields;
+        for(const field in fields)if (Object.hasOwn(fields, field)) {
+            const attr = fields[field];
+            if (attr?.references) {
+                const referencedModel = capitalizeFirstLetter(attr.references.model);
+                if (!manyToManyRelations.has(referencedModel)) manyToManyRelations.set(referencedModel, new Set());
+                manyToManyRelations.get(referencedModel)?.add(capitalizeFirstLetter(table));
             }
-            manyToManyRelations.get(referencedModel).add(capitalizeFirstLetter(table));
-          }
         }
-      }
     }
-  }
-  const schema = produceSchema(schemaPrisma, (builder) => {
-    function getPrismaType(type, isOptional, isBigint) {
-      const isJsonField = type === "json" || type === "jsonb";
-      if (isJsonField) {
-        if (provider === "postgresql" || provider === "mysql") {
-          return isOptional ? "Json?" : "Json";
-        }
-        return isOptional ? "String?" : 'String @map("json_as_text")';
-      }
-      if (type === "string") {
-        return isOptional ? "String?" : "String";
-      }
-      if (type === "number" && isBigint) {
-        return isOptional ? "BigInt?" : "BigInt";
-      }
-      if (type === "number") {
-        return isOptional ? "Int?" : "Int";
-      }
-      if (type === "boolean") {
-        return isOptional ? "Boolean?" : "Boolean";
-      }
-      if (type === "date") {
-        return isOptional ? "DateTime?" : "DateTime";
-      }
-      if (type === "string[]") {
-        return "String[]";
-      }
-      if (type === "number[]") {
-        return "Int[]";
-      }
-      return "String";
-    }
-    for (const table in tables) {
-      if (Object.hasOwn(tables, table)) {
-        const fields = tables[table]?.fields;
-        const originalTable = tables[table]?.modelName;
-        const modelName = capitalizeFirstLetter(originalTable || table);
-        const prismaModel = builder.findByType("model", { name: modelName });
-        if (!prismaModel) {
-          if (provider === "mongodb") {
-            builder.model(modelName).field("id", "String").attribute("id").attribute(`map("_id")`);
-          } else {
-            builder.model(modelName).field("id", "String").attribute("id");
-          }
+    const schema = (0, __WEBPACK_EXTERNAL_MODULE__mrleebo_prisma_ast_c5b328aa__.produceSchema)(schemaPrisma, (builder)=>{
+        function getPrismaType(type, isOptional, isBigint) {
+            const isJsonField = 'json' === type || 'jsonb' === type;
+            if (isJsonField) {
+                if ('postgresql' === provider || 'mysql' === provider) return isOptional ? 'Json?' : 'Json';
+                return isOptional ? 'String?' : 'String @map("json_as_text")';
+            }
+            if ('string' === type) return isOptional ? 'String?' : 'String';
+            if ('number' === type && isBigint) return isOptional ? 'BigInt?' : 'BigInt';
+            if ('number' === type) return isOptional ? 'Int?' : 'Int';
+            if ('boolean' === type) return isOptional ? 'Boolean?' : 'Boolean';
+            if ('date' === type) return isOptional ? 'DateTime?' : 'DateTime';
+            if ('string[]' === type) return 'String[]';
+            if ('number[]' === type) return 'Int[]';
+            return 'String';
         }
-        for (const field in fields) {
-          if (Object.hasOwn(fields, field)) {
-            const attr = fields[field];
-            const existingField = builder.findByType("field", {
-              name: field,
-              within: prismaModel?.properties
+        for(const table in tables)if (Object.hasOwn(tables, table)) {
+            const fields = tables[table]?.fields;
+            const originalTable = tables[table]?.modelName;
+            const modelName = capitalizeFirstLetter(originalTable || table);
+            const prismaModel = builder.findByType('model', {
+                name: modelName
             });
-            if (existingField) {
-              continue;
+            if (!prismaModel) {
+                if ('mongodb' === provider) builder.model(modelName).field('id', 'String').attribute('id').attribute('map("_id")');
+                else builder.model(modelName).field('id', 'String').attribute('id');
             }
-            builder.model(modelName).field(
-              field,
-              getPrismaType(attr.type, !attr?.required, attr?.bigint || false)
-            );
-            if (attr.unique) {
-              builder.model(modelName).blockAttribute(`unique([${field}])`);
+            for(const field in fields)if (Object.hasOwn(fields, field)) {
+                const attr = fields[field];
+                const existingField = builder.findByType('field', {
+                    name: field,
+                    within: prismaModel?.properties
+                });
+                if (existingField) continue;
+                if (!attr) continue;
+                builder.model(modelName).field(field, getPrismaType(attr.type, !attr?.required, attr?.bigint || false));
+                if (attr.unique) builder.model(modelName).blockAttribute(`unique([${field}])`);
+                if (attr.references) builder.model(modelName).field(`${attr.references.model.toLowerCase()}`, capitalizeFirstLetter(attr.references.model)).attribute(`relation(fields: [${field}], references: [${attr.references.field}], onDelete: Cascade)`);
+                if (!attr.unique && !attr.references && 'mysql' === provider && 'string' === attr.type) builder.model(modelName).field(field).attribute('db.Text');
             }
-            if (attr.references) {
-              builder.model(modelName).field(
-                `${attr.references.model.toLowerCase()}`,
-                capitalizeFirstLetter(attr.references.model)
-              ).attribute(
-                `relation(fields: [${field}], references: [${attr.references.field}], onDelete: Cascade)`
-              );
+            if (originalTable && originalTable !== modelName) {
+                const hasMapAttribute = builder.findByType('attribute', {
+                    name: 'map',
+                    within: prismaModel?.properties
+                });
+                if (!hasMapAttribute) builder.model(modelName).blockAttribute('map', originalTable);
             }
-            if (!attr.unique && !attr.references && provider === "mysql" && attr.type === "string") {
-              builder.model(modelName).field(field).attribute("db.Text");
-            }
-          }
-        }
-        if (originalTable && originalTable !== modelName) {
-          const hasMapAttribute = builder.findByType("attribute", {
-            name: "map",
-            within: prismaModel?.properties
-          });
-          if (!hasMapAttribute) {
-            builder.model(modelName).blockAttribute("map", originalTable);
-          }
         }
-      }
-    }
-    for (const [
-      referencedModel,
-      relatedModels
-    ] of manyToManyRelations.entries()) {
-      for (const relatedModel of relatedModels) {
-        const fieldName = `${relatedModel.toLowerCase()}s`;
-        const model = builder.findByType("model", { name: referencedModel });
-        if (model) {
-          const existingField = builder.findByType("field", {
-            name: fieldName,
-            within: model.properties
-          });
-          if (!existingField) {
-            builder.model(referencedModel).field(fieldName, `${relatedModel}[]`);
-          }
+        for (const [referencedModel, relatedModels] of manyToManyRelations.entries())for (const relatedModel of relatedModels){
+            const fieldName = `${relatedModel.toLowerCase()}s`;
+            const model = builder.findByType('model', {
+                name: referencedModel
+            });
+            if (model) {
+                const existingField = builder.findByType('field', {
+                    name: fieldName,
+                    within: model.properties
+                });
+                if (!existingField) builder.model(referencedModel).field(fieldName, `${relatedModel}[]`);
+            }
         }
-      }
-    }
-  });
-  return {
-    code: schema.trim() === schemaPrisma.trim() ? "" : schema,
-    fileName: filePath
-  };
+    });
+    return {
+        code: schema.trim() === schemaPrisma.trim() ? '' : schema,
+        fileName: filePath
+    };
 };
-const getNewPrisma = (provider) => `generator client {
+const getNewPrisma = (provider)=>`generator client {
     provider = "prisma-client-js"
   }
   
   datasource db {
     provider = "${provider}"
-    url      = ${provider === "sqlite" ? `"file:./dev.db"` : `env("DATABASE_URL")`}
+    url      = ${'sqlite' === provider ? '"file:./dev.db"' : 'env("DATABASE_URL")'}
   }`;
-
 const adapters = {
-  prisma: generatePrismaSchema,
-  drizzle: generateDrizzleSchema,
-  kysely: generateMigrations
+    prisma: generatePrismaSchema,
+    drizzle: generateDrizzleSchema,
+    kysely: generateMigrations
 };
-const getGenerator = (opts) => {
-  const adapter = opts.adapter;
-  const generator = adapter.id in adapters ? adapters[adapter.id] : null;
-  if (!generator) {
-    logger.error(`${adapter.id} is not supported.`);
-    process.exit(1);
-  }
-  return generator(opts);
+const getGenerator = (opts)=>{
+    const adapter = opts.adapter;
+    const generator = adapter.id in adapters ? adapters[adapter.id] : null;
+    if (!generator) {
+        utils_logger.error(`${adapter.id} is not supported.`);
+        process.exit(1);
+    }
+    return generator(opts);
 };
-
 function addSvelteKitEnvModules(aliases) {
-  aliases["$env/dynamic/private"] = createDataUriModule(
-    createDynamicEnvModule()
-  );
-  aliases["$env/dynamic/public"] = createDataUriModule(
-    createDynamicEnvModule()
-  );
-  aliases["$env/static/private"] = createDataUriModule(
-    createStaticEnvModule(filterPrivateEnv("PUBLIC_", ""))
-  );
-  aliases["$env/static/public"] = createDataUriModule(
-    createStaticEnvModule(filterPublicEnv("PUBLIC_", ""))
-  );
+    aliases['$env/dynamic/private'] = createDataUriModule(createDynamicEnvModule());
+    aliases['$env/dynamic/public'] = createDataUriModule(createDynamicEnvModule());
+    aliases['$env/static/private'] = createDataUriModule(createStaticEnvModule(filterPrivateEnv('PUBLIC_', '')));
+    aliases['$env/static/public'] = createDataUriModule(createStaticEnvModule(filterPublicEnv('PUBLIC_', '')));
 }
 function createDataUriModule(module) {
-  return `data:text/javascript;charset=utf-8,${encodeURIComponent(module)}`;
+    return `data:text/javascript;charset=utf-8,${encodeURIComponent(module)}`;
 }
 function createStaticEnvModule(env) {
-  const declarations = Object.keys(env).filter((k) => validIdentifier.test(k) && !reserved.has(k)).map((k) => `export const ${k} = ${JSON.stringify(env[k])};`);
-  return `
-  ${declarations.join("\n")}
+    const declarations = Object.keys(env).filter((k)=>validIdentifier.test(k) && !reserved.has(k)).map((k)=>`export const ${k} = ${JSON.stringify(env[k])};`);
+    return `
+  ${declarations.join('\n')}
   // jiti dirty hack: .unknown
   `;
 }
 function createDynamicEnvModule() {
-  return `
+    return `
   export const env = process.env;
   // jiti dirty hack: .unknown
   `;
 }
 function filterPrivateEnv(publicPrefix, privatePrefix) {
-  return Object.fromEntries(
-    Object.entries(process.env).filter(
-      ([k]) => k.startsWith(privatePrefix) && (!k.startsWith(publicPrefix))
-    )
-  );
+    return Object.fromEntries(Object.entries(process.env).filter(([k])=>k.startsWith(privatePrefix) && ('' === publicPrefix || !k.startsWith(publicPrefix))));
 }
 function filterPublicEnv(publicPrefix, privatePrefix) {
-  return Object.fromEntries(
-    Object.entries(process.env).filter(
-      ([k]) => k.startsWith(publicPrefix) && (privatePrefix === "")
-    )
-  );
+    return Object.fromEntries(Object.entries(process.env).filter(([k])=>k.startsWith(publicPrefix) && ('' === privatePrefix || !k.startsWith(privatePrefix))));
 }
 const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-const reserved = /* @__PURE__ */ new Set([
-  "do",
-  "if",
-  "in",
-  "for",
-  "let",
-  "new",
-  "try",
-  "var",
-  "case",
-  "else",
-  "enum",
-  "eval",
-  "null",
-  "this",
-  "true",
-  "void",
-  "with",
-  "await",
-  "break",
-  "catch",
-  "class",
-  "const",
-  "false",
-  "super",
-  "throw",
-  "while",
-  "yield",
-  "delete",
-  "export",
-  "import",
-  "public",
-  "return",
-  "static",
-  "switch",
-  "typeof",
-  "default",
-  "extends",
-  "finally",
-  "package",
-  "private",
-  "continue",
-  "debugger",
-  "function",
-  "arguments",
-  "interface",
-  "protected",
-  "implements",
-  "instanceof"
+const reserved = new Set([
+    'do',
+    'if',
+    'in',
+    'for',
+    'let',
+    'new',
+    'try',
+    'var',
+    'case',
+    'else',
+    'enum',
+    'eval',
+    'null',
+    'this',
+    'true',
+    'void',
+    'with',
+    'await',
+    'break',
+    'catch',
+    'class',
+    'const',
+    'false',
+    'super',
+    'throw',
+    'while',
+    'yield',
+    'delete',
+    'export',
+    'import',
+    'public',
+    'return',
+    'static',
+    'switch',
+    'typeof',
+    'default',
+    'extends',
+    'finally',
+    'package',
+    'private',
+    'continue',
+    'debugger',
+    'function',
+    'arguments',
+    'interface',
+    'protected',
+    'implements',
+    'instanceof'
 ]);
-
-const configFileNames = ["c15t", "consent", "cmp"];
+const configFileNames = [
+    'c15t',
+    'consent',
+    'cmp'
+];
 const extensions = [
-  ".js",
-  ".jsx",
-  ".ts",
-  ".tsx",
-  ".cjs",
-  ".cts",
-  ".mjs",
-  ".mts",
-  ".server.cjs",
-  ".server.cts",
-  ".server.js",
-  ".server.jsx",
-  ".server.mjs",
-  ".server.mts",
-  ".server.ts",
-  ".server.tsx"
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.cjs',
+    '.cts',
+    '.mjs',
+    '.mts',
+    '.server.cjs',
+    '.server.cts',
+    '.server.js',
+    '.server.jsx',
+    '.server.mjs',
+    '.server.mts',
+    '.server.ts',
+    '.server.tsx'
 ];
-let possiblePaths = configFileNames.flatMap(
-  (name) => extensions.map((ext) => `${name}${ext}`)
-);
+let possiblePaths = configFileNames.flatMap((name)=>extensions.map((ext)=>`${name}${ext}`));
 const directories = [
-  "",
-  "lib/server/",
-  "server/",
-  "lib/",
-  "utils/",
-  "config/",
-  "src/",
-  "app/"
+    '',
+    'lib/server/',
+    'server/',
+    'lib/',
+    'utils/',
+    'config/',
+    'src/',
+    'app/'
+];
+possiblePaths = directories.flatMap((dir)=>possiblePaths.map((file)=>`${dir}${file}`));
+const monorepoSubdirs = [
+    'packages/*',
+    'apps/*'
 ];
-possiblePaths = directories.flatMap(
-  (dir) => possiblePaths.map((file) => `${dir}${file}`)
-);
-const monorepoSubdirs = ["packages/*", "apps/*"];
 function stripJsonComments(jsonString) {
-  return jsonString.replace(
-    /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g,
-    (m, g) => g ? "" : m
-  ).replace(/,(?=\s*[}\]])/g, "");
+    return jsonString.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g)=>g ? '' : m).replace(/,(?=\s*[}\]])/g, '');
 }
 function getPathAliases(cwd) {
-  const tsConfigPath = path.join(cwd, "tsconfig.json");
-  if (!fs$1.existsSync(tsConfigPath)) {
-    const jsConfigPath = path.join(cwd, "jsconfig.json");
-    if (!fs$1.existsSync(jsConfigPath)) {
-      return null;
+    const tsConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, 'tsconfig.json');
+    if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(tsConfigPath)) {
+        const jsConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, 'jsconfig.json');
+        if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(jsConfigPath)) return null;
+        return extractAliasesFromConfigFile(jsConfigPath, cwd);
     }
-    return extractAliasesFromConfigFile(jsConfigPath, cwd);
-  }
-  return extractAliasesFromConfigFile(tsConfigPath, cwd);
+    return extractAliasesFromConfigFile(tsConfigPath, cwd);
 }
 function extractAliasesFromConfigFile(configPath, cwd) {
-  try {
-    const configContent = fs$1.readFileSync(configPath, "utf8");
-    const strippedConfigContent = stripJsonComments(configContent);
-    const config = JSON.parse(strippedConfigContent);
-    const { paths = {}, baseUrl = "." } = config.compilerOptions || {};
-    const result = {};
-    const obj = Object.entries(paths);
-    for (const [alias, aliasPaths] of obj) {
-      for (const aliasedPath of aliasPaths) {
-        const resolvedBaseUrl = path.join(cwd, baseUrl);
-        const finalAlias = alias.slice(-1) === "*" ? alias.slice(0, -1) : alias;
-        const finalAliasedPath = aliasedPath.slice(-1) === "*" ? aliasedPath.slice(0, -1) : aliasedPath;
-        result[finalAlias || ""] = path.join(resolvedBaseUrl, finalAliasedPath);
-      }
+    try {
+        const configContent = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(configPath, 'utf8');
+        const strippedConfigContent = stripJsonComments(configContent);
+        const config = JSON.parse(strippedConfigContent);
+        const { paths = {}, baseUrl = '.' } = config.compilerOptions || {};
+        const result = {};
+        const obj = Object.entries(paths);
+        for (const [alias, aliasPaths] of obj)for (const aliasedPath of aliasPaths){
+            const resolvedBaseUrl = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, baseUrl);
+            const finalAlias = '*' === alias.slice(-1) ? alias.slice(0, -1) : alias;
+            const finalAliasedPath = '*' === aliasedPath.slice(-1) ? aliasedPath.slice(0, -1) : aliasedPath;
+            result[finalAlias || ''] = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(resolvedBaseUrl, finalAliasedPath);
+        }
+        addSvelteKitEnvModules(result);
+        return result;
+    } catch (error) {
+        utils_logger.warn(`Error parsing config file ${configPath}`, error);
+        return null;
     }
-    addSvelteKitEnvModules(result);
-    return result;
-  } catch (error) {
-    logger.warn(`Error parsing config file ${configPath}`, error);
-    return null;
-  }
 }
-const jitiOptions = (cwd) => {
-  const alias = getPathAliases(cwd) || {};
-  return {
-    transformOptions: {
-      babel: {
-        presets: [
-          [
-            babelPresetTypescript,
-            {
-              isTSX: true,
-              allExtensions: true
+const jitiOptions = (cwd)=>{
+    const alias = getPathAliases(cwd) || {};
+    return {
+        transformOptions: {
+            babel: {
+                presets: [
+                    [
+                        __WEBPACK_EXTERNAL_MODULE__babel_preset_typescript_a7789c85__["default"],
+                        {
+                            isTSX: true,
+                            allExtensions: true
+                        }
+                    ],
+                    [
+                        __WEBPACK_EXTERNAL_MODULE__babel_preset_react_76cf724d__["default"],
+                        {
+                            runtime: 'automatic'
+                        }
+                    ]
+                ]
             }
-          ],
-          [babelPresetReact, { runtime: "automatic" }]
-        ]
-      }
-    },
-    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
-    alias
-  };
+        },
+        extensions: [
+            '.ts',
+            '.tsx',
+            '.js',
+            '.jsx',
+            '.mjs',
+            '.cjs',
+            '.mts',
+            '.cts'
+        ],
+        alias
+    };
 };
 function extractOptionsFromConfig(config) {
-  if (config.c15t && typeof config.c15t === "function") {
-    return config.c15t;
-  }
-  if (config.default && typeof config.default === "function") {
-    return config.default;
-  }
-  if (config.c15tInstance && typeof config.c15tInstance === "function") {
-    return config.c15tInstance;
-  }
-  if (config.consent && typeof config.consent === "function") {
-    return config.consent;
-  }
-  return config.c15t?.options || config.default?.options || config.c15tInstance?.options || config.instance?.options || config.consent?.options || config.config?.options || // Also check for direct exports of options objects
-  (config.default && typeof config.default === "object" && "appName" in config.default ? config.default : null) || // Finally check for direct exports of the instance
-  (config.c15t && typeof config.c15t === "object" && "appName" in config.c15t ? config.c15t : null) || null;
+    if (config.c15t && 'function' == typeof config.c15t) return config.c15t;
+    if (config.default && 'function' == typeof config.default) return config.default;
+    if (config.c15tInstance && 'function' == typeof config.c15tInstance) return config.c15tInstance;
+    if (config.consent && 'function' == typeof config.consent) return config.consent;
+    return config.c15t?.options || config.default?.options || config.c15tInstance?.options || config.instance?.options || config.consent?.options || config.config?.options || (config.default && 'object' == typeof config.default && 'appName' in config.default ? config.default : null) || (config.c15t && 'object' == typeof config.c15t && 'appName' in config.c15t ? config.c15t : null) || null;
 }
 function findDirectories(cwd, patterns) {
-  const results = [];
-  for (const pattern of patterns) {
-    if (pattern.includes("*")) {
-      const [prefix, _] = pattern.split("*");
-      const basePath = path.join(cwd, prefix);
-      try {
-        if (fs$1.existsSync(basePath)) {
-          const entries = fs$1.readdirSync(basePath, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.isDirectory()) {
-              results.push(path.join(prefix, entry.name));
-            }
-          }
+    const results = [];
+    for (const pattern of patterns)if (pattern.includes('*')) {
+        const [prefix] = pattern.split('*');
+        if (prefix) {
+            const basePath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, prefix);
+            try {
+                if (__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(basePath)) {
+                    const entries = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readdirSync(basePath, {
+                        withFileTypes: true
+                    });
+                    for (const entry of entries)if (entry.isDirectory()) results.push(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(prefix, entry.name));
+                }
+            } catch  {}
         }
-      } catch {
-      }
-    } else if (fs$1.existsSync(path.join(cwd, pattern)) && fs$1.statSync(path.join(cwd, pattern)).isDirectory()) {
-      results.push(pattern);
-    }
-  }
-  return results;
+    } else if (__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, pattern)) && __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].statSync(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, pattern)).isDirectory()) results.push(pattern);
+    return results;
 }
 function validateConfig(config) {
-  if (!config) {
-    return false;
-  }
-  return typeof config === "object";
+    if (!config) return false;
+    return 'object' == typeof config;
 }
-async function getConfig({
-  cwd,
-  configPath
-}) {
-  const foundPaths = [];
-  const failedImports = [];
-  try {
-    let configFile = null;
-    if (configPath) {
-      const resolvedPath = path.join(cwd, configPath);
-      try {
-        if (!fs$1.existsSync(resolvedPath)) {
-          throw new DoubleTieError(
-            `Configuration file not found: ${resolvedPath}
-Make sure the path is correct and the file exists.`,
-            {
-              code: "CONFIG_FILE_NOT_FOUND",
-              status: 404,
-              category: "CONFIG_FILE_NOT_FOUND"
+async function getConfig({ cwd, configPath }) {
+    const foundPaths = [];
+    const failedImports = [];
+    try {
+        let configFile = null;
+        if (configPath) {
+            const resolvedPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, configPath);
+            try {
+                if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(resolvedPath)) throw new __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError(`Configuration file not found: ${resolvedPath}\nMake sure the path is correct and the file exists.`, {
+                    code: 'CONFIG_FILE_NOT_FOUND',
+                    status: 404,
+                    category: 'CONFIG_FILE_NOT_FOUND'
+                });
+                foundPaths.push(resolvedPath);
+                const { config } = await (0, __WEBPACK_EXTERNAL_MODULE_c12__.loadConfig)({
+                    configFile: resolvedPath,
+                    dotenv: true,
+                    jitiOptions: jitiOptions(cwd)
+                });
+                configFile = extractOptionsFromConfig(config);
+                if (!configFile) throw new __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError(`Found config file at ${resolvedPath} but couldn't extract c15t options.\nMake sure you're exporting c15t with one of these patterns:\n- export const c15t = c15tInstance({...})\n- export const consent = c15tInstance({...})\n- export const c15tInstance = c15tInstance({...})\n- export default c15tInstance({...})`, {
+                    code: 'CONFIG_FILE_LOAD_ERROR',
+                    status: 500,
+                    category: 'CONFIG_FILE_LOAD_ERROR'
+                });
+            } catch (e) {
+                if (__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(resolvedPath)) {
+                    failedImports.push(resolvedPath);
+                    if (e instanceof __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError) throw e;
+                    throw new __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError(`Config file found at ${resolvedPath} but failed to load.\nThis usually happens because of import problems:\n- Check for invalid import paths\n- Ensure all dependencies are installed\n- Verify path aliases in tsconfig.json\n\nError details: ${e instanceof Error ? e.message : String(e)}`, {
+                        code: 'CONFIG_FILE_LOAD_ERROR',
+                        status: 500,
+                        category: 'CONFIG_FILE_LOAD_ERROR',
+                        cause: e instanceof Error ? e : new Error(String(e))
+                    });
+                }
+                throw e;
             }
-          );
         }
-        foundPaths.push(resolvedPath);
-        const { config } = await loadConfig({
-          configFile: resolvedPath,
-          dotenv: true,
-          jitiOptions: jitiOptions(cwd)
-        });
-        configFile = extractOptionsFromConfig(config);
         if (!configFile) {
-          throw new DoubleTieError(
-            // biome-ignore lint/style/useTemplate: keep it split so its easier to read
-            `Found config file at ${resolvedPath} but couldn't extract c15t options.
-Make sure you're exporting c15t with one of these patterns:
-- export const c15t = c15tInstance({...})
-- export const consent = c15tInstance({...})
-- export const c15tInstance = c15tInstance({...})
-- export default c15tInstance({...})`,
-            {
-              code: "CONFIG_FILE_LOAD_ERROR",
-              status: 500,
-              category: "CONFIG_FILE_LOAD_ERROR"
-            }
-          );
-        }
-      } catch (e) {
-        if (fs$1.existsSync(resolvedPath)) {
-          failedImports.push(resolvedPath);
-          if (e instanceof DoubleTieError) {
-            throw e;
-          }
-          throw new DoubleTieError(
-            // biome-ignore lint/style/useTemplate: keep it split so its easier to read
-            `Config file found at ${resolvedPath} but failed to load.
-This usually happens because of import problems:
-- Check for invalid import paths
-- Ensure all dependencies are installed
-- Verify path aliases in tsconfig.json
-
-Error details: ${e instanceof Error ? e.message : String(e)}`,
-            {
-              code: "CONFIG_FILE_LOAD_ERROR",
-              status: 500,
-              category: "CONFIG_FILE_LOAD_ERROR",
-              cause: e
+            const searchDirs = [
+                ''
+            ];
+            searchDirs.push(...findDirectories(cwd, monorepoSubdirs));
+            for (const dir of searchDirs){
+                for (const possiblePath of possiblePaths){
+                    const configPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(dir, possiblePath);
+                    const fullPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, configPath);
+                    if (!!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(fullPath)) {
+                        foundPaths.push(fullPath);
+                        try {
+                            const { config } = await (0, __WEBPACK_EXTERNAL_MODULE_c12__.loadConfig)({
+                                configFile: configPath,
+                                jitiOptions: jitiOptions(cwd)
+                            });
+                            if (Object.keys(config).length > 0) {
+                                configFile = extractOptionsFromConfig(config);
+                                if (configFile && validateConfig(configFile)) {
+                                    utils_logger.info(`✅ Using c15t config from ${fullPath}`);
+                                    break;
+                                }
+                            }
+                        } catch (e) {
+                            if ('object' == typeof e && e && 'message' in e && 'string' == typeof e.message && e.message.includes('This module cannot be imported from a Client Component module')) throw new __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError(`Found config file at ${fullPath}, but it imports 'server-only'.\nPlease temporarily remove the 'server-only' import while using the CLI,\nand you can add it back afterwards.`, {
+                                code: 'SERVER_ONLY_IMPORT_DETECTED',
+                                status: 500,
+                                category: 'SERVER_ONLY_IMPORT_DETECTED'
+                            });
+                            failedImports.push(fullPath);
+                        }
+                    }
+                }
+                if (configFile) break;
             }
-          );
         }
-        throw e;
-      }
-    }
-    if (!configFile) {
-      const searchDirs = [""];
-      searchDirs.push(...findDirectories(cwd, monorepoSubdirs));
-      for (const dir of searchDirs) {
-        for (const possiblePath of possiblePaths) {
-          const configPath2 = path.join(dir, possiblePath);
-          const fullPath = path.join(cwd, configPath2);
-          if (!fs$1.existsSync(fullPath)) {
-            continue;
-          }
-          foundPaths.push(fullPath);
-          try {
-            const { config } = await loadConfig({
-              configFile: configPath2,
-              jitiOptions: jitiOptions(cwd)
-            });
-            if (Object.keys(config).length > 0) {
-              configFile = extractOptionsFromConfig(config);
-              if (configFile && validateConfig(configFile)) {
-                logger.info(`\u2705 Using c15t config from ${fullPath}`);
-                break;
-              }
-            }
-          } catch (e) {
-            if (typeof e === "object" && e && "message" in e && typeof e.message === "string" && e.message.includes(
-              "This module cannot be imported from a Client Component module"
-            )) {
-              throw new DoubleTieError(
-                // biome-ignore lint/style/useTemplate: keep it split so its easier to read
-                `Found config file at ${fullPath}, but it imports 'server-only'.
-Please temporarily remove the 'server-only' import while using the CLI,
-and you can add it back afterwards.`,
-                {
-                  code: "SERVER_ONLY_IMPORT_DETECTED",
-                  status: 500,
-                  category: "SERVER_ONLY_IMPORT_DETECTED"
+        if (!configFile) {
+            if (foundPaths.length > 0) {
+                utils_logger.error(`❌ Found ${foundPaths.length} potential config files, but couldn't load any of them:`);
+                for (const filePath of foundPaths.slice(0, 3))utils_logger.error(`   - ${filePath}`);
+                if (foundPaths.length > 3) utils_logger.error(`   - ...and ${foundPaths.length - 3} more`);
+                if (failedImports.length > 0) {
+                    utils_logger.error('\n❓ Common issues that prevent loading config files:');
+                    utils_logger.error('   - Missing dependencies (check your package.json)');
+                    utils_logger.error('   - Import path issues (check your import statements)');
+                    utils_logger.error('   - Path alias configuration (check your tsconfig.json)');
+                    utils_logger.error("   - Export format (make sure you're exporting c15t, c15tInstance, consent, or default)");
                 }
-              );
+                throw new __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError('Unable to load any c15t configuration file', {
+                    code: 'CONFIG_FILE_LOAD_ERROR',
+                    status: 500,
+                    category: 'CONFIG_FILE_LOAD_ERROR'
+                });
             }
-            failedImports.push(fullPath);
-          }
-        }
-        if (configFile) {
-          break;
-        }
-      }
-    }
-    if (!configFile) {
-      if (foundPaths.length > 0) {
-        logger.error(
-          `\u274C Found ${foundPaths.length} potential config files, but couldn't load any of them:`
-        );
-        for (const filePath of foundPaths.slice(0, 3)) {
-          logger.error(`   - ${filePath}`);
-        }
-        if (foundPaths.length > 3) {
-          logger.error(`   - ...and ${foundPaths.length - 3} more`);
-        }
-        if (failedImports.length > 0) {
-          logger.error("\n\u2753 Common issues that prevent loading config files:");
-          logger.error("   - Missing dependencies (check your package.json)");
-          logger.error(
-            "   - Import path issues (check your import statements)"
-          );
-          logger.error(
-            "   - Path alias configuration (check your tsconfig.json)"
-          );
-          logger.error(
-            "   - Export format (make sure you're exporting c15t, c15tInstance, consent, or default)"
-          );
-        }
-        throw new DoubleTieError("Unable to load any c15t configuration file", {
-          code: "CONFIG_FILE_LOAD_ERROR",
-          status: 500,
-          category: "CONFIG_FILE_LOAD_ERROR"
-        });
-      }
-      logger.error(
-        "\u274C No c15t configuration files found in standard locations"
-      );
-      logger.info("\n\u{1F4DD} Create a c15t.ts file with your configuration:");
-      logger.info(`
+            utils_logger.error('❌ No c15t configuration files found in standard locations');
+            utils_logger.info('\n📝 Create a c15t.ts file with your configuration:');
+            utils_logger.info(`
 import { c15tInstance } from '@c15t/backend';
 
 export const c15t = c15tInstance({
@@ -839,264 +655,205 @@ export const c15t = c15tInstance({
   // Add your configuration here
 });
 			`);
-      throw new DoubleTieError(
-        "No c15t config file found. Create a c15t.ts file or specify with --config",
-        {
-          code: "CONFIG_FILE_NOT_FOUND",
-          status: 404,
-          category: "CONFIG_FILE_NOT_FOUND"
+            throw new __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError('No c15t config file found. Create a c15t.ts file or specify with --config', {
+                code: 'CONFIG_FILE_NOT_FOUND',
+                status: 404,
+                category: 'CONFIG_FILE_NOT_FOUND'
+            });
+        }
+        return configFile;
+    } catch (e) {
+        if ('object' == typeof e && e && 'message' in e && 'string' == typeof e.message && e.message.includes('This module cannot be imported from a Client Component module')) {
+            utils_logger.error("❌ Server-only import detected in config file\nPlease temporarily remove the 'server-only' import while using the CLI,\nand you can add it back afterwards.");
+            process.exit(1);
+        }
+        if (e instanceof __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError) utils_logger.error(`❌ ${e.message}`);
+        else if (e instanceof Error) {
+            utils_logger.error(`❌ Couldn't read your c15t configuration`);
+            utils_logger.error(`   Error: ${e.message}`);
+        } else {
+            utils_logger.error(`❌ Couldn't read your c15t configuration`);
+            utils_logger.error(`   Error: ${String(e)}`);
         }
-      );
+        if (failedImports.length > 0) {
+            utils_logger.info("\n💡 Tip: If you're having import issues, try running with verbose logging:");
+            utils_logger.info('   DEBUG=c15t* npx c15t@latest <command>');
+        }
+        process.exit(1);
     }
-    return configFile;
-  } catch (e) {
-    if (typeof e === "object" && e && "message" in e && typeof e.message === "string" && e.message.includes(
-      "This module cannot be imported from a Client Component module"
-    )) {
-      logger.error(
-        "\u274C Server-only import detected in config file\nPlease temporarily remove the 'server-only' import while using the CLI,\nand you can add it back afterwards."
-      );
-      process.exit(1);
+}
+async function generateAction(opts) {
+    const options = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        cwd: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+        config: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+        output: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+        y: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().optional()
+    }).parse(opts);
+    const cwd = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(options.cwd);
+    if (!(0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(cwd)) {
+        utils_logger.error(`The directory "${cwd}" does not exist.`);
+        process.exit(1);
     }
-    if (e instanceof DoubleTieError) {
-      logger.error(`\u274C ${e.message}`);
-    } else {
-      logger.error(`\u274C Couldn't read your c15t configuration`);
-      logger.error(`   Error: ${e instanceof Error ? e.message : String(e)}`);
+    const config = await getConfig({
+        cwd,
+        configPath: options.config
+    });
+    if (!config) {
+        utils_logger.error('No configuration file found. Add a `c15t.ts` file to your project or pass the path to the configuration file using the `--config` flag.');
+        return;
     }
-    if (failedImports.length > 0) {
-      logger.info(
-        "\n\u{1F4A1} Tip: If you're having import issues, try running with verbose logging:"
-      );
-      logger.info("   DEBUG=c15t* npx c15t@latest <command>");
+    const adapter = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_db_adapters_cee37d0f__.getAdapter)(config).catch((e)=>{
+        utils_logger.error(e.message);
+        process.exit(1);
+    });
+    const spinner = (0, __WEBPACK_EXTERNAL_MODULE_yocto_spinner_579f0326__["default"])({
+        text: 'preparing schema...'
+    }).start();
+    const schema = await getGenerator({
+        adapter,
+        file: options.output,
+        options: config
+    });
+    spinner.stop();
+    if (!schema.code) {
+        utils_logger.info('Your schema is already up to date.');
+        process.exit(0);
     }
-    process.exit(1);
-  }
-}
-
-async function generateAction(opts) {
-  const options = z.object({
-    cwd: z.string(),
-    config: z.string().optional(),
-    output: z.string().optional(),
-    y: z.boolean().optional()
-  }).parse(opts);
-  const cwd = path.resolve(options.cwd);
-  if (!existsSync(cwd)) {
-    logger.error(`The directory "${cwd}" does not exist.`);
-    process.exit(1);
-  }
-  const config = await getConfig({
-    cwd,
-    configPath: options.config
-  });
-  if (!config) {
-    logger.error(
-      "No configuration file found. Add a `c15t.ts` file to your project or pass the path to the configuration file using the `--config` flag."
-    );
-    return;
-  }
-  const adapter = await getAdapter(config).catch((e) => {
-    logger.error(e.message);
-    process.exit(1);
-  });
-  const spinner = yoctoSpinner({ text: "preparing schema..." }).start();
-  const schema = await getGenerator({
-    adapter,
-    file: options.output,
-    options: config
-  });
-  spinner.stop();
-  if (!schema.code) {
-    logger.info("Your schema is already up to date.");
-    process.exit(0);
-  }
-  if (schema.append || schema.overwrite) {
-    let confirm2 = options.y;
-    if (!confirm2) {
-      const response = await prompts({
-        type: "confirm",
-        name: "confirm",
-        message: `The file ${schema.fileName} already exists. Do you want to ${chalk.yellow(
-          `${schema.overwrite ? "overwrite" : "append"}`
-        )} the schema to the file?`
-      });
-      confirm2 = response.confirm;
+    if (schema.append || schema.overwrite) {
+        let confirm = options.y;
+        if (!confirm) {
+            const response = await (0, __WEBPACK_EXTERNAL_MODULE_prompts__["default"])({
+                type: 'confirm',
+                name: 'confirm',
+                message: `The file ${schema.fileName} already exists. Do you want to ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].yellow(`${schema.overwrite ? 'overwrite' : 'append'}`)} the schema to the file?`
+            });
+            confirm = response.confirm;
+        }
+        if (confirm) {
+            const exist = (0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, schema.fileName));
+            if (!exist) await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].mkdir(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, schema.fileName)), {
+                recursive: true
+            });
+            if (schema.overwrite) await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, schema.fileName), schema.code);
+            else await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].appendFile(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, schema.fileName), schema.code);
+            utils_logger.success(`🚀 Schema was ${schema.overwrite ? 'overwritten' : 'appended'} successfully!`);
+            process.exit(0);
+        } else {
+            utils_logger.error('Schema generation aborted.');
+            process.exit(1);
+        }
     }
-    if (confirm2) {
-      const exist = existsSync(path.join(cwd, schema.fileName));
-      if (!exist) {
-        await fs.mkdir(path.dirname(path.join(cwd, schema.fileName)), {
-          recursive: true
+    let confirm = options.y;
+    if (!confirm) {
+        const response = await (0, __WEBPACK_EXTERNAL_MODULE_prompts__["default"])({
+            type: 'confirm',
+            name: 'confirm',
+            message: `Do you want to generate the schema to ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].yellow(schema.fileName)}?`
         });
-      }
-      if (schema.overwrite) {
-        await fs.writeFile(path.join(cwd, schema.fileName), schema.code);
-      } else {
-        await fs.appendFile(path.join(cwd, schema.fileName), schema.code);
-      }
-      logger.success(
-        `\u{1F680} Schema was ${schema.overwrite ? "overwritten" : "appended"} successfully!`
-      );
-      process.exit(0);
-    } else {
-      logger.error("Schema generation aborted.");
-      process.exit(1);
+        confirm = response.confirm;
     }
-  }
-  let confirm = options.y;
-  if (!confirm) {
-    const response = await prompts({
-      type: "confirm",
-      name: "confirm",
-      message: `Do you want to generate the schema to ${chalk.yellow(
-        schema.fileName
-      )}?`
-    });
-    confirm = response.confirm;
-  }
-  if (!confirm) {
-    logger.error("Schema generation aborted.");
-    process.exit(1);
-  }
-  if (!options.output) {
-    const dirExist = existsSync(path.dirname(path.join(cwd, schema.fileName)));
-    if (!dirExist) {
-      await fs.mkdir(path.dirname(path.join(cwd, schema.fileName)), {
-        recursive: true
-      });
+    if (!confirm) {
+        utils_logger.error('Schema generation aborted.');
+        process.exit(1);
     }
-  }
-  await fs.writeFile(
-    options.output || path.join(cwd, schema.fileName),
-    schema.code
-  );
-  logger.success("\u{1F680} Schema was generated successfully!");
-  process.exit(0);
+    if (!options.output) {
+        const dirExist = (0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, schema.fileName)));
+        if (!dirExist) await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].mkdir(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, schema.fileName)), {
+            recursive: true
+        });
+    }
+    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(options.output || __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, schema.fileName), schema.code);
+    utils_logger.success('🚀 Schema was generated successfully!');
+    process.exit(0);
 }
-const generate = new Command("generate").option(
-  "-c, --cwd <cwd>",
-  "the working directory. defaults to the current directory.",
-  process.cwd()
-).option(
-  "--config <config>",
-  "the path to the configuration file. defaults to the first configuration file found."
-).option("--output <output>", "the file to output to the generated schema").option("-y, --y", "automatically answer yes to all prompts", false).action(generateAction);
-
+const generate = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('generate').option('-c, --cwd <cwd>', 'the working directory. defaults to the current directory.', process.cwd()).option('--config <config>', 'the path to the configuration file. defaults to the first configuration file found.').option('--output <output>', 'the file to output to the generated schema').option('-y, --y', 'automatically answer yes to all prompts', false).action(generateAction);
 async function migrateAction(opts) {
-  const options = z.object({
-    cwd: z.string(),
-    config: z.string().optional(),
-    y: z.boolean().optional()
-  }).parse(opts);
-  const cwd = path.resolve(options.cwd);
-  if (!existsSync(cwd)) {
-    logger.error(`The directory "${cwd}" does not exist.`);
-    process.exit(1);
-  }
-  const config = await getConfig({
-    cwd,
-    configPath: options.config
-  });
-  if (!config) {
-    logger.error(
-      "No configuration file found. Add a `c15t.ts` file to your project or pass the path to the configuration file using the `--config` flag."
-    );
-    return;
-  }
-  const db = await getAdapter(config);
-  if (!db) {
-    logger.error(
-      "Invalid database configuration. Make sure you're not using adapters. Migrate command only works with built-in Kysely adapter."
-    );
-    process.exit(1);
-  }
-  if (db.id !== "kysely") {
-    if (db.id === "prisma") {
-      logger.error(
-        "The migrate command only works with the built-in Kysely adapter. For Prisma, run `npx @c15t/cli generate` to create the schema, then use Prisma\u2019s migrate or push to apply it."
-      );
-      process.exit(0);
+    const options = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        cwd: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+        config: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+        y: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().optional()
+    }).parse(opts);
+    const cwd = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(options.cwd);
+    if (!(0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(cwd)) {
+        utils_logger.error(`The directory "${cwd}" does not exist.`);
+        process.exit(1);
     }
-    if (db.id === "drizzle") {
-      logger.error(
-        "The migrate command only works with the built-in Kysely adapter. For Drizzle, run `npx @c15t/cli generate` to create the schema, then use Drizzle\u2019s migrate or push to apply it."
-      );
-      process.exit(0);
+    const config = await getConfig({
+        cwd,
+        configPath: options.config
+    });
+    if (!config) {
+        utils_logger.error('No configuration file found. Add a `c15t.ts` file to your project or pass the path to the configuration file using the `--config` flag.');
+        return;
+    }
+    const db = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_db_adapters_cee37d0f__.getAdapter)(config);
+    if (!db) {
+        utils_logger.error("Invalid database configuration. Make sure you're not using adapters. Migrate command only works with built-in Kysely adapter.");
+        process.exit(1);
+    }
+    if ('kysely' !== db.id) {
+        if ('prisma' === db.id) {
+            utils_logger.error('The migrate command only works with the built-in Kysely adapter. For Prisma, run `npx @c15t/cli generate` to create the schema, then use Prisma’s migrate or push to apply it.');
+            process.exit(0);
+        }
+        if ('drizzle' === db.id) {
+            utils_logger.error('The migrate command only works with the built-in Kysely adapter. For Drizzle, run `npx @c15t/cli generate` to create the schema, then use Drizzle’s migrate or push to apply it.');
+            process.exit(0);
+        }
+        utils_logger.error("Migrate command isn't supported for this adapter.");
+        process.exit(1);
+    }
+    const spinner = (0, __WEBPACK_EXTERNAL_MODULE_yocto_spinner_579f0326__["default"])({
+        text: 'preparing migration...'
+    }).start();
+    const { toBeAdded, toBeCreated, runMigrations } = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_migrations_80b6e3bd__.getMigrations)(config);
+    if (!toBeAdded.length && !toBeCreated.length) {
+        spinner.stop();
+        utils_logger.info('🚀 No migrations needed.');
+        process.exit(0);
     }
-    logger.error("Migrate command isn't supported for this adapter.");
-    process.exit(1);
-  }
-  const spinner = yoctoSpinner({ text: "preparing migration..." }).start();
-  const { toBeAdded, toBeCreated, runMigrations } = await getMigrations(config);
-  if (!toBeAdded.length && !toBeCreated.length) {
     spinner.stop();
-    logger.info("\u{1F680} No migrations needed.");
-    process.exit(0);
-  }
-  spinner.stop();
-  logger.info("\u{1F511} The migration will affect the following:");
-  for (const table of [...toBeCreated, ...toBeAdded]) {
-    console.log(
-      "->",
-      chalk.magenta(Object.keys(table.fields).join(", ")),
-      chalk.white("fields on"),
-      chalk.yellow(`${table.table}`),
-      chalk.white("table.")
-    );
-  }
-  let migrate2 = options.y;
-  if (!migrate2) {
-    const response = await prompts({
-      type: "confirm",
-      name: "migrate",
-      message: "Are you sure you want to run these migrations?",
-      initial: false
-    });
-    migrate2 = response.migrate;
-  }
-  if (!migrate2) {
-    logger.info("Migration cancelled.");
+    utils_logger.info('🔑 The migration will affect the following:');
+    for (const table of [
+        ...toBeCreated,
+        ...toBeAdded
+    ])console.log('->', __WEBPACK_EXTERNAL_MODULE_chalk__["default"].magenta(Object.keys(table.fields).join(', ')), __WEBPACK_EXTERNAL_MODULE_chalk__["default"].white('fields on'), __WEBPACK_EXTERNAL_MODULE_chalk__["default"].yellow(`${table.table}`), __WEBPACK_EXTERNAL_MODULE_chalk__["default"].white('table.'));
+    let migrate = options.y;
+    if (!migrate) {
+        const response = await (0, __WEBPACK_EXTERNAL_MODULE_prompts__["default"])({
+            type: 'confirm',
+            name: 'migrate',
+            message: 'Are you sure you want to run these migrations?',
+            initial: false
+        });
+        migrate = response.migrate;
+    }
+    if (!migrate) {
+        utils_logger.info('Migration cancelled.');
+        process.exit(0);
+    }
+    spinner?.start('migrating...');
+    await runMigrations();
+    spinner.stop();
+    utils_logger.info('🚀 migration was completed successfully!');
     process.exit(0);
-  }
-  spinner?.start("migrating...");
-  await runMigrations();
-  spinner.stop();
-  logger.info("\u{1F680} migration was completed successfully!");
-  process.exit(0);
 }
-const migrate = new Command("migrate").option(
-  "-c, --cwd <cwd>",
-  "the working directory. defaults to the current directory.",
-  process.cwd()
-).option(
-  "--config <config>",
-  "the path to the configuration file. defaults to the first configuration file found."
-).option(
-  "-y, --y",
-  "automatically accept and run migrations without prompting",
-  false
-).action(migrateAction);
-
-const generateSecret = new Command("secret").action(() => {
-  const secret = Crypto.randomBytes(32).toString("hex");
-  logger.info(`
-Add the following to your .env file: 
-${chalk.gray("# C15T Secret") + chalk.green(`
-C15T_SECRET=${secret}`)}`);
+const migrate_migrate = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('migrate').option('-c, --cwd <cwd>', 'the working directory. defaults to the current directory.', process.cwd()).option('--config <config>', 'the path to the configuration file. defaults to the first configuration file found.').option('-y, --y', 'automatically accept and run migrations without prompting', false).action(migrateAction);
+const generateSecret = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('secret').action(()=>{
+    const secret = __WEBPACK_EXTERNAL_MODULE_node_crypto_9ba42079__["default"].randomBytes(32).toString('hex');
+    utils_logger.info(`\nAdd the following to your .env file: 
+${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].gray('# C15T Secret') + __WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(`\nC15T_SECRET=${secret}`)}`);
 });
-
 function getPackageInfo() {
-  const packageJsonPath = path.join("package.json");
-  return fs$2.readJSONSync(packageJsonPath);
+    const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join('package.json');
+    return __WEBPACK_EXTERNAL_MODULE_fs_extra_ce68a66b__["default"].readJSONSync(packageJsonPath);
 }
-
-process.on("SIGINT", () => process.exit(0));
-process.on("SIGTERM", () => process.exit(0));
+process.on('SIGINT', ()=>process.exit(0));
+process.on('SIGTERM', ()=>process.exit(0));
 async function main() {
-  const program = new Command("c15t");
-  const packageInfo = await getPackageInfo();
-  program.addCommand(migrate).addCommand(generate).addCommand(generateSecret).version(packageInfo.version || "1.1.2").description("c15t CLI");
-  program.parse();
+    const program = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('c15t');
+    const packageInfo = await getPackageInfo();
+    program.addCommand(migrate_migrate).addCommand(generate).addCommand(generateSecret).version(packageInfo.version || '1.1.2').description('c15t CLI');
+    program.parse();
 }
 main();