PostgreSQL alpha 1

forward_engineering/api.js

@@ -1,29 +1,31 @@
 const reApi = require('../reverse_engineering/api');
+const { createLogger } = require('../reverse_engineering/helpers/loggerHelper');
 const applyToInstanceHelper = require('./applyToInstanceHelper');
 
 module.exports = {
-	applyToInstance(connectionInfo, logger, callback, app) {
-		logger.clear();
-		logger.log('info', connectionInfo, 'connectionInfo', connectionInfo.hiddenKeys);
+    getDatabases(connectionInfo, logger, callback, app) {
+        logger.progress({ message: 'Find all databases' });
 
-		applyToInstanceHelper.applyToInstance(connectionInfo, logger, app)
-			.then(result => {
-				callback(null, result);
-			})
-			.catch(error => {
-				const err = {
-					message: error.message,
-					stack: error.stack,
-				};
-				logger.log('error', err, 'Error when applying to instance');
-				callback(err);
-			});
-	},
-	testConnection(connectionInfo, logger, callback, app) {
-		reApi.testConnection(connectionInfo, logger, callback, app)
-			.then(
-				callback,
-				callback
-			);
-	}
-};
+        reApi.getDatabases(connectionInfo, logger, callback, app);
+    },
+    applyToInstance(connectionInfo, logger, callback, app) {
+        logger.clear();
+        logger.log(
+            'info',
+            app.require('lodash').omit(connectionInfo, 'script', 'containerData'),
+            'connectionInfo',
+            connectionInfo.hiddenKeys
+        );
+
+        const postgresLogger = createLogger({
+            title: 'Apply to instance',
+            hiddenKeys: connectionInfo.hiddenKeys,
+            logger,
+        });
+
+        applyToInstanceHelper.applyToInstance(connectionInfo, postgresLogger, app).then(callback, callback);
+    },
+    testConnection(connectionInfo, logger, callback, app) {
+        reApi.testConnection(connectionInfo, logger, callback, app).then(callback, callback);
+    },
+};

forward_engineering/applyToInstanceHelper.js

@@ -1,43 +1,27 @@
-const connectionHelper = require('../reverse_engineering/helpers/connectionHelper');
-
-const removeDelimiter = (statement) => {
-	const regExp = /delimiter (.*)/i;
-
-	if (!regExp.test(statement)) {
-		return statement;
-	}
-
-	const delimiter = statement.match(regExp)[1];
-	const statementWithoutDelimiter = statement.replace(new RegExp(regExp, 'gi'), '');
-
-	return statementWithoutDelimiter.trim().replace(new RegExp(delimiter.split('').map(n => '\\' + n).join('') + '$'), '');
-};
+const postgresService = require('../reverse_engineering/helpers/postgresService');
 
 const applyToInstance = async (connectionInfo, logger, app) => {
-	const _ = app.require('lodash');
-	const async = app.require('async');
-	const connection = connectionHelper.createInstance(
-		await connectionHelper.connect(connectionInfo),
-		logger,
-	);
-
-	try {
-		const queries = connectionInfo.script.split('\n\n').map((query) => {
-			return removeDelimiter(_.trim(query));
-		}).filter(Boolean);
-		let i = 0;
+    try {
+        postgresService.setDependencies(app);
+        await postgresService.connect(connectionInfo, logger);
+        await postgresService.logVersion();
+        await postgresService.applyScript(removeCreateDbScript(connectionInfo.script));
+    } catch (error) {
+        logger.error(error);
+        throw prepareError(error);
+    }
+};
 
-		await async.mapSeries(queries, async query => {
-			const message = 'Query: ' + query.split('\n').shift().substr(0, 150);
-			logger.progress({ message });
-			await connection.query(query);
-		});
+const removeCreateDbScript = script => {
+    const createDbScriptRegexp = /CREATE DATABASE[^;]*;/gi;
 
-	} catch (e) {
-		connectionHelper.close();
-		throw e;
-	}
+    return script.replace(createDbScriptRegexp, '');
+};
 
+const prepareError = error => {
+    error = JSON.stringify(error, Object.getOwnPropertyNames(error));
+    error = JSON.parse(error);
+    return error;
 };
 
 module.exports = { applyToInstance };

forward_engineering/config.json

@@ -1,12 +1,19 @@
 {
 	"type": "ddl",
 	"ddlType": "plugin",
-	"namePrefix": "MariaDB",
+	"namePrefix": "PostgreSQL",
 	"level": {
 		"container": true,
 		"entity": true,
 		"view": true
 	},
-	"resolvedDefinitions": true,
-	"applyScriptToInstance": true
+	"applyScriptToInstance": true,
+	"applyToInstanceSettings": {
+		"scenario": "getDatabases"
+	},
+	"combinedContainers": true,
+	"feLevelSelector": {
+		"container": true,
+		"model": true
+	}
 }

forward_engineering/configs/defaultTypes.js

@@ -1,12 +1,12 @@
 module.exports = {
-	number: 'NUMBER',
-	string: 'TEXT',
-	date: 'DATE',
-	timestamp: 'TIMESTAMP',
-	binary: 'BINARY',
-	boolean: 'BIT',
-	document: 'LONGTEXT',
-	array: 'LONGTEXT',
-	objectId: 'VARCHAR(24)',
-	default: 'CHAR',
+    number: 'numeric',
+    string: 'text',
+    date: 'date',
+    timestamp: 'timestamp',
+    binary: 'bytea',
+    boolean: 'boolean',
+    document: 'jsonb',
+    array: 'jsonb',
+    objectId: 'uuid',
+    default: 'char',
 };

