@better-auth/cli 0.0.1

package/LICENSE.md

@@ -0,0 +1,17 @@
+The MIT License (MIT)
+Copyright (c) 2024 - present, Bereket Engida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+and associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/index.mjs

@@ -0,0 +1,610 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command3 } from "commander";
+
+// src/commands/migrate.ts
+import { Command } from "commander";
+import { z } from "zod";
+import { existsSync } from "fs";
+import path2 from "path";
+import yoctoSpinner from "yocto-spinner";
+import chalk from "chalk";
+import prompts from "prompts";
+import { logger as logger2 } from "better-auth";
+import { getAdapter, getMigrations } from "better-auth/db";
+
+// src/utils/get-config.ts
+import { loadConfig } from "c12";
+import { logger } from "better-auth";
+import path from "path";
+import babelPresetTypescript from "@babel/preset-typescript";
+import babelPresetReact from "@babel/preset-react";
+import fs from "fs";
+import { BetterAuthError } from "better-auth";
+
+// src/utils/add-svelte-kit-env-modules.ts
+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) && (publicPrefix === "" || !k.startsWith(publicPrefix))
+    )
+  );
+}
+function filterPublicEnv(publicPrefix, privatePrefix) {
+  return Object.fromEntries(
+    Object.entries(process.env).filter(
+      ([k]) => k.startsWith(publicPrefix) && (privatePrefix === "" || !k.startsWith(privatePrefix))
+    )
+  );
+}
+var validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+var 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"
+]);
+
+// src/utils/get-config.ts
+var possiblePaths = ["auth.ts", "auth.tsx"];
+possiblePaths = [
+  ...possiblePaths,
+  ...possiblePaths.map((it) => `lib/server${it}`),
+  ...possiblePaths.map((it) => `lib/${it}`),
+  ...possiblePaths.map((it) => `utils/${it}`)
+];
+possiblePaths = [
+  ...possiblePaths,
+  ...possiblePaths.map((it) => `src/${it}`),
+  ...possiblePaths.map((it) => `app/${it}`)
+];
+function stripJsonComments(jsonString) {
+  return jsonString.replace(
+    /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g,
+    (m, g) => g ? "" : m
+  );
+}
+function getPathAliases(cwd) {
+  const tsConfigPath = path.join(cwd, "tsconfig.json");
+  if (!fs.existsSync(tsConfigPath)) {
+    logger.warn("[#better-auth]: tsconfig.json not found.");
+    return null;
+  }
+  try {
+    const tsConfigContent = fs.readFileSync(tsConfigPath, "utf8");
+    const strippedTsConfigContent = stripJsonComments(tsConfigContent);
+    const tsConfig = JSON.parse(strippedTsConfigContent);
+    const { paths = {} } = tsConfig.compilerOptions || {};
+    const result = {};
+    const obj = Object.entries(paths);
+    for (const [alias, aliasPaths] of obj) {
+      for (const _ of aliasPaths) {
+        result[alias[0] || ""] = "../";
+      }
+    }
+    addSvelteKitEnvModules(result);
+    return result;
+  } catch (error) {
+    console.error(error);
+    throw new BetterAuthError("Error parsing tsconfig.json");
+  }
+}
+var jitiOptions = (cwd) => {
+  const alias = getPathAliases(cwd) || {};
+  return {
+    transformOptions: {
+      babel: {
+        presets: [
+          [
+            babelPresetTypescript,
+            {
+              isTSX: true,
+              allExtensions: true
+            }
+          ],
+          [babelPresetReact, { runtime: "automatic" }]
+        ]
+      }
+    },
+    extensions: [".ts", ".tsx", ".js", ".jsx"],
+    alias
+  };
+};
+async function getConfig({
+  cwd,
+  configPath
+}) {
+  try {
+    let configFile = null;
+    if (configPath) {
+      const { config } = await loadConfig({
+        configFile: path.join(cwd, configPath),
+        dotenv: true,
+        jitiOptions: jitiOptions(cwd)
+      });
+      if (!config.auth && !config.default) {
+        logger.error(
+          "[#better-auth]: Couldn't read your auth config. Make sure to default export your auth instance or to export as a variable named auth."
+        );
+        process.exit(1);
+      }
+      configFile = config.auth?.options || config.default?.options || null;
+    }
+    if (!configFile) {
+      for (const possiblePath of possiblePaths) {
+        try {
+          const { config } = await loadConfig({
+            configFile: possiblePath,
+            jitiOptions: jitiOptions(cwd)
+          });
+          const hasConfig = Object.keys(config).length > 0;
+          if (hasConfig) {
+            configFile = config.auth?.options || config.default?.options || null;
+            if (!configFile) {
+              logger.error("[#better-auth]: Couldn't read your auth config.");
+              logger.break();
+              logger.info(
+                "[#better-auth]: Make sure to default export your auth instance or to export as a variable named auth."
+              );
+              process.exit(1);
+            }
+            break;
+          }
+        } catch (e) {
+          logger.error("[#better-auth]: Couldn't read your auth config.", e);
+          process.exit(1);
+        }
+      }
+    }
+    return configFile;
+  } catch (e) {
+    logger.error("Couldn't read your auth config.");
+    process.exit(1);
+  }
+}
+
+// src/commands/migrate.ts
+var 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", "").action(async (opts) => {
+  const options = z.object({
+    cwd: z.string(),
+    config: z.string().optional()
+  }).parse(opts);
+  const cwd = path2.resolve(options.cwd);
+  if (!existsSync(cwd)) {
+    logger2.error(`The directory "${cwd}" does not exist.`);
+    process.exit(1);
+  }
+  const config = await getConfig({
+    cwd,
+    configPath: options.config
+  });
+  if (!config) {
+    logger2.error(
+      "No configuration file found. Add a `auth.ts` file to your project or pass the path to the configuration file using the `--config` flag."
+    );
+    return;
+  }
+  const db = await getAdapter(config, true);
+  if (!db) {
+    logger2.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") {
+    logger2.error("Migrate command only works with built-in Kysely 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();
+    logger2.success("\u{1F680} No migrations needed.");
+    process.exit(0);
+  }
+  spinner.stop();
+  logger2.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.")
+    );
+  }
+  const { migrate: migrate2 } = await prompts({
+    type: "confirm",
+    name: "migrate",
+    message: "Are you sure you want to run these migrations?",
+    initial: false
+  });
+  if (!migrate2) {
+    logger2.info("Migration cancelled.");
+    process.exit(0);
+  }
+  spinner?.start("migrating...");
+  await runMigrations();
+  spinner.stop();
+  logger2.success("\u{1F680} migration was completed successfully!");
+  process.exit(0);
+});
+
+// src/commands/generate.ts
+import { Command as Command2 } from "commander";
+import { z as z2 } from "zod";
+import { existsSync as existsSync4 } from "fs";
+import path4 from "path";
+import { logger as logger4 } from "better-auth";
+import yoctoSpinner2 from "yocto-spinner";
+import prompts2 from "prompts";
+import fs3 from "fs/promises";
+import chalk2 from "chalk";
+import { getAdapter as getAdapter2 } from "better-auth/db";
+
+// src/generators/index.ts
+import { logger as logger3 } from "better-auth";
+
+// src/generators/drizzle.ts
+import { getAuthTables } from "better-auth/db";
+import { existsSync as existsSync2 } from "fs";
+var generateDrizzleSchema = async ({
+  options,
+  file,
+  adapter
+}) => {
+  const tables = getAuthTables(options);
+  const filePath = file || "./auth-schema.ts";
+  const databaseType = adapter.options?.provider;
+  const timestampAndBoolean = databaseType !== "sqlite" ? "timestamp, boolean" : "";
+  const int = databaseType === "mysql" ? "int" : "integer";
+  let code = `import { ${databaseType}Table, text, ${int}, ${timestampAndBoolean} } from "drizzle-orm/${databaseType}-core";
+			`;
+  const fileExist = existsSync2(filePath);
+  for (const table in tables) {
+    let getType2 = function(name, type) {
+      if (type === "string") {
+        return `text('${name}')`;
+      }
+      if (type === "number") {
+        return `${int}('${name}')`;
+      }
+      if (type === "boolean") {
+        if (databaseType === "sqlite") {
+          return `integer('${name}', {
+								mode: "boolean"
+							})`;
+        }
+        return `boolean('${name}')`;
+      }
+      if (type === "date") {
+        if (databaseType === "sqlite") {
+          return `integer('${name}', {
+								mode: "timestamp"
+							})`;
+        }
+        return `timestamp('${name}')`;
+      }
+    };
+    var getType = getType2;
+    const tableName = tables[table].tableName;
+    const fields = tables[table].fields;
+    const schema = `export const ${table} = ${databaseType}Table("${tableName}", {
+					id: text("id").primaryKey(),
+					${Object.keys(fields).map((field) => {
+      const attr = fields[field];
+      return `${field}: ${getType2(field, attr.type)}${attr.required ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${attr.references ? `.references(()=> ${attr.references.model}.${attr.references.field})` : ""}`;
+    }).join(",\n ")}
+				});`;
+    code += `
+${schema}
+`;
+  }
+  return {
+    code,
+    fileName: filePath,
+    overwrite: fileExist
+  };
+};
+
+// src/generators/prisma.ts
+import { getAuthTables as getAuthTables2 } from "better-auth/db";
+import { produceSchema } from "@mrleebo/prisma-ast";
+import { existsSync as existsSync3 } from "fs";
+import path3 from "path";
+import fs2 from "fs/promises";
+import { capitalizeFirstLetter } from "better-auth";
+var generatePrismaSchema = async ({
+  adapter,
+  options,
+  file
+}) => {
+  const provider = adapter.options?.provider || "pg";
+  const tables = getAuthTables2(options);
+  const filePath = file || "./prisma/schema.prisma";
+  const schemaPrismaExist = existsSync3(path3.join(process.cwd(), filePath));
+  let schemaPrisma = "";
+  if (schemaPrismaExist) {
+    schemaPrisma = await fs2.readFile(
+      path3.join(process.cwd(), filePath),
+      "utf-8"
+    );
+  } else {
+    schemaPrisma = getNewPrisma(provider);
+  }
+  const schema = produceSchema(schemaPrisma, (builder) => {
+    for (const table in tables) {
+      let getType2 = function(type, isOptional) {
+        if (type === "string") {
+          return isOptional ? "String?" : "String";
+        }
+        if (type === "number") {
+          return isOptional ? "Int?" : "Int";
+        }
+        if (type === "boolean") {
+          return isOptional ? "Boolean?" : "Boolean";
+        }
+        if (type === "date") {
+          return isOptional ? "DateTime?" : "DateTime";
+        }
+      };
+      var getType = getType2;
+      const fields = tables[table]?.fields;
+      const originalTable = tables[table]?.tableName;
+      const tableName = capitalizeFirstLetter(originalTable || "");
+      const prismaModel = builder.findByType("model", {
+        name: tableName
+      });
+      !prismaModel && builder.model(tableName).field("id", "String").attribute("id");
+      for (const field in fields) {
+        const attr = fields[field];
+        if (prismaModel) {
+          const isAlreadyExist = builder.findByType("field", {
+            name: field,
+            within: prismaModel.properties
+          });
+          if (isAlreadyExist) {
+            continue;
+          }
+        }
+        builder.model(tableName).field(field, getType2(attr.type, !attr?.required));
+        if (attr.unique) {
+          builder.model(tableName).blockAttribute(`unique([${field}])`);
+        }
+        if (attr.references) {
+          builder.model(tableName).field(
+            `${attr.references.model.toLowerCase()}`,
+            capitalizeFirstLetter(attr.references.model)
+          ).attribute(
+            `relation(fields: [${field}], references: [${attr.references.field}], onDelete: Cascade)`
+          );
+        }
+      }
+      const hasAttribute = builder.findByType("attribute", {
+        name: "map",
+        within: prismaModel?.properties
+      });
+      if (originalTable !== tableName && !hasAttribute) {
+        builder.model(tableName).blockAttribute("map", originalTable);
+      }
+    }
+  });
+  return {
+    code: schema.trim() === schemaPrisma.trim() ? "" : schema,
+    fileName: filePath
+  };
+};
+var getNewPrisma = (provider) => `generator client {
+    provider = "prisma-client-js"
+  }
+  
+  datasource db {
+    provider = "${provider}"
+    url      = ${provider === "sqlite" ? `"file:./dev.db"` : `env("DATABASE_URL")`}
+  }`;
+
+// src/generators/index.ts
+var adapters = {
+  prisma: generatePrismaSchema,
+  drizzle: generateDrizzleSchema
+};
+var getGenerator = (opts) => {
+  const adapter = opts.adapter;
+  const generator = adapter.id in adapters ? adapters[adapter.id] : null;
+  if (!generator) {
+    logger3.error(`${adapter.id} is not supported.`);
+    process.exit(1);
+  }
+  return generator(opts);
+};
+
+// src/commands/generate.ts
+var generate = new Command2("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", "").action(async (opts) => {
+  const options = z2.object({
+    cwd: z2.string(),
+    config: z2.string().optional(),
+    output: z2.string().optional()
+  }).parse(opts);
+  const cwd = path4.resolve(options.cwd);
+  if (!existsSync4(cwd)) {
+    logger4.error(`The directory "${cwd}" does not exist.`);
+    process.exit(1);
+  }
+  const config = await getConfig({
+    cwd,
+    configPath: options.config
+  });
+  if (!config) {
+    logger4.error(
+      "No configuration file found. Add a `auth.ts` file to your project or pass the path to the configuration file using the `--config` flag."
+    );
+    return;
+  }
+  const spinner = yoctoSpinner2({ text: "preparing schema..." }).start();
+  const adapter = await getAdapter2(config, true).catch((e) => {
+    logger4.error(e.message);
+    process.exit(1);
+  });
+  const schema = await getGenerator({
+    adapter,
+    file: options.output,
+    options: config
+  });
+  spinner.stop();
+  if (!schema.code) {
+    logger4.success("Your schema is already up to date.");
+    process.exit(0);
+  }
+  if (schema.append || schema.overwrite) {
+    const { confirm: confirm2 } = await prompts2({
+      type: "confirm",
+      name: "confirm",
+      message: `The file ${schema.fileName} already exists. Do you want to ${chalk2.yellow(
+        `${schema.overwrite ? "overwrite" : "append"}`
+      )} the schema to the file?`
+    });
+    if (confirm2) {
+      const exist = existsSync4(path4.join(cwd, schema.fileName));
+      if (!exist) {
+        await fs3.mkdir(path4.dirname(path4.join(cwd, schema.fileName)), {
+          recursive: true
+        });
+      }
+      if (schema.overwrite) {
+        await fs3.writeFile(path4.join(cwd, schema.fileName), schema.code);
+      } else {
+        await fs3.appendFile(path4.join(cwd, schema.fileName), schema.code);
+      }
+      logger4.success(`\u{1F680} schema was appended successfully!`);
+      process.exit(0);
+    } else {
+      logger4.error("Schema generation aborted.");
+      process.exit(1);
+    }
+  }
+  const { confirm } = await prompts2({
+    type: "confirm",
+    name: "confirm",
+    message: `Do you want to generate the schema to ${chalk2.yellow(
+      schema.fileName
+    )}?`
+  });
+  if (!confirm) {
+    logger4.error("Schema generation aborted.");
+    process.exit(1);
+  }
+  if (!options.output) {
+    const dirExist = existsSync4(
+      path4.dirname(path4.join(cwd, schema.fileName))
+    );
+    if (!dirExist) {
+      await fs3.mkdir(path4.dirname(path4.join(cwd, schema.fileName)), {
+        recursive: true
+      });
+    }
+  }
+  await fs3.writeFile(
+    options.output || path4.join(cwd, schema.fileName),
+    schema.code
+  );
+  logger4.success(`\u{1F680} schema was generated successfully!`);
+  process.exit(0);
+});
+
+// src/index.ts
+import "dotenv/config";
+async function main() {
+  const program = new Command3();
+  program.name("better-auth").addCommand(migrate).addCommand(generate).version("0.0.1").description("Better Auth CLI");
+  program.parse();
+}
+main();

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@better-auth/cli",
+  "version": "0.0.1",
+  "description": "The CLI for BetterAuth",
+  "module": "dist/index.mjs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/better-auth/better-auth",
+    "directory": "packages/cli"
+  },
+  "main": "./dist/index.mjs",
+  "bin": "./dist/index.mjs",
+  "devDependencies": {
+    "tsup": "^8.2.4",
+    "typescript": "^5.6.3"
+  },
+  "dependencies": {
+    "@babel/preset-react": "^7.24.7",
+    "@babel/preset-typescript": "^7.24.7",
+    "@mrleebo/prisma-ast": "^0.12.0",
+    "@types/prompts": "^2.4.9",
+    "c12": "^2.0.1",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5",
+    "prompts": "^2.4.2",
+    "tinyexec": "^0.3.0",
+    "yocto-spinner": "^0.1.1",
+    "zod": "^3.23.8",
+    "better-auth": "0.4.9-beta.7"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsup --watch --sourcemap",
+    "build": "tsup --clean"
+  }
+}