foxhound 1.0.33 → 1.0.37

package/.config/code-server/config.yaml

@@ -0,0 +1,4 @@
+bind-addr: 127.0.0.1:8080
+auth: password
+password: retold
+cert: false

package/.config/configstore/update-notifier-npm-check-updates.json

@@ -0,0 +1,4 @@
+{
+	"optOut": false,
+	"lastUpdateCheck": 1648097783781
+}

package/.config/configstore/update-notifier-npm.json

@@ -0,0 +1,4 @@
+{
+	"optOut": false,
+	"lastUpdateCheck": 1648063932373
+}

package/.github/workflows/test-master.yml

@@ -0,0 +1,29 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [10.x, 12.x, 14.x, 16.x]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v2
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm i
+    - run: npm test
+    - run: npm run coverage

package/.vscode/launch.json

@@ -5,14 +5,42 @@
     "version": "0.2.0",
     "configurations": [
         {
+            "name": "Launch Debug Harness",
             "type": "pwa-node",
             "request": "launch",
-            "name": "Launch Program",
             "outputCapture": "std",
             "skipFiles": [
                 "<node_internals>/**"
             ],
-            "program": "${workspaceFolder}/debug/Harness.js"
+            "program": "${workspaceFolder}/debug/Harness.js",
+            "presentation": {
+                "hidden": false,
+                "group": "",
+                "order": 1
+            }
+        },
+        {
+            "name": "Mocha Tests",
+            "args": [
+                "-u",
+                "tdd",
+                "--timeout",
+                "999999",
+                "--colors",
+                "${workspaceFolder}/test"
+            ],
+            "internalConsoleOptions": "openOnSessionStart",
+            "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
+            "request": "launch",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "type": "pwa-node",
+            "presentation": {
+                "hidden": false,
+                "group": "",
+                "order": 2
+            }
         }
     ]
 }

package/Dockerfile

@@ -0,0 +1,32 @@
+# Use the codercom/code-server image
+FROM codercom/code-server:latest
+MAINTAINER steven velozo
+
+VOLUME /home/coder/.config
+VOLUME /home/coder/.vscode
+
+RUN echo "...installing debian dependencies..."
+RUN sudo apt update
+RUN sudo apt install vim curl tmux -y
+
+RUN echo "Building RETOLD development image..."
+
+
+RUN echo "...mapping library specific volumes..."
+# Volume mappings for RETOLD:Foxhound library
+VOLUME /home/coder/foxhound
+# VOLUME /home/coder/foxhound/node_modules
+
+SHELL ["/bin/bash", "-c"]
+USER coder
+
+RUN echo "...installing node version manager..."
+# Because there is a .bashrc chicken/egg problem, we will create one here to simulate logging in.  This is not great.
+RUN touch ~/.bashrc && chmod +x ~/.bashrc
+RUN curl https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash
+
+RUN echo "...installing node version 14 as the default..."
+RUN . ~/.nvm/nvm.sh && source ~/.bashrc && nvm install 14
+RUN . ~/.nvm/nvm.sh && source ~/.bashrc && nvm alias default 14
+
+WORKDIR /home/coder/foxhound

package/README.md

@@ -2,7 +2,6 @@
 
 The FoxHound javascript query generator, for node.js and the browser.
 
