@steroidsjs/nest 3.0.0 → 3.0.2

package/infrastructure/commands/generate/CustomPostgresQueryRunner.js

@@ -29,11 +29,20 @@ class TableSqlInMemory extends SqlInMemory_1.SqlInMemory {
     }
 }
 exports.TableSqlInMemory = TableSqlInMemory;
+/**
+ * Runs queries on a single postgres database connection.
+ */
 class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunner {
     constructor() {
         super(...arguments);
+        /**
+         * Sql-s stored if "sql in memory" mode is enabled.
+         */
         this.sqlInMemory = new TableSqlInMemory();
     }
+    /**
+     * Creates a new table.
+     */
     async createTable(table, ifNotExist = false, createForeignKeys = true, createIndices = true) {
         if (ifNotExist) {
             const isTableExist = await this.hasTable(table);
@@ -42,17 +51,21 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         }
         const upQueries = [];
         const downQueries = [];
+        // if table have column with ENUM type, we must create this type in postgres.
         const enumColumns = table.columns.filter(column => column.type === "enum" || column.type === "simple-enum");
         const createdEnumTypes = [];
         for (const column of enumColumns) {
+            // TODO: Should also check if values of existing type matches expected ones
             const hasEnum = await this.hasEnumType(table, column);
             const enumName = this.buildEnumName(table, column);
+            // if enum with the same "enumName" is defined more then once, me must prevent double creation
             if (!hasEnum && createdEnumTypes.indexOf(enumName) === -1) {
                 createdEnumTypes.push(enumName);
                 upQueries.push(new TableQuery(table.name, this.createEnumTypeSql(table, column, enumName)));
                 downQueries.push(new TableQuery(table.name, this.dropEnumTypeSql(table, column, enumName)));
             }
         }
+        // if table have column with generated type, we must add the expression to the metadata table
         const generatedColumns = table.columns.filter(column => column.generatedType === "STORED" && column.asExpression);
         for (const column of generatedColumns) {
             const tableNameWithSchema = (await this.getTableNameWithSchema(table.name)).split('.');
@@ -79,10 +92,13 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         }
         upQueries.push(new TableQuery(table.name, this.createTableSql(table, createForeignKeys)));
         downQueries.push(new TableQuery(table.name, this.dropTableSql(table)));
+        // if createForeignKeys is true, we must drop created foreign keys in down query.
+        // createTable does not need separate method to create foreign keys, because it create fk's in the same query with table creation.
         if (createForeignKeys)
             table.foreignKeys.forEach(foreignKey => downQueries.push(new TableQuery(table.name, this.dropForeignKeySql(table, foreignKey))));
         if (createIndices) {
             table.indices.forEach(index => {
+                // new index may be passed without name. In this case we generate index name manually.
                 if (!index.name)
                     index.name = this.connection.namingStrategy.indexName(table, index.columnNames, index.where);
                 upQueries.push(new TableQuery(table.name, this.createIndexSql(table, index)));
@@ -91,12 +107,17 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         }
         await this.executeQueries(upQueries, downQueries);
     }
+    /**
+     * Drops the table.
+     */
     async dropTable(target, ifExist, dropForeignKeys = true, dropIndices = true) {
+        // to perform drop queries for foreign keys and indices.
         if (ifExist) {
             const isTableExist = await this.hasTable(target);
             if (!isTableExist)
                 return Promise.resolve();
         }
+        // if dropTable called with dropForeignKeys = true, we must create foreign keys in down query.
         const createForeignKeys = dropForeignKeys;
         const tablePath = this.getTablePath(target);
         const table = await this.getCachedTable(tablePath);
@@ -114,6 +135,9 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         downQueries.push(new TableQuery(table.name, this.createTableSql(table, createForeignKeys)));
         await this.executeQueries(upQueries, downQueries);
     }
+    /**
+     * Creates a new column from the column in the table.
+     */
     async addColumn(tableOrName, column) {
         const table = tableOrName instanceof Table_1.Table ? tableOrName : await this.getCachedTable(tableOrName);
         const clonedTable = table.clone();
@@ -130,8 +154,10 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
             ADD ${this.buildCreateColumnSql(table, column)}`)));
         downQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
             DROP COLUMN "${column.name}"`)));
+        // create or update primary key constraint
         if (column.isPrimary) {
             const primaryColumns = clonedTable.primaryColumns;
+            // if table already have primary key, me must drop it and recreate again
             if (primaryColumns.length > 0) {
                 const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map(column => column.name));
                 const columnNames = primaryColumns.map(column => `"${column.name}"`).join(", ");
@@ -148,11 +174,13 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
             downQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                 DROP CONSTRAINT "${pkName}"`)));
         }
+        // create column index
         const columnIndex = clonedTable.indices.find(index => index.columnNames.length === 1 && index.columnNames[0] === column.name);
         if (columnIndex) {
             upQueries.push(new TableQuery(table.name, this.createIndexSql(table, columnIndex)));
             downQueries.push(new TableQuery(table.name, this.dropIndexSql(table, columnIndex)));
         }
+        // create unique constraint
         if (column.isUnique) {
             const uniqueConstraint = new TableUnique_1.TableUnique({
                 name: this.connection.namingStrategy.uniqueConstraintName(table, [column.name]),
@@ -187,6 +215,7 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
             upQueries.push(new TableQuery(tableName, insertQuery));
             downQueries.push(new TableQuery(tableName, deleteQuery));
         }
+        // create column's comment
         if (column.comment) {
             upQueries.push(new TableQuery(table.name, new Query_1.Query(`COMMENT ON COLUMN ${this.escapePath(table)}."${column.name}" IS ${this.escapeComment(column.comment)}`)));
             downQueries.push(new TableQuery(table.name, new Query_1.Query(`COMMENT ON COLUMN ${this.escapePath(table)}."${column.name}" IS ${this.escapeComment(column.comment)}`)));
@@ -195,6 +224,9 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         clonedTable.addColumn(column);
         this.replaceCachedTable(table, clonedTable);
     }
+    /**
+     * Renames column in the given table.
+     */
     async renameColumn(tableOrName, oldTableColumnOrName, newTableColumnOrName) {
         const table = tableOrName instanceof Table_1.Table ? tableOrName : await this.getCachedTable(tableOrName);
         const oldColumn = oldTableColumnOrName instanceof TableColumn_1.TableColumn ? oldTableColumnOrName : table.columns.find(c => c.name === oldTableColumnOrName);
@@ -210,6 +242,9 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         }
         return this.changeColumn(table, oldColumn, newColumn);
     }
+    /**
+     * Changes a column in the table.
+     */
     async changeColumn(tableOrName, oldTableColumnOrName, newColumn) {
         const table = tableOrName instanceof Table_1.Table ? tableOrName : await this.getCachedTable(tableOrName);
         let clonedTable = table.clone();
@@ -226,33 +261,42 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
             || newColumn.isArray !== oldColumn.isArray
             || (!oldColumn.generatedType && newColumn.generatedType === "STORED")
             || (oldColumn.asExpression !== newColumn.asExpression && newColumn.generatedType === "STORED")) {
+            // To avoid data conversion, we just recreate column
             await this.dropColumn(table, oldColumn);
             await this.addColumn(table, newColumn);
+            // update cloned table
             clonedTable = table.clone();
         }
         else {
             if (oldColumn.name !== newColumn.name) {
+                // rename column
                 upQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                     RENAME COLUMN "${oldColumn.name}" TO "${newColumn.name}"`)));
                 downQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                     RENAME COLUMN "${newColumn.name}" TO "${oldColumn.name}"`)));
+                // rename ENUM type
                 if (oldColumn.type === "enum" || oldColumn.type === "simple-enum") {
                     const oldEnumType = await this.getUserDefinedTypeName(table, oldColumn);
                     upQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TYPE "${oldEnumType.schema}"."${oldEnumType.name}" RENAME TO ${this.buildEnumName(table, newColumn, false)}`)));
                     downQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TYPE ${this.buildEnumName(table, newColumn)} RENAME TO "${oldEnumType.name}"`)));
                 }
+                // rename column primary key constraint
                 if (oldColumn.isPrimary === true) {
                     const primaryColumns = clonedTable.primaryColumns;
+                    // build old primary constraint name
                     const columnNames = primaryColumns.map(column => column.name);
                     const oldPkName = this.connection.namingStrategy.primaryKeyName(clonedTable, columnNames);
+                    // replace old column name with new column name
                     columnNames.splice(columnNames.indexOf(oldColumn.name), 1);
                     columnNames.push(newColumn.name);
+                    // build new primary constraint name
                     const newPkName = this.connection.namingStrategy.primaryKeyName(clonedTable, columnNames);
                     upQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                         RENAME CONSTRAINT "${oldPkName}" TO "${newPkName}"`)));
                     downQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                         RENAME CONSTRAINT "${newPkName}" TO "${oldPkName}"`)));
                 }
+                // rename column sequence
                 if (oldColumn.isGenerated === true && newColumn.generationStrategy === "increment") {
                     const sequencePath = this.buildSequencePath(table, oldColumn.name);
                     const sequenceName = this.buildSequenceName(table, oldColumn.name);
@@ -263,37 +307,50 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
                     upQueries.push(new TableQuery(table.name, new Query_1.Query(up)));
                     downQueries.push(new TableQuery(table.name, new Query_1.Query(down)));
                 }
+                // rename unique constraints
                 clonedTable.findColumnUniques(oldColumn).forEach(unique => {
+                    // build new constraint name
                     unique.columnNames.splice(unique.columnNames.indexOf(oldColumn.name), 1);
                     unique.columnNames.push(newColumn.name);
                     const newUniqueName = this.connection.namingStrategy.uniqueConstraintName(clonedTable, unique.columnNames);
+                    // build queries
                     upQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                         RENAME CONSTRAINT "${unique.name}" TO "${newUniqueName}"`)));
                     downQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                         RENAME CONSTRAINT "${newUniqueName}" TO "${unique.name}"`)));
+                    // replace constraint name
                     unique.name = newUniqueName;
                 });
+                // rename index constraints
                 clonedTable.findColumnIndices(oldColumn).forEach(index => {
+                    // build new constraint name
                     index.columnNames.splice(index.columnNames.indexOf(oldColumn.name), 1);
                     index.columnNames.push(newColumn.name);
                     const { schema } = this.driver.parseTableName(table);
                     const newIndexName = this.connection.namingStrategy.indexName(clonedTable, index.columnNames, index.where);
+                    // build queries
                     const up = schema ? `ALTER INDEX "${schema}"."${index.name}" RENAME TO "${newIndexName}"` : `ALTER INDEX "${index.name}" RENAME TO "${newIndexName}"`;
                     const down = schema ? `ALTER INDEX "${schema}"."${newIndexName}" RENAME TO "${index.name}"` : `ALTER INDEX "${newIndexName}" RENAME TO "${index.name}"`;
                     upQueries.push(new TableQuery(table.name, new Query_1.Query(up)));
                     downQueries.push(new TableQuery(table.name, new Query_1.Query(down)));
+                    // replace constraint name
                     index.name = newIndexName;
                 });
+                // rename foreign key constraints
                 clonedTable.findColumnForeignKeys(oldColumn).forEach(foreignKey => {
+                    // build new constraint name
                     foreignKey.columnNames.splice(foreignKey.columnNames.indexOf(oldColumn.name), 1);
                     foreignKey.columnNames.push(newColumn.name);
                     const newForeignKeyName = this.connection.namingStrategy.foreignKeyName(clonedTable, foreignKey.columnNames, this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
+                    // build queries
                     upQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                         RENAME CONSTRAINT "${foreignKey.name}" TO "${newForeignKeyName}"`)));
                     downQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                         RENAME CONSTRAINT "${newForeignKeyName}" TO "${foreignKey.name}"`)));
+                    // replace constraint name
                     foreignKey.name = newForeignKeyName;
                 });
+                // rename old column in the Table object
                 const oldTableColumn = clonedTable.columns.find(column => column.name === oldColumn.name);
                 clonedTable.columns[clonedTable.columns.indexOf(oldTableColumn)].name = newColumn.name;
                 oldColumn.name = newColumn.name;
@@ -308,34 +365,47 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
                 && (oldColumn.type === "enum" || oldColumn.type === "simple-enum")
                 && (!OrmUtils_1.OrmUtils.isArraysEqual(newColumn.enum, oldColumn.enum) || newColumn.enumName !== oldColumn.enumName)) {
                 const arraySuffix = newColumn.isArray ? "[]" : "";
+                // "public"."new_enum"
                 const newEnumName = this.buildEnumName(table, newColumn);
+                // "public"."old_enum"
                 const oldEnumName = this.buildEnumName(table, oldColumn);
+                // "old_enum"
                 const oldEnumNameWithoutSchema = this.buildEnumName(table, oldColumn, false);
+                //"public"."old_enum_old"
                 const oldEnumNameWithSchema_old = this.buildEnumName(table, oldColumn, true, false, true);
+                //"old_enum_old"
                 const oldEnumNameWithoutSchema_old = this.buildEnumName(table, oldColumn, false, false, true);
+                // rename old ENUM
                 upQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TYPE ${oldEnumName} RENAME TO ${oldEnumNameWithoutSchema_old}`)));
                 downQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TYPE ${oldEnumNameWithSchema_old} RENAME TO ${oldEnumNameWithoutSchema}`)));
+                // create new ENUM
                 upQueries.push(new TableQuery(table.name, this.createEnumTypeSql(table, newColumn, newEnumName)));
                 downQueries.push(new TableQuery(table.name, this.dropEnumTypeSql(table, newColumn, newEnumName)));
+                // if column have default value, we must drop it to avoid issues with type casting
                 if (oldColumn.default !== null && oldColumn.default !== undefined) {
+                    // mark default as changed to prevent double update
                     defaultValueChanged = true;
                     upQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                         ALTER COLUMN "${oldColumn.name}" DROP DEFAULT`)));
                     downQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                         ALTER COLUMN "${oldColumn.name}" SET DEFAULT ${oldColumn.default}`)));
                 }
+                // build column types
                 const upType = `${newEnumName}${arraySuffix} USING "${newColumn.name}"::"text"::${newEnumName}${arraySuffix}`;
                 const downType = `${oldEnumNameWithSchema_old}${arraySuffix} USING "${newColumn.name}"::"text"::${oldEnumNameWithSchema_old}${arraySuffix}`;
+                // update column to use new type
                 upQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                     ALTER COLUMN "${newColumn.name}" TYPE ${upType}`)));
                 downQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                     ALTER COLUMN "${newColumn.name}" TYPE ${downType}`)));
+                // restore column default or create new one
                 if (newColumn.default !== null && newColumn.default !== undefined) {
                     upQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                         ALTER COLUMN "${newColumn.name}" SET DEFAULT ${newColumn.default}`)));
                     downQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                         ALTER COLUMN "${newColumn.name}" DROP DEFAULT`)));
                 }
+                // remove old ENUM
                 upQueries.push(new TableQuery(table.name, this.dropEnumTypeSql(table, oldColumn, oldEnumNameWithSchema_old)));
                 downQueries.push(new TableQuery(table.name, this.createEnumTypeSql(table, oldColumn, oldEnumNameWithSchema_old)));
             }
@@ -359,6 +429,7 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
             }
             if (newColumn.isPrimary !== oldColumn.isPrimary) {
                 const primaryColumns = clonedTable.primaryColumns;
+                // if primary column state changed, we must always drop existed constraint.
                 if (primaryColumns.length > 0) {
                     const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map(column => column.name));
                     const columnNames = primaryColumns.map(column => `"${column.name}"`).join(", ");
@@ -369,6 +440,7 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
                 }
                 if (newColumn.isPrimary === true) {
                     primaryColumns.push(newColumn);
+                    // update column in table
                     const column = clonedTable.columns.find(column => column.name === newColumn.name);
                     column.isPrimary = true;
                     const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map(column => column.name));
@@ -381,8 +453,10 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
                 else {
                     const primaryColumn = primaryColumns.find(c => c.name === newColumn.name);
                     primaryColumns.splice(primaryColumns.indexOf(primaryColumn), 1);
+                    // update column in table
                     const column = clonedTable.columns.find(column => column.name === newColumn.name);
                     column.isPrimary = false;
+                    // if we have another primary keys, we must recreate constraint.
                     if (primaryColumns.length > 0) {
                         const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map(column => column.name));
                         const columnNames = primaryColumns.map(column => `"${column.name}"`).join(", ");
@@ -436,6 +510,7 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
                     downQueries.push(new TableQuery(table.name, new Query_1.Query(`CREATE SEQUENCE IF NOT EXISTS ${this.escapePath(this.buildSequencePath(table, newColumn))} OWNED BY ${this.escapePath(table)}."${newColumn.name}"`)));
                 }
             }
+            // the default might have changed when the enum changed
             if (newColumn.default !== oldColumn.default && !defaultValueChanged) {
                 if (newColumn.default !== null && newColumn.default !== undefined) {
                     upQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
@@ -463,7 +538,9 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
                     ALTER COLUMN "${newColumn.name}" TYPE ${this.driver.createFullType(oldColumn)}`)));
             }
             if (newColumn.generatedType !== oldColumn.generatedType) {
+                // Convert generated column data to normal column
                 if (!newColumn.generatedType || newColumn.generatedType === "VIRTUAL") {
+                    // We can copy the generated data to the new column
                     const tableNameWithSchema = (await this.getTableNameWithSchema(table.name)).split('.');
                     const tableName = tableNameWithSchema[1];
                     const schema = tableNameWithSchema[0];
@@ -482,6 +559,7 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
                         type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
                         name: oldColumn.name
                     })));
