juampi92 / adonis-mongoose-model Goto Github PK

/*
  Goal of this file is to prevent the MongooseSerializer from returning "live" Mongoose models which
  then fail to be stored in a session because they contain non-trivial types such as ObjectID.
*/

module.exports = () => {
  const MongooseSerializer = use('adonis-mongoose-model/src/Serializers/MongooseSerializer')

  function wrapWithSanitizer (klass, method) {
    const oldMethod = klass.prototype[method]

    klass.prototype[method] = async function (...args) {
      const result = await oldMethod.call(this, ...args)
      return result ? JSON.parse(JSON.stringify(result)) : result
    }
  }

  wrapWithSanitizer(MongooseSerializer, 'findById')
  wrapWithSanitizer(MongooseSerializer, 'findByUid')

  // Not sure if this is needed also for 'listTokens'?
}

  mongodb: {
    client: 'mongodb',
    connectionString: Env.get('DB_CONNECTION_STRING', ''),
    connection: {
      host: Env.get('DB_HOST', 'localhost'),
      port: Env.get('DB_PORT', 27017),
      user: Env.get('DB_USER', 'admin'),
      pass: Env.get('DB_PASSWORD', ''),
      database: Env.get('DB_DATABASE', 'adonis'),
          options: {
            // All options can be found at http://mongoosejs.com/docs/connections.html
            useNewUrlParser: true // stops throwing warning
          },
    }
  }

  jwt: {
    serializer: 'mongoose',
    scheme: 'jwt',
    model: 'App/Models/User',
    token: 'App/Models/Token',
    uid: 'email',
    password: 'password',
    expiry: '30d', // Not yet implemented
    options: {
      secret: Config.get('app.appKey')
    }
  },

api: {
    serializer: 'mongoose',
    model: 'App/Models/Player',
    scheme: 'api',
    uid: 'name',
    token: 'App/Models/Token',
    options: {
        secret: Env.get('APP_KEY')
    }
}

// we need:

this.buildSchema();
const schema = this.buildSchema();
schema.virtual('something').get(.......);

// or:

this.buildSchema();
this._schema.virtual('something').get(.......);

// instead of simply:

const schema = this.buildSchema();
schema.virtual('something').get(.......);

return this.remove({
      uid,
      token: { [selector]: tokens },
    }).exec()

const BaseModel = use('MongooseModel')

require('./user')
require('./account')

class Membership extends BaseModel {

  static boot ({ schema }) {
    schema.virtual('user', {
      ref: 'User',
      localField: 'user_id',
      foreignField: '_id',
      justOne: true
    })

    schema.virtual('account', {
      ref: 'Account',
      localField: 'account_id',
      foreignField: '_id',
      justOne: true
    })

    this.addHook('preFind', async function(next){
      this.populate('user')
      this.populate('account')
      next()
    })
  }

  static get schemaOptions() {
    return {
      toObject: { virtuals: true },
      toJSON: { virtuals: true }
    }
  }

}

module.exports = Membership.buildModel('Membership')

  async logout ({ request, response, auth }) {
    const user = await this.User.find(auth.user._id)

    await auth.authenticator('jwt').revokeTokensForUser(user)

    return response.apiSuccess(user)
  }

    this.addHook('preSave', async function() {
      this.password = await Hash.make(this.password)
    })

    const { email, password } = request.all()

    const user = await User.findOne({
      email: email,
      confirmed: true
    })

    const passwordIsCorrect = await Hash.verify(password, user.password)

    console.log(passwordIsCorrect)

// Hooks/UserHook.js

const Hash = use('Hash')

const UserHook = exports = module.exports = {}

UserHook.hashPassword = async (user) => {
  user.password = await Hash.make(user.password)
}

// Models/User.js

const BaseModel = use('Model')
const mongooseHidden = require('mongoose-hidden', )({ defaultHidden: { password: true }})

/**
 * @class User
 */
class User extends BaseModel {
  static boot ({ schema }) {
    schema.plugin(mongooseHidden)
    this.addHook('beforeCreate', 'UserHook.hashPassword')
  }
  /**
   * User's schema
   */
  static get schema () {
    return {
      name: { type: String, required: true },
      email: { type: String, required: true },
      password: { type: String, required: true },
      type: { type:String, enum: ['root', 'dealer'], required: true },
      address: { type:String, required: true }
    }
  }

  static get primaryKey () {
    return '_id'
  }
}

module.exports = User.buildModel('User')

TypeError: this._schema[instruction] is not a function
TypeError: this._schema[instruction] is not a function
    at Function.addHook (C:\Users\Bryann\Desktop\works\formacho\android_app\server\node_modules\adonis-mongoose-model\src\Model\Base.js:44:30)
    at Function.boot (C:\Users\Bryann\Desktop\works\formacho\android_app\server\app\Models\User.js:12:10)
    at Function.buildModel (C:\Users\Bryann\Desktop\works\formacho\android_app\server\node_modules\adonis-mongoose-model\src\Model\Base.js:162:10)
    at Object.<anonymous> (C:\Users\Bryann\Desktop\works\formacho\android_app\server\app\Models\User.js:36:23)
    at Module._compile (module.js:624:30)
    at Object.Module._extensions..js (module.js:635:10)
    at Module.load (module.js:545:32)
    at tryModuleLoad (module.js:508:12)
    at Function.Module._load (module.js:500:3)
    at Module.require (module.js:568:17)
    at require (internal/module.js:11:18)
    at requireStack (C:\Users\Bryann\Desktop\works\formacho\android_app\server\node_modules\require-stack\src\index.js:44:12)
    at Ioc._resolveAutoloadedPath (C:\Users\Bryann\Desktop\works\formacho\android_app\server\node_modules\@adonisjs\fold\src\Ioc\index.js:265:20)
    at Ioc.make (C:\Users\Bryann\Desktop\works\formacho\android_app\server\node_modules\@adonisjs\fold\src\Ioc\index.js:793:40)
    at MongooseSerializer.setConfig (C:\Users\Bryann\Desktop\works\formacho\android_app\server\node_modules\adonis-mongoose-model\src\Serializers\MongooseSerializer.js:42:23)
    at Auth.authenticator (C:\Users\Bryann\Desktop\works\formacho\android_app\server\node_modules\@adonisjs\auth\src\Auth\index.js:113:24)

async index() {
    const user = User.findOne({})
    console.log(await auth.generate(user))
}

'use strict'

const BaseModel = use('MongooseModel')

/**
 * @class User
 */
class User extends BaseModel {
  static boot({ schema }) {
    this.addHook('preSave', 'UserHook.hashPassword')
  }

  static get primaryKey() {
    return 'id'
  }

  /**
   * User's schema
   */
  static get schema() {
    return {
      email: {
        type: String,
        required: true,
        unique: true
      },
      activationKey: {
        type: String,
        unique: true,
        select: false
      }
    }
  }
}

module.exports = User.buildModel('User')

E_RUNTIME_ERROR: Primary key value is missing for user > More details: https://err.sh/adonisjs/errors/E_RUNTIME_ERROR

const Route = use('Route')
const User = use('App/Models/User')

Route.get('/', async ({ request }) => {
    const user = await User.create({
      name: 'test'
    })
    console.log(user)
    return 'test';
})

// User Model
'use strict'

const BaseModel = use('MongooseModel')

/**
 * @class User
 */
class User extends BaseModel {
  static boot ({ schema }) {  }
  /**
   * User's schema
   */
  static get schema () {
    return {
      name: 'String'
    }
  }
}

module.exports = User.buildModel('User')