@c15t/cli 1.2.0-beta.17

package/dist/index.mjs

@@ -0,0 +1,1058 @@
+#!/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 { logger } from '@c15t/backend';
+import { getConsentTables, getMigrations, getAdapter } from '@c15t/backend/db';
+import chalk from 'chalk';
+import prompts from 'prompts';
+import yoctoSpinner from 'yocto-spinner';
+import { z } from 'zod';
+import { produceSchema } from '@mrleebo/prisma-ast';
+import babelPresetReact from '@babel/preset-react';
+import babelPresetTypescript from '@babel/preset-typescript';
+import { C15TError } from '@c15t/backend/error';
+import { loadConfig } from 'c12';
+import 'dotenv/config';
+import Crypto from 'node:crypto';
+import fs$2 from 'fs-extra';
+
+function convertToSnakeCase(str) {
+  if (str === void 0 || str === null) {
+    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 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' })` : ""}`;
+        }
+        return "";
+      }).filter(Boolean).join(",\n")}
+});`;
+      code += schema;
+    }
+  }
+  return {
+    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;
+const PRIMARY_KEY_REGEX = /\bprimary key\b/gi;
+const REFERENCES_REGEX = /\breferences\b/gi;
+const UNIQUE_REGEX = /\bunique\b/gi;
+const CREATE_TABLE_KEYWORD_REGEX = /\bcreate\s+table\b/gi;
+const CREATE_INDEX_KEYWORD_REGEX = /\bcreate\s+index\b/gi;
+const ALTER_TABLE_REGEX = /\balter\s+table\b/gi;
+const INSERT_INTO_REGEX = /\binsert\s+into\b/gi;
+const UPDATE_REGEX = /\bupdate\b/gi;
+const DELETE_FROM_REGEX = /\bdelete\s+from\b/gi;
+const SELECT_REGEX = /\bselect\b/gi;
+const FROM_REGEX = /\bfrom\b/gi;
+const WHERE_REGEX = /\bwhere\b/gi;
+const JOIN_REGEX = /\bjoin\b/gi;
+const ON_REGEX = /\bon\b/gi;
+const AND_REGEX = /\band\b/gi;
+const OR_REGEX = /\bor\b/gi;
+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";
+  const transactionStart = useTransactions ? dbType === "mysql" ? "START TRANSACTION;" : "BEGIN;" : "";
+  const transactionEnd = useTransactions ? "COMMIT;" : "";
+  const timestamp = options?.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  return `-- Migration generated by C15T (${timestamp})
+-- Database type: ${dbType}
+-- Description: Automatically generated schema migration
+-- 
+-- Wrapped in a transaction for atomicity
+-- To roll back this migration, use the ROLLBACK section below
+
+${transactionStart}
+-- MIGRATION
+${formattedStatements}
+${transactionEnd}
+
+-- ROLLBACK
+-- Uncomment the section below to roll back this migration
+/*
+${transactionStart}
+
+${rollbackStatements.join(";\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
+  };
+};
+
+function capitalizeFirstLetter(str) {
+  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());
+            }
+            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");
+          }
+        }
+        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;
+            }
+            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 && 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}[]`);
+          }
+        }
+      }
+    }
+  });
+  return {
+    code: schema.trim() === schemaPrisma.trim() ? "" : schema,
+    fileName: filePath
+  };
+};
+const getNewPrisma = (provider) => `generator client {
+    provider = "prisma-client-js"
+  }
+  
+  datasource db {
+    provider = "${provider}"
+    url      = ${provider === "sqlite" ? `"file:./dev.db"` : `env("DATABASE_URL")`}
+  }`;
+
+const adapters = {
+  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);
+};
+
+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_", ""))
+  );
+}
+function createDataUriModule(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")}
+  // jiti dirty hack: .unknown
+  `;
+}
+function createDynamicEnvModule() {
+  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))
+    )
+  );
+}
+function filterPublicEnv(publicPrefix, privatePrefix) {
+  return Object.fromEntries(
+    Object.entries(process.env).filter(
+      ([k]) => k.startsWith(publicPrefix) && (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 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"
+];
+let possiblePaths = configFileNames.flatMap(
+  (name) => extensions.map((ext) => `${name}${ext}`)
+);
+const directories = [
+  "",
+  "lib/server/",
+  "server/",
+  "lib/",
+  "utils/",
+  "config/",
+  "src/",
+  "app/"
+];
+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, "");
+}
+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;
+    }
+    return extractAliasesFromConfigFile(jsConfigPath, 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);
+      }
+    }
+    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
+            }
+          ],
+          [babelPresetReact, { runtime: "automatic" }]
+        ]
+      }
+    },
+    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;
+}
+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));
+            }
+          }
+        }
+      } catch {
+      }
+    } else if (fs$1.existsSync(path.join(cwd, pattern)) && fs$1.statSync(path.join(cwd, pattern)).isDirectory()) {
+      results.push(pattern);
+    }
+  }
+  return results;
+}
+function validateConfig(config) {
+  if (!config) {
+    return false;
+  }
+  return typeof config === "object";
+}
+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 C15TError(
+            `Configuration file not found: ${resolvedPath}
+Make sure the path is correct and the file exists.`
+          );
+        }
+        foundPaths.push(resolvedPath);
+        const { config } = await loadConfig({
+          configFile: resolvedPath,
+          dotenv: true,
+          jitiOptions: jitiOptions(cwd)
+        });
+        configFile = extractOptionsFromConfig(config);
+        if (!configFile) {
+          throw new C15TError(
+            // 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({...})`
+          );
+        }
+      } catch (e) {
+        if (fs$1.existsSync(resolvedPath)) {
+          failedImports.push(resolvedPath);
+          if (e instanceof C15TError) {
+            throw e;
+          }
+          throw new C15TError(
+            // 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)}`
+          );
+        }
+        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 C15TError(
+                // 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.`
+              );
+            }
+            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 C15TError("Unable to load any c15t configuration file");
+      }
+      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(`
+import { c15tInstance } from '@c15t/backend';
+
+export const c15t = c15tInstance({
+  appName: 'My App',
+  basePath: '/api/c15t',
+  // Add your configuration here
+});
+			`);
+      throw new C15TError(
+        "No c15t config file found. Create a c15t.ts file or specify with --config"
+      );
+    }
+    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);
+    }
+    if (e instanceof C15TError) {
+      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)}`);
+    }
+    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>");
+    }
+    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 (confirm2) {
+      const exist = existsSync(path.join(cwd, schema.fileName));
+      if (!exist) {
+        await fs.mkdir(path.dirname(path.join(cwd, schema.fileName)), {
+          recursive: true
+        });
+      }
+      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);
+    }
+  }
+  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
+      });
+    }
+  }
+  await fs.writeFile(
+    options.output || path.join(cwd, schema.fileName),
+    schema.code
+  );
+  logger.success("\u{1F680} 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);
+
+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);
+    }
+    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);
+    }
+    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.");
+    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("# Auth Secret") + chalk.green(`
+C15T_SECRET=${secret}`)}`);
+});
+
+function getPackageInfo() {
+  const packageJsonPath = path.join("package.json");
+  return fs$2.readJSONSync(packageJsonPath);
+}
+
+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();
+}
+main();

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@c15t/cli",
+  "version": "1.2.0-beta.17",
+  "description": "The CLI for c15t",
+  "exports": "./dist/index.mjs",
+  "main": "./dist/index.mjs",
+  "module": "dist/index.mjs",
+  "bin": "./dist/index.mjs",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "fmt": "pnpm biome format --write . && biome check --formatter-enabled=false --linter-enabled=false --organize-imports-enabled=true --write",
+    "lint": "pnpm biome lint ./src",
+    "start": "node ./dist/index.mjs",
+    "stub": "unbuild --stub",
+    "test": "vitest"
+  },
+  "dependencies": {
+    "@babel/preset-react": "^7.26.3",
+    "@babel/preset-typescript": "^7.26.0",
+    "@c15t/backend": "workspace:*",
+    "@mrleebo/prisma-ast": "^0.12.1",
+    "@prisma/client": "^6.5.0",
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/prompts": "^2.4.9",
+    "better-sqlite3": "^11.8.1",
+    "c12": "^3.0.2",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "dotenv": "^16.4.7",
+    "drizzle-orm": "^0.40.0",
+    "fs-extra": "^11.3.0",
+    "get-tsconfig": "^4.10.0",
+    "prisma": "^6.4.1",
+    "prompts": "^2.4.2",
+    "tinyexec": "^0.3.2",
+    "unbuild": "^3.5.0",
+    "yocto-spinner": "^0.2.1",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "vitest": "^3.0.8"
+  },
+  "publishConfig": {
+    "access": "public",
+    "executableFiles": [
+      "./dist/index.mjs"
+    ]
+  }
+}