WIP: Major overhaul / 2.0

.prettierrc

@@ -0,0 +1,5 @@
+{
+  "bracketSpacing": false,
+  "singleQuote": true,
+  "trailingComma": "es5"
+}

.travis.yml

@@ -1,8 +1,8 @@
 language: node_js
 node_js:
+  - "12"
+  - "10"
   - "8"
-  - "6"
-  - "4"
 env:
   - MONGOOSE_VERSION=5
   - MONGOOSE_VERSION=4
@@ -16,13 +16,12 @@ install:
   - yarn
   - yarn add --dev mongoose@^$MONGOOSE_VERSION
 script:
-  - yarn hint
-  - yarn test-and-cover
+  - yarn test:all
 jobs:
   include:
   - stage: deploy
     if: env(MONGOOSE_VERSION) = 5
-    node_js: "8"
+    node_js: "12"
     script:
-      - yarn test-and-cover
+      - yarn test:coverage
       - yarn coveralls

jest.config.integration.js

@@ -0,0 +1,5 @@
+const testConfig = require('./jest.config');
+module.exports = {
+  ...testConfig,
+  testMatch: ['**/?(*.)+(test.integration).js'],
+};

jest.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  testEnvironment: 'node',
+};

package.json

@@ -17,13 +17,16 @@
     "mongo"
   ],
   "scripts": {
-    "hint": "jshint .",
-    "test": "mocha --exit",
-    "test-and-cover": "nyc --reporter=html --reporter=text npm run test",
-    "coveralls": "nyc report --reporter=text-lcov | coveralls",
+    "test": "yarn test:all",
+    "test:all": "yarn test:style && yarn test:coverage && yarn test:integration",
+    "test:style": "prettier -c src/**/*.js",
+    "test:unit": "jest",
+    "test:coverage": "jest --coverage",
+    "test:integration": "jest --config ./jest.config.integration.js --forceExit",
+    "coveralls": "coveralls < ./coverage/lcov.info",
     "validate-release-notes": "release-notes validate"
   },
-  "main": "index.js",
+  "main": "src/index.js",
   "bugs": {
     "url": "https://github.com/craftup/node-mongo-tenant/issues"
   },