+                    // However, we can't copy it back on downgrade. It needs to regenerate.
                     downQueries.push(new TableQuery(tableName, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                         DROP COLUMN "${newColumn.name}"`)));
                     downQueries.push(new TableQuery(tableName, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
@@ -507,6 +585,9 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         await this.executeQueries(upQueries, downQueries);
         this.replaceCachedTable(table, clonedTable);
     }
+    /**
+     * Drops column in the table.
+     */
     async dropColumn(tableOrName, columnOrName) {
         const table = tableOrName instanceof Table_1.Table ? tableOrName : await this.getCachedTable(tableOrName);
         const column = columnOrName instanceof TableColumn_1.TableColumn ? columnOrName : table.findColumnByName(columnOrName);
@@ -515,6 +596,7 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         const clonedTable = table.clone();
         const upQueries = [];
         const downQueries = [];
+        // drop primary key constraint
         if (column.isPrimary) {
             const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, clonedTable.primaryColumns.map(column => column.name));
             const columnNames = clonedTable.primaryColumns.map(primaryColumn => `"${primaryColumn.name}"`).join(", ");
@@ -522,8 +604,10 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
                 DROP CONSTRAINT "${pkName}"`)));
             downQueries.push(new TableQuery(clonedTable.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(clonedTable)}
                 ADD CONSTRAINT "${pkName}" PRIMARY KEY (${columnNames})`)));
+            // update column in table
             const tableColumn = clonedTable.findColumnByName(column.name);
             tableColumn.isPrimary = false;
+            // if primary key have multiple columns, we must recreate it without dropped column
             if (clonedTable.primaryColumns.length > 0) {
                 const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, clonedTable.primaryColumns.map(column => column.name));
                 const columnNames = clonedTable.primaryColumns.map(primaryColumn => `"${primaryColumn.name}"`).join(", ");
@@ -533,18 +617,21 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
                     DROP CONSTRAINT "${pkName}"`)));
             }
         }
