mongoosejs-model

Mongoose.js model manager by javascript class

Installation instruction:

npm install mongoosejs-model

Use:

Connect to databse

const mongoose = require("mongoose");

const startDatabase = () => {
  return new Promise((resolve, reject) => {
    mongoose.connect(uri)
      .then(() => {
        console.log("💪 connected to DB.");
        resolve();
      })
      .catch(err => {
        console.log("DB connection error:", err);
        startDatabase();
        reject(err);
      });
  });
};

const { init } = require("mongoosejs-model");
init(require("mongoose"));

Define field

const { Field } = require("mongoosejs-model");
let field1 = new Field({
  isRequire: true,
  isArray: true,
  default: ["test"],
  type: String,
});

Define enum

const { Enum } = require("mongoosejs-model");
let field1 = new Enum({
  multi: false,
  default: "E1",
  keys: ["E1", "E2"],
});

OR

const { Enum } = require("mongoosejs-model");
const EConst1 = Object.freeze({
  E1: "E1",
  E2: "E2",
});
let field1 = new Enum({
  multi: false,
  default: "E1",
  type: EConst1,
});

const { Enum } = require("mongoosejs-model");
let field2 = new Enum({
  multi: true,
  default: ["E1"],
  keys: ["E1", "E2"],
});

Define model as subdocument:

const { Model, Field } = require("mongoosejs-model");

class Person extends Model {
  firstName = new Field({ isRequire: true, type: String });
  lastName = new Field({ isRequire: true, type: String });
}

Model enum methods:

const { Model, Field, Enum } = require("mongoosejs-model");

class Person extends Model {
  gender = new Enum({ keys: ["MALE", "FEMALE"] });
  properties = new Enum({ keys: ["CAR", "HOUSE"], multi: true });
  firstName = new Field({ isRequire: true, type: String });
  lastName = new Field({ isRequire: true, type: String });
}

Person.create({ firstName: "hasan", lastName: "Kachal", gender: "MALE", properies: ["CAR", "HOUSE"] });

genderHasKey("MALE"); // Returns 'true'
genderHasKey("FEMALE"); // Returns 'true'

genderCheck("FEMALE"); // Returns 'false'
genderCheck("MALE"); // Returns 'true'

genderCompare("FEMALE"); // Returns 'false'
genderCompare("MALE"); // Returns 'true'


propertiesHasKey("CAR"); // Returns 'true'
propertiesHasKey("HOUSE"); // Returns 'true'

propertiesCheck("HOUSE"); // Returns 'true'
propertiesCheck("CAR"); // Returns 'true'

propertiesCompare("HOUSE"); // Returns 'false'
propertiesCompare("CAR"); // Returns 'false'
propertiesCompare("HOUSE", "CAR"); // Returns 'true'

Define model as collection

const { Model, Field } = require("mongoosejs-model");

class Person extends Model {
  static get modelName() {
    return "person";
  }

  firstName = new Field({ isRequire: true, type: String });
  lastName = new Field({ isRequire: true, type: String });
}

Inheritance models

const EEngine = Object.freeze({
  ELECTRIC: "ELECTRIC",
  GAS: "GAS",
  GASOLINE: "GASOLINE",
  HYBRID: "HYBRID",
});

class Vehicle extends Model {
  color = new Field({ isRequire: true, type: String });
  width = new Field({ isRequire: true, type: Number });
  length = new Field({ isRequire: true, type: Number });
  height = new Field({ isRequire: true, type: Number });
  engineType = new Enum({ type: EEngine });
}

class LandVehicleInfo extends Model {
  wheels = new Field({ isRequier: true, type: Number });
  doors = new Field({ isRequier: true, type: Number });
}

class WaterVehicleInfo extends Model {
  floors = new Field({ isRequire: true, type: Number });
  helipad = new Field({ default: false, type: Boolean });
}

class ElectricEngine extends Vehicle {
  batteryCapacity = new Field({ isRequire: true, type: Number });

  check(next) {
    this.engineType = EEngine.ELECTRIC;
    next();
  }
}

class GasEngine extends Vehicle {
  fuelCapacity = new Field({ isRequire: true, type: Number });

  check(next) {
    this.engineType = EEngine.GAS;
    next();
  }
}

class GasolineEngine extends Vehicle {
  fuelCapacity = new Field({ isRequire: true, type: Number });

  check(next) {
    this.engineType = EEngine.GASOLINE;
    next();
  }
}

class HybridEngine extends Vehicle {
  fuelCapacity = new Field({ isRequire: true, type: Number });
  batteryCapacity = new Field({ isRequire: true, type: Number });

  check(next) {
    this.engineType = EEngine.HYBRID;
    next();
  }
}

class ElectricBycicle extends ElectricEngine {
  static get modelName() {
    return "landVehicle";
  }

  vehicleInfo = new Field({ isRequire: true, type: LandVehicleInfo });
}

class SedanCar extends GasEngine {
  static get modelName() {
    return "landVehicle";
  }

  vehicleInfo = new Field({ isRequire: true, type: LandVehicleInfo });
}

class HybridVan extends HybridEngine {
  static get modelName() {
    return "landVehicle";
  }

  vehicleInfo = new Field({ isRequire: true, type: LandVehicleInfo });
}

class Truck extends GasolineEngine {
  static get modelName() {
    return "landVehicle";
  }

  vehicleInfo = new Field({ isRequire: true, type: LandVehicleInfo });
}

class Boat extends GasolineEngine {
  static get modelName() {
    return "waterVehicle";
  }