forward_engineering/configs/templates.js

@@ -1,42 +1,50 @@
 module.exports = {
-	createDatabase: 'CREATE${orReplace} DATABASE${ifNotExist} `${name}`${dbOptions};\n\nUSE `${name}`;\n',
+    createDatabase: 'CREATE DATABASE ${name}${template}${encoding}${locale}${collate}${characterClassification}${tablespace};\n',
 
-	createTable:
-		'CREATE ${orReplace}${temporary}TABLE ${ifNotExist}${name} (\n' +
-		'\t${column_definitions}${keyConstraints}${checkConstraints}${foreignKeyConstraints}\n' +
-		')${options}${partitions}${selectStatement};\n',
+    createSchema: 'CREATE SCHEMA${ifNotExist} ${name};\nSET search_path TO ${name};\n${comment}\n',
 
-	createLikeTable: 'CREATE ${orReplace}${temporary}TABLE ${ifNotExist}${name} LIKE ${likeTableName};\n',
+    comment: 'COMMENT ON ${object} ${objectName} IS ${comment};\n',
 
-	columnDefinition:
-		'`${name}` ${national}${type}${signed}${primary_key}${unique_key}${default}${autoIncrement}${zeroFill}${not_null}${invisible}${compressed}${charset}${collate}${comment}',
+    createTable:
+        'CREATE${temporary} TABLE${ifNotExist} ${name} (\n' +
+        '${columnDefinitions}${keyConstraints}${checkConstraints}${foreignKeyConstraints}\n' +
+        ')${options};\n${comment}${columnDescriptions}',
 
-	checkConstraint: 'CONSTRAINT ${name}CHECK (${expression})',
+    columnDefinition: '${name} ${type}${collation}${primaryKey}${uniqueKey}${defaultValue}${notNull}',
 
-	createForeignKeyConstraint:
-		'CONSTRAINT `${name}` FOREIGN KEY (${foreignKey}) REFERENCES ${primaryTable}(${primaryKey})',
+    checkConstraint: '${name} CHECK (${expression})${noInherit}',
 
-	createKeyConstraint: '${constraintName}${keyType}${columns}${using}${blockSize}${comment}${ignore}',
+    createForeignKeyConstraint: '${name} FOREIGN KEY (${foreignKey}) REFERENCES ${primaryTable} (${primaryKey})',
 
-	createForeignKey:
-		'ALTER TABLE ${foreignTable} ADD CONSTRAINT `${name}` FOREIGN KEY (${foreignKey}) REFERENCES ${primaryTable}(${primaryKey});',
+    createKeyConstraint: '${constraintName}${keyType}${columns}${includeNonKey}${storageParameters}${tablespace}',
 
-	index:
-		'CREATE ${indexType}INDEX ${ifNotExist}${name}${indexCategory}\n' +
-		'\tON ${table} ( ${keys} )${indexOptions};\n',
+    createForeignKey:
+        'ALTER TABLE IF EXISTS ${foreignTable} ADD CONSTRAINT ${name} FOREIGN KEY (${foreignKey}) REFERENCES ${primaryTable}(${primaryKey});',
 
-	createView:
-		'CREATE ${orReplace}${algorithm}${sqlSecurity}VIEW ${ifNotExist}${name} AS ${selectStatement}${checkOption};\n',
+    index:
+        'CREATE${unique} INDEX${concurrently}${ifNotExist} ${name}\n' +
+        ' ON${only} ${tableName}${using}${keys}${options};\n\n',
 
-	viewSelectStatement: 'SELECT ${keys}\n\tFROM ${tableName}',
+    createView:
+        'CREATE${orReplace}${temporary} VIEW ${name}${withOptions}\nAS ${selectStatement}${checkOption};\n${comment}\n',
 
-	createFunction:
-		'CREATE ${orReplace}${aggregate}FUNCTION ${ifNotExist}${name}\n' +
-		'\t(${parameters})\n' +
-		'\tRETURNS ${type}\n' +
-		'\t${characteristics}\n' +
-		'${body}${delimiter}\n',
+    viewSelectStatement: 'SELECT ${keys}\n\tFROM ${tableName}',
 
-	createProcedure:
-		'CREATE ${orReplace}PROCEDURE ${name} (${parameters})\n' + '\t${characteristics}\n' + '${body}${delimiter}\n',
+    createFunction:
+        'CREATE${orReplace} FUNCTION ${name}\n' +
+        '\t(${parameters})\n' +
+        '\tRETURNS ${returnType}\n' +
+        '\tLANGUAGE ${language}\n' +
+        '${properties}' +
+        'AS $BODY$\n${definition}\n$BODY$;\n',
+
+    createProcedure:
+        'CREATE${orReplace} PROCEDURE ${name} (${parameters})\n' +
+        '\tLANGUAGE ${language}\n' +
+        'AS $BODY$\n${body}\n$BODY$;\n',
+
+    createCompositeType: 'CREATE TYPE ${name} AS (\n\t${columnDefinitions}\n);\n${comment}',
+    createEnumType: 'CREATE TYPE ${name} AS ENUM (${values});\n${comment}',
+    createRangeType: 'CREATE TYPE ${name} AS RANGE (\n\tSUBTYPE=${subtype}${options}\n);\n${comment}',
+    createDomainType: 'CREATE DOMAIN ${name} AS ${underlyingType}${notNull}${collate}${default}${constraints};\n${comment}'
 };