+        // drop column index
         const columnIndex = clonedTable.indices.find(index => index.columnNames.length === 1 && index.columnNames[0] === column.name);
         if (columnIndex) {
             clonedTable.indices.splice(clonedTable.indices.indexOf(columnIndex), 1);
             upQueries.push(new TableQuery(table.name, this.dropIndexSql(table, columnIndex)));
             downQueries.push(new TableQuery(table.name, this.createIndexSql(table, columnIndex)));
         }
+        // drop column check
         const columnCheck = clonedTable.checks.find(check => !!check.columnNames && check.columnNames.length === 1 && check.columnNames[0] === column.name);
         if (columnCheck) {
             clonedTable.checks.splice(clonedTable.checks.indexOf(columnCheck), 1);
             upQueries.push(new TableQuery(table.name, this.dropCheckConstraintSql(table, columnCheck)));
             downQueries.push(new TableQuery(table.name, this.createCheckConstraintSql(table, columnCheck)));
         }
+        // drop column unique
         const columnUnique = clonedTable.uniques.find(unique => unique.columnNames.length === 1 && unique.columnNames[0] === column.name);
         if (columnUnique) {
             clonedTable.uniques.splice(clonedTable.uniques.indexOf(columnUnique), 1);
@@ -555,6 +642,7 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
             DROP COLUMN "${column.name}"`)));
         downQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
             ADD ${this.buildCreateColumnSql(table, column)}`)));
