typescript mongoose schema type code example

Example 1: typescript generic mongoose example

import { Schema, model, Document, Model } from 'mongoose';

declare interface IContact extends Document{
    name: string;
    email: string;
    phone?: string;
    message?: string;
    course_enquiry?: string;
    creation_date: Date;
}

export interface ContactModel extends Model {};

export class Contact {

    private _model: Model;

    constructor() {
        const schema =  new Schema({
            name: { type: String, required: true },
            email: { type: String, required: true },
            phone: { type: String },
            message: { type: String },
            course_enquiry: { type: String },
            creation_date: { type: Date, default: Date.now }
        });

        this._model = model('User', schema);
    }

    public get model(): Model {
        return this._model
    }
}Copied!

Example 2: mongoose schema type

var schema = new Schema({
  name:    String,
  binary:  Buffer,
  living:  Boolean,
  updated: { type: Date, default: Date.now },
  age:     { type: Number, min: 18, max: 65 },
  mixed:   Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  decimal: Schema.Types.Decimal128,
  array: [],
  ofString: [String],
  ofNumber: [Number],
  ofDates: [Date],
  ofBuffer: [Buffer],
  ofBoolean: [Boolean],
  ofMixed: [Schema.Types.Mixed],
  ofObjectId: [Schema.Types.ObjectId],
  ofArrays: [[]],
  ofArrayOfNumbers: [[Number]],
  nested: {
    stuff: { type: String, lowercase: true, trim: true }
  },
  map: Map,
  mapOfString: {
    type: Map,
    of: String
  }
})

// example use

var Thing = mongoose.model('Thing', schema);

var m = new Thing;
m.name = 'Statue of Liberty';
m.age = 125;
m.updated = new Date;
m.binary = Buffer.alloc(0);
m.living = false;
m.mixed = { any: { thing: 'i want' } };
m.markModified('mixed');
m._someId = new mongoose.Types.ObjectId;
m.array.push(1);
m.ofString.push("strings!");
m.ofNumber.unshift(1,2,3,4);
m.ofDates.addToSet(new Date);
m.ofBuffer.pop();
m.ofMixed = [1, [], 'three', { four: 5 }];
m.nested.stuff = 'good';
m.map = new Map([['key', 'value']]);
m.save(callback);

Example 3: mongoose with typescript

import mongoose from 'mongoose'
import consola from 'consola'
import q from 'q'

export const mongooseConnection = (): void => {
	mongoose.Promise = q.Promise

	mongoose.connect(process.env.MONGO_URI, {
		minPoolSize: 1,
		maxPoolSize: 20,
		compression: { compressors: ['zlib'] },
		useUnifiedTopology: true,
		useNewUrlParser: true,
		useFindAndModify: false,
		socketTimeoutMS: 60000,
		serverSelectionTimeoutMS: 60000,
		loggerLevel: 'error'
	})

	mongoose.connection.on('connecting', () => consola.info('database connecting'))
	mongoose.connection.on('connected', () => consola.success('database connected'))
	mongoose.connection.on('disconnecting', () => consola.info('database disconnecting'))
	mongoose.connection.on('disconnected', () => consola.info('database disconnected'))
	mongoose.connection.on('error', () => consola.error('database error'))
}