npm - vibefast-cli - Versions diffs - 0.2.4 → 0.3.1 - Mend

vibefast-cli 0.2.4 → 0.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (892) hide show

package/2/packages/backend/convex/authCustomEmailOtpProvider.ts ADDED Viewed

@@ -0,0 +1,175 @@
+'use node';
+import type { EmailConfig } from '@auth/core/providers/email';
+// Import configuration constants
+import { APP_CONFIG, EMAIL_CONFIG, getDefaultFromEmail } from './lib/config';
+/**
+ * Generate a numeric OTP of specified length.
+ * Uses crypto.getRandomValues for cryptographically secure random numbers.
+ */
+function generateNumericOtp(length: number): string {
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    result += crypto.getRandomValues(new Uint32Array(1))[0] % 10;
+  }
+  return result;
+}
+/**
+ * Create HTML email template for OTP verification
+ */
+function createOtpEmailTemplate(token: string): string {
+  return `
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+      <meta charset="UTF-8">
+      <meta name="viewport" content="width=device-width, initial-scale=1.0">
+      <title>Email Verification</title>
+      <style>
+        body {
+          font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+          margin: 0;
+          padding: 0;
+          background-color: #f3f4f6;
+        }
+        .container {
+          max-width: 600px;
+          margin: 0 auto;
+          background-color: #ffffff;
+          border-radius: 8px;
+          box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+          overflow: hidden;
+        }
+        .header {
+          background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+          color: white;
+          padding: 30px;
+          text-align: center;
+        }
+        .logo {
+          font-size: 28px;
+          font-weight: bold;
+          margin-bottom: 10px;
+        }
+        .header h1 {
+          margin: 0;
+          font-size: 24px;
+        }
+        .content {
+          padding: 30px;
+        }
+        .otp-code {
+          background: #f8fafc;
+          border: 2px solid #e2e8f0;
+          border-radius: 8px;
+          padding: 20px;
+          text-align: center;
+          margin: 25px 0;
+        }
+        .otp-number {
+          font-size: 32px;
+          font-weight: bold;
+          letter-spacing: 8px;
+          color: #1f2937;
+          font-family: 'Courier New', monospace;
+        }
+        .warning {
+          background: #fef3c7;
+          border-left: 4px solid #f59e0b;
+          padding: 12px;
+          margin: 20px 0;
+          border-radius: 4px;
+        }
+        .footer {
+          margin-top: 30px;
+          padding-top: 20px;
+          border-top: 1px solid #e5e7eb;
+          font-size: 12px;
+          color: #6b7280;
+          text-align: center;
+        }
+      </style>
+    </head>
+    <body>
+      <div class="container">
+        <div class="header">
+          <div class="logo">${APP_CONFIG.NAME}</div>
+          <h1>Verify Your Email Address</h1>
+        </div>
+        <p>Hello,</p>
+        <p>To complete your account setup, please use the verification code below:</p>
+        <div class="otp-code">
+          <div class="otp-number">${token}</div>
+        </div>
+        <div class="warning">
+          <strong>Important:</strong> This code will expire in ${Math.floor(
+            EMAIL_CONFIG.OTP.EXPIRY_SECONDS / 60,
+          )} minutes. Do not share this code with anyone.
+        </div>
+        <p>If you didn't request this verification code, please ignore this email.</p>
+        <div class="footer">
+          <p>This email was sent by ${APP_CONFIG.NAME}. If you have any questions, please contact our support team.</p>
+        </div>
+      </div>
+    </body>
+    </html>
+  `;
+}
+export const customEmailProvider: EmailConfig & {
+  generateVerificationToken: () => Promise<string>;
+} = {
+  id: 'email-otp',
+  type: 'email',
+  name: 'VibeFast Email OTP',
+  maxAge: EMAIL_CONFIG.OTP.EXPIRY_SECONDS,
+  options: {},
+  generateVerificationToken: async () => {
+    return generateNumericOtp(EMAIL_CONFIG.OTP.LENGTH);
+  },
+  async sendVerificationRequest(params: {
+    identifier: string;
+    url: string;
+    expires: Date;
+    provider: EmailConfig;
+    token: string;
+    theme: any;
+  }) {
+    const { identifier: email, token } = params;
+    const { Resend } = await import('resend');
+    const resend = new Resend(process.env.AUTH_RESEND_KEY!);
+    const { error } = await resend.emails.send({
+      from: getDefaultFromEmail(),
+      to: [email],
+      subject: EMAIL_CONFIG.SUBJECTS.EMAIL_VERIFICATION,
+      text: `Your verification code is: ${token}. This code will expire in ${Math.floor(
+        EMAIL_CONFIG.OTP.EXPIRY_SECONDS / 60,
+      )} minutes.`,
+      html: createOtpEmailTemplate(token),
+    });
+    if (error) {
+      throw new Error(
+        `Could not send verification email via Resend: ${JSON.stringify(error)}`,
+      );
+    }
+  },
+};
+export function getEmailOtpProvider() {
+  if (!process.env.AUTH_RESEND_KEY) {
+    throw new Error(
+      'Resend email provider requires AUTH_RESEND_KEY environment variable',
+    );
+  }
+  return customEmailProvider;
+}

