@dbml/core 2.4.0 → 2.4.1

package/lib/export/DbmlExporter.js

@@ -193,10 +193,6 @@ var DbmlExporter = /*#__PURE__*/function () {
         settingStr += "headerColor: ".concat(table.headerColor).concat(settingSep);
       }
 
-      if (table.note) {
-        settingStr += "note: '".concat(table.note, "'").concat(settingSep);
-      }
-
       if (settingStr.endsWith(', ')) {
         settingStr = settingStr.replace(/,\s$/, '');
       }
@@ -223,9 +219,10 @@ var DbmlExporter = /*#__PURE__*/function () {
           }).join('\n'), "\n}");
         }
 
+        var tableNote = table.note ? "  Note: '".concat(table.note, "'\n") : '';
         var tableStr = "Table ".concat((0, _utils.shouldPrintSchema)(schema, model) ? "\"".concat(schema.name, "\".") : '', "\"").concat(table.name, "\"").concat(tableSettingStr, " {\n").concat(tableContent.fieldContents.map(function (line) {
           return "  ".concat(line);
-        }).join('\n'), "\n").concat(indexStr ? "".concat(indexStr, "\n") : '', "}\n");
+        }).join('\n'), "\n").concat(indexStr ? "".concat(indexStr, "\n") : '').concat(tableNote, "}\n");
         return tableStr;
       });
       return tableStrs.length ? tableStrs.join('\n') : '';

package/lib/parse/mssql/keyword_parsers.js

@@ -83,6 +83,7 @@ exports.KeywordCollate = keyword(/COLLATE/i);
 exports.KeywordClose = keyword(/CLOSE/i);
 exports.KeywordDeny = keyword(/DENY/i);
 exports.KeywordExecute = keyword(/EXECUTE/i);
+exports.KeywordExec = keyword(/EXEC/i);
 exports.KeywordGrant = keyword(/GRANT/i);
 exports.KeywordOpen = keyword(/OPEN/i);
 exports.KeywordRevoke = keyword(/REVOKE/i);
@@ -96,6 +97,7 @@ exports.KeywordSend = keyword(/SEND/i);
 exports.KeywordRename = keyword(/RENAME/i);
 exports.KeywordDelete = keyword(/DELETE/i);
 exports.KeywordIf = keyword(/IF/i);
+exports.KeywordSP_ADDEXTENDEDPROPERTY = keyword(/sp_addextendedproperty/i);
 exports.LogicalOpIn = keyword(/IN/i);
 exports.LogicalOpAnd = keyword(/AND/i);
 exports.LessThan = word('<');
@@ -104,7 +106,16 @@ exports.LParen = word('(');
 exports.Comma = word(',');
 exports.RParen = word(')');
 exports.DoubleQuote = word('"');
+exports.SingleQuote = word('\'');
 exports.LBracket = word('[');
 exports.RBracket = word(']');
 exports.Equal = word('=');
-exports.Semicolon = word(';');
+exports.Semicolon = word(';');
+exports.KeywordAtName = keyword(/@name/i);
+exports.KeywordAtValue = keyword(/@value/i);
+exports.KeywordAtLevel0Type = keyword(/@level0type/i);
+exports.KeywordAtLevel0Name = keyword(/@level0name/i);
+exports.KeywordAtLevel1Type = keyword(/@level1type/i);
+exports.KeywordAtLevel1Name = keyword(/@level1name/i);
+exports.KeywordAtLevel2Type = keyword(/@level2type/i);
+exports.KeywordAtLevel2Name = keyword(/@level2name/i);

package/lib/parse/mssql/statements/actions.js

@@ -59,6 +59,30 @@ function handleEnums(_enum, ast) {
   }).join(', ');
 }
 
