google-oauth-cli-generator
Version:
CLI tool to quickly set up Google OAuth authentication for hackathons and projects
246 lines (213 loc) • 6.43 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateMongoTemplate = generateMongoTemplate;
const fs_extra_1 = __importDefault(require("fs-extra"));
const path_1 = __importDefault(require("path"));
async function generateMongoTemplate(data) {
const { projectPath } = data;
const backendPath = path_1.default.join(projectPath, 'backend');
// Generate database config
const databaseConfigTs = `import mongoose from 'mongoose';
export async function connectDatabase(): Promise<void> {
try {
const mongoUri = process.env.MONGODB_URI || 'mongodb://localhost:27017/auth-app';
await mongoose.connect(mongoUri);
console.log('✅ Connected to MongoDB');
} catch (error) {
console.error('❌ MongoDB connection error:', error);
throw error;
}
}
// Graceful shutdown
process.on('SIGINT', async () => {
await mongoose.connection.close();
console.log('MongoDB connection closed.');
process.exit(0);
});`;
await fs_extra_1.default.writeFile(path_1.default.join(backendPath, 'src', 'config', 'database.ts'), databaseConfigTs);
// Generate User model
const userModelTs = `import mongoose, { Schema, Document } from 'mongoose';
export interface IUser extends Document {
googleId: string;
name: string;
email: string;
picture: string;
createdAt: Date;
updatedAt: Date;
}
const UserSchema: Schema = new Schema({
googleId: {
type: String,
required: true,
unique: true,
index: true
},
name: {
type: String,
required: true,
trim: true
},
email: {
type: String,
required: true,
unique: true,
lowercase: true,
trim: true
},
picture: {
type: String,
required: true
}
}, {
timestamps: true
});
// Indexes for better query performance
UserSchema.index({ email: 1 });
UserSchema.index({ googleId: 1 });
const UserModel = mongoose.model<IUser>('User', UserSchema);
export class User {
static async findByGoogleId(googleId: string): Promise<IUser | null> {
return UserModel.findOne({ googleId });
}
static async findByEmail(email: string): Promise<IUser | null> {
return UserModel.findOne({ email });
}
static async create(userData: {
id: string;
name: string;
email: string;
picture: string;
}): Promise<IUser> {
const user = new UserModel({
googleId: userData.id,
name: userData.name,
email: userData.email,
picture: userData.picture
});
return user.save();
}
static async update(googleId: string, userData: {
name: string;
email: string;
picture: string;
}): Promise<IUser | null> {
return UserModel.findOneAndUpdate(
{ googleId },
{
name: userData.name,
email: userData.email,
picture: userData.picture
},
{ new: true }
);
}
static async delete(googleId: string): Promise<boolean> {
const result = await UserModel.deleteOne({ googleId });
return result.deletedCount > 0;
}
static async findAll(): Promise<IUser[]> {
return UserModel.find({}).sort({ createdAt: -1 });
}
static async count(): Promise<number> {
return UserModel.countDocuments();
}
}
export default UserModel;`;
await fs_extra_1.default.writeFile(path_1.default.join(backendPath, 'src', 'models', 'User.ts'), userModelTs);
// Generate database utilities
const dbUtilsTs = `import mongoose from 'mongoose';
export class DatabaseUtils {
static async isConnected(): Promise<boolean> {
return mongoose.connection.readyState === 1;
}
static async ping(): Promise<boolean> {
try {
await mongoose.connection.db.admin().ping();
return true;
} catch (error) {
return false;
}
}
static getConnectionState(): string {
const states = {
0: 'disconnected',
1: 'connected',
2: 'connecting',
3: 'disconnecting'
};
return states[mongoose.connection.readyState as keyof typeof states] || 'unknown';
}
static async dropDatabase(): Promise<void> {
if (process.env.NODE_ENV !== 'test') {
throw new Error('Database can only be dropped in test environment');
}
await mongoose.connection.db.dropDatabase();
}
static async clearCollection(collectionName: string): Promise<void> {
if (process.env.NODE_ENV !== 'test') {
throw new Error('Collections can only be cleared in test environment');
}
await mongoose.connection.db.collection(collectionName).deleteMany({});
}
}`;
await fs_extra_1.default.writeFile(path_1.default.join(backendPath, 'src', 'config', 'db-utils.ts'), dbUtilsTs);
// Generate database seeds (optional)
const seedsTs = `import { User } from '../models/User';
import { connectDatabase } from './database';
interface SeedUser {
googleId: string;
name: string;
email: string;
picture: string;
}
const seedUsers: SeedUser[] = [
{
googleId: 'demo_user_1',
name: 'Demo User',
email: 'demo@example.com',
picture: 'https://via.placeholder.com/150'
}
];
export async function seedDatabase(): Promise<void> {
try {
console.log('🌱 Seeding database...');
await connectDatabase();
// Clear existing data
const userCount = await User.count();
if (userCount > 0) {
console.log(\`⚠️ Database already has \${userCount} users. Skipping seed.\`);
return;
}
// Create seed users
for (const userData of seedUsers) {
await User.create({
id: userData.googleId,
name: userData.name,
email: userData.email,
picture: userData.picture
});
}
console.log(\`✅ Created \${seedUsers.length} seed users\`);
} catch (error) {
console.error('❌ Error seeding database:', error);
throw error;
}
}
// Run seeds if called directly
if (require.main === module) {
seedDatabase()
.then(() => {
console.log('✅ Database seeded successfully');
process.exit(0);
})
.catch((error) => {
console.error('❌ Seeding failed:', error);
process.exit(1);
});
}`;
await fs_extra_1.default.writeFile(path_1.default.join(backendPath, 'src', 'config', 'seeds.ts'), seedsTs);
}
//# sourceMappingURL=mongo-template.js.map