@@ -32,15 +35,13 @@
   },
   "license": "MIT",
   "devDependencies": {
-    "@release-notes/cli": "^0.1.0",
-    "chai": "^4.1.2",
+    "@release-notes/cli": "^0.3.0",
     "coveralls": "^3.0.0",
-    "jshint": "^2.9.5",
-    "mocha": "^5.0.4",
-    "mocha-mongoose": "^1.2.0",
-    "mongodb": "^2.2.35",
-    "mongoose": "^5.0.11",
-    "nyc": "^11.6.0"
+    "jest": "^24.8.0",
+    "mongodb": "^3.2.7",
+    "mongoose": "^5.6.1",
+    "nyc": "^11.6.0",
+    "prettier": "^1.18.2"
   },
   "peerDependencies": {
     "mongoose": ">=4.3.0 <=4.8.0 || >=4.8.3"

release-notes.yml

@@ -4,9 +4,30 @@ description: >
   document level (for now...). It creates a tenant-reference field and takes care of unique indexes.
   Also it provides access to tenant-bound model-classes, that prohibit the exploid of the given tenant scope.
   Last but not least the "MAGIC" can be disabled so that shipping of the same code in single- and
-  multi-tenancy environment (on premis vs. cloud hosted) is a question of a single line of config.
+  multi-tenancy environment (on premise vs. cloud hosted) is a question of a single line of config.
 
 releases:
+- version: Unreleased
+  added:
+    - >
+      Plugin can now be applied multiple times on single schema to achieve multi dimensional setups.
+
+      To achieve this a new config option named `dimension` is available. This is the prime indicator for compatibility
+      between two different plugin instances. That option is optional with `tenant` as default so backward compatibility
+      is guaranteed.
+    - 'Full support of path level index options (`new Schema({t: {type: String, index: {...}})`).'
+  changed:
+    - >
+      **BREAKING** Default value of option to make tenant id required is now `true` instead of `false`. This changes the
+      default behaviour.
+  removed:
+    - >
+      **BREAKING** Schemas, Models and Documents no longer expose `hasTenantContext` to indicate if the plugin is
+      applied to them.
+    - >
+      **BREAKING** Schema types no longer support the shorthand `partialFilterExpression` option. That shorthand option
+      was never supported by mongoose in the first place. If that option is needed please use
+      `{..., index: { partialFilterExpression: ...}}` instead.
 - version: 1.6.0
   date: 2019-03-21
   fixed:

src/api/are-plugins-compatible.js

@@ -0,0 +1,28 @@
+/**
+ * Check if something looks like options
+ * @param {MongoTenantOptions} options
+ * @returns {boolean}
+ */
+const isPluginOptions = options =>
+  (options &&
+    options.dimension &&
+    options.accessorMethod &&
+    options.dimensionIdKey &&
+    true) ||
+  false;
+/**
+ * Checks if instance is compatible to other plugin instance
+ *
+ * For population of referenced models it's necessary to detect if the tenant
+ * plugin installed in these models is compatible to the plugin of the host
+ * model. This is done by comparing the dimension key.
+ *
+ * @param {MongoTenantOptions} a
+ * @param {MongoTenantOptions} b
+ * @returns {boolean}
+ */
+module.exports = (a, b) => {
+  return (
+    isPluginOptions(a) && isPluginOptions(b) && a.dimension === b.dimension
+  );
+};

src/api/are-plugins-compatible.test.js

@@ -0,0 +1,28 @@
+const arePluginsCompatible = require('./are-plugins-compatible');
+
+describe('are-plugins-compatible', () => {
+  describe('when called with proper plugin options', () => {
+    const options = {
+      dimension: 'dim',
+      accessorMethod: 'byDim',
+      dimensionIdKey: 'dimId',
+    };
+
+    it("returns true if they have equal dimension's", () => {
+      const a = {...options};
+      const b = {...options};
+      const result = arePluginsCompatible(a, b);
+      expect(result).toBe(true);
+    });
+
+    it("returns false if they have different dimension's", () => {
+      const a = {...options};
+      const b = {
+        ...options,
+        dimension: 'universe',
+      };
+      const result = arePluginsCompatible(a, b);
+      expect(result).toBe(false);
+    });
+  });
+});

src/api/dimension-aware-db.js

@@ -0,0 +1,27 @@
+const arePluginsCompatible = require('./are-plugins-compatible');
+const dimensionInterface = require('../dimension-interface');
+
+/**
+ * Create db connection bound to a specific dimension
+ *
+ * @param {Connection} db
+ * @param {*} dimensionId
+ * @param {MongoTenantOptions} options
+ * @returns {Connection}
+ */
+module.exports = ({db, dimensionId, options}) => {
+  const awareDb = Object.create(db);
+  awareDb.model = name => {
+    const unawareModel = db.model(name);
+    const otherPluginOptions = dimensionInterface(unawareModel.schema).get(
+      options.dimension
+    );
+
+    if (!arePluginsCompatible(options, otherPluginOptions)) {
+      return unawareModel;
+    }
+
+    return unawareModel[otherPluginOptions.accessorMethod](dimensionId);
+  };
+  return awareDb;
+};

src/api/dimension-aware-db.test.js

@@ -0,0 +1,52 @@
+const buildOptions = require('../options');
+const createDimensionAwareDb = require('./dimension-aware-db');
+const dimensionInterface = require('../dimension-interface');
+
+describe('dimension-aware-db', () => {
+  describe('when called with proper parameters', () => {
+    const dimension = 'dim';
+    const dimensionId = '23';
+    const options = buildOptions({dimension});
+
+    it('overwrites the model method', () => {
+      const db = {
+        model: () => {},
+      };
+      const result = createDimensionAwareDb({db, dimensionId, options});
+      expect(result).toHaveProperty('model');
+      expect(result.model).toBeInstanceOf(Function);
+      expect(result.model).not.toBe(db.model);
+    });
+
+    it('returns a dimension aware model if compatible', () => {
+      const awareModel = {};
+      const unawareModel = {
+        schema: {},
+        [options.accessorMethod]: () => awareModel,
+      };
+      dimensionInterface(unawareModel.schema).add(dimension, options);
+      const db = {
+        model: () => unawareModel,
+      };
+
+      const awareDb = createDimensionAwareDb({db, dimensionId, options});
+      const result = awareDb.model('test');
+
+      expect(result).toBe(awareModel);
+    });
+
+    it('returns a dimension unaware model if not compatible', () => {
+      const unawareModel = {
+        schema: {},
+      };
+      const db = {
+        model: () => unawareModel,
+      };
+
+      const awareDb = createDimensionAwareDb({db, dimensionId, options});
+      const result = awareDb.model('test');
+
+      expect(result).toBe(unawareModel);
+    });
+  });
+});