  vehicleInfo = new Field({ isRequire: true, type: WaterVehicleInfo });
}

const bycicle1 = ElectricBycicle.create({
  color: "white",
  width: 20,
  length: 100,
  height: 95,
  batteryCapacity: 100000,
  vehicleInfo: {
    wheels: 2,
    doors: 0,
  },
});

const boat1 = Boat.create({
  color: "red",
  width: 20,
  length: 100,
  height: 95,
  fuelCapacity: 200,
  vehicleInfo: {
    floors: 1,
    doors: 0,
  },
});

await bycicle1.save();
await boat1.save();

Define virtual fields

const { Model, Field } = require("mongoosejs-model");

class Person extends Model {
  static get modelName() {
    return "person";
  }

  firstName = new Field({ isRequire: true, type: String });
  lastName = new Field({ isRequire: true, type: String });

  get fullName() {
    return this.firstName + " " + this.lastName;
  }
}

Use collection methods

const { Model, Field } = require("mongoosejs-model");

class Person extends Model {
  static get modelName() {
    return "person";
  }

  firstName = new Field({ isRequire: true, type: String });
  lastName = new Field({ isRequire: true, type: String });

  get fullName() {
    return this.firstName + " " + this.lastName;
  }
}

Person.collection.findOne({
  firstName: "jack",
  lastName: "gonjishke"
});

Define collection methods

const { Model, Field } = require("mongoosejs-model");

class Person extends Model {
  static get modelName() {
    return "person";
  }

  firstName = new Field({ isRequire: true, type: String });
  lastName = new Field({ isRequire: true, type: String });

  get fullName() {
    return this.firstName + " " + this.lastName;
  }

  static getAllPersons() {
    return this.collection.find({});
  }
}

Create new document

const { Model, Field } = require("mongoosejs-model");

class Person extends Model {
  static get modelName() {
    return "person";
  }

  firstName = new Field({ isRequire: true, type: String });
  lastName = new Field({ isRequire: true, type: String });

  get fullName() {
    return this.firstName + " " + this.lastName;
  }

  static getAllPersons() {
    return this.collection.find({});
  }
}

Person.create({firstName: "jack", lastName: "gonjishke"});
Person.save().then(person => {
  console.log(person);
});

Use aggregation in collection methods

const { Model, Field, sort } = require("mongoosejs-model");

class Person extends Model {
  static get modelName() {
    return "person";
  }

  firstName = new Field({ isRequire: true, type: String });
  lastName = new Field({ isRequire: true, type: String });

  get fullName() {
    return this.firstName + " " + this.lastName;
  }

  static getAllPersons() {
    const agrPerson = this.collection.aggregate();
    agrPerson.append({$match: {
      firstName: "jack",
    }});
    
    return agrPerson.exec();
  }
}

Sort result (by aggregation)

const { Model, Field, sort } = require("mongoosejs-model");

class Person extends Model {
  static get modelName() {
    return "person";
  }

  firstName = new Field({ isRequire: true, type: String });
  lastName = new Field({ isRequire: true, type: String });

  get fullName() {
    return this.firstName + " " + this.lastName;
  }

  static getAllPersons() {
    const agrPerson = this.collection.aggregate();

    sort(agrPerson, "-lastName");
    return agrPerson.exec();
  }
}

Filter result (by aggregation)

const { Model, Field, filter } = require("mongoosejs-model");

class Person extends Model {
  static get modelName() {
    return "person";
  }

  firstName = new Field({ isRequire: true, type: String });
  lastName = new Field({ isRequire: true, type: String });

  get fullName() {
    return this.firstName + " " + this.lastName;
  }

  static getAllPersons() {
    const agrPerson = this.collection.aggregate();

    filter(agrPerson, {
      lastName: "gonjishke"
    });
    return agrPerson.exec();
  }
}

Complecated filters

const { Model, Field, filter } = require("mongoosejs-model");

class Person extends Model {
  static get modelName() {
    return "person";
  }

  firstName = new Field({ isRequire: true, type: String });
  lastName = new Field({ isRequire: true, type: String });

  get fullName() {
    return this.firstName + " " + this.lastName;
  }

  static getAllPersons() {
    const agrPerson = this.collection.aggregate();

    filter(agrPerson, {
      "firstName|lastName": "gonjishke|gandomi",
    });
    return agrPerson.exec();
  }
}

Filter operators

• Key part:

No.	Symbol	Operator	Sample
1	|	Or	{"firstName|lastName": ...}
2	!	Not	{"gender!": ...}
3	>	Greater	{"age>": ...}
4	>=	Greater Or Equal	{"age>=": ...}
5	>	Less	{"age<": ...}
6	>=	Less Or Equal	{"age<=": ...}

• Value part:

No.	Symbol	Operator	Sample
1	|	Or	{...: "gonjishke|gandomi"}

• Mix:

{
  "firstName|lastName": "gonjishke|gandomi"
}

Paginate result (by aggregation)

const { Model, Field, paginate } = require("mongoosejs-model");

class Person extends Model {
  static get modelName() {
    return "person";
  }

  firstName = new Field({ isRequire: true, type: String });
  lastName = new Field({ isRequire: true, type: String });

  get fullName() {
    return this.firstName + " " + this.lastName;
  }

  static getAllPersons() {
    const agrPerson = this.collection.aggregate();

    paginate(agrPerson, 0 /* Page number */, 10 /* Page size */);
    return agrPerson.exec();
  }
}