+function handleComment(comment, ast) {
+  if (comment.type === 'table') handleTableNote(comment, ast);else if (comment.type === 'column') handleFieldNote(comment, ast);
+}
+
+function handleTableNote(comment, ast) {
+  var schemaName = comment.schemaName;
+  if (schemaName === 'dbo') schemaName = null; // treat `dbo` as public schema
+
+  var foundTable = findTable(ast, comment.tableName, schemaName);
+  if (foundTable) foundTable.note = comment.note;
+}
+
+function handleFieldNote(comment, ast) {
+  var schemaName = comment.schemaName;
+  if (schemaName === 'dbo') schemaName = null; // treat `dbo` as public schema
+
+  var foundTable = findTable(ast, comment.tableName, schemaName);
+
+  if (foundTable) {
+    var foundField = findField(foundTable, comment.columnName);
+    if (foundField) foundField.note = comment.note;
+  }
+}
+
 function handleStatement(_statements) {
   var ast = {
     tables: [],
@@ -90,6 +114,10 @@ function handleStatement(_statements) {
         handleEnums(statement.value, ast);
         break;
 
+      case 'comment':
+        handleComment(statement.value, ast);
+        break;
+
       default:
         break;
     }

package/lib/parse/mssql/statements/index.js

@@ -18,7 +18,7 @@ var Lang = P.createLanguage({
     return wss.then(r.Seperator).then(P.sepBy(r.StatementTypes, r.Seperator)).skip(r.Seperator).map(A.handleStatement);
   },
   StatementTypes: function StatementTypes(r) {
-    return P.alt(S.pCreateIndex, S.pCreateTable, S.pAlterTable, r.IgnoredStatementTypes);
+    return P.alt(S.pCreateIndex, S.pCreateTable, S.pAlterTable, S.pCommentSyntax, r.IgnoredStatementTypes);
   },
   IgnoredStatementTypes: function IgnoredStatementTypes(r) {
     return P.seq(r.IgnoredStatementSyntax, pIgnore);

package/lib/parse/mssql/statements/statement_types/comments/actions.js

@@ -0,0 +1,57 @@
+"use strict";
+
+function handleComment(_ref) {
+  var note = _ref.note,
+      level = _ref.level;
+  var type = 'unsupported';
+  var schemaName = null,
+      tableName = null,
+      columnName = null;
+
+  if (isValidTableNote(level)) {
+    schemaName = level[0].name;
+    tableName = level[1].name; // Table Comment
+
+    type = 'table';
+  } else if (isValidColumnNote(level)) {
+    schemaName = level[0].name;
+    tableName = level[1].name;
+    columnName = level[2].name;
+    type = 'column';
+  }
+
+  return {
+    type: 'comment',
+    value: {
+      type: type,
+      note: note,
+      schemaName: schemaName,
+      tableName: tableName,
+      columnName: columnName
+    }
+  };
+}
+
+var isSchema = function isSchema(type) {
+  return type.toLowerCase() === 'schema';
+};
+
+var isTable = function isTable(type) {
+  return type.toLowerCase() === 'table';
+};
+
+var isColumn = function isColumn(type) {
+  return type.toLowerCase() === 'column';
+};
+
+var isValidTableNote = function isValidTableNote(level) {
+  return level.length === 2 && isSchema(level[0].type) && isTable(level[1].type);
+};
+
+var isValidColumnNote = function isValidColumnNote(level) {
+  return level.length === 3 && isSchema(level[0].type) && isTable(level[1].type) && isColumn(level[2].type);
+};
+
+module.exports = {
+  handleComment: handleComment
+};

package/lib/parse/mssql/statements/statement_types/comments/index.js

@@ -0,0 +1,97 @@
+"use strict";
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var P = require('parsimmon');
+
+var KP = require('../../../keyword_parsers');
+
+var A = require('./actions');
+
+var _require = require('../../../utils'),
+    makeNode = _require.makeNode;
+
+var Lang = P.createLanguage({
+  StartComment: function StartComment() {
+    return P.seq(KP.KeywordExec, KP.KeywordSP_ADDEXTENDEDPROPERTY);
+  },
+  EndComment: function EndComment() {
+    return P.seq(KP.Semicolon.atMost(1), KP.KeywordGo);
+  },
+  StartString: function StartString() {
+    return P.alt(KP.SingleQuote, P.string("N'"));
+  },
+  ManyDoubleSingleQuote: function ManyDoubleSingleQuote() {
+    return P.string("''");
+  },
+  NoSingleQuote: function NoSingleQuote() {
+    return P.regex(/[^']/);
+  },
+  StringType: function StringType(r) {
+    return P.alt(r.NoSingleQuote, r.ManyDoubleSingleQuote).atLeast(1).map(function (res) {
+      return res.join('');
+    });
+  },
+  NVarchar: function NVarchar(r) {
+    return r.StartString.then(r.StringType).skip(KP.SingleQuote);
+  },
+  NameOption: function NameOption(r) {
+    return KP.KeywordAtName.skip(KP.Equal).then(r.NVarchar);
+  },
+  ValueOption: function ValueOption(r) {
+    return KP.KeywordAtValue.skip(KP.Equal).then(r.NVarchar);
+  },
+  Level0Type: function Level0Type(r) {
+    return KP.KeywordAtLevel0Type.skip(KP.Equal).then(r.NVarchar);
+  },
+  Level0Name: function Level0Name(r) {
+    return KP.KeywordAtLevel0Name.skip(KP.Equal).then(r.NVarchar);
+  },
+  Level1Type: function Level1Type(r) {
+    return KP.KeywordAtLevel1Type.skip(KP.Equal).then(r.NVarchar);
+  },
+  Level1Name: function Level1Name(r) {
+    return KP.KeywordAtLevel1Name.skip(KP.Equal).then(r.NVarchar);
+  },
+  Level2Type: function Level2Type(r) {
+    return KP.KeywordAtLevel2Type.skip(KP.Equal).then(r.NVarchar);
+  },
+  Level2Name: function Level2Name(r) {
+    return KP.KeywordAtLevel2Name.skip(KP.Equal).then(r.NVarchar);
+  },
+  Level0Stmt: function Level0Stmt(r) {
+    return P.seqObj(['type', r.Level0Type], KP.Comma, ['name', r.Level0Name]);
+  },
+  Level1Stmt: function Level1Stmt(r) {
+    return P.seqObj(['type', r.Level1Type], KP.Comma, ['name', r.Level1Name]);
+  },
+  Level2Stmt: function Level2Stmt(r) {
+    return P.seqObj(['type', r.Level2Type], KP.Comma, ['name', r.Level2Name]);
+  },
+  Level0Wrapper: function Level0Wrapper(r) {
+    return P.alt(P.seq(r.Level0Stmt.skip(KP.Comma), r.Level1Wrapper), r.Level0Stmt).map(function (res) {
+      return Array.isArray(res) ? [res[0]].concat(_toConsumableArray(res[1])) : [res];
+    }).atMost(1).map(function (res) {
+      return res.length === 1 ? res[0] : res;
+    });
+  },
+  Level1Wrapper: function Level1Wrapper(r) {
+    return P.alt(P.seq(r.Level1Stmt.skip(KP.Comma), r.Level2Stmt), r.Level1Stmt).map(function (res) {
+      return Array.isArray(res) ? res : [res];
+    });
+  },
+  CommentSyntax: function CommentSyntax(r) {
+    return P.seqObj(r.StartComment, ['name', r.NameOption], KP.Comma, ['note', r.ValueOption], KP.Comma, ['level', r.Level0Wrapper], r.EndComment).map(A.handleComment).thru(makeNode());
+  }
+});
+module.exports = Lang.CommentSyntax;

package/lib/parse/mssql/statements/statement_types/index.js

@@ -6,8 +6,11 @@ var pCreateIndex = require('./create_index/index');
 
 var pCreateTable = require('./create_table');
 
+var pCommentSyntax = require('./comments');
+
 module.exports = {
   pAlterTable: pAlterTable,
   pCreateIndex: pCreateIndex,
-  pCreateTable: pCreateTable
+  pCreateTable: pCreateTable,
+  pCommentSyntax: pCommentSyntax
 };

package/lib/parse/mysql/parser.pegjs

@@ -34,20 +34,20 @@ Rule = (Expr)* {
   return {tables, refs, enums};
 }
 
-Expr = 
+Expr =
 	t:TableSyntax { tables.push(t) }
 	/AlterSyntax
 	/IndexSyntax
 	/IgnoreSyntax
 	/__
-    
+
 // 				TableSyntax: support "CREATE TABLE" syntax.
 // Try to support as mush as possible syntax in MySQL offical documents.
 // https://dev.mysql.com/doc/refman/8.0/en/create-table.html
 // Return: table object: {name, schemaName, fields, [,indexes]}
-TableSyntax 
-	= create_table (__ if_not_exist)? __ table_name:table_name _ 
-    "(" _ body:TableBody _ ")" _ TableOptions? _ semicolon endline?
+TableSyntax
+	= create_table (__ if_not_exist)? __ table_name:table_name _
+    "(" _ body:TableBody _ ")" _ options:TableOptions? _ semicolon endline?
 {
 	const fields = body.fields;
 	const indexes = body.indexes;
@@ -68,7 +68,7 @@ TableSyntax
 			});
 
 			const _enum = {
-				name: `${table_name.schemaName 
+				name: `${table_name.schemaName
 				? `${table_name.schemaName}_` : ''}${table_name.name}_${field.name}_enum`,
 				values
 			};
@@ -84,10 +84,12 @@ TableSyntax
 		refs.push(ref);
 	});
 
-    // return statement
-    return indexes ? 
-    	{...table_name, fields, indexes} 
-      : {...table_name, fields}
+  let res = {...table_name, fields};
+
+	if (options && options.comment) res.note = options.comment;
+	if (indexes) res.indexes = indexes;
+	// return statement
+	return res;
 }
 
 // TableBody: this is the part between parenthesis.
@@ -416,6 +418,7 @@ IgnoreSyntax
 	/ BeginSyntax
 	/ CommitSyntax
 	/ RollbackSyntax
+	/ "ALTER"i _ (comment / !(semicolon) .)*
 	) semicolon newline?
 
 // InsertSyntax: "INSERTO INTO" syntax