mongoose-just

BETA VERSION - DEV

• Installing
• Usage

Installing

npm install mongoose-just

Usage

TypeScript

import createMogooseStore, { Types } from 'mongoose-just'
import dbStoreTypes from './types'

const dbName = "dbtest"

// Map
const dbMongooseMap = [{
  dbName,
  host: 'localhost',
  port: 27017,
  // user: 'user',
  // password:'password',
  collections: [
    {
      name: 'users',
      shema: {
        login: {
          type: String,
          unique: true,
          index: true
        }
        email: {
          type: String,
          unique: true
        },
        phone: {
          type: String,
           unique: true         
        }        
      }
    },
    {
      name: 'options',
      shema: {
        key: {
          type: String,
          unique: true
        },
        value: Types.Mixed
      },
      // shemaOptions: {
      //   isUpdatedAt: true // default options
      // },
      defaultDocs: [{
        key: 'version',
        value: '0.0.1',
        __options: {
          ignores: ['value']
        }
      }],
      prototypes: {
        getListKeys: function () {
          return new Promise(async (resolve) => {
            this.find().then(resolve)
          })
        }
      }
    },
    {
      name: 'lists',
      shema: {
        time: {
          type: Date,
          index: true
        },
        value: {
          type: Types.Mixed,
          index: true
        }
      },
      shemaOptions: {
        setIndex: [[{ time: 1, value: 1 }, { unique: true }]]
      }
    }
  ]
}]


const dbStore = createMogooseStore(dbMongooseMap) as dbStoreTypes;

// Event Connected 
dbStore.on(`connected`, props => {
  console.log('connected', props)
})

// Event Connected `dbName`
dbStore.on(`connected.${dbName}`, async (db:dbMogooseStore) => {
  console.log(`connected.${dbName}`)
  let version = await db.options.getKey('version')
  console.log(`${dbName}.options.version:`,version)
  
  let docs = db.lists.find({ select: { time: 1 }})  
})

// Event reconnect db
// dbStore.on(`reconnect`, props => {
//   console.log(reconnect, props)
// })

// Event disconnect db
dbStore.on(`disconnected`, data => {
  console.log('disconnected', data)
})

// Event disconnect `dbName`
// dbStore.on(`disconnect.${dbName}`, () => {
//   console.log(`disconnect.${dbName}`)
// })

// Event error store
dbStore.on(`error`, error => {
  console.log('error:', error)
})


// Event Connected all db
dbStore.on('connectedAll', async store => {
  
  console.log('connected all data bases')

  await store[dbName].options.setKey('version', "0.0.11")
  // let doc = await store[dbName].options.findOne({ find: { key: "version", selected: { key:true, value: true } } })  
  // console.log(doc)
  let version = await store[dbName].options.getKey('version')  
  // console.log(version) 

  let docs = await store[dbName].options.listKeys()
  console.log(docs)

})

// connect to db
dbStore.connect()

export default dbStore

Types

.types.ts

import { dbMogooseStore, collectionType, dbMongooseStoreDefaultType }  from 'mongoose-just/types'


interface ObjectKeysType {
    key:string;
    value:any;
}

// dbtest.options.listKeys
interface dbTestOptionsType {
    listKeys: () => ObjectKeysType[];
}

// dbtest
interface dbStoreTest extends dbMogooseStore {
    users: collectionType,
    options: collectionType & dbTestOptionsType;
}

// dbStore
interface dbStoreTypes extends dbMongooseStoreDefaultType {
    dbtest: dbStoreTest;
}

export default dbStoreTypes