mongoose-seeder-ts v0.2.0

Mongoose Seeder TS

🌱 A robust, TypeScript-first MongoDB seeder built on top of Mongoose. Perfect for seeding test data, bootstrapping databases, and managing data migrations.

Keywords: mongodb, mongoose, seed, database, typescript, nodejs, data-seeding, testing, development, migration

A TypeScript-based MongoDB seeder that leverages Mongoose validation for reliable data seeding.

Installation

npm install mongoose-seed
# or
yarn add mongoose-seed

Features

• Full TypeScript support
• Modern async/await API
• Mongoose validation
• Customizable logging
• Connection options support

Basic Example

import { Seeder } from 'mongoose-seed';
import mongoose from 'mongoose';

// Define models
interface IUserBase {
  name: string;
  email: string;
  isActive: boolean;
}

interface IUser extends IUserBase, Document {}

interface IUserModel extends Model<IUser> {}

interface IProductBase {
  name: string;
  price: number;
  inStock: boolean;
}

interface IProduct extends IProductBase, Document {}

interface IProductModel extends Model<IProduct> {}

const userSchema = new Schema<IUser>({
  name: {
    type: String,
    required: true,
    trim: true
  },
  email: {
    type: String, 
    required: true,
    unique: true,
    trim: true
  },
  isActive: {
    type: Boolean,
    default: true
  }
});

const productSchema = new Schema<IProduct>({
  name: {
    type: String,
    required: true,
    trim: true
  },
  price: {
    type: Number,
    required: true
  },
  inStock: {
    type: Boolean,
    default: false
  }
});

export const UserModel = model<IUser, IUserModel>('User', userSchema);
export const ProductModel = model<IProduct, IProductModel>('Product', productSchema);

async function seed() {
  // Initialize seeder
  const seeder = new Seeder(mongoose);
  
  try {
    // Connect to MongoDB
    await seeder.connect('mongodb://localhost/sample-dev', {
      useNewUrlParser: true
    });

    // Load Mongoose models
    seeder.loadModels([UserModel, ProductModel]);

    // Clear specified collections
    await seeder.clearModels(['User', 'Product']);

    // Seed data
    await seeder.populateModels([
      {
        model: 'User',
        documents: [
          {
            name: 'John Doe',
            email: 'john@example.com',
            isActive: true
          },
          {
            name: 'Jane Smith',
            email: 'jane@example.com',
            isActive: true
          }
        ]
      },
      {
        model: 'Product',
        documents: [
          {
            name: 'Product 1',
            price: 99.99,
            inStock: true
          }
        ]
      }
    ]);

    console.log('Database seeded successfully!');
  } catch (error) {
    console.error('Error seeding database:', error);
  }
}

seed();

API Reference

Constructor

new Seeder(mongoose: Mongoose, logger?: Logger)

Creates a new seeder instance. You can optionally provide a custom logger.

Methods

connect(db: string, options?: MongooseConnectionOptions): Promise

Connects to MongoDB using the provided connection string and options.

await seeder.connect('mongodb://localhost/db', {
  useNewUrlParser: true,
  // ... other mongoose options
});

loadModels(models: Model[]): Seeder

Loads Mongoose models into the seeder. Only loaded models can be cleared or populated.

seeder.loadModels([UserModel, ProductModel]);

clearModels(modelNames: string[]): Promise

Clears the specified collections.

await seeder.clearModels(['User', 'Product']);

populateModels(data: SeedData[]): Promise

Populates collections with the provided data. Data must follow the SeedData interface:

interface SeedData<T = any> {
  model: string;
  documents: T[];
}

await seeder.populateModels([
  {
    model: 'User',
    documents: [/* ... */]
  }
]);

setLogger(logger: Logger): void

Sets a custom logger. Logger must implement the Logger interface:

interface Logger {
  log(message: string): void;
  error(message: string): void;
}

const customLogger = {
  log: (msg) => console.log(`[SEED] ${msg}`),
  error: (msg) => console.error(`[SEED ERROR] ${msg}`)
};

seeder.setLogger(customLogger);

Error Handling

The seeder provides detailed error messages and proper error handling:

• ConnectionError: When database connection fails
• ModelError: When there are issues with models or documents
• SeederError: Base class for all seeder-specific errors

TypeScript Support

The package includes TypeScript definitions and supports generic types for your models:

interface User {
  name: string;
  email: string;
  isActive: boolean;
}

const userData: SeedData<User> = {
  model: 'User',
  documents: [
    {
      name: 'John',
      email: 'john@example.com',
      isActive: true
    }
  ]
};

License

MIT