-[![Build Status](https://travis-ci.org/stevenvelozo/foxhound.svg?branch=master)](https://travis-ci.org/stevenvelozo/foxhound)
 
 ### Getting Started
 
@@ -32,3 +31,35 @@ Which now will output:
 
     $ npm test
     $ npm run coverage
+
+### Docker Development Environment
+
+
+1. Run this command to build this image:
+```
+docker build ./ -t retold/foxhound:local
+```
+
+alternatively you can use npm to run this
+
+
+```
+npm run docker-dev-build-image
+```
+
+2. Run this command to build the local container:
+```
+docker run -it --name foxhound-dev -p 127.0.0.1:12346:8080 -v "$PWD/.config:/home/coder/.config"  -v "$PWD:/home/coder/foxhound" -u "$(id -u):$(id -g)" -e "DOCKER_USER=$USER" retold/foxhound:local
+```
+
+alternatively you can use npm to run this
+
+```
+npm run docker-dev-run
+```
+
+3. Go to http://localhost:12346/ in a web browser
+
+4. The password is "retold"
+
+5. Right now you (may) need to delete the `node_modules` folders and regenerate it for Linux.

package/debug/Harness.js

@@ -25,22 +25,21 @@ var _AnimalSchemaWithoutDeleted = (
 ]);
 
 var tmpQuery = libFoxHound.new(libFable)
-.setDialect('MeadowEndpoints')
-.setScope('Animal')
-.setDataElements(['Name', 'Age', 'Cost'])
-.setCap(100)
-.addFilter('Age', '25')
-.addFilter('', '', '(')
-.addFilter('Color', 'Red')
-.addFilter('Color', 'Green', '=', 'OR')
-.addFilter('', '', ')')
-.addFilter('Description', '', 'IS NOT NULL')
-.addFilter('IDOffice', [10, 11, 15, 18, 22], 'IN');
+	.setDialect('MeadowEndpoints')
+	.setScope('Animal')
+	.setDataElements(['Name', 'Age', 'Cost'])
+	.setCap(100)
+	.addFilter('Age', '25')
+	.addFilter('', '', '(')
+	.addFilter('Color', 'Red')
+	.addFilter('Color', 'Green', '=', 'OR')
+	.addFilter('', '', ')')
+	.addFilter('Description', '', 'IS NOT NULL')
+	.addFilter('IDOffice', [10, 11, 15, 18, 22], 'IN');
 tmpQuery.setLogLevel(3).addSort('Age');
 // Build the query
 tmpQuery.buildReadQuery();
 // This is the query generated by the MeadowEndpoints dialect
 libFable.log.trace('Select Query', tmpQuery.query);
 
-
 console.log(tmpQuery.query.body);

package/package.json

@@ -1,12 +1,32 @@
 {
   "name": "foxhound",
-  "version": "1.0.33",
+  "version": "1.0.37",
   "description": "A Database Query generation library.",
   "main": "source/FoxHound.js",
   "scripts": {
     "start": "node source/FoxHound.js",
     "coverage": "./node_modules/istanbul/lib/cli.js cover ./node_modules/mocha/bin/_mocha -- -u tdd -R spec",
-    "test": "./node_modules/mocha/bin/_mocha -u tdd -R spec"
+    "test": "./node_modules/.bin/mocha -u tdd -R spec",
+    "docker-dev-build-image": "docker build ./ -t retold/foxhound:local",
+    "docker-dev-run": "docker run -it -d --name foxhound-dev -p 127.0.0.1:12346:8080 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/foxhound\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" retold/foxhound:local"
+  },
+  "mocha": {
+    "diff": true,
+    "extension": [
+      "js"
+    ],
+    "package": "./package.json",
+    "reporter": "spec",
+    "slow": "75",
+    "timeout": "5000",
+    "ui": "tdd",
+    "watch-files": [
+      "source/**/*.js",
+      "test/**/*.js"
+    ],
+    "watch-ignore": [
+      "lib/vendor"
+    ]
   },
   "repository": {
     "type": "git",
@@ -24,14 +44,12 @@
   },
   "homepage": "https://github.com/stevenvelozo/foxhound",
   "devDependencies": {
-    "chai": "3.4.1",
-    "codeclimate-test-reporter": "0.1.1",
-    "coveralls": "2.11.4",
+    "chai": "4.3.6",
     "istanbul": "0.4.1",
-    "mocha": "2.3.4"
+    "mocha": "9.2.2"
   },
   "dependencies": {
-    "fable": "~1.0.1",
-    "underscore": "1.8.3"
+    "fable": "~2.0.5",
+    "underscore": "1.13.2"
   }
 }

package/source/dialects/ALASQL/FoxHound-Dialect-ALASQL.js

@@ -67,14 +67,33 @@ var FoxHoundDialectALASQL = function()
 	 *
 	 * @method: generateFieldList
 	 * @param: {Object} pParameters SQL Query Parameters
-	 * @return: {String} Returns the field list clause
+	 * @param {Boolean} pIsForCountClause (optional) If true, generate fields for use within a count clause.
+	 * @return: {String} Returns the field list clause, or empty string if explicit fields are requested but cannot be fulfilled
+	 *          due to missing schema.
 	 */
-	var generateFieldList = function(pParameters)
+	var generateFieldList = function(pParameters, pIsForCountClause)
 	{
 		var tmpDataElements = pParameters.dataElements;
 		if (!Array.isArray(tmpDataElements) || tmpDataElements.length < 1)
 		{
-			return ' *';
+			if (!pIsForCountClause)
+			{
+				return ' *';
+			}
+			// we need to list all of the table fields explicitly; get them from the schema
+			const tmpSchema = Array.isArray(pParameters.query.schema) ? pParameters.query.schema : [];
+			if (tmpSchema.length < 1)
+			{
+				// this means we have no schema; returning an empty string here signals the calling code to handle this case
+				return '';
+			}
+			const idColumn = tmpSchema.find((entry) => entry.Type === 'AutoIdentity');
+			if (!idColumn)
+			{
+				// this means there is no autoincrementing unique ID column; treat as above
+				return '';
+			}
+			return ` ${idColumn.Column}`;
 		}
 
 		var tmpFieldList = ' ';
@@ -740,9 +759,14 @@ var FoxHoundDialectALASQL = function()
 	{
 		var tmpTableName = generateTableName(pParameters);
 		var tmpWhere = generateWhere(pParameters);
-		const tmpOptDistinct = pParameters.distinct ? 'DISTINCT' : '';
-		const tmpCountClause = pParameters.distinct ? `${tmpOptDistinct}${generateFieldList(pParameters)}` : '*';
+		const tmpFieldList = pParameters.distinct ? generateFieldList(pParameters, true) : '*';
 
+		// here, we ignore the distinct keyword if no fields have been specified and
+		if (pParameters.distinct && tmpFieldList.length < 1)
+		{
+			console.warn('Distinct requested but no field list or schema are available, so not honoring distinct for count query.');
+		}
+		const tmpOptDistinct = pParameters.distinct && tmpFieldList.length > 0 ? 'DISTINCT' : '';
 		if (pParameters.queryOverride)
 		{
 			try
@@ -758,7 +782,7 @@ var FoxHoundDialectALASQL = function()
 			}
 		}
 
-		return `SELECT COUNT(${tmpCountClause}) AS RowCount FROM${tmpTableName}${tmpWhere};`;
+		return `SELECT COUNT(${tmpOptDistinct}${tmpFieldList || '*'}) AS RowCount FROM${tmpTableName}${tmpWhere};`;
 	};
 
 	var tmpDialect = ({

package/source/dialects/MeadowEndpoints/FoxHound-Dialect-MeadowEndpoints.js

@@ -22,6 +22,19 @@ var FoxHoundDialectMeadowEndpoints = function()
 		return pParameters.scope;
 	};
 
+	/**
+	 * Generate the Identity column from the schema or scope
+	 * 
+	 * @method: generateIdentityColumnName
+	 * @param: {Object} pParameters SQL Query Parameters
+	 * @return: {String} Returns the table name clause
+	 */
+	var generateIdentityColumnName = function(pParameters)
+	{
+		// TODO: See about using the Schema or the Schemata for this
+		return `ID${pParameters.scope}`;
+	};
+
 	/**
 	 * Generate a field list from the array of dataElements
 	 *
@@ -353,22 +366,44 @@ var FoxHoundDialectMeadowEndpoints = function()
 		var tmpWhere = generateWhere(pParameters);
 		var tmpLimit = generateLimit(pParameters);
 
-        var tmpURL = `${tmpTableName}s`;
-        if (tmpFieldList)
-        {
-            tmpURL = `${tmpURL}/LiteExtended/${tmpFieldList}`
-        }
-        if (tmpWhere)
-        {
-            tmpURL = `${tmpURL}/FilteredTo/${tmpWhere}`;
-        }
-        if (tmpLimit)
-        {
-            tmpURL = `${tmpURL}/${tmpLimit}`;
-        }
+		var tmpURL = `${tmpTableName}`;
+		// In the case that there is only a single query parameter, and the parameter is a single identity, 
+		// we will cast it to the READ endpoint rather than READS.
+		if ((pParameters.filter)
+			 && (pParameters.filter.length == 1)
+             // If there is exactly one query filter parameter
+			 && (pParameters.filter[0].Column === generateIdentityColumnName(pParameters))
+			 // AND It is the Identity column
+			 && (pParameters.filter[0].Operator === '=')
+			 // AND The comparators is a simple equals 
+			 && (tmpLimit == '') && (tmpFieldList == '')
+			 // AND There is no limit or field list set
+			 && (!pParameters.sort))
+			 // AND There is no sort clause
+		{
+			// THEN This is a SINGLE READ by presumption.
+			// There are some bad side affects this could cause with chaining and overridden behaviors, if 
+			// we are requesting a filtered list of 1 record.
+			tmpURL = `${tmpURL}/${pParameters.filter[0].Value}`;
+		}
+		else
+		{
+			tmpURL = `${tmpURL}s`;
+			if (tmpFieldList)
+			{
+				tmpURL = `${tmpURL}/LiteExtended/${tmpFieldList}`
+			}
+			if (tmpWhere)
+			{
+				tmpURL = `${tmpURL}/FilteredTo/${tmpWhere}`;
+			}
+			if (tmpLimit)
+			{
+				tmpURL = `${tmpURL}/${tmpLimit}`;
+			}
+		}
 
 		return tmpURL;
-        ///'SELECT'+tmpFieldList+' FROM'+tmpTableName+tmpJoin+tmpWhere+tmpOrderBy+tmpLimit+';';
 	};
 
 	var Update = function(pParameters)
@@ -413,7 +448,7 @@ var FoxHoundDialectMeadowEndpoints = function()
 
         if (tmpWhere)
         {
-            return `${tmpCountQuery}s/Count/FilteredTo/${tmpWhere}`;
+            return `${tmpTableName}s/Count/FilteredTo/${tmpWhere}`;
         }
 
         return tmpCountQuery;

package/source/dialects/MySQL/FoxHound-Dialect-MySQL.js

@@ -44,28 +44,35 @@ var FoxHoundDialectMySQL = function()
 	 *
 	 * @method: generateFieldList
 	 * @param: {Object} pParameters SQL Query Parameters
-	 * @param {Boolean} pExplicitFields (optional) If true, generate explicit fields rather than "TableName.*" (for count distinct).
+	 * @param {Boolean} pIsForCountClause (optional) If true, generate fields for use within a count clause.
 	 * @return: {String} Returns the field list clause, or empty string if explicit fields are requested but cannot be fulfilled
 	 *          due to missing schema.
 	 */
-	var generateFieldList = function(pParameters, pExplicitFields)
+	var generateFieldList = function(pParameters, pIsForCountClause)
 	{
 		var tmpDataElements = pParameters.dataElements;
 		if (!Array.isArray(tmpDataElements) || tmpDataElements.length < 1)
 		{
 			const tmpTableName = generateTableName(pParameters);
-			if (!pExplicitFields)
+			if (!pIsForCountClause)
 			{
 				return tmpTableName + '.*';
 			}
 			// we need to list all of the table fields explicitly; get them from the schema
-			var tmpSchema = Array.isArray(pParameters.query.schema) ? pParameters.query.schema : [];
-			tmpDataElements = tmpSchema.map((entry) => `${tmpTableName}.${entry.Column}`.trim());
-			if (tmpDataElements.length < 1)
+			const tmpSchema = Array.isArray(pParameters.query.schema) ? pParameters.query.schema : [];
+			if (tmpSchema.length < 1)
 			{
 				// this means we have no schema; returning an empty string here signals the calling code to handle this case
 				return '';
 			}
+			const idColumn = tmpSchema.find((entry) => entry.Type === 'AutoIdentity');
+			if (!idColumn)
+			{
+				// this means there is no autoincrementing unique ID column; treat as above
+				return '';
+			}
+			const qualifiedIDColumn = `${tmpTableName}.${idColumn.Column}`;
+			return ` ${generateSafeFieldName(qualifiedIDColumn)}`;
 		}
 
 		var tmpFieldList = ' ';
@@ -801,7 +808,7 @@ var FoxHoundDialectMySQL = function()
 		var tmpTableName = generateTableName(pParameters);
 		var tmpJoin = generateJoins(pParameters);
 		var tmpWhere = generateWhere(pParameters);
-		// here, we ignore the distinct keyword if no fields have bene specified and
+		// here, we ignore the distinct keyword if no fields have been specified and
 		if (pParameters.distinct && tmpFieldList.length < 1)
 		{
 			console.warn('Distinct requested but no field list or schema are available, so not honoring distinct for count query.');

package/test/FoxHound-Dialect-ALASQL_tests.js

@@ -347,7 +347,7 @@ suite
 						// This is the query generated by the ALASQL dialect
 						libFable.log.trace('Custom Count Query', tmpQuery.query);
 						Expect(tmpQuery.query.body)
-							.to.equal('SELECT COUNT(DISTINCT *) AS RowCount FROM Animal WHERE `Age` = :Age_w0;');
+							.to.equal('SELECT COUNT(*) AS RowCount FROM Animal WHERE `Age` = :Age_w0;');
 					}
 				);
 				test
@@ -420,6 +420,43 @@ suite
 							.to.equal('SELECT COUNT(*) AS RowCount FROM Animal;');
 					}
 				);
