HCK-15522: Add support for procedures (FE)

forward_engineering/configs/templates.js

@@ -72,4 +72,6 @@ module.exports = {
 	dropView: 'DROP VIEW IF EXISTS ${name}${terminator}',
 
 	alterView: 'ALTER VIEW ${name}\nAS ${select_statement}${terminator}',
+
+	createProcedure: 'CREATE PROCEDURE ${name}${arguments}\nAS\n${body}${terminator}',
 };

forward_engineering/ddlProvider.js

@@ -42,46 +42,48 @@ const {
 	createDefaultConstraint,
 	generateConstraintsString,
 } = require('./helpers/constraintsHelper');
+const { hydrateProcedures } = require('./helpers/proceduresHelper');
 
 const provider = (baseProvider, options, app) => {
 	const terminator = getTerminator(options);
 
 	return {
-		createSchema({ schemaName, databaseName, ifNotExist, isActivated = true }) {
+		createSchema({ schemaName, databaseName, ifNotExist, procedures = [], isActivated = true }) {
 			const schemaTerminator = ifNotExist ? ';' : terminator;
-			let schemaStatement = commentIfDeactivated(
-				assignTemplates(templates.createSchema, {
-					name: schemaName,
-					terminator: schemaTerminator,
-				}),
-				{ isActivated },
-			);
 
-			if (!databaseName) {
-				return ifNotExist
-					? wrapIfNotExistSchema({ templates, schemaStatement, schemaName, terminator })
-					: schemaStatement;
+			let databaseStatement = '';
+			let schemaStatement = '';
+
+			schemaStatement = assignTemplates(templates.createSchema, {
+				name: schemaName,
+				terminator: schemaTerminator,
+			});
+
+			schemaStatement = commentIfDeactivated(schemaStatement, { isActivated });
+
+			if (ifNotExist) {
+				schemaStatement = wrapIfNotExistSchema({ templates, schemaStatement, schemaName, terminator });
 			}
 
-			const databaseStatement = wrapIfNotExistDatabase({
-				templates,
-				databaseName,
-				terminator,
-				databaseStatement: assignTemplates(templates.createDatabase, {
+			if (databaseName) {
+				databaseStatement = assignTemplates(templates.createDatabase, {
 					name: databaseName,
 					terminator: schemaTerminator,
-				}),
-			});
+				});
 
-			if (ifNotExist) {
-				return (
-					databaseStatement +
-					'\n\n' +
-					wrapIfNotExistSchema({ templates, schemaStatement, schemaName, terminator })
-				);
+				databaseStatement = wrapIfNotExistDatabase({
+					templates,
+					databaseName,
+					terminator,
+					databaseStatement,
+				});
 			}
 
-			return databaseStatement + '\n\n' + schemaStatement;
+			const procedureStatements = procedures.map(procedure =>
+				this.createProcedure({ ...procedure, schemaName, isActivated }),
+			);
+
+			return [databaseStatement, schemaStatement, ...procedureStatements].filter(Boolean).join('\n\n');
 		},
 
 		createTable(
@@ -369,12 +371,13 @@ const provider = (baseProvider, options, app) => {
 			return hydrateTableIndex(indexData, schemaData);
 		},
 
-		hydrateSchema(containerData) {
+		hydrateSchema(containerData, { procedures } = {}) {
 			return {
 				schemaName: containerData.name,
 				databaseName: containerData.databaseName,
 				ifNotExist: containerData.ifNotExist,
 				isActivated: containerData.isActivated,
+				procedures: hydrateProcedures(procedures),
 			};
 		},
 
@@ -599,6 +602,20 @@ const provider = (baseProvider, options, app) => {
 				terminator: viewTerminator,
 			});
 		},
+
+		createProcedure({ schemaName, isActivated, name, inputArgs, body }) {
+			const procedureName = getTableName(name, schemaName);
+			const args = inputArgs ? `\n${inputArgs.replace(/^\(([\s\S]+)\)$/, '$1')}` : '';
+
+			const procedureStatement = assignTemplates(templates.createProcedure, {
+				name: procedureName,
+				arguments: args,
+				body,
+				terminator,
+			});
+
+			return commentIfDeactivated(procedureStatement, { isActivated });
+		},
 	};
 };
 

forward_engineering/helpers/proceduresHelper.js

@@ -0,0 +1,30 @@
+/**
+ * @typedef {import('../types').Procedure} Procedure
+ */
+const { trim } = require('lodash');
+const { clean, tab } = require('../utils/general');
+
+/**
+ *
+ * @param {Procedure[]} [procedures]
+ * @returns {Procedure[]}
+ */
+const hydrateProcedures = procedures => {
+	if (!Array.isArray(procedures)) {
+		return [];
+	}
+
+	return procedures
+		.map(procedure => {
+			return clean({
+				name: procedure.name || undefined,
+				inputArgs: procedure.inputArgs ? tab(trim(procedure.inputArgs)) : undefined,
+				body: procedure.body || undefined,
+			});
+		})
+		.filter(procedure => procedure.name);
+};
+
+module.exports = {
+	hydrateProcedures,
+};

forward_engineering/types.d.ts

@@ -1,26 +1,32 @@
 export type ColumnDefinition = {
-  name: string;
-  type: string;
-  isActivated: boolean;
-  length?: number;
-  precision?: number;
-  primaryKey?: boolean;
-  scale?: number;
-  timePrecision?: number;
-  unique?: boolean;
+	name: string;
+	type: string;
+	isActivated: boolean;
+	length?: number;
+	precision?: number;
+	primaryKey?: boolean;
+	scale?: number;
+	timePrecision?: number;
+	unique?: boolean;
 };
 
 export type ConstraintDtoColumn = {
-  name: string;
-  isActivated: boolean;
+	name: string;
+	isActivated: boolean;
 };
 
 export type KeyType = 'PRIMARY KEY' | 'UNIQUE';
 
 export type ConstraintDto = {
-  keyType: KeyType;
-  name: string;
-  columns?: ConstraintDtoColumn[];
+	keyType: KeyType;
+	name: string;
+	columns?: ConstraintDtoColumn[];
 };
 
 export type JsonSchema = Record<string, unknown>;
+
+export type Procedure = {
+	name: string;
+	inputArgs?: string;
+	body?: string;
+};

properties_pane/container_level/containerLevelConfig.json

@@ -161,5 +161,61 @@ making sure that you maintain a proper JSON format.
 			}
 		],
 		"containerLevelKeys": []
+	},
+	{
+		"lowerTab": "Procedures",
+		"structure": [
+			{
+				"propertyName": "Procedure",
+				"propertyType": "group",
+				"propertyKeyword": "Procedures",
+				"propertyTooltip": "Creates a new stored procedure or alter an existing procedure for the current schema.",
+				"structure": [
+					{
+						"propertyName": "Name",
+						"propertyKeyword": "name",
+						"propertyTooltip": "The name of the procedure.",
+						"propertyType": "text"
+					},
+					{
+						"propertyName": "Arguments",
+						"propertyKeyword": "inputArgs",
+						"propertyTooltip": "A list of arguments' names and their data types.",
+						"propertyType": "details",
+						"markdown": false,
+						"template": "codeEditor",
+						"templateOptions": {
+							"editorDialect": "sql"
+						}
+					},
+					{
+						"propertyName": "Procedure body",
+						"propertyKeyword": "body",
+						"propertyTooltip": "Valid SQL procedure statement.",
+						"propertyType": "details",
+						"markdown": false,
+						"template": "codeEditor",
+						"templateOptions": {
+							"editorDialect": "sql"
+						}
+					},
+					{
+						"propertyName": "Comments",
+						"propertyKeyword": "description",
+						"propertyType": "details",
+						"template": "textarea"
+					},
+					{
+						"propertyName": "Remarks",
+						"propertyKeyword": "comments",
+						"shouldValidate": false,
+						"propertyTooltip": "comments",
+						"addTimestampButton": false,
+						"propertyType": "details",
+						"template": "textarea"
+					}
+				]
+			}
+		]
 	}
 ]