meadow-connection-postgresql 1.0.0

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "meadow-connection-postgresql",
+  "version": "1.0.0",
+  "description": "Meadow PostgreSQL Connection Plugin",
+  "main": "source/Meadow-Connection-PostgreSQL.js",
+  "scripts": {
+    "coverage": "npx quack coverage",
+    "test": "npx quack test"
+  },
+  "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",
+    "url": "https://github.com/stevenvelozo/meadow-connection-postgresql.git"
+  },
+  "keywords": [
+    "meadow",
+    "postgresql",
+    "database"
+  ],
+  "author": "Steven Velozo <steven@velozo.com> (http://velozo.com/)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/stevenvelozo/meadow-connection-postgresql/issues"
+  },
+  "homepage": "https://github.com/stevenvelozo/meadow-connection-postgresql",
+  "devDependencies": {
+    "fable": "^3.1.55",
+    "quackage": "^1.0.58"
+  },
+  "dependencies": {
+    "fable-serviceproviderbase": "^3.0.18",
+    "pg": "^8.13.0"
+  }
+}

package/source/Meadow-Connection-PostgreSQL.js

@@ -0,0 +1,254 @@
+/**
+* Meadow PostgreSQL Provider Fable Service
+* @author Steven Velozo <steven@velozo.com>
+*/
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
+const libPG = require('pg');
+
+class MeadowConnectionPostgreSQL extends libFableServiceProviderBase
+{
+	constructor(pFable, pManifest, pServiceHash)
+	{
+		super(pFable, pManifest, pServiceHash);
+
+		this.serviceType = 'MeadowConnectionPostgreSQL';
+
+		// See if the user passed in a PostgreSQL object already
+		if (typeof(this.options.PostgreSQL) == 'object')
+		{
+			// Test if this needs property coercion from the old format to the raw
+			if (!this.options.PostgreSQL.hasOwnProperty('max') && this.options.PostgreSQL.hasOwnProperty('ConnectionPoolLimit'))
+			{
+				this.options.PostgreSQL.max = this.options.PostgreSQL.ConnectionPoolLimit;
+			}
+			if (!this.options.PostgreSQL.hasOwnProperty('host') && this.options.PostgreSQL.hasOwnProperty('Server'))
+			{
+				this.options.PostgreSQL.host = this.options.PostgreSQL.Server;
+			}
+			if (!this.options.PostgreSQL.hasOwnProperty('port') && this.options.PostgreSQL.hasOwnProperty('Port'))
+			{
+				this.options.PostgreSQL.port = this.options.PostgreSQL.Port;
+			}
+			if (!this.options.PostgreSQL.hasOwnProperty('user') && this.options.PostgreSQL.hasOwnProperty('User'))
+			{
+				this.options.PostgreSQL.user = this.options.PostgreSQL.User;
+			}
+			if (!this.options.PostgreSQL.hasOwnProperty('password') && this.options.PostgreSQL.hasOwnProperty('Password'))
+			{
+				this.options.PostgreSQL.password = this.options.PostgreSQL.Password;
+			}
+			if (!this.options.PostgreSQL.hasOwnProperty('database') && this.options.PostgreSQL.hasOwnProperty('Database'))
+			{
+				this.options.PostgreSQL.database = this.options.PostgreSQL.Database;
+			}
+		}
+		else if (typeof(this.fable.settings.PostgreSQL) == 'object')
+		{
+			this.options.PostgreSQL = (
+				{
+					max: this.fable.settings.PostgreSQL.ConnectionPoolLimit,
+					host: this.fable.settings.PostgreSQL.Server,
+					port: this.fable.settings.PostgreSQL.Port,
+					user: this.fable.settings.PostgreSQL.User,
+					password: this.fable.settings.PostgreSQL.Password,
+					database: this.fable.settings.PostgreSQL.Database
+				});
+		}
+
+		if (!this.options.MeadowConnectionPostgreSQLAutoConnect)
+		{
+			// See if there is a global autoconnect
+			this.options.MeadowConnectionPostgreSQLAutoConnect = this.fable.settings.MeadowConnectionPostgreSQLAutoConnect;
+		}
+
+		this.serviceType = 'MeadowConnectionPostgreSQL';
+		this._ConnectionPool = false;
+		this.connected = false;
+
+		if (this.options.MeadowConnectionPostgreSQLAutoConnect)
+		{
+			this.connect();
+		}
+	}
+
+	generateDropTableStatement(pTableName)
+	{
+		return `DROP TABLE IF EXISTS "${pTableName}";`;
+	}
+
+	generateCreateTableStatement(pMeadowTableSchema)
+	{
+		this.log.info(`--> Building the table create string for ${pMeadowTableSchema} ...`);
+
+		let tmpPrimaryKey = false;
+		let tmpCreateTableStatement = `--   [ ${pMeadowTableSchema.TableName} ]`;
+
+		tmpCreateTableStatement += `\nCREATE TABLE IF NOT EXISTS\n    "${pMeadowTableSchema.TableName}"\n    (`;
+		for (let j = 0; j < pMeadowTableSchema.Columns.length; j++)
+		{
+			let tmpColumn = pMeadowTableSchema.Columns[j];
+
+			// If we aren't the first column, append a comma.
+			if (j > 0)
+			{
+				tmpCreateTableStatement += `,`;
+			}
+
+			tmpCreateTableStatement += `\n`;
+			// Dump out each column......
+			switch (tmpColumn.DataType)
+			{
+				case 'ID':
+					tmpCreateTableStatement += `        "${tmpColumn.Column}" SERIAL PRIMARY KEY`;
+					tmpPrimaryKey = tmpColumn.Column;
+					break;
+				case 'GUID':
+					let tmpSize = tmpColumn.hasOwnProperty('Size') ? tmpColumn.Size : 36;
+					if (isNaN(tmpSize))
+					{
+						// Use the old default if Size is improper
+						tmpSize = 36;
+					}
+					tmpCreateTableStatement += `        "${tmpColumn.Column}" VARCHAR(${tmpSize}) DEFAULT '0xDe'`;
+					break;
+				case 'ForeignKey':
+					tmpCreateTableStatement += `        "${tmpColumn.Column}" INTEGER NOT NULL DEFAULT 0`;
+					break;
+				case 'Numeric':
+					tmpCreateTableStatement += `        "${tmpColumn.Column}" INTEGER NOT NULL DEFAULT 0`;
+					break;
+				case 'Decimal':
+					tmpCreateTableStatement += `        "${tmpColumn.Column}" DECIMAL(${tmpColumn.Size})`;
+					break;
+				case 'String':
+					tmpCreateTableStatement += `        "${tmpColumn.Column}" VARCHAR(${tmpColumn.Size}) NOT NULL DEFAULT ''`;
+					break;
+				case 'Text':
+					tmpCreateTableStatement += `        "${tmpColumn.Column}" TEXT`;
+					break;
+				case 'DateTime':
+					tmpCreateTableStatement += `        "${tmpColumn.Column}" TIMESTAMP`;
+					break;
+				case 'Boolean':
+					tmpCreateTableStatement += `        "${tmpColumn.Column}" BOOLEAN NOT NULL DEFAULT false`;
+					break;
+				default:
+					break;
+			}
+		}
+		// PostgreSQL SERIAL PRIMARY KEY is declared inline; no separate PRIMARY KEY clause needed
+		tmpCreateTableStatement += `\n    );`;
+
+		return tmpCreateTableStatement;
+	}
+
+	createTables(pMeadowSchema, fCallback)
+	{
+		this.fable.Utility.eachLimit(pMeadowSchema.Tables, 1,
+			(pTable, fCreateComplete) =>
+			{
+				return this.createTable(pTable, fCreateComplete);
+			},
+			(pCreateError) =>
+			{
+				if (pCreateError)
+				{
+					this.log.error(`Meadow-PostgreSQL Error creating tables from Schema: ${pCreateError}`, pCreateError);
+				}
+				this.log.info('Done creating tables!');
+				return fCallback(pCreateError);
+			});
+	}
+
+	createTable(pMeadowTableSchema, fCallback)
+	{
+		let tmpCreateTableStatement = this.generateCreateTableStatement(pMeadowTableSchema);
+		this._ConnectionPool.query(tmpCreateTableStatement,
+			(pError, pResult) =>
+			{
+				if (pError)
+				{
+					// Check for "already exists" type errors
+					if (pError.code === '42P07')
+					{
+						// 42P07 = duplicate_table
+						this.log.warn(`Meadow-PostgreSQL CREATE TABLE ${pMeadowTableSchema.TableName} executed but table already existed.`);
+						return fCallback();
+					}
+					else
+					{
+						this.log.error(`Meadow-PostgreSQL CREATE TABLE ${pMeadowTableSchema.TableName} failed!`, pError);
+						return fCallback(pError);
+					}
+				}
+				else
+				{
+					this.log.info(`Meadow-PostgreSQL CREATE TABLE ${pMeadowTableSchema.TableName} executed successfully.`);
+					return fCallback();
+				}
+			});
+	}
+
+	connect()
+	{
+		let tmpConnectionSettings = (
+			{
+				max: this.options.PostgreSQL.max,
+				host: this.options.PostgreSQL.host,
+				port: this.options.PostgreSQL.port,
+				user: this.options.PostgreSQL.user,
+				password: this.options.PostgreSQL.password,
+				database: this.options.PostgreSQL.database
+			});
+		if (this._ConnectionPool)
+		{
+			let tmpCleansedLogSettings = JSON.parse(JSON.stringify(tmpConnectionSettings));
+			// No leaking passwords!
+			tmpCleansedLogSettings.password = '*****************';
+			this.log.error(`Meadow-Connection-PostgreSQL trying to connect but is already connected - skipping the generation of extra connections.`, tmpCleansedLogSettings);
+		}
+		else
+		{
+			this.fable.log.info(`Meadow-Connection-PostgreSQL connecting to [${this.options.PostgreSQL.host} : ${this.options.PostgreSQL.port}] as ${this.options.PostgreSQL.user} for database ${this.options.PostgreSQL.database} at a pool limit of ${this.options.PostgreSQL.max}`);
+			this._ConnectionPool = new libPG.Pool(tmpConnectionSettings);
+			this.connected = true;
+		}
+	}
+
+	connectAsync(fCallback)
+	{
+		let tmpCallback = fCallback;
+		if (typeof (tmpCallback) !== 'function')
+		{
+			this.log.error(`Meadow PostgreSQL connectAsync() called without a callback; this could lead to connection race conditions.`);
+			tmpCallback = () => { };
+		}
+
+		try
+		{
+			// Create the pool if it doesn't exist
+			if (this._ConnectionPool)
+			{
+				return tmpCallback(null, this._ConnectionPool);
+			}
+			else
+			{
+				this.connect();
+				return tmpCallback(null, this._ConnectionPool);
+			}
+		}
+		catch(pError)
+		{
+			this.log.error(`Meadow PostgreSQL connectAsync() trapped an error trying to connect to server: ${pError}`, pError);
+			return tmpCallback(pError);
+		}
+	}
+
+	get pool()
+	{
+		return this._ConnectionPool;
+	}
+}
+
+module.exports = MeadowConnectionPostgreSQL;