+        // drop enum type
         if (column.type === "enum" || column.type === "simple-enum") {
             const hasEnum = await this.hasEnumType(table, column);
             if (hasEnum) {
@@ -590,12 +678,16 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         clonedTable.removeColumn(column);
         this.replaceCachedTable(table, clonedTable);
     }
+    /**
+     * Updates composite primary keys.
+     */
     async updatePrimaryKeys(tableOrName, columns) {
         const table = tableOrName instanceof Table_1.Table ? tableOrName : await this.getCachedTable(tableOrName);
         const clonedTable = table.clone();
         const columnNames = columns.map(column => column.name);
         const upQueries = [];
         const downQueries = [];
+        // if table already have primary columns, we must drop them.
         const primaryColumns = clonedTable.primaryColumns;
         if (primaryColumns.length > 0) {
             const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map(column => column.name));
@@ -605,6 +697,7 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
             downQueries.push(new TableQuery(table.name, new Query_1.Query(`ALTER TABLE ${this.escapePath(table)}
                 ADD CONSTRAINT "${pkName}" PRIMARY KEY (${columnNamesString})`)));
         }
+        // update columns in table.
         clonedTable.columns
             .filter(column => columnNames.indexOf(column.name) !== -1)
             .forEach(column => column.isPrimary = true);
@@ -617,8 +710,12 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         await this.executeQueries(upQueries, downQueries);
         this.replaceCachedTable(table, clonedTable);
     }