package/2/packages/backend/convex/authOtp.ts ADDED Viewed

@@ -0,0 +1,144 @@
+import { v } from 'convex/values';
+import { api, internal } from './_generated/api'; // Import the generated API
+import { action, internalMutation, internalQuery } from './_generated/server';
+import { getEmailOtpProvider } from './authCustomEmailOtpProvider';
+import { AUTH_CONFIG } from './lib/config';
+export const signUpWithOtp = action({
+  args: {
+    name: v.optional(v.string()),
+    email: v.string(),
+    password: v.string(),
+  },
+  handler: async (
+    ctx,
+    { name, email, password },
+  ): Promise<{ navigateToOtp: boolean; sessionId?: any }> => {
+    // Validate password length
+    if (password.length < 8) {
+      throw new Error('Password must be at least 8 characters long');
+    }
+    if (AUTH_CONFIG.SEND_OTP_ON_SIGNUP) {
+      const emailOtpProvider = getEmailOtpProvider();
+      if (!emailOtpProvider) {
+        throw new Error('Email OTP provider is not configured.');
+      }
+      if (typeof emailOtpProvider.generateVerificationToken !== 'function') {
+        throw new Error(
+          'generateVerificationToken is not a function on the email OTP provider.',
+        );
+      }
+      const token = await emailOtpProvider.generateVerificationToken();
+      await ctx.runMutation(internal.authOtp.createOtp, {
+        email,
+        token,
+      });
+      await emailOtpProvider.sendVerificationRequest({
+        identifier: email,
+        token,
+        url: 'http://localhost', // Dummy URL, as it's required by the type
+        expires: new Date(Date.now() + 10 * 60 * 1000), // Dummy expiry, as it's required by the type
+        provider: emailOtpProvider, // Pass the actual provider config
+        theme: {}, // Dummy theme, as it's required by the type
+        request: {} as any, // Dummy request object, as it's required by the type
+      });
+      return { navigateToOtp: true };
+    }
+    // Call the signIn action using ctx.runAction
+    const result: any = await ctx.runAction(api.auth.signIn, {
+      provider: 'password',
+      params: {
+        email,
+        password,
+        name,
+        flow: 'signUp',
+      },
+    });
+    // Assuming signIn action returns a session object or similar
+    return { navigateToOtp: false, sessionId: result.sessionId };
+  },
+});
+export const verifyOtpAndCreateUser = action({
+  args: {
+    email: v.string(),
+    otp: v.string(),
+    name: v.optional(v.string()),
+    password: v.string(),
+  },
+  handler: async (
+    ctx,
+    { email, otp, name, password },
+  ): Promise<{ success: boolean; error?: string; sessionId?: any }> => {
+    // Validate password length
+    if (password.length < 8) {
+      return {
+        success: false,
+        error: 'Password must be at least 8 characters long',
+      };
+    }
+    const otpRecord = await ctx.runQuery(internal.authOtp.getOtp, {
+      email,
+      otp,
+    });
+    if (!otpRecord) {
+      return { success: false, error: 'Invalid OTP.' };
+    }
+    if (otpRecord.expires < Date.now()) {
+      return { success: false, error: 'OTP has expired.' };
+    }
+    await ctx.runMutation(internal.authOtp.deleteOtp, { id: otpRecord._id });
+    // Call the signIn action using ctx.runAction
+    const result: any = await ctx.runAction(api.auth.signIn, {
+      provider: 'password',
+      params: {
+        flow: 'signUp',
+        email,
+        password,
+        name,
+      },
+    });
+    return { success: true, sessionId: result.sessionId };
+  },
+});
+export const createOtp = internalMutation({
+  args: { email: v.string(), token: v.string() },
+  handler: async (ctx, { email, token }) => {
+    await ctx.db.insert('otps', {
+      email,
+      token,
+      expires: Date.now() + 10 * 60 * 1000, // 10 minutes
+    });
+  },
+});
+export const getOtp = internalQuery({
+  args: { email: v.string(), otp: v.string() },
+  handler: async (ctx, { email, otp }) => {
+    return await ctx.db
+      .query('otps')
+      .withIndex('by_email_and_token', (q) =>
+        q.eq('email', email).eq('token', otp),
+      )
+      .first();
+  },
+});
+export const deleteOtp = internalMutation({
+  args: { id: v.id('otps') },
+  handler: async (ctx, { id }) => {
+    await ctx.db.delete(id);
+  },
+});

