jxp 2.8.3 → 2.10.1

package/.env

@@ -0,0 +1,8 @@
+MONGODB_USER=root
+MONGODB_PASSWORD=password
+MONGODB_DATABASE=jxp
+MONGODB_LOCAL_PORT=7017
+MONGODB_DOCKER_PORT=27017
+
+NODE_LOCAL_PORT=4001
+NODE_DOCKER_PORT=4001

package/.env.sample

@@ -0,0 +1,6 @@
+DB_HOST=localhost
+DB_USER=root
+DB_PASSWORD=password
+DB_NAME=jxp
+DB_PORT=27017
+NODE_DOCKER_PORT=4001

package/Dockerfile

@@ -0,0 +1,7 @@
+FROM node:17
+
+WORKDIR /jxp
+COPY package.json .
+RUN yarn install
+COPY . .
+CMD npm start

package/bin/server.js

@@ -195,6 +195,7 @@ Add the parameter `_silence` to supress callbacks. Useful to avoid infinite loop
 const mongoose = require("mongoose");
 const JXP = require("../libs/jxp");
 const config = require("config");
+require("dotenv").config();
 
 config.callbacks = {
 	post: function(modelname, item, user) {
@@ -232,15 +233,16 @@ config.pre_hooks = {
 //DB connection
 // ES6 promises
 mongoose.Promise = Promise;
+if (!config.mongo) config.mongo = {};
 if (!config.mongo.options) config.mongo.options = {};
 const mongo_options = Object.assign(config.mongo.options, {
-	promiseLibrary: global.Promise,
 	useNewUrlParser: true,
-	useCreateIndex: true
+	useUnifiedTopology: true
 });
 
-// mongodb connection
-mongoose.connect(config.mongo.connection_string, mongo_options);
+const connection_string = require("../libs/connection_string");
+console.log(`Connecting to ${connection_string}`);
+mongoose.connect(connection_string, mongo_options);
 
 const db = mongoose.connection;
 
@@ -254,7 +256,9 @@ db.once('open', () => {
 
 var server = new JXP(config);
 
-server.listen(config.port || 4001, function() {
+let port = process.env.NODE_DOCKER_PORT || process.env.PORT || config.port || 4001;
+if (process.env.NODE_ENV === "test") port = 4005;
+server.listen(port, function() {
 	console.log('%s listening at %s', server.name, server.url);
 });
 

package/docker-compose.yml

@@ -0,0 +1,32 @@
+version: "3.9"
+
+services:
+  mongodb:
+    image: mongo
+    restart: always
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: root
+      MONGO_INITDB_ROOT_PASSWORD: password
+    ports:
+      - $MONGODB_LOCAL_PORT:$MONGODB_DOCKER_PORT
+    volumes:
+      - db:/data/db
+
+  jxp:
+    depends_on:
+      - mongodb
+    build: ./
+    restart: unless-stopped
+    env_file: ./.env
+    ports:
+      - $NODE_LOCAL_PORT:$NODE_DOCKER_PORT
+    environment:
+      - DB_HOST=mongodb
+      - DB_USER=$MONGODB_USER
+      - DB_PASSWORD=$MONGODB_PASSWORD
+      - DB_NAME=$MONGODB_DATABASE
+      - DB_PORT=$MONGODB_DOCKER_PORT
+    stdin_open: true
+    tty: true
+volumes:
+  db:

package/docs/configuration.md

@@ -1,5 +1,7 @@
 # Configuring JXP
 
+### NB: The `config` methodology will be deprecated in future versions in favour of dotenv. See the .env.sample for an example.
+
 The config files are stored in `/config` in strict JSON format. (Remember to enclose your keys in inverted commas!) Typically, you'd use `/config/default.json` for a simple configuration, or `/config/development.json` and `/config/production.json` for separating development and production. 
 
 If you used the `jxp-setup` command for setting everything up, you should have a basic `/config/default.json` file ready to go.

package/docs/installation.md

@@ -4,7 +4,7 @@ JXP would typically run as a stand-alone server, although you can include it as
 
 ## Requirements
 
-JXP runs on [Node JS](https://nodejs.org/en/). We support Node v10 and above, and recommend Node v12.
+JXP runs on [Node JS](https://nodejs.org/en/). We support Node v10 and above, and recommend Node v16. It has been tested up to Node v17.
 
 JXP requires a [Mongo](https://www.mongodb.com/) database server to connect to. You can host your own, or we also support connecting to [MongoDB Atlas](https://www.mongodb.com/cloud/atlas), which has a free tier if you don't want to have Mongo running locally. 
 
@@ -12,6 +12,10 @@ JXP will also take advantage of Memcache if you have it installed, although it's
 
 If you want to send out forgotten password links, you'll need an SMTP server you can connect to.
 
+## Running on Docker
+
+You can run JXP on Docker using Docker Compose. Just run `docker-compose up -d` and it should Just Work (tm).
+
 ## Installing the easy way
 
 JXP has a helper that will set up and configure an instance for you. 

package/libs/connection_string.js

@@ -0,0 +1,14 @@
+const config = require("config");
+require("dotenv").config();
+
+// mongodb connection
+let connection_string = `mongodb://localhost:27017/jxp`;
+if (config.mongo && config.mongo.connection_string) {
+	connection_string = config.mongo.connection_string;
+	console.warn("`config` to be deprecated in favour of dotenv in future versions");
+}
+if (process.env.DB_HOST) {
+	connection_string = `mongodb://${process.env.DB_USER}:${process.env.DB_PASSWORD}@${process.env.DB_HOST}:${process.env.DB_PORT}/${process.env.NODE_ENV === "test" ? "jxp-test" : process.env.DB_NAME}?authSource=admin`
+}
+
+module.exports = connection_string;

package/libs/jxp.js

@@ -272,6 +272,47 @@ const actionPut = async (req, res, next) => {
 	}
 };
 
+const actionUpdate = async (req, res, next) => {
+	const opname = `update ${req.modelname}/${req.params.item_id} ${ops++}`;
+	console.time(opname);
+	try {
+		// let item = await req.Model.findById(req.params.item_id);
+		// if (!item) {
+		// 	console.error(new Date(), "Document not found");
+		// 	res.send(404, { status: "error", message: "Document not found" });
+		// 	return;
+		// }
+		// _populateItem(item, datamunging.deserialize(req.body));
+		// _versionItem(item);
+		// if (res.user) {
+		// 	item.__user = res.user;
+		// 	item._updated_by_id = res.user._id;
+		// }
+		// const data = await item.save();
+		console.log({ body: req.body });
+		let body_data =  datamunging.deserialize(req.body);
+		const data = await req.Model.update({ _id: req.params.item_id }, body_data);
+		let silence = req.params._silence;
+		if (req.body && req.body._silence) silence = true;
+		if (!silence) {
+			req.config.callbacks.put.call(null, req.modelname, data, res.user );
+			ws.putHook.call(null, req.modelname, data, res.user);
+		}
+		res.json({
+			status: "ok",
+			message: req.modelname + " updateed",
+			data
+		});
+		if (debug) console.timeEnd(opname);
+		next();
+	} catch (err) {
+		console.error(new Date(), err);
+		if (debug) console.timeEnd(opname);
+		res.send(500, { status: "error", message: err.toString() });
+		return;
+	}
+};
+
 const actionDelete = async (req, res, next) => {
 	const permaDelete = req.query._permaDelete;
 	const cascade = req.query._cascade;
@@ -759,7 +800,8 @@ const JXP = function(options) {
 			post: function() {},
 			delete: function() {},
 			get: function() {},
-			getOne: function() {}
+			getOne: function() {},
+			update: function() {},
 		},
 		log: "access.log",
 		pre_hooks: {
@@ -778,6 +820,9 @@ const JXP = function(options) {
 			put: (req, res, next) => {
 				next();
 			},
+			update: (req, res, next) => {
+				next();
+			},
 			delete: (req, res, next) => {
 				next();
 			}
@@ -816,6 +861,11 @@ const JXP = function(options) {
 
 	if (config.debug) debug = true;
 
+	// Set apikey and server globally to inject into schemas
+	global.apikey = config.apikey;
+	global.server = config.server;
+	global.model_dir = model_dir;
+	
 	// Pre-load models
 	var files = fs.readdirSync(config.model_dir);
 	let modelnames = files.filter(function(fname) {
@@ -970,6 +1020,17 @@ const JXP = function(options) {
 		actionBulkWrite,
 	);
 
+	server.post(
+		"/update/:modelname/:item_id",
+		middlewareModel,
+		security.login,
+		security.auth,
+		middlewarePasswords,
+		middlewareCheckAdmin,
+		config.pre_hooks.update,
+		actionUpdate,
+	);
+
 	/* Batch routes - ROLLED BACK FOR NOW */
 	// server.post('/batch/create/:modelname', middlewareModel, security.login, security.auth, actionBatch);
 

package/libs/login.js

@@ -122,10 +122,7 @@ const oauth_callback = async (req, res, next) => {
 		}
 		user[provider] = data;
 		await user.save();
-		var apikey = new APIKey();
-		apikey.user_id = user._id;
-		apikey.apikey = require('rand-token').generate(16);
-		await apikey.save();
+		const apikey = await security.generateApiKey(user._id)
 		var jwt_token = jwt.sign({ apikey: apikey.apikey, user: user }, req.config.shared_secret, {
 			expiresIn: "1m"
 		});

package/libs/schema.js

@@ -7,13 +7,6 @@ const config = require("config");
 const JXPHelper = require('jxp-helper');
 const modeldir = require("./modeldir");
 
-// Set up our jxp-helper so that we call call the API from within the API (if we've set config.apikey)
-const jxp_settings = {};
-if (config.apikey) jxp_settings.apikey = config.apikey;
-if (config.server) jxp_settings.server = config.server;
-if (jxp_settings.apikey && jxp_settings.server) global.jxphelper = new JXPHelper(jxp_settings);
-
-
 // Set some global types
 global.ObjectId = mongoose.Schema.Types.ObjectId;
 global.Mixed = mongoose.Schema.Types.Mixed;
@@ -39,6 +32,13 @@ class Schema extends mongoose.Schema {
             _owner_id: { type: ObjectId, link: "User", map_to: "_owner", index: true },
             _updated_by_id: { type: ObjectId, link: "User", map_to: "_updated_by", index: true },
         }, definition);
+        // Set up our jxp-helper so that we call call the API from within the API (if we've set config.apikey)
+        if (!global.jxphelper) {
+            const jxp_settings = {};
+            if (global.apikey) jxp_settings.apikey = global.apikey;
+            if (global.server) jxp_settings.server = global.server;
+            if (jxp_settings.apikey && jxp_settings.server) global.jxphelper = new JXPHelper(jxp_settings);
+        }
         // construct our parent
         super(definition, opts);
         // Some properties

package/libs/setup.js

@@ -3,11 +3,10 @@ const path = require("path");
 const security = require("./security");
 const ObjectID = require('mongodb').ObjectID;
 var User = null;
-var connection_string = null;
+const connection_string = require("./connection_string");
 
 const init = config => {
 	User = require(path.join(config.model_dir, "user_model"));
-	connection_string = config.mongo.connection_string;
 }
 
 const checkUserDoesNotExist = async (req, res, next) => {

package/models/test_model.js

@@ -10,7 +10,10 @@ const TestSchema = new JXPSchema({
     fulltext: { type: String, index: { text: true } },
     link_id: { type: ObjectId, link: "Link", }, // We can populate these links during a query
     other_link_id: { type: ObjectId, link: "Link", map_to: "other_link" },
-    array_link_id: [{ type: ObjectId, link: "Link", map_to: "array_link", justOne: false } ]
+    array_link_id: [{ type: ObjectId, link: "Link", map_to: "array_link", justOne: false } ],
+    composite_array: [ 
+        { afoo: String, abar: Number }
+    ]
 },
 {
     perms: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jxp",
   "description:": "An opinionated RESTful API library based on Mongoose and Restify. Make an API by just writing Mongoose models.",
-  "version": "2.8.3",
+  "version": "2.10.1",
   "private": false,
   "main": "libs/jxp.js",
   "scripts": {
@@ -27,37 +27,38 @@
     "url": "https://github.com/j-norwood-young/jexpress-2/issues"
   },
   "dependencies": {
-    "axios": "^0.21.1",
+    "axios": "^0.24.0",
     "bcryptjs": "^2.4.3",
-    "commander": "^7.2.0",
+    "commander": "^8.3.0",
     "config": "^3.3.6",
-    "glob": "7.1.6",
-    "js-yaml": "4.0.0",
+    "dotenv": "^10.0.0",
+    "glob": "7.2.0",
+    "js-yaml": "4.1.0",
     "json2csv": "^5.0.6",
     "jsonwebtoken": "^8.5.1",
     "jstransformer-markdown-it": "^2.1.0",
-    "jxp-helper": "^1.3.10",
+    "jxp-helper": "^1.3.14",
     "mkdirp": "^1.0.4",
-    "mongoose": "5.12.3",
+    "mongoose": "6.0.13",
     "mongoose-friendly": "^0.1.4",
     "morgan": "^1.10.0",
-    "nodemailer": "^6.5.0",
+    "nodemailer": "^6.7.1",
     "nodemailer-smtp-transport": "^2.7.4",
     "path": "^0.12.7",
     "pug": "^3.0.2",
     "querystring": "^0.2.1",
     "rand-token": "^1.0.1",
     "readline-sync": "^1.4.10",
-    "restify": "^8.5.1",
+    "restify": "^8.6.0",
     "restify-cors-middleware": "^1.1.1",
     "traverse": "^0.6.6",
-    "underscore": "^1.12.1",
-    "ws": "^7.4.4"
+    "underscore": "^1.13.1",
+    "ws": "^8.2.3"
   },
   "devDependencies": {
     "chai": "^4.3.4",
     "chai-http": "^4.3.0",
-    "mocha": "^8.3.2",
+    "mocha": "^9.1.3",
     "should": "^13.2.3"
   }
 }

package/test/init.js

@@ -11,14 +11,6 @@ const Test = require(path.join(model_dir, "test_model"));
 
 const security = require("../libs/security");
 
-const chai = require('chai');
-const chaiHttp = require('chai-http');
-const should = chai.should();
-
-const server = require(path.join(__dirname, "../bin/server.js"));
-
-chai.use(chaiHttp);
-
 const empty = async model => {
 	try {
 		const result = await model.deleteMany({});

package/test/test.js

@@ -832,6 +832,21 @@ describe('Test', () => {
 					});
 			});
 		});
+		it("should $push to an array", done => {
+			chai.request(server)
+				.patch("/api/test/" + post_id)
+				.auth(init.email, init.password)
+				.send({ $push: { shmack: "fah" } })
+				.end((err, res) => {
+					console.log(res.body.data);
+					res.should.have.status(200);
+					res.body.data.should.be.an('object');
+					res.body.data.should.have.property("shmack")
+					res.body.data.shmack.should.be.an("array");
+					res.body.data.shmack.should.have.length(4);
+					done();
+				});
+		});
 	});
 
 	describe("Models", () => {