+    /**
+     * Creates new unique constraint.
+     */
     async createUniqueConstraint(tableOrName, uniqueConstraint) {
         const table = tableOrName instanceof Table_1.Table ? tableOrName : await this.getCachedTable(tableOrName);
+        // new unique constraint may be passed without name. In this case we generate unique name manually.
         if (!uniqueConstraint.name)
             uniqueConstraint.name = this.connection.namingStrategy.uniqueConstraintName(table, uniqueConstraint.columnNames);
         const up = this.createUniqueConstraintSql(table, uniqueConstraint);
@@ -626,6 +723,9 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         await this.executeQueries(new TableQuery(table.name, up), new TableQuery(table.name, down));
         table.addUniqueConstraint(uniqueConstraint);
     }
+    /**
+     * Drops unique constraint.
+     */
     async dropUniqueConstraint(tableOrName, uniqueOrName) {
         const table = tableOrName instanceof Table_1.Table ? tableOrName : await this.getCachedTable(tableOrName);
         const uniqueConstraint = uniqueOrName instanceof TableUnique_1.TableUnique ? uniqueOrName : table.uniques.find(u => u.name === uniqueOrName);
@@ -636,8 +736,12 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         await this.executeQueries(new TableQuery(table.name, up), new TableQuery(table.name, down));
         table.removeUniqueConstraint(uniqueConstraint);
     }
