@sap/cds 5.4.6 → 5.5.0

package/bin/build/provider/hana/2tabledata.js

@@ -1,42 +1,46 @@
-const DEBUG = /\b(y|all|tabledata)\b/.test (process.env.DEBUG) && console.warn // eslint-disable-line
-const _warn = (message) => { console.error ('[WARNING] [hdbtabledata] -', message) }  // eslint-disable-line
-const cds = require ('../../cds')
+const cds = require('../../cds')
 const CSV = require('../../csv-reader')
-const { getElementCdsPersistenceName, getArtifactCdsPersistenceName } = require ('@sap/cds-compiler')
+const { getElementCdsPersistenceName, getArtifactCdsPersistenceName } = require('@sap/cds-compiler')
+const { LOG_MODULE_NAMES } = require('../../constants')
 const { fs, path, isdir } = cds.utils
 const { readdir } = fs.promises
+let logger = cds.log(LOG_MODULE_NAMES)
+
+module.exports = async (model, options = {}) => {
+  if (options.logger) {
+    logger = options.logger
+  }
 
-module.exports = async (model, options={}) => {
   const baseDir = options.baseDir  // where the hdbtabledata will be located, for usage in the file_name path
-  const dirs = Array.isArray(options.dirs) ? options.dirs : _csvDirs (model.$sources.map (path.dirname))
-  if (dirs.length === 0)  return []  // nothing to do
+  const dirs = Array.isArray(options.dirs) ? options.dirs : _csvDirs(model.$sources.map(path.dirname))
+  if (dirs.length === 0) return []  // nothing to do
   const naming = options.sqlMapping || options.names || cds.env.sql.names
 
   const datas = (await Promise.all(dirs.map(async dir => {
     let files = []
     if (isdir(dir)) {
-      files = await readdir (dir)
+      files = await readdir(dir)
     }
-    return Promise.all(files.filter (_csvs).map (file => _tabledata4 (dir, file, cds.linked (model), baseDir, naming)))
+    return Promise.all(files.filter(_csvs).map(file => _tabledata4(dir, file, cds.linked(model), baseDir, naming)))
   })))
-  .reduce((a, b) => a.concat(b), [])
-  return _toOutput (datas)
+    .reduce((a, b) => a.concat(b), [])
+  return _toOutput(datas)
 }
 
-async function _tabledata4 (dir, csvFile, model, baseDir, naming)  {
+async function _tabledata4(dir, csvFile, model, baseDir, naming) {
   const baseFileName = path.parse(csvFile).name
-  const entityName = baseFileName.replace(/-/g,'.')
-  const entity = _entity4 (entityName, model)
+  const entityName = baseFileName.replace(/-/g, '.')
+  const entity = _entity4(entityName, model)
   if (!entity) {
     let message = `no entity '${entityName}' found for CSV file '${path.relative(process.cwd(), path.join(dir, csvFile))}'`
     const candidate = Object.keys(model.definitions)
       .filter(name => !name.startsWith('localized.'))
-      .find  (name => name.toLowerCase().includes(entityName.toLowerCase()))
-    if (candidate)  message += `. Did you mean '${candidate}'?`
-    return _warn (message)
+      .find(name => name.toLowerCase().includes(entityName.toLowerCase()))
+    if (candidate) message += `. Did you mean '${candidate}'?`
+    return logger.warn(`[hdbtabledata] ${message}`)
   }
 
-  const tableName = getArtifactCdsPersistenceName (entity.name, naming, model)
+  const tableName = getArtifactCdsPersistenceName(entity.name, naming, model)
   const tabledata = { format_version: 1, imports: [] }
   const _import = {
     target_table: tableName,
@@ -47,84 +51,84 @@ async function _tabledata4 (dir, csvFile, model, baseDir, naming)  {
 
   const file = path.join(dir, csvFile)
   const reader = fs.createReadStream(file)
-  const { cols, delimiter } = await CSV.readHeader (reader)
-  if (cols.length === 0)  return  // no columns at all -> skip import
+  const { cols, delimiter } = await CSV.readHeader(reader)
+  if (cols.length === 0) return  // no columns at all -> skip import
 
   cols.forEach(csvCol => {
     // Only translate the column name, but do not check for the existence of the element in the model.
     // This gets tricky for foreign key elements, and the DB deployment anyways checks the column.
-    const tableCol = getElementCdsPersistenceName (csvCol, naming)
-    _import.import_settings.import_columns.push (tableCol)
+    const tableCol = getElementCdsPersistenceName(csvCol, naming)
+    _import.import_settings.import_columns.push(tableCol)
     _import.column_mappings[tableCol] = csvCol
   })
 
   _import.source_data.type_config.delimiter = delimiter
 
   // add a locale filter for mono-lingual files that refer to generated text tables
-  if (entity.elements.locale)  {
-    const locale = /_texts_(.+)\.csv$/.test (csvFile) ? RegExp.$1 : null
+  if (entity.elements.locale) {
+    const locale = /_texts_(.+)\.csv$/.test(csvFile) ? RegExp.$1 : null
     if (locale) {
-      const localeKey = getElementCdsPersistenceName (entity.elements.locale.name/*usually 'LOCALE'*/, naming)
-      _import.import_settings.include_filter.push ({ [localeKey]: locale })
+      const localeKey = getElementCdsPersistenceName(entity.elements.locale.name/*usually 'LOCALE'*/, naming)
+      _import.import_settings.include_filter.push({ [localeKey]: locale })
     }
   }
 
-  tabledata.imports.push (_import)
+  tabledata.imports.push(_import)
   const suffix = '.hdbtabledata'
   return [
     tabledata, {
       name: baseFileName, suffix,
       file: baseFileName + suffix,
-      folder: (baseDir||dir), // as metadata, add the dir to which the csvs are relative to
+      folder: (baseDir || dir), // as metadata, add the dir to which the csvs are relative to
       csvFolder: dir
     }
   ]
 }
 
-function _entity4 (name, csn) {
-  const entity = csn.definitions [name]
+function _entity4(name, csn) {
+  const entity = csn.definitions[name]
   if (!entity) {
-    if (/(.+)[._]texts_?/.test (name)) { // 'Books_texts', 'Books_texts_de'
-      const base = csn.definitions [RegExp.$1]
+    if (/(.+)[._]texts_?/.test(name)) { // 'Books_texts', 'Books_texts_de'
+      const base = csn.definitions[RegExp.$1]
       if (base && base.elements && base.elements.texts) {
-        return _entity4 (base.elements.texts.target, csn)
+        return _entity4(base.elements.texts.target, csn)
       }
     }
     return
   }
-  if (entity['@cds.persistence.skip'] === true)  return _warn (`exclude skipped entity '${name}'`)
+  if (entity['@cds.persistence.skip'] === true) return logger.warn(`[hdbtabledata] exclude skipped entity '${name}'`)
   const p = entity.query && entity.query.SELECT || entity.projection
   if (p) {
     let from = p.from
     if (from && from.ref && from.ref.length === 1) {
-      return _entity4 (from.ref[0], csn)
+      return _entity4(from.ref[0], csn)
     }
   }
   return entity
 }
 
-function _csvDirs (sources) {
-  sources = Array.from (new Set(sources)) // uniq
+function _csvDirs(sources) {
+  sources = Array.from(new Set(sources)) // uniq
   const folders = []
   for (let src of sources) {
-    for (let data of ['/data','/csv']) {
-      for (let each of [ src+data, src+'/src'+data, src+'/..'+data ]) {
-        let folder = path.resolve (cds.root,each)
-        if (isdir (folder))  folders.push (folder)
+    for (let data of ['/data', '/csv']) {
+      for (let each of [src + data, src + '/src' + data, src + '/..' + data]) {
+        let folder = path.resolve(cds.root, each)
+        if (isdir(folder)) folders.push(folder)
       }
     }
   }
   return folders
 }
 
-function _csvs (filename,_,allFiles) {
-  if (filename[0] === '-' || !filename.endsWith ('.csv'))  return false
+function _csvs(filename, _, allFiles) {
+  if (filename[0] === '-' || !filename.endsWith('.csv')) return false
   // ignores 'Books_texts.csv' if there is any 'Books_texts_LANG.csv'
-  if (/(.*)[._]texts\.csv$/.test (filename)) {
+  if (/(.*)[._]texts\.csv$/.test(filename)) {
     const basename = RegExp.$1
-    const monoLangFiles = allFiles.filter (file => new RegExp(basename+'_texts_').test (file))
+    const monoLangFiles = allFiles.filter(file => new RegExp(basename + '_texts_').test(file))
     if (monoLangFiles.length > 0) {
-      DEBUG && DEBUG (` - ignoring '${filename}' in favor of [${monoLangFiles}]`)  // eslint-disable-line
+      logger._debug && logger.debug(`[hdbtabledata] ignoring '${filename}' in favor of [${monoLangFiles}]`)
       return false
     }
   }
@@ -132,8 +136,8 @@ function _csvs (filename,_,allFiles) {
 }
 
 // generator function compliant to what `cds.compile.to` backends can return
-function* _toOutput (datas) {
+function* _toOutput(datas) {
   for (let i = 0; i < datas.length; i++) {
-    if (datas[i])  yield datas[i]
+    if (datas[i]) yield datas[i]
   }
 }

package/bin/build/provider/hana/index.js

@@ -1,15 +1,15 @@
-const {fs} = require('@sap/cds-foss')
+const { fs } = require('@sap/cds-foss')
 const path = require('path')
 const BuildTaskHandlerInternal = require('../buildTaskHandlerInternal')
 const { getHanaDbModuleDescriptor } = require('../../mtaUtil')
-const { OUTPUT_MODE_RESULT_ONLY, BUILD_OPTION_OUTPUT_MODE, FILE_EXT_CDS } = require('../../constants')
+const { OUTPUT_MODE_RESULT_ONLY, BUILD_OPTION_OUTPUT_MODE, SKIP_HDBTABLEDATA_GENERATION, SKIP_PACKAGE_JSON_GENERATION,
+    SKIP_MANIFEST_GENERATION, CONTENT_MANIFEST, CONTENT_PACKAGE_JSON, CONTENT_HDBTABLEDATA } = require('../../constants')
 const { BuildError, setProperty, relativePaths } = require('../../util')
 const CSV = require('../../csv-reader')
 const to_hdbmigration = require('./2migration')
 const to_hdbtabledata = require('./2tabledata')
 const { ERROR } = require('../../buildTaskHandler')
 
-const DEBUG = process.env.DEBUG
 const DEFAULT_COMPILE_DEST_FOLDER = path.normalize("src/gen")
 
 const FILE_EXT_CSV = ".csv"
@@ -31,6 +31,11 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
             dest: this.task.dest,
             hana: []
         }
+        // set unified option values in order to easy access later on
+        this.task.options[CONTENT_MANIFEST] = !this.hasBuildOption(CONTENT_MANIFEST, false) && !this.hasBuildOption(SKIP_MANIFEST_GENERATION, true) ? true : false
+        this.task.options[CONTENT_PACKAGE_JSON] = !this.hasBuildOption(CONTENT_PACKAGE_JSON, false) && !this.hasBuildOption(SKIP_PACKAGE_JSON_GENERATION, true) ? true : false
+        this.task.options[CONTENT_HDBTABLEDATA] = !this.hasBuildOption(CONTENT_HDBTABLEDATA, false) && !this.hasBuildOption(SKIP_HDBTABLEDATA_GENERATION, true) ? true : false
+
         this.task.options.compileDest = path.resolve(this.task.dest, this.task.options.compileDest || DEFAULT_COMPILE_DEST_FOLDER)
     }
 
@@ -60,13 +65,13 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
             await this._writeHdiConfig(plugins)
             await this._writeHdiNamespace()
 
-            if (!this.hasBuildOption("skipHdbtabledataGeneration", true)) {
+            if (this.hasBuildOption(CONTENT_HDBTABLEDATA, true)) {
                 await this._compileToHdbtabledata(model, dest)
             }
-            if (!this.hasBuildOption("skipPackageJsonGeneration", true)) {
+            if (this.hasBuildOption(CONTENT_PACKAGE_JSON, true)) {
                 await this._writePackageJson()
             }
-            if (!this.hasBuildOption("skipManifestGeneration", true)) {
+            if (this.hasBuildOption(CONTENT_MANIFEST, true)) {
                 await this._writeManifestYml()
                 await this._writeCfIgnore()
             }
@@ -97,14 +102,15 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
         const dbCsvDir = path.join(src, "csv")
         const dbDataDir = path.join(src, "data")
         const csvDirs = [dbCsvDir, dbDataDir]
+        const regex = RegExp('\\.cds$|\\.csv$|\\.hdbtabledata$')
+        const regexData = RegExp('\\.csv$|\\.hdbtabledata$')
 
         await super.copyNativeContent(src, dest, (entry) => {
             if (fs.statSync(entry).isDirectory()) {
                 return true // using common filter for folders
             }
-            const extName = path.extname(entry)
-            return (extName !== FILE_EXT_CSV && extName !== FILE_EXT_HDBTABLEDATA && extName !== FILE_EXT_CDS && entry !== this.env.build.outputfile) ||
-                ((extName === FILE_EXT_CSV || extName === FILE_EXT_HDBTABLEDATA) && !entry.startsWith(dbCsvDir) && !entry.startsWith(dbCsvDir))
+            return (!regex.test(entry) && entry !== this.env.build.outputfile) ||
+                (regexData.test(entry) && !entry.startsWith(dbCsvDir) && !entry.startsWith(dbCsvDir))
         }) || []
 
         // handle *.csv and *.hdbtabledata located in '<dbSrc>/data' and '<dbSrc>/csv' folder
@@ -113,8 +119,7 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
                 if (fs.statSync(entry).isDirectory()) {
                     return false
                 }
-                const extName = path.extname(entry)
-                return (extName === FILE_EXT_CSV || extName === FILE_EXT_HDBTABLEDATA)
+                return regexData.test(entry)
             }))
         }, [])
 
@@ -162,8 +167,9 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
 
             const promises = []
             const relDest = path.relative(this.task.dest, this.task.options.compileDest)
+            const options = { ...this.options(), dirs: csvDirs, baseDir: this.task.options.compileDest }
 
-            const tableDatas = await to_hdbtabledata(model, { dirs: csvDirs, baseDir: this.task.options.compileDest })
+            const tableDatas = await to_hdbtabledata(model, options)
             for (let [tableData, { file, csvFolder }] of tableDatas) {
                 // create .hdbtabledata side-by-side if .csv is contained in 'src/gen/**' subfolder
                 // otherwise create in 'src/gen'
@@ -261,8 +267,8 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
                     if (!this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
                         promises.push(this.write(content).to(path.join(dbSrcDir, file)))
                     }
-                } else if (DEBUG) {
-                    this.logger.log(`[cds] - no change, keep existing ${file}`)
+                } else {
+                    this.logger._debug && this.logger.debug(`no change, keep existing ${file}`)
                 }
             } else {
                 this._result.hana.push(path.join(relDestDir, file))
@@ -294,8 +300,8 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
         const packageJson = path.join(this.task.src, "package.json")
         const exists = await fs.pathExists(packageJson)
 
-        if (DEBUG && exists) {
-            this.logger.log(`[cds] - skip create [${relativePaths(this.buildOptions.root, packageJson)}], already existing`)
+        if (exists) {
+            this.logger._debug && this.logger.debug(`skip create [${relativePaths(this.buildOptions.root, packageJson)}], already existing`)
         }
         if (this.isStagingBuild() && !exists) {
             const content = await this._readTemplateAsJson(FILE_NAME_PACKAGE_JSON)
@@ -354,9 +360,7 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
             return
         }
         if (await fs.pathExists(path.join(this.task.src, FILE_NAME_MANIFEST_YML)) || await fs.pathExists(path.join(this.task.src, 'manifest.yml'))) {
-            if (DEBUG) {
-                this.logger.log('[cds] - skip cf manifest generation, already existing')
-            }
+            this.logger.debug('skip cf manifest generation, already existing')
             return
         }
         try {
@@ -373,10 +377,8 @@ applications:
     services:
       - ${descriptor.hdiServiceName}`
 
-            if (DEBUG) {
-                this.logger.log("[cds] - Cloud Foundry service binding required for HDI container. To create a service use CF command")
-                this.logger.log(`  cf cs hana hdi-shared ${descriptor.hdiServiceName}`)
-            }
+            this.logger.debug("Cloud Foundry service binding required for HDI container. To create a service use CF command")
+            this.logger._debug && this.logger.debug(`  cf cs hana hdi-shared ${descriptor.hdiServiceName}`)
 
             await this.write(MANIFEST_YML_CONTENT).to(path.join(this.task.dest, FILE_NAME_MANIFEST_YML))
         } catch (e) {
@@ -413,11 +415,11 @@ applications:
             return fs.statSync(res).isFile() && path.extname(res) === FILE_EXT_HDBMIGRATIONTABLE
         })
         if (migrationTableFiles.length > 0) {
-            const { MigrationTableParser } = require('./migrationtable')
+            const parser = require('./migrationtable')
 
             await Promise.all(migrationTableFiles.map(async file => {
                 try {
-                    const tableModel = await MigrationTableParser.read(file)
+                    const tableModel = await parser.read(file)
                     if (tableModel && /^>>>>>/m.test(tableModel.migrations.toString())) {
                         this.pushMessage(`Current model changes require manual resolution. See migration file ${path.relative(this.buildOptions.root, file)} for further details.`, ERROR)
                     }

package/bin/build/provider/hana/migrationtable.js

@@ -1,4 +1,4 @@
-const {fs} = require('@sap/cds-foss')
+const { fs } = require('@sap/cds-foss')
 
 class MigrationTableParser {
   constructor() {
@@ -27,15 +27,15 @@ class MigrationTableParser {
 
   _validate(lines) {
     let isTableBegin = false, isTableEnd = false, isMigration = false
-    let version = -1
-    lines.forEach(line => {
-      if (/^\s*== version=\d+\s*$/.test(line)) {
-        version = MigrationTableParser._parseVersionNumber(line)
+    let tVersion, mVersion = -1
+    for (let idx = 0; idx < lines.length; idx++) {
+      if (MigrationTableParser._isVersionMarker(lines[idx])) {
+        tVersion = MigrationTableParser._parseVersionNumber(lines[idx])
         if (isTableBegin || isTableEnd || isMigration) {
           throw new Error(`Invalid format, version defintion must be very first statement`)
         }
-      } else if (/^\s*COLUMN TABLE\s/.test(line)) {
-        if (version === -1) {
+      } else if (/^\s*COLUMN TABLE\s/.test(lines[idx])) {
+        if (tVersion === -1) {
           throw new Error(`Invalid format, version entry not complying to format '^== version=d+'`)
         }
         if (isTableBegin) {
@@ -45,55 +45,66 @@ class MigrationTableParser {
           throw new Error(`Invalid format, migrations must not be mixed with COLUMN TABLE definitions`)
         }
         isTableBegin = true
-      } else if (isTableBegin && /^\s*\)\s*$/.test(line)) {
-        if (isTableEnd) {
-          throw new Error(`Invalid format, multiple COLUMN TABLE matching closing brackets found`)
-        }
-        if (isMigration) {
-          throw new Error(`Invalid format, migrations must not be mixed with COLUMN TABLE definitions`)
-        }
-        isTableEnd = true
-      } else if (!isMigration && /^\s*== migration=\d+\s*$/.test(line)) {
-        if (!new RegExp(`^\\s*== migration=${version}\\s*$`).test(line)) {
-          throw new Error(`Invalid format, migration and table version number do not match'`)
-        }
+      } else if (MigrationTableParser._isMigrationMarker(lines[idx])) {
+        const version = MigrationTableParser._parseVersionNumber(lines[idx])
         if (version === -1) {
           throw new Error(`Invalid format, migration entry not complying to format '^== version=d+'`)
         }
-        if (!isTableBegin) {
-          throw new Error(`Invalid format, COLUMN TABLE missing`)
+        if (version > mVersion) {
+          mVersion = version
         }
-        if (!isTableEnd) {
-          throw new Error(`Invalid format, COLUMN TABLE matching closing bracket missing`)
+        if (!isMigration) {
+          if (!isTableBegin) {
+            throw new Error(`Invalid format, COLUMN TABLE statement missing`)
+          }
+          // back search for end table
+          for (let tIdx = idx - 1; tIdx > 0; tIdx--) {
+            if (MigrationTableParser._isDDL(lines[tIdx])
+              || MigrationTableParser._isComment(lines[tIdx])) {
+              isTableEnd = true
+              break
+            }
+          }
+          isMigration = true
         }
-        isMigration = true
+      } else if (isTableBegin && !isMigration && idx + 1 === lines.length) {
+        isTableEnd = true
       }
-    })
+    }
     if (!isTableBegin) {
       throw new Error(`Invalid format, COLUMN TABLE statement missing`)
     }
     if (!isTableEnd) {
-      throw new Error(`Invalid format, COLUMN TABLE closing bracket missing`)
+      throw new Error(`Invalid format, COLUMN TABLE statement not correctly terminated`)
     }
-    if (!isMigration && version > 1) {
-      throw new Error(`Invalid format, '== migration=${version}' entry missing`)
+    if (!isMigration && tVersion > 1) {
+      throw new Error(`Invalid format, '== migration=${tVersion}' entry missing`)
+    }
+    if (mVersion !== -1 && mVersion !== tVersion) {
+      throw new Error(`Invalid format, migration version ${mVersion} does not match table version ${tVersion}`)
     }
   }
 
   _parseTable(lines) {
     const format = { startLine: -1, endLine: -1 }
     for (let idx = 0; idx < lines.length; idx++) {
-      let line = lines[idx]
-      if (format.startLine === -1 && /^\s*== version=\d+\s*$/.test(line)) {
-        format.startLine = idx
+      if (format.startLine === -1) {
+        if (MigrationTableParser._isVersionMarker(lines[idx])) {
+          format.startLine = idx
+        }
       } else if (format.endLine === -1) {
-        if (idx + 1 === lines.length || /^\s*== migration=\s*$/.test(line)) {
-          // back search for end table
-          for (let tableIdx = idx; tableIdx > format.startLine; tableIdx--) {
-            if (/^\s*\)\s*$/.test(lines[tableIdx])) {
-              format.endLine = tableIdx
-              break
-            }
+        let tIdx = -1
+        if (MigrationTableParser._isMigrationMarker(lines[idx])) {
+          tIdx = idx - 1
+        } else if (idx + 1 === lines.length) {
+          tIdx = idx
+        }
+        // back search for end of table, comments belong to table
+        for (; tIdx > format.startLine; tIdx--) {
+          if (MigrationTableParser._isDDL(lines[tIdx])
+            || MigrationTableParser._isComment(lines[tIdx])) {
+            format.endLine = tIdx
+            break
           }
         }
       } else {
@@ -101,7 +112,7 @@ class MigrationTableParser {
       }
     }
     if (format.startLine === -1) {
-      throw new Error(`Invalid format: .hdbmigrationtable content version not found`)
+      throw new Error(`Invalid format, '== version=' entry missing`)
     }
     return new MigrationTable(lines, format)
   }
@@ -109,10 +120,9 @@ class MigrationTableParser {
   _parseMigrations(lines, table) {
     const migrations = []
     let format = { startLine: -1, endLine: -1 }
-    for (let idx = table.lines.length; idx < lines.length; idx++) { //next line of table statement
-      let line = lines[idx]
+    for (let idx = table.lines.length; idx < lines.length; idx++) {
       let nextMigration = false
-      if (/^\s*== migration=\d+\s*$/.test(line)) {
+      if (MigrationTableParser._isMigrationMarker(lines[idx])) {
         if (format.startLine === -1) {
           format.startLine = idx
         } else {
@@ -120,25 +130,42 @@ class MigrationTableParser {
         }
       }
       if (format.startLine !== -1 && (nextMigration || (idx + 1) === lines.length)) {
-        // back search for end migration
-        for (let migrationIdx = (idx + 1) < lines.length ? idx - 1 : idx; migrationIdx > format.startLine; migrationIdx--) {
-          if (!/^\s*$|^\s*\)\s*$/.test(lines[migrationIdx])) {
-            format.endLine = migrationIdx
-            migrations.push(new Migration(lines, format))
-            if (nextMigration !== -1) {
-              format = { startLine: idx, endLine: -1 }
-            }
+        // back search for end of migration, comments belong to former migration
+        for (let mIdx = nextMigration ? idx - 1 : idx; mIdx > format.startLine; mIdx--) {
+          if (MigrationTableParser._isDDL(lines[mIdx])
+            || MigrationTableParser._isComment(lines[mIdx])) {
+            format.endLine = mIdx
             break
           }
         }
+        migrations.push(new Migration(lines, format))
+        if (nextMigration) {
+          format = { startLine: idx, endLine: -1 }
+        }
       }
     }
     return new Migrations(migrations)
   }
 
-  static _isSqlStatement(line) {
-    // lines that do not represent comments are treated as valid DDL statements
-    return !/^\s*--|^\s*==/.test(line)
+  // any lines that do not start with a comment or conflict marker and do not represent version tags
+  static _isDDL(line) {
+    return !/^\s*--|^\s*==|^\s*$|^\s*>>>>>/.test(line)
+  }
+
+  static _isComment(line) {
+    return /^\s*--/.test(line)
+  }
+
+  static _isConflictMarker(line) {
+    return /^\s*>>>>>/.test(line)
+  }
+
+  static _isVersionMarker(line) {
+    return /^\s*== version=\d+\s*$/.test(line)
+  }
+
+  static _isMigrationMarker(line) {
+    return /^\s*== migration=\d+\s*$/.test(line)
   }
 
   static _parseVersionNumber(line) {
@@ -154,7 +181,6 @@ class MigrationTableParser {
   }
 }
 
-
 /**
  * Model representation of an entire .hdbmigrationtable file.
  * <p>
@@ -269,10 +295,6 @@ class MigrationTable {
     this._versionNumber = newVersion
   }
 
-  get sql() {
-    return this._lines.filter(line => MigrationTableParser._isSqlStatement(line)).join('\n')
-  }
-
   get lines() {
     return this._lines
   }
@@ -288,7 +310,7 @@ class MigrationTable {
 
 class Migrations {
   constructor(migrations = []) {
-    this._migrations = migrations
+    this._migrations = migrations.sort((a, b) => b.versionNumber - a.versionNumber)
   }
   get versionNumber() {
     return this._migrations.length > 0 ? this._migrations[0].versionNumber : 1
@@ -327,7 +349,7 @@ class Migration {
       this._lines = lines
     }
     this._versionNumber = MigrationTableParser._parseVersionNumber(this.lines[0])
-    this._changeset = this._lines.filter(line => MigrationTableParser._isSqlStatement(line))
+    this._changeset = this._lines.filter(line => !MigrationTableParser._isMigrationMarker(line))
   }
 
   /**
@@ -359,6 +381,14 @@ class Migration {
     return this._changeset
   }
 
+  /**
+   * Returns the DDL statements of this changeset. Any lines that do not start with a comment or conflict marker
+   * and do not represent version tags are treated as valid DDL statements.
+   */
+  get ddl() {
+    return this.changeset.filter(line => MigrationTableParser._isDDL(line))
+  }
+
   /**
    * Returns the string representation of this migration.
    */
@@ -371,10 +401,4 @@ class Migration {
   }
 }
 
-module.exports = {
-  MigrationTableParser: new MigrationTableParser(),
-  MigrationTableModel,
-  MigrationTable,
-  Migrations,
-  Migration
-}
+module.exports = new MigrationTableParser()