+				test
+				(
+					'Count Query with Distinct',
+					function()
+					{
+						var tmpQuery = libFoxHound.new(libFable)
+							.setDialect('ALASQL')
+							.setScope('Animal')
+							.setDistinct(true);
+
+						// Build the query
+						tmpQuery.buildCountQuery();
+						// This is the query generated by the ALASQL dialect
+						libFable.log.trace('Count Query', tmpQuery.query);
+						Expect(tmpQuery.query.body)
+							.to.equal('SELECT COUNT(*) AS RowCount FROM Animal;');
+					}
+				);
+				test
+				(
+					'Count Query with Schema and Distinct',
+					function()
+					{
+						var tmpQuery = libFoxHound.new(libFable)
+							.setDialect('ALASQL')
+							.setScope('Animal')
+							.setDistinct(true);
+						tmpQuery.query.schema = _AnimalSchema;
+
+						// Build the query
+						tmpQuery.buildCountQuery();
+						// This is the query generated by the ALASQL dialect
+						libFable.log.trace('Count Query', tmpQuery.query);
+						Expect(tmpQuery.query.body)
+							.to.equal('SELECT COUNT(DISTINCT IDAnimal) AS RowCount FROM Animal WHERE `Deleted` = :Deleted_w0;');
+					}
+				);
 			}
 		);
 

