stackkit-cli 0.4.1 → 0.4.3

package/dist/utils/detect.js

@@ -9,9 +9,9 @@ exports.getLibPath = getLibPath;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 async function detectProjectInfo(targetDir) {
-    const packageJsonPath = path_1.default.join(targetDir, 'package.json');
+    const packageJsonPath = path_1.default.join(targetDir, "package.json");
     if (!(await fs_extra_1.default.pathExists(packageJsonPath))) {
-        throw new Error('No package.json found. This does not appear to be a Node.js project.');
+        throw new Error("No package.json found. This does not appear to be a Node.js project.");
     }
     const packageJson = await fs_extra_1.default.readJSON(packageJsonPath);
     // Detect framework
@@ -21,62 +21,66 @@ async function detectProjectInfo(targetDir) {
     const isVite = packageJson.dependencies?.vite || packageJson.devDependencies?.vite;
     let framework;
     if (isNextJs) {
-        framework = 'nextjs';
+        framework = "nextjs";
     }
     else if (isExpress) {
-        framework = 'express';
+        framework = "express";
     }
     else if (isReact && isVite) {
-        framework = 'react-vite';
+        framework = "react-vite";
     }
     else if (isReact) {
-        framework = 'react';
+        framework = "react";
     }
     else {
-        framework = 'unknown';
+        framework = "unknown";
     }
-    if (framework === 'unknown') {
-        throw new Error('Only Next.js, Express, and React projects are currently supported.');
+    if (framework === "unknown") {
+        throw new Error("Only Next.js, Express, and React projects are currently supported.");
     }
     // Detect router type (only for Next.js)
-    let router = 'unknown';
-    if (framework === 'nextjs') {
-        const appDirExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, 'app'));
-        const pagesDirExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, 'pages'));
-        const srcAppDirExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, 'src', 'app'));
-        const srcPagesDirExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, 'src', 'pages'));
+    let router = "unknown";
+    if (framework === "nextjs") {
+        const appDirExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "app"));
+        const pagesDirExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "pages"));
+        const srcAppDirExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "src", "app"));
+        const srcPagesDirExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "src", "pages"));
         if (appDirExists || srcAppDirExists) {
-            router = 'app';
+            router = "app";
         }
         else if (pagesDirExists || srcPagesDirExists) {
-            router = 'pages';
+            router = "pages";
         }
     }
     // Detect TypeScript vs JavaScript
-    const tsconfigExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, 'tsconfig.json'));
-    const language = tsconfigExists ? 'ts' : 'js';
+    const tsconfigExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "tsconfig.json"));
+    const language = tsconfigExists ? "ts" : "js";
     // Detect package manager
-    const yarnLockExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, 'yarn.lock'));
-    const pnpmLockExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, 'pnpm-lock.yaml'));
-    let packageManager = 'npm';
+    const yarnLockExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "yarn.lock"));
+    const pnpmLockExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "pnpm-lock.yaml"));
+    const bunLockExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "bun.lockb"));
+    let packageManager = "npm";
     if (pnpmLockExists) {
-        packageManager = 'pnpm';
+        packageManager = "pnpm";
     }
     else if (yarnLockExists) {
-        packageManager = 'yarn';
+        packageManager = "yarn";
+    }
+    else if (bunLockExists) {
+        packageManager = "bun";
     }
     // Check for existing integrations
-    const hasAuth = !!(packageJson.dependencies?.['next-auth'] ||
-        packageJson.dependencies?.['better-auth'] ||
-        packageJson.dependencies?.['@auth/core'] ||
-        packageJson.dependencies?.['@clerk/nextjs'] ||
-        packageJson.dependencies?.['@kinde-oss/kinde-auth-nextjs'] ||
-        packageJson.dependencies?.['passport']);
-    const hasPrisma = !!(packageJson.dependencies?.['@prisma/client'] || packageJson.devDependencies?.['prisma']);
+    const hasAuth = !!(packageJson.dependencies?.["next-auth"] ||
+        packageJson.dependencies?.["better-auth"] ||
+        packageJson.dependencies?.["@auth/core"] ||
+        packageJson.dependencies?.["@clerk/nextjs"] ||
+        packageJson.dependencies?.["@kinde-oss/kinde-auth-nextjs"] ||
+        packageJson.dependencies?.["passport"]);
+    const hasPrisma = !!(packageJson.dependencies?.["@prisma/client"] || packageJson.devDependencies?.["prisma"]);
     const hasDatabase = hasPrisma ||