package/test/PostgreSQL_tests.js

@@ -0,0 +1,148 @@
+/**
+* Unit tests for Meadow Connection PostgreSQL
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+const Chai = require('chai');
+const Expect = Chai.expect;
+
+const libFable = require('fable');
+const libMeadowConnectionPostgreSQL = require('../source/Meadow-Connection-PostgreSQL.js');
+
+const _FableConfig = (
+	{
+		"Product": "MeadowPostgreSQLTest",
+		"ProductVersion": "1.0.0",
+
+		"UUID":
+			{
+				"DataCenter": 0,
+				"Worker": 0
+			},
+		"LogStreams":
+			[
+				{
+					"streamtype": "console"
+				}
+			],
+
+		"PostgreSQL":
+			{
+				"Server": "127.0.0.1",
+				"Port": 5432,
+				"User": "postgres",
+				"Password": "testpassword",
+				"Database": "testdb",
+				"ConnectionPoolLimit": 20
+			}
+	});
+
+suite
+(
+	'Meadow-Connection-PostgreSQL',
+	() =>
+	{
+		setup(() => {});
+
+		suite
+		(
+			'Object Sanity',
+			() =>
+			{
+				test
+				(
+					'constructor should create a connection service',
+					() =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowPostgreSQLProvider', libMeadowConnectionPostgreSQL);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowPostgreSQLProvider');
+
+						Expect(_Fable.MeadowPostgreSQLProvider).to.be.an('object');
+						Expect(_Fable.MeadowPostgreSQLProvider.serviceType).to.equal('MeadowConnectionPostgreSQL');
+						Expect(_Fable.MeadowPostgreSQLProvider.connected).to.equal(false);
+					}
+				);
+				test
+				(
+					'pass in your own settings',
+					() =>
+					{
+						let _Fable = new libFable();
+						_Fable.serviceManager.addServiceType('MeadowPostgreSQLProvider', libMeadowConnectionPostgreSQL);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowPostgreSQLProvider', {PostgreSQL: _FableConfig.PostgreSQL});
+
+						Expect(_Fable.MeadowPostgreSQLProvider).to.be.an('object');
+						Expect(_Fable.MeadowPostgreSQLProvider.serviceType).to.equal('MeadowConnectionPostgreSQL');
+						Expect(_Fable.MeadowPostgreSQLProvider.connected).to.equal(false);
+					}
+				);
+			}
+		);
+		suite
+		(
+			'DDL Generation',
+			() =>
+			{
+				test
+				(
+					'generateCreateTableStatement produces valid PostgreSQL DDL',
+					() =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowPostgreSQLProvider', libMeadowConnectionPostgreSQL);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowPostgreSQLProvider');
+
+						let tmpSchema = {
+							TableName: 'Animal',
+							Columns: [
+								{ Column: 'IDAnimal', DataType: 'ID' },
+								{ Column: 'GUIDAnimal', DataType: 'GUID', Size: 36 },
+								{ Column: 'Name', DataType: 'String', Size: 128 },
+								{ Column: 'Age', DataType: 'Numeric' },
+								{ Column: 'Cost', DataType: 'Decimal', Size: '10,2' },
+								{ Column: 'Description', DataType: 'Text' },
+								{ Column: 'Birthday', DataType: 'DateTime' },
+								{ Column: 'Active', DataType: 'Boolean' },
+								{ Column: 'IDFarm', DataType: 'ForeignKey' }
+							]
+						};
+
+						let tmpResult = _Fable.MeadowPostgreSQLProvider.generateCreateTableStatement(tmpSchema);
+						Expect(tmpResult).to.contain('CREATE TABLE IF NOT EXISTS');
+						Expect(tmpResult).to.contain('"Animal"');
+						Expect(tmpResult).to.contain('SERIAL PRIMARY KEY');
+						Expect(tmpResult).to.contain('VARCHAR(36)');
+						Expect(tmpResult).to.contain('VARCHAR(128)');
+						Expect(tmpResult).to.contain('INTEGER NOT NULL DEFAULT 0');
+						Expect(tmpResult).to.contain('DECIMAL(10,2)');
+						Expect(tmpResult).to.contain('TEXT');
+						Expect(tmpResult).to.contain('TIMESTAMP');
+						Expect(tmpResult).to.contain('BOOLEAN NOT NULL DEFAULT false');
+						// Should NOT contain MySQL-specific syntax
+						Expect(tmpResult).to.not.contain('AUTO_INCREMENT');
+						Expect(tmpResult).to.not.contain('TINYINT');
+						Expect(tmpResult).to.not.contain('CHARSET');
+						Expect(tmpResult).to.not.contain('COLLATE');
+					}
+				);
+				test
+				(
+					'generateDropTableStatement produces valid PostgreSQL DDL',
+					() =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowPostgreSQLProvider', libMeadowConnectionPostgreSQL);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowPostgreSQLProvider');
+
+						let tmpResult = _Fable.MeadowPostgreSQLProvider.generateDropTableStatement('Animal');
+						Expect(tmpResult).to.equal('DROP TABLE IF EXISTS "Animal";');
+					}
+				);
+			}
+		);
+	}
+);