+    /**
+     * Creates new check constraint.
+     */
     async createCheckConstraint(tableOrName, checkConstraint) {
         const table = tableOrName instanceof Table_1.Table ? tableOrName : await this.getCachedTable(tableOrName);
+        // new unique constraint may be passed without name. In this case we generate unique name manually.
         if (!checkConstraint.name)
             checkConstraint.name = this.connection.namingStrategy.checkConstraintName(table, checkConstraint.expression);
         const up = this.createCheckConstraintSql(table, checkConstraint);
@@ -645,6 +749,9 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         await this.executeQueries(new TableQuery(table.name, up), new TableQuery(table.name, down));
         table.addCheckConstraint(checkConstraint);
     }
+    /**
+     * Drops check constraint.
+     */
     async dropCheckConstraint(tableOrName, checkOrName) {
         const table = tableOrName instanceof Table_1.Table ? tableOrName : await this.getCachedTable(tableOrName);
         const checkConstraint = checkOrName instanceof TableCheck_1.TableCheck ? checkOrName : table.checks.find(c => c.name === checkOrName);
@@ -655,8 +762,12 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         await this.executeQueries(new TableQuery(table.name, up), new TableQuery(table.name, down));
         table.removeCheckConstraint(checkConstraint);
     }
+    /**
+     * Creates new exclusion constraint.
+     */
     async createExclusionConstraint(tableOrName, exclusionConstraint) {
         const table = tableOrName instanceof Table_1.Table ? tableOrName : await this.getCachedTable(tableOrName);
+        // new unique constraint may be passed without name. In this case we generate unique name manually.
         if (!exclusionConstraint.name)
             exclusionConstraint.name = this.connection.namingStrategy.exclusionConstraintName(table, exclusionConstraint.expression);
         const up = this.createExclusionConstraintSql(table, exclusionConstraint);
@@ -664,6 +775,9 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         await this.executeQueries(new TableQuery(table.name, up), new TableQuery(table.name, down));
         table.addExclusionConstraint(exclusionConstraint);
     }
