@factiii/auth 0.5.3 → 0.5.4

package/bin/init.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -17,21 +17,215 @@ function printHelp() {
 @factiii/auth CLI
 
 Usage:
-  npx @factiii/auth <command>
+  npx @factiii/auth <command> [--prisma | --drizzle]
 
 Commands:
-  init     Copy the reference Prisma schema to your project
+  init     Generate the auth schema for your ORM (auto-detected)
   schema   Print the schema path (for manual copying)
   doctor   Check your project setup for common issues
   help     Show this help message
 
+Flags:
+  --prisma   Force Prisma mode (skip auto-detection)
+  --drizzle  Force Drizzle mode (skip auto-detection)
+
 Examples:
-  npx @factiii/auth init
+  npx @factiii/auth init            # auto-detects your ORM
+  npx @factiii/auth init --drizzle  # force Drizzle schema
   npx @factiii/auth doctor
 `);
 }
 
-function init() {
+/**
+ * Read package.json deps and detect ORM.
+ * Returns 'prisma' | 'drizzle' | 'both' | 'none'.
+ */
+function detectORMFromPackageJson() {
+  const packageJsonPath = resolve(process.cwd(), 'package.json');
+  if (!existsSync(packageJsonPath)) return 'none';
+  try {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    return detectORM(deps);
+  } catch {
+    return 'none';
+  }
+}
+
+/**
+ * Resolve which ORM to use for init, considering CLI flags and auto-detection.
+ */
+function resolveORMForInit() {
+  if (args.includes('--prisma')) return 'prisma';
+  if (args.includes('--drizzle')) return 'drizzle';
+
+  const detected = detectORMFromPackageJson();
+
+  if (detected === 'both') {
+    console.log('Both @prisma/client and drizzle-orm detected.');
+    console.log('Use --prisma or --drizzle to specify which schema to generate:');
+    console.log('  npx @factiii/auth init --prisma');
+    console.log('  npx @factiii/auth init --drizzle');
+    process.exit(1);
+  }
+
+  if (detected === 'none') {
+    console.log('No ORM detected in package.json.');
+    console.log('Install one first, or use a flag to force:');
+    console.log('  npm install @prisma/client prisma   # then: npx @factiii/auth init');
+    console.log('  npm install drizzle-orm              # then: npx @factiii/auth init');
+    console.log('  npx @factiii/auth init --prisma      # force without installing first');
+    console.log('  npx @factiii/auth init --drizzle     # force without installing first');
+    process.exit(1);
+  }
+
+  return detected; // 'prisma' or 'drizzle'
+}
+
+// ── Drizzle schema template ─────────────────────────────────────────────────
+
+const DRIZZLE_SCHEMA_TEMPLATE = `import { pgTable, pgEnum, serial, text, integer, boolean, timestamp, uniqueIndex } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+
+// ==============================================================================
+// Enums
+// ==============================================================================
+
+export const userStatusEnum = pgEnum('UserStatus', ['ACTIVE', 'DEACTIVATED', 'BANNED']);
+export const userTagEnum = pgEnum('UserTag', ['HUMAN', 'BOT']);
+export const emailVerificationStatusEnum = pgEnum('EmailVerificationStatus', ['UNVERIFIED', 'PENDING', 'VERIFIED']);
+export const oauthProviderEnum = pgEnum('OAuthProvider', ['GOOGLE', 'APPLE']);
+
+// ==============================================================================
+// Users
+// ==============================================================================
+
+export const users = pgTable('User', {
+  id: serial('id').primaryKey(),
+  createdAt: timestamp('createdAt').defaultNow().notNull(),
+  status: userStatusEnum('status').default('ACTIVE').notNull(),
+  email: text('email').unique().notNull(),
+  emailVerificationStatus: emailVerificationStatusEnum('emailVerificationStatus').default('UNVERIFIED').notNull(),
+  password: text('password'),
+  username: text('username').unique().notNull(),
+  twoFaEnabled: boolean('twoFaEnabled').default(false).notNull(),
+  oauthProvider: oauthProviderEnum('oauthProvider'),
+  oauthId: text('oauthId'),
+  tag: userTagEnum('tag').default('HUMAN').notNull(),
+  isActive: boolean('isActive').default(false).notNull(),
+  verifiedHumanAt: timestamp('verifiedHumanAt'),
+  otpForEmailVerification: text('otpForEmailVerification'),
+});
+
+// ==============================================================================
+// Sessions
+// ==============================================================================
+
+export const sessions = pgTable('Session', {
+  id: serial('id').primaryKey(),
+  socketId: text('socketId').unique(),
+  twoFaSecret: text('twoFaSecret').unique(),
+  issuedAt: timestamp('issuedAt').defaultNow().notNull(),
+  browserName: text('browserName').default('Unknown').notNull(),
+  lastUsed: timestamp('lastUsed').defaultNow().notNull(),
+  deviceId: integer('deviceId').references(() => devices.id),
+  userId: integer('userId').references(() => users.id, { onDelete: 'cascade' }).notNull(),
+  revokedAt: timestamp('revokedAt'),
+});
+
+// ==============================================================================
+// Admins
+// ==============================================================================
+
+export const admins = pgTable('Admin', {
+  userId: integer('userId').primaryKey().references(() => users.id, { onDelete: 'cascade' }),
+  ip: text('ip').notNull(),
+});
+
+// ==============================================================================
+// Password Resets
+// ==============================================================================
+
+export const passwordResets = pgTable('PasswordReset', {
+  id: text('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  createdAt: timestamp('createdAt').defaultNow().notNull(),
+  userId: integer('userId').references(() => users.id, { onDelete: 'cascade' }).notNull(),
+  invalidatedAt: timestamp('invalidatedAt'),
+});
+
+// ==============================================================================
+// OTPs
+// ==============================================================================
+
+export const otps = pgTable('OTP', {
+  id: serial('id').primaryKey(),
+  code: integer('code').notNull(),
+  expiresAt: timestamp('expiresAt').notNull(),
+  userId: integer('userId').references(() => users.id, { onDelete: 'cascade' }).notNull(),
+});
+
+// ==============================================================================
+// Devices
+// ==============================================================================
+
+export const devices = pgTable('Device', {
+  id: serial('id').primaryKey(),
+  pushToken: text('pushToken').unique().notNull(),
+  createdAt: timestamp('createdAt').defaultNow().notNull(),
+});
+
+// ==============================================================================
+// Join Tables (many-to-many)
+// ==============================================================================
+
+export const devicesToUsers = pgTable('_devices', {
+  deviceId: integer('A').references(() => devices.id, { onDelete: 'cascade' }).notNull(),
+  userId: integer('B').references(() => users.id, { onDelete: 'cascade' }).notNull(),
+});
+
+// ==============================================================================
+// Relations
+// ==============================================================================
+
+export const usersRelations = relations(users, ({ many, one }) => ({
+  sessions: many(sessions),
+  passwordResets: many(passwordResets),
+  otps: many(otps),
+  devices: many(devicesToUsers),
+  admin: one(admins),
+}));
+
+export const sessionsRelations = relations(sessions, ({ one }) => ({
+  user: one(users, { fields: [sessions.userId], references: [users.id] }),
+  device: one(devices, { fields: [sessions.deviceId], references: [devices.id] }),
+}));
+
+export const adminsRelations = relations(admins, ({ one }) => ({
+  user: one(users, { fields: [admins.userId], references: [users.id] }),
+}));
+
+export const passwordResetsRelations = relations(passwordResets, ({ one }) => ({
+  user: one(users, { fields: [passwordResets.userId], references: [users.id] }),
+}));
+
+export const otpsRelations = relations(otps, ({ one }) => ({
+  user: one(users, { fields: [otps.userId], references: [users.id] }),
+}));
+
+export const devicesRelations = relations(devices, ({ many }) => ({
+  sessions: many(sessions),
+  users: many(devicesToUsers),
+}));
+
+export const devicesToUsersRelations = relations(devicesToUsers, ({ one }) => ({
+  device: one(devices, { fields: [devicesToUsers.deviceId], references: [devices.id] }),
+  user: one(users, { fields: [devicesToUsers.userId], references: [users.id] }),
+}));
+`;
+
+// ── Init commands ───────────────────────────────────────────────────────────
+
+function initPrisma() {
   // Ensure prisma directory exists
   if (!existsSync(targetDir)) {
     mkdirSync(targetDir, { recursive: true });
@@ -48,7 +242,7 @@ function init() {
   // Copy schema
   try {
     copyFileSync(schemaSource, targetFile);
-    console.log(`✓ Copied schema to ${targetFile}`);
+    console.log(`✓ Copied Prisma schema to ${targetFile}`);
     console.log('');
     console.log('Next steps:');
     console.log('  1. Review and customize the schema for your database provider');
@@ -61,12 +255,92 @@ function init() {
   }
 }
 
+function initDrizzle() {
+  // Determine target location
+  const candidates = [
+    { dir: 'src/db', file: 'src/db/auth-schema.ts' },
+    { dir: 'drizzle', file: 'drizzle/auth-schema.ts' },
+  ];
+
+  // Pick the first directory that already exists, or default to src/db
+  let target = candidates[0];
+  for (const c of candidates) {
+    if (existsSync(resolve(process.cwd(), c.dir))) {
+      target = c;
+      break;
+    }
+  }
+
+  const targetDirDrizzle = resolve(process.cwd(), target.dir);
+  const targetFileDrizzle = resolve(process.cwd(), target.file);
+
+  // Ensure directory exists
+  if (!existsSync(targetDirDrizzle)) {
+    mkdirSync(targetDirDrizzle, { recursive: true });
+    console.log(`Created ${target.dir}/ directory`);
+  }
+
+  // Check if file already exists
+  if (existsSync(targetFileDrizzle)) {
+    console.log(`⚠️  ${target.file} already exists`);
+    console.log('   To overwrite, delete it first and run again.');
+    process.exit(1);
+  }
+
+  try {
+    writeFileSync(targetFileDrizzle, DRIZZLE_SCHEMA_TEMPLATE);
+    console.log(`✓ Generated Drizzle schema at ${target.file}`);
+    console.log('');
+    console.log('Next steps:');
+    console.log('  1. Review and customize the schema (table names, column types, etc.)');
+    console.log('  2. Import and merge into your existing schema (if you have one)');
+    console.log('  3. Create a drizzle.config.ts if you haven\'t already');
+    console.log('  4. Run: npx drizzle-kit generate');
+    console.log('  5. Run: npx drizzle-kit migrate');
+    console.log('');
+    console.log('Usage with @factiii/auth:');
+    console.log('  import { createDrizzleAdapter } from \'@factiii/auth\';');
+    console.log(`  import * as schema from './${target.file.replace(/\.ts$/, '')}';`);
+    console.log('  const adapter = createDrizzleAdapter(db, {');
+    console.log('    users: schema.users,');
+    console.log('    sessions: schema.sessions,');
+    console.log('    otps: schema.otps,');
+    console.log('    passwordResets: schema.passwordResets,');
+    console.log('    devices: schema.devices,');
+    console.log('    admins: schema.admins,');
+    console.log('    devicesToUsers: schema.devicesToUsers,');
+    console.log('  });');
+  } catch (err) {
+    console.error('Failed to generate schema:', err.message);
+    process.exit(1);
+  }
+}
+
+function init() {
+  const orm = resolveORMForInit();
+  console.log(`Detected ORM: ${orm}\n`);
+
+  if (orm === 'prisma') {
+    initPrisma();
+  } else if (orm === 'drizzle') {
+    initDrizzle();
+  }
+}
+
 function printSchemaPath() {
-  console.log('Schema location:');
-  console.log(`  ${schemaSource}`);
-  console.log('');
-  console.log('Copy manually:');
-  console.log(`  cp "${schemaSource}" ./prisma/auth-schema.prisma`);
+  const orm = resolveORMForInit();
+
+  if (orm === 'prisma') {
+    console.log('Prisma schema location:');
+    console.log(`  ${schemaSource}`);
+    console.log('');
+    console.log('Copy manually:');
+    console.log(`  cp "${schemaSource}" ./prisma/auth-schema.prisma`);
+  } else if (orm === 'drizzle') {
+    console.log('Drizzle schema:');
+    console.log('  Run: npx @factiii/auth init --drizzle');
+    console.log('  This generates a TypeScript schema file with all required tables.');
+  }
 }
 
 // ANSI color codes
@@ -182,6 +456,56 @@ function parseReferenceSchema() {
   return { models, enums, modelFields };
 }
 
+/**
+ * Detect which ORM the consumer's project uses.
+ * Returns 'prisma' | 'drizzle' | 'both' | 'none'.
+ */
+function detectORM(deps) {
+  const hasPrisma = Boolean(deps['@prisma/client']);
+  const hasDrizzle = Boolean(deps['drizzle-orm']);
+  if (hasPrisma && hasDrizzle) return 'both';
+  if (hasPrisma) return 'prisma';
+  if (hasDrizzle) return 'drizzle';
+  return 'none';
+}
+
+/**
+ * Look for Drizzle schema files (*.ts files exporting table definitions).
+ * Common patterns: src/db/schema.ts, drizzle/schema.ts, src/schema.ts
+ */
+function findDrizzleSchema() {
+  const candidates = [
+    'src/db/schema.ts',
+    'src/db/schema/index.ts',
+    'src/schema.ts',
+    'drizzle/schema.ts',
+    'db/schema.ts',
+    'src/db/schema.js',
+    'drizzle/schema.js',
+  ];
+
+  for (const candidate of candidates) {
+    const fullPath = resolve(process.cwd(), candidate);
+    if (existsSync(fullPath)) {
+      return { found: true, location: candidate };
+    }
+  }
+  return { found: false, location: '' };
+}
+
+/**
+ * Check for drizzle config file (drizzle.config.ts or drizzle.config.js)
+ */
+function findDrizzleConfig() {
+  const candidates = ['drizzle.config.ts', 'drizzle.config.js', 'drizzle.config.mjs'];
+  for (const candidate of candidates) {
+    if (existsSync(resolve(process.cwd(), candidate))) {
+      return { found: true, location: candidate };
+    }
+  }
+  return { found: false, location: '' };
+}
+
 function doctor() {
   console.log(`${colors.bold}${colors.cyan}Running diagnostics...${colors.reset}\n`);
 
@@ -197,24 +521,38 @@ function doctor() {
     process.exit(1);
   }
 
-  // Check 1: package.json exists
+  // Check 1: package.json exists and detect ORM
   const packageJsonPath = resolve(process.cwd(), 'package.json');
+  let orm = 'none';
+
   if (!existsSync(packageJsonPath)) {
     fail('No package.json found in current directory');
     issues++;
   } else {
     ok('package.json found');
 
-    // Check for @prisma/client dependency
     try {
       const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-      if (deps['@prisma/client']) {
-        ok('@prisma/client is installed');
-      } else {
-        fail('@prisma/client not found in dependencies');
-        hint('Run: npm install @prisma/client');
-        issues++;
+      orm = detectORM(deps);
+
+      switch (orm) {
+        case 'prisma':
+          ok('@prisma/client found — using Prisma adapter');
+          break;
+        case 'drizzle':
+          ok('drizzle-orm found — using Drizzle adapter');
+          break;
+        case 'both':
+          ok('@prisma/client and drizzle-orm both found');
+          hint('You can use either createPrismaAdapter() or createDrizzleAdapter()');
+          break;
+        case 'none':
+          fail('No ORM detected — install @prisma/client or drizzle-orm');
+          hint('Prisma:  npm install @prisma/client prisma');
+          hint('Drizzle: npm install drizzle-orm');
+          issues++;
+          break;
       }
     } catch (e) {
       warn('Could not parse package.json');
@@ -222,70 +560,117 @@ function doctor() {
     }
   }
 
-  // Check 2: Prisma schema exists (supports single file and modularized schemas)
-  const { found: schemaFound, schemaContent: schema, location: schemaLocation } = findPrismaSchema();
-  if (!schemaFound) {
-    fail('No Prisma schema found');
-    hint('Checked: prisma/schema.prisma, prisma/schema/*.prisma, prisma/*.prisma');
-    hint('Run: npx @factiii/auth init');
-    issues++;
-  } else {
-    ok(`Prisma schema found (${schemaLocation})`);
-
-    // Parse user's schema
-    try {
-      // Check models
-      for (const model of reference.models) {
-        const regex = new RegExp(`model\\s+${model}\\s*\\{`, 'm');
-        if (regex.test(schema)) {
-          ok(`Model ${colors.cyan}${model}${colors.reset} found`);
-        } else {
-          fail(`Model ${colors.cyan}${model}${colors.reset} not found in schema`);
-          issues++;
+  // Check 2: ORM-specific schema checks
+  if (orm === 'prisma' || orm === 'both') {
+    console.log(`\n${colors.bold}Prisma checks:${colors.reset}`);
+
+    const { found: schemaFound, schemaContent: schema, location: schemaLocation } = findPrismaSchema();
+    if (!schemaFound) {
+      fail('No Prisma schema found');
+      hint('Checked: prisma/schema.prisma, prisma/schema/*.prisma, prisma/*.prisma');
+      hint('Run: npx @factiii/auth init');
+      issues++;
+    } else {
+      ok(`Prisma schema found (${schemaLocation})`);
+
+      try {
+        // Check models
+        for (const model of reference.models) {
+          const regex = new RegExp(`model\\s+${model}\\s*\\{`, 'm');
+          if (regex.test(schema)) {
+            ok(`Model ${colors.cyan}${model}${colors.reset} found`);
+          } else {
+            fail(`Model ${colors.cyan}${model}${colors.reset} not found in schema`);
+            issues++;
+          }
         }
-      }
 
-      // Check enums
-      for (const enumName of reference.enums) {
-        const regex = new RegExp(`enum\\s+${enumName}\\s*\\{`, 'm');
-        if (regex.test(schema)) {
-          ok(`Enum ${colors.cyan}${enumName}${colors.reset} found`);
-        } else {
-          fail(`Enum ${colors.cyan}${enumName}${colors.reset} not found in schema`);
-          issues++;
+        // Check enums
+        for (const enumName of reference.enums) {
+          const regex = new RegExp(`enum\\s+${enumName}\\s*\\{`, 'm');
+          if (regex.test(schema)) {
+            ok(`Enum ${colors.cyan}${enumName}${colors.reset} found`);
+          } else {
+            fail(`Enum ${colors.cyan}${enumName}${colors.reset} not found in schema`);
+            issues++;
+          }
         }
-      }
 
-      // Check fields for each model
-      for (const [model, fields] of Object.entries(reference.modelFields)) {
-        const modelMatch = schema.match(new RegExp(`model\\s+${model}\\s*\\{([^}]+)\\}`, 'm'));
-        if (modelMatch) {
-          const block = modelMatch[1];
-          for (const field of fields) {
-            const fieldRegex = new RegExp(`\\b${field}\\b`, 'm');
-            if (!fieldRegex.test(block)) {
-              warn(`${model}.${colors.cyan}${field}${colors.reset} field not found`);
-              warnings++;
+        // Check fields for each model
+        for (const [model, fields] of Object.entries(reference.modelFields)) {
+          const modelMatch = schema.match(new RegExp(`model\\s+${model}\\s*\\{([^}]+)\\}`, 'm'));
+          if (modelMatch) {
+            const block = modelMatch[1];
+            for (const field of fields) {
+              const fieldRegex = new RegExp(`\\b${field}\\b`, 'm');
+              if (!fieldRegex.test(block)) {
+                warn(`${model}.${colors.cyan}${field}${colors.reset} field not found`);
+                warnings++;
+              }
             }
           }
         }
+      } catch (e) {
+        warn('Could not parse Prisma schema');
+        warnings++;
       }
-    } catch (e) {
-      warn('Could not parse Prisma schema');
+    }
+  }
+
+  if (orm === 'drizzle' || orm === 'both') {
+    console.log(`\n${colors.bold}Drizzle checks:${colors.reset}`);
+
+    const drizzleConfig = findDrizzleConfig();
+    if (drizzleConfig.found) {
+      ok(`Drizzle config found (${drizzleConfig.location})`);
+    } else {
+      warn('No drizzle.config.ts found (optional but recommended for migrations)');
+      warnings++;
+    }
+
+    const drizzleSchema = findDrizzleSchema();
+    if (drizzleSchema.found) {
+      ok(`Drizzle schema found (${drizzleSchema.location})`);
+    } else {
+      warn('No Drizzle schema file found');
+      hint('Expected in: src/db/schema.ts, drizzle/schema.ts, or src/schema.ts');
+      hint('See SETUP.md for required table definitions');
       warnings++;
     }
+
+    // Check that required tables are referenced (basic text scan of schema file)
+    if (drizzleSchema.found) {
+      try {
+        const schemaContent = readFileSync(resolve(process.cwd(), drizzleSchema.location), 'utf-8');
+        const requiredTables = ['users', 'sessions', 'admins', 'passwordResets', 'otps', 'devices'];
+        for (const table of requiredTables) {
+          // Look for pgTable/mysqlTable/sqliteTable calls or export names
+          const tableRegex = new RegExp(`(?:Table|export).*${table}`, 'i');
+          if (tableRegex.test(schemaContent)) {
+            ok(`Table ${colors.cyan}${table}${colors.reset} found`);
+          } else {
+            warn(`Table ${colors.cyan}${table}${colors.reset} not found in schema`);
+            hint(`createDrizzleAdapter() expects a '${table}' table reference`);
+            warnings++;
+          }
+        }
+      } catch (e) {
+        warn('Could not read Drizzle schema file');
+        warnings++;
+      }
+    }
   }
 
   // Summary
   console.log(`\n${colors.bold}--- Summary ---${colors.reset}`);
   if (issues === 0 && warnings === 0) {
-    console.log(`${colors.green}${colors.bold}✓ All checks passed!${colors.reset} Your setup looks good.`);
+    console.log(`${colors.green}${colors.bold}All checks passed!${colors.reset} Your setup looks good.`);
   } else {
     if (issues > 0) {
-      console.log(`${colors.red}${colors.bold}✗ ${issues} issue(s) found${colors.reset}`);
+      console.log(`${colors.red}${colors.bold}${issues} issue(s) found${colors.reset}`);
     }
     if (warnings > 0) {
-      console.log(`${colors.yellow}${colors.bold}⚠ ${warnings} warning(s) found${colors.reset}`);
+      console.log(`${colors.yellow}${colors.bold}${warnings} warning(s) found${colors.reset}`);
     }
   }
 

package/dist/{chunk-EHI4P63M.mjs → chunk-KUYH4DBN.mjs}

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/validators.ts
 import { z } from "zod";
 var usernameValidationRegex = /^[a-zA-Z0-9_]+$/;
@@ -77,6 +84,7 @@ function createSchemas(extensions) {
 }
 
 export {
+  __require,
   signupSchema,
   loginSchema,
   oAuthLoginSchema,