-        !!(packageJson.dependencies?.['mongoose'] ||
-            packageJson.dependencies?.['typeorm'] ||
-            packageJson.dependencies?.['drizzle-orm']);
+        !!(packageJson.dependencies?.["mongoose"] ||
+            packageJson.dependencies?.["typeorm"] ||
+            packageJson.dependencies?.["drizzle-orm"]);
     return {
         framework,
         router,
@@ -89,19 +93,19 @@ async function detectProjectInfo(targetDir) {
     };
 }
 function getRouterBasePath(projectInfo) {
-    const srcExists = fs_extra_1.default.existsSync(path_1.default.join(projectInfo.rootDir, 'src'));
-    if (projectInfo.router === 'app') {
-        return srcExists ? 'src/app' : 'app';
+    const srcExists = fs_extra_1.default.existsSync(path_1.default.join(projectInfo.rootDir, "src"));
+    if (projectInfo.router === "app") {
+        return srcExists ? "src/app" : "app";
     }
-    else if (projectInfo.router === 'pages') {
-        return srcExists ? 'src/pages' : 'pages';
+    else if (projectInfo.router === "pages") {
+        return srcExists ? "src/pages" : "pages";
     }
-    throw new Error('Unknown router type');
+    throw new Error("Unknown router type");
 }
 function getLibPath(projectInfo) {
-    if (projectInfo.framework === 'express') {
-        return 'src/lib';
+    if (projectInfo.framework === "express") {
+        return "src/lib";
     }
-    const srcExists = fs_extra_1.default.existsSync(path_1.default.join(projectInfo.rootDir, 'src'));
-    return srcExists ? 'src/lib' : 'lib';
+    const srcExists = fs_extra_1.default.existsSync(path_1.default.join(projectInfo.rootDir, "src"));
+    return srcExists ? "src/lib" : "lib";
 }

package/dist/utils/env-editor.js

@@ -8,28 +8,28 @@ exports.removeEnvVariables = removeEnvVariables;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const logger_1 = require("./logger");
-const ENV_MARKER_START = '# StackKit:';
-const ENV_MARKER_END = '# End StackKit';
+const ENV_MARKER_START = "# StackKit:";
+const ENV_MARKER_END = "# End StackKit";
 async function addEnvVariables(projectRoot, variables, options = {}) {
-    const envExamplePath = path_1.default.join(projectRoot, '.env.example');
-    const envPath = path_1.default.join(projectRoot, '.env');
+    const envExamplePath = path_1.default.join(projectRoot, ".env.example");
+    const envPath = path_1.default.join(projectRoot, ".env");
     // Add to .env.example
-    await appendToEnvFile(envExamplePath, variables, 'example', options);
+    await appendToEnvFile(envExamplePath, variables, "example", options);
     // Add to .env if it exists or create it
     const envExists = await fs_extra_1.default.pathExists(envPath);
     if (envExists || options.force) {
-        await appendToEnvFile(envPath, variables, 'local', options);
+        await appendToEnvFile(envPath, variables, "local", options);
     }
-    logger_1.logger.success('Environment variables added');
+    logger_1.logger.success("Environment variables added");
 }
 async function appendToEnvFile(filePath, variables, fileType, options = {}) {
-    let content = '';
+    let content = "";
     if (await fs_extra_1.default.pathExists(filePath)) {
-        content = await fs_extra_1.default.readFile(filePath, 'utf-8');
+        content = await fs_extra_1.default.readFile(filePath, "utf-8");
     }
     // Check if variables already exist
     const existingKeys = new Set();
-    const lines = content.split('\n');
+    const lines = content.split("\n");
     for (const line of lines) {
         const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
         if (match) {
@@ -49,25 +49,25 @@ async function appendToEnvFile(filePath, variables, fileType, options = {}) {
         return;
     }
     // Ensure file ends with newline
-    if (content && !content.endsWith('\n')) {
-        content += '\n';
+    if (content && !content.endsWith("\n")) {
+        content += "\n";
     }
     // Add marker and variables
-    content += '\n';
+    content += "\n";
     content += `${ENV_MARKER_START} Added by StackKit\n`;
     for (const variable of newVariables) {
         if (variable.description) {
             content += `# ${variable.description}\n`;
         }
-        const value = fileType === 'example' ? variable.value || '' : variable.value || '';
+        const value = fileType === "example" ? variable.value || "" : variable.value || "";
         content += `${variable.key}=${value}\n`;
     }
     content += `${ENV_MARKER_END}\n`;
-    await fs_extra_1.default.writeFile(filePath, content, 'utf-8');
+    await fs_extra_1.default.writeFile(filePath, content, "utf-8");
 }
 async function removeEnvVariables(projectRoot, keys) {
-    const envExamplePath = path_1.default.join(projectRoot, '.env.example');
-    const envPath = path_1.default.join(projectRoot, '.env');
+    const envExamplePath = path_1.default.join(projectRoot, ".env.example");
+    const envPath = path_1.default.join(projectRoot, ".env");
     await removeFromEnvFile(envExamplePath, keys);
     if (await fs_extra_1.default.pathExists(envPath)) {
         await removeFromEnvFile(envPath, keys);
@@ -77,8 +77,8 @@ async function removeFromEnvFile(filePath, keys) {
     if (!(await fs_extra_1.default.pathExists(filePath))) {
         return;
     }
-    let content = await fs_extra_1.default.readFile(filePath, 'utf-8');
-    const lines = content.split('\n');
+    const content = await fs_extra_1.default.readFile(filePath, "utf-8");
+    const lines = content.split("\n");
     const newLines = [];
     for (const line of lines) {
         const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
@@ -87,5 +87,5 @@ async function removeFromEnvFile(filePath, keys) {
         }
         newLines.push(line);
     }
-    await fs_extra_1.default.writeFile(filePath, newLines.join('\n'), 'utf-8');
+    await fs_extra_1.default.writeFile(filePath, newLines.join("\n"), "utf-8");
 }

package/dist/utils/files.js

@@ -21,11 +21,11 @@ async function copyTemplate(templatePath, targetPath, projectName) {
         filter: (src) => {
             const basename = path_1.default.basename(src);
             // Skip template.json metadata file and node_modules
-            return basename !== 'template.json' && basename !== 'node_modules';
+            return basename !== "template.json" && basename !== "node_modules";
         },
     });
     // Update package.json with project name
-    const packageJsonPath = path_1.default.join(targetPath, 'package.json');
+    const packageJsonPath = path_1.default.join(targetPath, "package.json");
     if (await fs_extra_1.default.pathExists(packageJsonPath)) {
         const packageJson = await fs_extra_1.default.readJSON(packageJsonPath);
         packageJson.name = projectName;
@@ -40,10 +40,10 @@ async function createFile(targetPath, content, options = {}) {
         return;
     }
     await fs_extra_1.default.ensureDir(path_1.default.dirname(targetPath));
-    await fs_extra_1.default.writeFile(targetPath, content, 'utf-8');
+    await fs_extra_1.default.writeFile(targetPath, content, "utf-8");
 }
 async function readFile(filePath) {
-    return fs_extra_1.default.readFile(filePath, 'utf-8');
+    return fs_extra_1.default.readFile(filePath, "utf-8");
 }
 async function fileExists(filePath) {
     return fs_extra_1.default.pathExists(filePath);

package/dist/utils/json-editor.d.ts

@@ -1,8 +1,8 @@
-export declare function modifyJson(filePath: string, modifier: (json: any) => any, options?: {
+export declare function modifyJson(filePath: string, modifier: (_json: Record<string, unknown>) => Record<string, unknown>, options?: {
     create?: boolean;
     force?: boolean;
 }): Promise<void>;
-export declare function addToPackageJson(filePath: string, section: 'dependencies' | 'devDependencies' | 'scripts', additions: Record<string, string>): Promise<void>;
-export declare function setJsonValue(filePath: string, path: string, value: any, options?: {
+export declare function addToPackageJson(filePath: string, section: "dependencies" | "devDependencies" | "scripts", additions: Record<string, string>): Promise<void>;
+export declare function setJsonValue(filePath: string, path: string, value: unknown, options?: {
     merge?: boolean;
 }): Promise<void>;

package/dist/utils/json-editor.js

@@ -12,24 +12,20 @@ async function modifyJson(filePath, modifier, options = {}) {
     if (!exists && !options.create) {
         throw new Error(`File not found: ${filePath}`);
     }
-    let json = {};
-    if (exists) {
-        json = await fs_extra_1.default.readJSON(filePath);
-    }
-    const modified = modifier(json);
+    const modified = modifier(exists ? await fs_extra_1.default.readJSON(filePath) : {});
     await fs_extra_1.default.writeJSON(filePath, modified, { spaces: 2 });
 }
 async function addToPackageJson(filePath, section, additions) {
-    await modifyJson(filePath, (json) => {
-        json[section] = json[section] || {};
-        Object.assign(json[section], additions);
-        return json;
+    await modifyJson(filePath, (_json) => {
+        _json[section] = _json[section] || {};
+        Object.assign(_json[section], additions);
+        return _json;
     });
 }
 async function setJsonValue(filePath, path, value, options = {}) {
-    await modifyJson(filePath, (json) => {
-        const keys = path.split('.');
-        let current = json;
+    await modifyJson(filePath, (_json) => {
+        const keys = path.split(".");
+        let current = _json;
         for (let i = 0; i < keys.length - 1; i++) {
             const key = keys[i];
             if (!current[key]) {
@@ -38,12 +34,12 @@ async function setJsonValue(filePath, path, value, options = {}) {
             current = current[key];
         }
         const lastKey = keys[keys.length - 1];
-        if (options.merge && typeof current[lastKey] === 'object' && typeof value === 'object') {
+        if (options.merge && typeof current[lastKey] === "object" && typeof value === "object") {
             current[lastKey] = { ...current[lastKey], ...value };
         }
         else {
             current[lastKey] = value;
         }
-        return json;
+        return _json;
     });
 }

package/dist/utils/logger.d.ts

@@ -1,4 +1,4 @@
-import { Ora } from 'ora';
+import { Ora } from "ora";
 export declare class Logger {
     private spinner;
     info(message: string): void;

package/dist/utils/logger.js

@@ -11,22 +11,22 @@ class Logger {
         this.spinner = null;
     }
     info(message) {
-        console.log(chalk_1.default.blue('ℹ'), message);
+        process.stdout.write(chalk_1.default.blue("ℹ") + " " + message + "\n");
     }
     success(message) {
-        console.log(chalk_1.default.green('✔'), message);
+        process.stdout.write(chalk_1.default.green("✔") + " " + message + "\n");
     }
     error(message) {
-        console.log(chalk_1.default.red('✖'), message);
+        process.stderr.write(chalk_1.default.red("✖") + " " + message + "\n");
     }
     warn(message) {
-        console.log(chalk_1.default.yellow('⚠'), message);
+        process.stdout.write(chalk_1.default.yellow("⚠") + " " + message + "\n");
     }
     log(message) {
-        console.log(message);
+        process.stdout.write(message + "\n");
     }
     newLine() {
-        console.log();
+        process.stdout.write("\n");
     }
     startSpinner(text) {
         this.spinner = (0, ora_1.default)(text).start();
@@ -49,10 +49,10 @@ class Logger {
         }
     }
     header(text) {
-        console.log(chalk_1.default.bold.cyan(text));
+        process.stdout.write(chalk_1.default.bold.cyan(text) + "\n");
     }
     footer() {
-        console.log();
+        process.stdout.write("\n");
     }
 }
 exports.Logger = Logger;

package/dist/utils/package-manager.d.ts

@@ -1,5 +1,5 @@
-export type PackageManager = 'npm' | 'yarn' | 'pnpm';
+export type PackageManager = "npm" | "yarn" | "pnpm" | "bun";
 export declare function detectPackageManager(cwd: string): Promise<PackageManager>;
-export declare function installDependencies(cwd: string, pm: PackageManager, dev?: boolean): Promise<void>;
+export declare function installDependencies(cwd: string, pm: PackageManager): Promise<void>;
 export declare function addDependencies(cwd: string, pm: PackageManager, packages: string[], dev?: boolean): Promise<void>;
 export declare function initGit(cwd: string): Promise<void>;

package/dist/utils/package-manager.js

@@ -16,63 +16,70 @@ async function detectPackageManager(cwd) {
         return pm;
     }
     catch {
-        return 'npm';
+        return "npm";
     }
 }
-async function installDependencies(cwd, pm, dev = false) {
+async function installDependencies(cwd, pm) {
     const spinner = logger_1.logger.startSpinner(`Installing dependencies with ${pm}...`);
     try {
         const args = [];
-        if (pm === 'npm') {
-            args.push('install');
+        if (pm === "npm") {
+            args.push("install");
         }
-        else if (pm === 'yarn') {
-            args.push('install');
+        else if (pm === "yarn") {
+            args.push("install");
         }
-        else if (pm === 'pnpm') {
-            args.push('install');
+        else if (pm === "pnpm") {
+            args.push("install");
         }
-        await (0, execa_1.default)(pm, args, { cwd, stdio: 'pipe' });
+        else if (pm === "bun") {
+            args.push("install");
+        }
+        await (0, execa_1.default)(pm, args, { cwd, stdio: "pipe" });
         spinner.succeed(`Dependencies installed successfully`);
     }
     catch (error) {
         spinner.fail(`Failed to install dependencies`);
-        throw error;
+        throw new Error(`Failed to install dependencies: ${error}`);
     }
 }
 async function addDependencies(cwd, pm, packages, dev = false) {
     if (packages.length === 0)
         return;
-    const spinner = logger_1.logger.startSpinner(`Adding ${dev ? 'dev ' : ''}dependencies: ${packages.join(', ')}...`);
+    const spinner = logger_1.logger.startSpinner(`Adding ${dev ? "dev " : ""}dependencies: ${packages.join(", ")}...`);
     try {
         const args = [];
-        if (pm === 'npm') {
-            args.push('install', dev ? '--save-dev' : '--save', ...packages);
+        if (pm === "npm") {
+            args.push("install", dev ? "--save-dev" : "--save", ...packages);
+        }
+        else if (pm === "yarn") {
+            args.push("add", dev ? "--dev" : "", ...packages);
         }
-        else if (pm === 'yarn') {
-            args.push('add', dev ? '--dev' : '', ...packages);
+        else if (pm === "pnpm") {
+            args.push("add", dev ? "-D" : "", ...packages);
         }
-        else if (pm === 'pnpm') {
-            args.push('add', dev ? '-D' : '', ...packages);
+        else if (pm === "bun") {
+            // bun uses `bun add` and `-d` for dev dependencies
+            args.push("add", ...(dev ? ["-d"] : []), ...packages);
         }
-        await (0, execa_1.default)(pm, args.filter(Boolean), { cwd, stdio: 'pipe' });
+        await (0, execa_1.default)(pm, args.filter(Boolean), { cwd, stdio: "pipe" });
         spinner.succeed(`Dependencies added successfully`);
     }
     catch (error) {
         spinner.fail(`Failed to add dependencies`);
-        throw error;
+        throw new Error(`Failed to add dependencies: ${error}`); // error is used here
     }
 }
 async function initGit(cwd) {
-    const spinner = logger_1.logger.startSpinner('Initializing git repository...');
+    const spinner = logger_1.logger.startSpinner("Initializing git repository...");
     try {
-        await (0, execa_1.default)('git', ['init'], { cwd });
-        await (0, execa_1.default)('git', ['add', '.'], { cwd });
-        await (0, execa_1.default)('git', ['commit', '-m', 'Initial commit from StackKit'], { cwd });
-        spinner.succeed('Git repository initialized');
+        await (0, execa_1.default)("git", ["init"], { cwd });
+        await (0, execa_1.default)("git", ["add", "."], { cwd });
+        await (0, execa_1.default)("git", ["commit", "-m", "Initial commit from StackKit"], { cwd });
+        spinner.succeed("Git repository initialized");
     }
-    catch (error) {
-        spinner.fail('Failed to initialize git repository');
+    catch {
+        spinner.fail("Failed to initialize git repository");
         // Don't throw - git init is optional
     }
 }

package/modules/auth/better-auth-express/adapters/mongoose-mongodb.ts

@@ -0,0 +1,13 @@
+import { betterAuth } from "better-auth";
+import { mongodbAdapter } from "better-auth/adapters/mongodb";
+import { client } from "./db";
+
+export const auth = betterAuth({
+  database: mongodbAdapter(client),
+  emailAndPassword: {
+    enabled: true,
+  },
+});
+
+export type Session = typeof auth.$Infer.Session;
+export type User = typeof auth.$Infer.User;

package/modules/auth/better-auth-express/adapters/prisma-mongodb.ts

@@ -0,0 +1,15 @@
+import { prismaAdapter } from "@better-auth/prisma";
+import { betterAuth } from "better-auth";
+import { prisma } from "./db";
+
+export const auth = betterAuth({
+  database: prismaAdapter(prisma, {
+    provider: "mongodb",
+  }),
+  emailAndPassword: {
+    enabled: true,
+  },
+});
+
+export type Session = typeof auth.$Infer.Session;
+export type User = typeof auth.$Infer.User;

package/modules/auth/better-auth-express/adapters/prisma-postgresql.ts

@@ -0,0 +1,15 @@
+import { prismaAdapter } from "@better-auth/prisma";
+import { betterAuth } from "better-auth";
+import { prisma } from "./db";
+
+export const auth = betterAuth({
+  database: prismaAdapter(prisma, {
+    provider: "postgresql",
+  }),
+  emailAndPassword: {
+    enabled: true,
+  },
+});
+
+export type Session = typeof auth.$Infer.Session;
+export type User = typeof auth.$Infer.User;

package/modules/auth/better-auth-express/files/lib/auth.ts

@@ -1,4 +1,4 @@
-import { betterAuth } from 'better-auth';
+import { betterAuth } from "better-auth";
 
 export const auth = betterAuth({
   secret: process.env.BETTER_AUTH_SECRET!,

package/modules/auth/better-auth-express/files/routes/auth.ts

@@ -1,10 +1,10 @@
-import { Router } from 'express';
-import { auth } from '../lib/auth';
+import { Router } from "express";
+import { auth } from "../lib/auth";
 
 const router = Router();
 
 // Mount Better Auth handlers
-router.all('/auth/*', async (req, res) => {
+router.all("/auth/*", async (req, res) => {
   const response = await auth.handler(req);
   return res.status(response.status).json(response.body);
 });

package/modules/auth/better-auth-express/files/schemas/prisma-mongodb-schema.prisma

@@ -0,0 +1,72 @@
+generator client {
+    provider = "prisma-client-js"
+}
+
+datasource db {
+    provider = "mongodb"
+    url      = env("DATABASE_URL")
+}
+
+// Better Auth models for MongoDB
+model User {
+  id            String    @id @default(auto()) @map("_id") @db.ObjectId
+  name          String
+  email         String
+  emailVerified Boolean   @default(false)
+  image         String?
+  createdAt     DateTime  @default(now())
+  updatedAt     DateTime  @updatedAt
+  sessions      Session[]
+  accounts      Account[]
+  role          String    @default("USER")
+
+  @@unique([email])
+  @@map("user")
+}
+
+model Session {
+  id        String   @id @default(auto()) @map("_id") @db.ObjectId
+  expiresAt DateTime
+  token     String   @unique
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+  ipAddress String?
+  userAgent String?
+  userId    String   @db.ObjectId
+  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@index([userId])
+  @@map("session")
+}
+
+model Account {
+  id                    String    @id @default(auto()) @map("_id") @db.ObjectId
+  accountId             String
+  providerId            String
+  userId                String    @db.ObjectId
+  user                  User      @relation(fields: [userId], references: [id], onDelete: Cascade)
+  accessToken           String?
+  refreshToken          String?
+  idToken               String?
+  accessTokenExpiresAt  DateTime?
+  refreshTokenExpiresAt DateTime?
+  scope                 String?
+  password              String?
+  createdAt             DateTime  @default(now())
+  updatedAt             DateTime  @updatedAt
+
+  @@index([userId])
+  @@map("account")
+}
+
+model Verification {
+  id         String   @id @default(auto()) @map("_id") @db.ObjectId
+  identifier String
+  value      String
+  expiresAt  DateTime
+  createdAt  DateTime @default(now())
+  updatedAt  DateTime @updatedAt
+
+  @@index([identifier])
+  @@map("verification")
+}