package/2/packages/backend/convex/authPasswordReset.ts ADDED Viewed

@@ -0,0 +1,367 @@
+import { v } from 'convex/values';
+import { internalMutation, internalQuery, query } from './_generated/server';
+// Note: The requestPasswordReset action is in passwordResetActions.ts
+// because it requires Node.js crypto APIs
+/**
+ * Internal helper query to find user by email.
+ */
+export const findUserByEmail = internalQuery({
+  args: { email: v.string() },
+  returns: v.union(
+    v.object({
+      _id: v.id('users'),
+      _creationTime: v.number(),
+      name: v.optional(v.string()),
+      email: v.optional(v.string()),
+      phone: v.optional(v.string()),
+      image: v.optional(v.string()),
+      emailVerificationTime: v.optional(v.number()),
+      phoneVerificationTime: v.optional(v.number()),
+      isAnonymous: v.optional(v.boolean()),
+      emailVerified: v.optional(v.number()),
+      credits: v.optional(v.number()),
+    }),
+    v.null(),
+  ),
+  handler: async (ctx, { email }) => {
+    return await ctx.db
+      .query('users')
+      .withIndex('email', (q) => q.eq('email', email.toLowerCase()))
+      .first();
+  },
+});
+/**
+ * Internal helper mutation to store a password reset token.
+ */
+export const internalStoreToken = internalMutation({
+  args: {
+    userId: v.id('users'),
+    token: v.string(),
+    expiresAt: v.number(),
+  },
+  returns: v.id('passwordResetTokens'),
+  handler: async (ctx, args) => {
+    // Invalidate any existing unused tokens for this user
+    const existingTokens = await ctx.db
+      .query('passwordResetTokens')
+      .withIndex('by_userId_and_used', (q) =>
+        q.eq('userId', args.userId).eq('used', false),
+      )
+      .collect();
+    for (const token of existingTokens) {
+      await ctx.db.patch(token._id, { used: true });
+    }
+    // Create new token
+    return await ctx.db.insert('passwordResetTokens', {
+      userId: args.userId,
+      token: args.token,
+      expiresAt: args.expiresAt,
+      used: false,
+    });
+  },
+});
+/**
+ * Helper function for tests - get token by ID
+ */
+export const getTokenById = internalQuery({
+  args: { tokenId: v.id('passwordResetTokens') },
+  returns: v.union(
+    v.object({
+      _id: v.id('passwordResetTokens'),
+      _creationTime: v.number(),
+      userId: v.id('users'),
+      token: v.string(),
+      expiresAt: v.number(),
+      used: v.boolean(),
+    }),
+    v.null(),
+  ),
+  handler: async (ctx, { tokenId }) => {
+    return await ctx.db.get(tokenId);
+  },
+});
+/**
+ * Helper function for tests - mark token as used
+ */
+export const markTokenAsUsed = internalMutation({
+  args: { tokenId: v.id('passwordResetTokens') },
+  returns: v.null(),
+  handler: async (ctx, { tokenId }) => {
+    await ctx.db.patch(tokenId, { used: true });
+    return null;
+  },
+});
+/**
+ * Helper function for tests - get all active tokens
+ */
+export const getAllActiveTokens = internalQuery({
+  args: {},
+  returns: v.array(
+    v.object({
+      _id: v.id('passwordResetTokens'),
+      _creationTime: v.number(),
+      userId: v.id('users'),
+      token: v.string(),
+      expiresAt: v.number(),
+      used: v.boolean(),
+    }),
+  ),
+  handler: async (ctx) => {
+    return await ctx.db
+      .query('passwordResetTokens')
+      .withIndex('by_used', (q) => q.eq('used', false))
+      .collect();
+  },
+});
+/**
+ * Helper function for tests - clear test data
+ * Uses batching to avoid timeout
+ */
+export const clearTestData = internalMutation({
+  args: {},
+  returns: v.null(),
+  handler: async (ctx) => {
+    // Clear all password reset tokens in batches
+    const BATCH_SIZE = 100;
+    while (true) {
+      const tokens = await ctx.db.query('passwordResetTokens').take(BATCH_SIZE);
+      if (tokens.length === 0) {
+        break;
+      }
+      for (const token of tokens) {
+        await ctx.db.delete(token._id);
+      }
+      if (tokens.length < BATCH_SIZE) {
+        break;
+      }
+    }
+    return null;
+  },
+});
+/**
+ * Internal query for password reset token verification (used by actions)
+ */
+export const verifyPasswordResetTokenInternal = internalQuery({
+  args: { token: v.string() },
+  returns: v.object({
+    valid: v.boolean(),
+    userId: v.union(v.id('users'), v.null()),
+    error: v.optional(v.string()),
+  }),
+  handler: async (ctx, { token }) => {
+    const tokenDoc = await ctx.db
+      .query('passwordResetTokens')
+      .withIndex('by_token', (q) => q.eq('token', token))
+      .first();
+    if (!tokenDoc || tokenDoc.used || tokenDoc.expiresAt < Date.now()) {
+      return { valid: false, userId: null, error: 'Invalid or expired token.' };
+    }
+    return { valid: true, userId: tokenDoc.userId };
+  },
+});
+/**
+ * Helper query to get user by ID
+ */
+export const getUserById = internalQuery({
+  args: { userId: v.id('users') },
+  returns: v.union(
+    v.object({
+      _id: v.id('users'),
+      _creationTime: v.number(),
+      name: v.optional(v.string()),
+      email: v.optional(v.string()),
+      phone: v.optional(v.string()),
+      image: v.optional(v.string()),
+      emailVerificationTime: v.optional(v.number()),
+      phoneVerificationTime: v.optional(v.number()),
+      isAnonymous: v.optional(v.boolean()),
+      emailVerified: v.optional(v.number()),
+      credits: v.optional(v.number()),
+    }),
+    v.null(),
+  ),
+  handler: async (ctx, { userId }) => {
+    return await ctx.db.get(userId);
+  },
+});
+/**
+ * Helper query to get password account for user
+ */
+export const getPasswordAccountForUser = internalQuery({
+  args: { userId: v.id('users') },
+  returns: v.union(
+    v.object({
+      _id: v.id('authAccounts'),
+      _creationTime: v.number(),
+      userId: v.id('users'),
+      provider: v.string(),
+      providerAccountId: v.string(),
+      secret: v.optional(v.string()),
+    }),
+    v.null(),
+  ),
+  handler: async (ctx, { userId }) => {
+    // Note: authAccounts table doesn't have a compound index yet
+    // This is from @convex-dev/auth package, so we use filter
+    return await ctx.db
+      .query('authAccounts')
+      .filter((q) =>
+        q.and(
+          q.eq(q.field('userId'), userId),
+          q.eq(q.field('provider'), 'password'),
+        ),
+      )
+      .first();
+  },
+});
+/**
+ * Helper mutation to update password hash
+ */
+export const updatePasswordHash = internalMutation({
+  args: {
+    accountId: v.id('authAccounts'),
+    newHash: v.string(),
+  },
+  returns: v.null(),
+  handler: async (ctx, { accountId, newHash }) => {
+    await ctx.db.patch(accountId, {
+      secret: newHash,
+    });
+    return null;
+  },
+});
+/**
+ * Helper mutation to mark token as used by token string
+ */
+export const markTokenAsUsedByToken = internalMutation({
+  args: { token: v.string() },
+  returns: v.null(),
+  handler: async (ctx, { token }) => {
+    const tokenDoc = await ctx.db
+      .query('passwordResetTokens')
+      .withIndex('by_token', (q) => q.eq('token', token))
+      .first();
+    if (tokenDoc) {
+      await ctx.db.patch(tokenDoc._id, { used: true });
+    }
+    return null;
+  },
+});
+/**
+ * Verifies a password reset token's validity.
+ */
+export const verifyPasswordResetToken = query({
+  args: { token: v.string() },
+  returns: v.object({
+    valid: v.boolean(),
+    userId: v.union(v.id('users'), v.null()),
+    error: v.optional(v.string()),
+  }),
+  handler: async (ctx, { token }) => {
+    const tokenDoc = await ctx.db
+      .query('passwordResetTokens')
+      .withIndex('by_token', (q) => q.eq('token', token))
+      .first();
+    if (!tokenDoc || tokenDoc.used || tokenDoc.expiresAt < Date.now()) {
+      return { valid: false, userId: null, error: 'Invalid or expired token.' };
+    }
+    return { valid: true, userId: tokenDoc.userId };
+  },
+});
+/**
+ * Helper function for tests - create a test user
+ */
+export const createTestUser = internalMutation({
+  args: {
+    email: v.string(),
+    name: v.optional(v.string()),
+  },
+  returns: v.id('users'),
+  handler: async (ctx, { email, name }) => {
+    return await ctx.db.insert('users', {
+      email: email.toLowerCase(),
+      name,
+      emailVerified: Date.now(),
+    });
+  },
+});
+/**
+ * Helper function for tests - create a password account for a user
+ */
+export const createTestPasswordAccount = internalMutation({
+  args: {
+    userId: v.id('users'),
+    email: v.string(),
+    password: v.string(),
+  },
+  returns: v.id('authAccounts'),
+  handler: async (ctx, { userId, email, password }) => {
+    // Simple hash for testing - NOT secure, only for tests
+    const simpleHash = `test_hash_${password}_${Date.now()}`;
+    return await ctx.db.insert('authAccounts', {
+      userId,
+      provider: 'password',
+      providerAccountId: email.toLowerCase(),
+      secret: simpleHash,
+    });
+  },
+});
+/**
+ * Helper mutation to delete a password account
+ */
+export const deletePasswordAccount = internalMutation({
+  args: {
+    accountId: v.id('authAccounts'),
+  },
+  returns: v.null(),
+  handler: async (ctx, { accountId }) => {
+    await ctx.db.delete(accountId);
+    return null;
+  },
+});
+/**
+ * Helper mutation to create a new password account (without hashing - hash should be provided)
+ */
+export const createPasswordAccount = internalMutation({
+  args: {
+    userId: v.id('users'),
+    email: v.string(),
+    hashedPassword: v.string(),
+  },
+  returns: v.id('authAccounts'),
+  handler: async (ctx, { userId, email, hashedPassword }) => {
+    return await ctx.db.insert('authAccounts', {
+      userId,
+      provider: 'password',
+      providerAccountId: email.toLowerCase(),
+      secret: hashedPassword,
+    });
+  },
+});