package/test/FoxHound-Dialect-MeadowEndpoints_tests.js

@@ -123,6 +123,38 @@ suite
 					}
 				);
 				test
+				(
+					'Read Query single record',
+					function()
+					{
+						var tmpQuery = libFoxHound.new(libFable).setDialect('MeadowEndpoints').setScope('Animal');
+						tmpQuery.addFilter('IDAnimal', 1);
+						// Build the query
+						tmpQuery.buildReadQuery();
+						// This is the query generated by the MeadowEndpoints dialect
+						libFable.log.trace('Simple Select Query', tmpQuery.query);
+						Expect(tmpQuery.query.body)
+							.to.equal('Animal/1');
+					}
+				);
+				test
+				(
+					'Read Query single record with sort',
+					function()
+					{
+						// Because we added a sorting clause, this should be a READS
+						var tmpQuery = libFoxHound.new(libFable).setDialect('MeadowEndpoints').setScope('Animal');
+						tmpQuery.addFilter('IDAnimal', 1);
+						tmpQuery.addSort({Column:'Cost',Direction:'Descending'});
+						// Build the query
+						tmpQuery.buildReadQuery();
+						// This is the query generated by the MeadowEndpoints dialect
+						libFable.log.trace('Simple Select Query', tmpQuery.query);
+						Expect(tmpQuery.query.body)
+							.to.equal('Animals/FilteredTo/FBV~IDAnimal~EQ~1~FSF~Cost~DESC~0');
+					}
+				);
+				test
 				(
 					'Complex Read Query',
 					function()

package/test/FoxHound-Dialect-MySQL_tests.js

@@ -352,7 +352,7 @@ suite
 						// This is the query generated by the MySQL dialect
 						libFable.log.trace('Count Distinct Query', tmpQuery.query);
 						Expect(tmpQuery.query.body)
-							.to.equal('SELECT COUNT(DISTINCT `Animal`.`IDAnimal`, `Animal`.`GUIDAnimal`, `Animal`.`CreateDate`, `Animal`.`CreatingIDUser`, `Animal`.`UpdateDate`, `Animal`.`UpdatingIDUser`, `Animal`.`Deleted`, `Animal`.`DeletingIDUser`, `Animal`.`DeleteDate`) AS RowCount FROM `Animal` WHERE  `Animal`.Deleted = :Deleted_w0;');
+							.to.equal('SELECT COUNT(DISTINCT `Animal`.`IDAnimal`) AS RowCount FROM `Animal` WHERE  `Animal`.Deleted = :Deleted_w0;');
 					}
 				);
 				test

package/.travis.yml

@@ -1,16 +0,0 @@
-language: node_js
-node_js:
-  - "6"
-  - "8"
-  - "12"
-  - "15"
-addons:
-  code_climate:
-    repo_token: 41529c21a4a756d41a2d8d288c26c941479606cd39e7d89d476642d1ab3c86c3
-after_success:
-  - npm run coverage
-after_script:
-  - cat coverage/lcov.info | ./node_modules/codeclimate-test-reporter/bin/codeclimate.js
-  - cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js
-notifications:
-  slack: paviateam:C1q99hL9XXpiPpau2PUrVZPC