+    /**
+     * Drops exclusion constraint.
+     */
     async dropExclusionConstraint(tableOrName, exclusionOrName) {
         const table = tableOrName instanceof Table_1.Table ? tableOrName : await this.getCachedTable(tableOrName);
         const exclusionConstraint = exclusionOrName instanceof TableExclusion_1.TableExclusion ? exclusionOrName : table.exclusions.find(c => c.name === exclusionOrName);
@@ -674,8 +788,12 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         await this.executeQueries(new TableQuery(table.name, up), new TableQuery(table.name, down));
         table.removeExclusionConstraint(exclusionConstraint);
     }
+    /**
+     * Creates a new foreign key.
+     */
     async createForeignKey(tableOrName, foreignKey) {
         const table = tableOrName instanceof Table_1.Table ? tableOrName : await this.getCachedTable(tableOrName);
+        // new FK may be passed without name. In this case we generate FK name manually.
         if (!foreignKey.name)
             foreignKey.name = this.connection.namingStrategy.foreignKeyName(table, foreignKey.columnNames, this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
         const up = this.createForeignKeySql(table, foreignKey);
@@ -683,6 +801,9 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         await this.executeQueries(new TableQuery(table.name, up), new TableQuery(table.name, down));
         table.addForeignKey(foreignKey);
     }
+    /**
+     * Drops a foreign key from the table.
+     */
     async dropForeignKey(tableOrName, foreignKeyOrName) {
         const table = tableOrName instanceof Table_1.Table ? tableOrName : await this.getCachedTable(tableOrName);
         const foreignKey = foreignKeyOrName instanceof TableForeignKey_1.TableForeignKey ? foreignKeyOrName : table.foreignKeys.find(fk => fk.name === foreignKeyOrName);
@@ -693,8 +814,12 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         await this.executeQueries(new TableQuery(table.name, up), new TableQuery(table.name, down));
         table.removeForeignKey(foreignKey);
     }
+    /**
+     * Creates a new index.
+     */
     async createIndex(tableOrName, index) {
         const table = tableOrName instanceof Table_1.Table ? tableOrName : await this.getCachedTable(tableOrName);
+        // new index may be passed without name. In this case we generate index name manually.
         if (!index.name)
             index.name = this.connection.namingStrategy.indexName(table, index.columnNames, index.where);
         const up = this.createIndexSql(table, index);
@@ -702,6 +827,9 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         await this.executeQueries(new TableQuery(table.name, up), new TableQuery(table.name, down));
         table.addIndex(index);
     }
+    /**
+     * Drops an index from the table.
+     */
     async dropIndex(tableOrName, indexOrName) {
         const table = tableOrName instanceof Table_1.Table ? tableOrName : await this.getCachedTable(tableOrName);
         const index = indexOrName instanceof TableIndex_1.TableIndex ? indexOrName : table.indices.find(i => i.name === indexOrName);
@@ -712,6 +840,9 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         await this.executeQueries(new TableQuery(table.name, up), new TableQuery(table.name, down));
         table.removeIndex(index);
     }
+    /**
+     * Executes sql used special for schema build.
+     */
     async executeQueries(upQueries, downQueries) {
         const resultUpQueries = upQueries instanceof Query_1.Query || upQueries instanceof TableQuery
             ? [upQueries]
@@ -742,6 +873,7 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
         const originalUpQueries = resultUpQueries.map(item => item instanceof TableQuery ? item.query : item);
         this.sqlInMemory.upQueries.push(...originalUpQueries);
         this.sqlInMemory.downQueries.push(...(resultDownQueries.map(item => item instanceof TableQuery ? item.query : item)));
+        // if sql-in-memory mode is enabled then simply store sql in memory and return
         if (this.sqlMemoryMode === true) {
             return Promise.resolve();
         }
@@ -749,17 +881,34 @@ class CustomPostgresQueryRunner extends PostgresQueryRunner_1.PostgresQueryRunne
             await this.query(query, parameters);
         }
     }
+    /**
+     * Enables special query runner mode in which sql queries won't be executed,
+     * instead they will be memorized into a special variable inside query runner.
+     * You can get memorized sql using getMemorySql() method.
+     */
     enableSqlMemory() {
         this.sqlInMemory = new TableSqlInMemory();
         this.sqlMemoryMode = true;
     }
+    /**
+     * Disables special query runner mode in which sql queries won't be executed
+     * started by calling enableSqlMemory() method.
+     *
+     * Previously memorized sql will be flushed.
+     */
     disableSqlMemory() {
         this.sqlInMemory = new TableSqlInMemory();
         this.sqlMemoryMode = false;
     }
+    /**
+     * Flushes all memorized sqls.
+     */
     clearSqlMemory() {
         this.sqlInMemory = new TableSqlInMemory();
     }
+    /**
+     * Gets sql stored in the memory. Parameters in the sql are already replaced.
+     */
     getMemorySql() {
         return this.sqlInMemory;
     }