@dbml/core 3.3.0 → 3.4.1-alpha.0

package/lib/export/ModelExporter.js

@@ -9,6 +9,7 @@ var _MysqlExporter = _interopRequireDefault(require("./MysqlExporter"));
 var _PostgresExporter = _interopRequireDefault(require("./PostgresExporter"));
 var _JsonExporter = _interopRequireDefault(require("./JsonExporter"));
 var _SqlServerExporter = _interopRequireDefault(require("./SqlServerExporter"));
+var _OracleExporter = _interopRequireDefault(require("./OracleExporter"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
@@ -24,7 +25,7 @@ var ModelExporter = /*#__PURE__*/function () {
     key: "export",
     value: function _export() {
       var model = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      var format = arguments.length > 1 ? arguments[1] : undefined;
+      var format = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
       var isNormalized = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
       var res = '';
       var normalizedModel = isNormalized ? model : model.normalize();
@@ -44,6 +45,9 @@ var ModelExporter = /*#__PURE__*/function () {
         case 'mssql':
           res = _SqlServerExporter["default"]["export"](normalizedModel);
           break;
+        case 'oracle':
+          res = _OracleExporter["default"]["export"](normalizedModel);
+          break;
         default:
           break;
       }

package/lib/export/OracleExporter.js

@@ -0,0 +1,453 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _lodash = _interopRequireDefault(require("lodash"));
+var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+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" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) 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; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var OracleExporter = /*#__PURE__*/function () {
+  function OracleExporter() {
+    _classCallCheck(this, OracleExporter);
+  }
+  _createClass(OracleExporter, null, [{
+    key: "buildSchemaToTableNameSetMap",
+    value: function buildSchemaToTableNameSetMap(model) {
+      var schemaToTableNameSetMap = new Map();
+      _lodash["default"].forEach(model.tables, function (table) {
+        var schema = model.schemas[table.schemaId];
+        var tableSet = schemaToTableNameSetMap.get(schema.name);
+        if (!tableSet) {
+          schemaToTableNameSetMap.set(schema.name, new Set([table.name]));
+          return;
+        }
+        tableSet.add(table.name);
+      });
+      return schemaToTableNameSetMap;
+    }
+  }, {
+    key: "buildTableNameWithSchema",
+    value: function buildTableNameWithSchema(model, schema, table) {
+      return "".concat((0, _utils.shouldPrintSchema)(schema, model) ? "".concat((0, _utils.escapeObjectName)(schema.name, 'oracle'), ".") : '').concat((0, _utils.escapeObjectName)(table.name, 'oracle'));
+    }
+  }, {
+    key: "exportSchema",
+    value: function exportSchema(schemaName) {
+      // According to Oracle, CREATE SCHEMA statement does not actually create a schema and it automatically creates a schema when we create a user
+      // Learn more: https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/CREATE-SCHEMA.html#GUID-2D154F9C-9E2B-4A09-B658-2EA5B99AC838__GUID-CC0A5080-2AF3-4460-AB2B-DEA6C79519BA
+      return "CREATE USER ".concat((0, _utils.escapeObjectName)(schemaName, 'oracle'), "\n") + 'NO AUTHENTICATION\n' + 'DEFAULT TABLESPACE system\n' + 'TEMPORARY TABLESPACE temp\n' + 'QUOTA UNLIMITED ON system;\n';
+    }
+  }, {
+    key: "getFieldLines",
+    value: function getFieldLines(tableId, model) {
+      var table = model.tables[tableId];
+      var lines = table.fieldIds.map(function (fieldId) {
+        var field = model.fields[fieldId];
+        var fieldName = (0, _utils.escapeObjectName)(field.name, 'oracle');
+        var line = fieldName;
+        if (field.enumId) {
+          var _enum = model.enums[field.enumId];
+          var enumValues = _enum.valueIds.map(function (valueId) {
+            var value = model.enumValues[valueId];
+            return "'".concat(value.name, "'");
+          });
+          var enumString = enumValues.join(', ');
+          line += " nvarchar2(255) NOT NULL CHECK (".concat(fieldName, " IN (").concat(enumString, "))");
+        } else {
+          line += " ".concat(field.type.type_name);
+        }
+        var cloneField = _objectSpread({}, field);
+        if (cloneField.increment) {
+          line += ' GENERATED AS IDENTITY';
+
+          // in oracle, increment means using identity. If a clause includes identity, we must ignore not null + default value
+          cloneField.dbdefault = null;
+          cloneField.not_null = false;
+        }
+        if (cloneField.unique) {
+          line += ' UNIQUE';
+        }
+        if (cloneField.pk) {
+          line += ' PRIMARY KEY';
+        }
+        if (cloneField.not_null) {
+          line += ' NOT NULL';
+        }
+        if (cloneField.dbdefault) {
+          if (cloneField.dbdefault.type === 'string') {
+            line += " DEFAULT '".concat(cloneField.dbdefault.value, "'");
+          } else {
+            line += " DEFAULT ".concat(cloneField.dbdefault.value);
+          }
+        }
+        return line;
+      });
+      return lines;
+    }
+  }, {
+    key: "getCompositePKs",
+    value: function getCompositePKs(tableId, model) {
+      var table = model.tables[tableId];
+      var compositePkIds = table.indexIds ? table.indexIds.filter(function (indexId) {
+        return model.indexes[indexId].pk;
+      }) : [];
+      var lines = compositePkIds.map(function (keyId) {
+        var key = model.indexes[keyId];
+        var line = 'PRIMARY KEY';
+        var columnArr = [];
+        key.columnIds.forEach(function (columnId) {
+          var column = model.indexColumns[columnId];
+          var columnStr = '';
+          if (column.type === 'expression') {
+            columnStr = "(".concat(column.value, ")");
+          } else {
+            columnStr = "\"".concat(column.value, "\"");
+          }
+          columnArr.push(columnStr);
+        });
+        line += " (".concat(columnArr.join(', '), ")");
+        return line;
+      });
+      return lines;
+    }
+  }, {
+    key: "getTableContents",
+    value: function getTableContents(tableIds, model) {
+      var _this = this;
+      var tableContentArr = tableIds.map(function (tableId) {
+        var fieldContents = _this.getFieldLines(tableId, model);
+        var compositePKs = _this.getCompositePKs(tableId, model);
+        return {
+          tableId: tableId,
+          fieldContents: fieldContents,
+          compositePKs: compositePKs
+        };
+      });
+      return tableContentArr;
+    }
+  }, {
+    key: "exportTables",
+    value: function exportTables(tableIds, model) {
+      var _this2 = this;
+      var tableContentList = this.getTableContents(tableIds, model);
+      var tableStrs = tableContentList.map(function (tableContent) {
+        var content = [].concat(_toConsumableArray(tableContent.fieldContents), _toConsumableArray(tableContent.compositePKs));
+        var table = model.tables[tableContent.tableId];
+        var schema = model.schemas[table.schemaId];
+        var tableName = _this2.buildTableNameWithSchema(model, schema, table);
+        var contentString = content.map(function (line) {
+          return "  ".concat(line);
+        }).join(',\n');
+        var tableStr = "CREATE TABLE ".concat(tableName, " (\n").concat(contentString, "\n);\n");
+        return tableStr;
+      });
+      return tableStrs;
+    }
+  }, {
+    key: "buildReferenceFieldNamesString",
+    value: function buildReferenceFieldNamesString(fieldIds, model) {
+      var fieldNames = fieldIds.map(function (fieldId) {
+        return "\"".concat(model.fields[fieldId].name, "\"");
+      }).join(', ');
+      return "(".concat(fieldNames, ")");
+    }
+  }, {
+    key: "buildTableManyToMany",
+    value: function buildTableManyToMany(firstTableFieldsMap, secondTableFieldsMap, tableName) {
+      var line = "CREATE TABLE ".concat(tableName, " (\n");
+      firstTableFieldsMap.forEach(function (fieldType, fieldName) {
+        line += "  \"".concat(fieldName, "\" ").concat(fieldType, ",\n");
+      });
+      secondTableFieldsMap.forEach(function (fieldType, fieldName) {
+        line += "  \"".concat(fieldName, "\" ").concat(fieldType, ",\n");
+      });
+      var key1s = _toConsumableArray(firstTableFieldsMap.keys()).join('`, `');
+      var key2s = _toConsumableArray(secondTableFieldsMap.keys()).join('`, `');
+      line += "  PRIMARY KEY (\"".concat(key1s, "\", \"").concat(key2s, "\")\n);\n");
+      return line;
+    }
+  }, {
+    key: "buildForeignKeyManyToMany",
+    value: function buildForeignKeyManyToMany(foreignEndpointTableName, foreignEndpointFields, refEndpointTableName, refEndpointFieldsString) {
+      var foreignEndpointFieldsString = _toConsumableArray(foreignEndpointFields.keys()).join('`, `');
+      var line = "ALTER TABLE ".concat(foreignEndpointTableName, " ADD FOREIGN KEY (\"").concat(foreignEndpointFieldsString, "\") REFERENCES ").concat(refEndpointTableName, " ").concat(refEndpointFieldsString, ";\n");
+      return line;
+    }
+  }, {
+    key: "exportReferencesAndNewTablesIfExists",
+    value: function exportReferencesAndNewTablesIfExists(refIds, model, usedTableNameMap) {
+      var _this3 = this;
+      var result = {
+        refs: [],
+        tables: []
+      };
+      refIds.forEach(function (refId) {
+        var ref = model.refs[refId];
+
+        // find the one relation in one-to-xxx or xxx-to-one relationship
+        var refOneIndex = ref.endpointIds.findIndex(function (endpointId) {
+          return model.endpoints[endpointId].relation === '1';
+        });
+        var refEndpointIndex = refOneIndex === -1 ? 0 : refOneIndex;
+
+        // refEndpointIndex could be 0 or 1, so use 1 - refEndpointIndex will take the remained index
+        var foreignEndpointId = ref.endpointIds[1 - refEndpointIndex];
+        var foreignEndpoint = model.endpoints[foreignEndpointId];
+        var foreignEndpointField = model.fields[foreignEndpoint.fieldIds[0]];
+        var foreignEndpointTable = model.tables[foreignEndpointField.tableId];
+        var foreignEndpointSchema = model.schemas[foreignEndpointTable.schemaId];
+        var foreignEndpointFieldNameString = _this3.buildReferenceFieldNamesString(foreignEndpoint.fieldIds, model);
+        var refEndpointId = ref.endpointIds[refEndpointIndex];
+        var refEndpoint = model.endpoints[refEndpointId];
+        var refEndpointField = model.fields[refEndpoint.fieldIds[0]];
+        var refEndpointTable = model.tables[refEndpointField.tableId];
+        var refEndpointSchema = model.schemas[refEndpointTable.schemaId];
+        var refEndpointFieldNameString = _this3.buildReferenceFieldNamesString(refEndpoint.fieldIds, model);
+        if (refOneIndex !== -1) {
+          var foreignTableName = _this3.buildTableNameWithSchema(model, foreignEndpointSchema, foreignEndpointTable);
+          var line = "ALTER TABLE ".concat(foreignTableName, " ADD");
+          if (ref.name) {
+            line += " CONSTRAINT ".concat((0, _utils.escapeObjectName)(ref.name, 'oracle'));
+          }
+          var refTableName = _this3.buildTableNameWithSchema(model, refEndpointSchema, refEndpointTable);
+          line += " FOREIGN KEY ".concat(foreignEndpointFieldNameString, " REFERENCES ").concat(refTableName, " ").concat(refEndpointFieldNameString);
+          if (ref.onDelete) {
+            line += " ON DELETE ".concat(ref.onDelete.toUpperCase());
+          }
+          line += ';\n';
+          result.refs.push(line);
+          return;
+        }
+
+        // many to many relationship
+        var firstTableFieldsMap = (0, _utils.buildJunctionFields1)(refEndpoint.fieldIds, model);
+        var secondTableFieldsMap = (0, _utils.buildJunctionFields2)(foreignEndpoint.fieldIds, model, firstTableFieldsMap);
+        var newTableName = (0, _utils.buildUniqueTableName)(refEndpointSchema, refEndpointTable.name, foreignEndpointTable.name, usedTableNameMap);
+        var tableNameSet = usedTableNameMap.get(refEndpointSchema);
+        if (!tableNameSet) {
+          usedTableNameMap.set(refEndpointSchema, new Set([newTableName]));
+        } else {
+          tableNameSet.add(newTableName);
+        }
+        var escapedNewTableName = "".concat((0, _utils.shouldPrintSchema)(refEndpointSchema, model) ? "\"".concat(refEndpointSchema.name, "\".") : '', "\"").concat(newTableName, "\"");
+        result.tables.push(_this3.buildTableManyToMany(firstTableFieldsMap, secondTableFieldsMap, escapedNewTableName));
+        var firstTableName = _this3.buildTableNameWithSchema(model, refEndpointSchema, refEndpointTable);
+        result.refs.push(_this3.buildForeignKeyManyToMany(escapedNewTableName, firstTableFieldsMap, firstTableName, refEndpointFieldNameString));
+        var secondTableName = _this3.buildTableNameWithSchema(model, foreignEndpointSchema, foreignEndpointTable);
+        result.refs.push(_this3.buildForeignKeyManyToMany(escapedNewTableName, secondTableFieldsMap, secondTableName, foreignEndpointFieldNameString));
+      });
+      return result;
+    }
+  }, {
+    key: "exportReferenceGrants",
+    value: function exportReferenceGrants(model, refIds) {
+      var _this4 = this;
+      // only default schema -> ignore it
+      if (Object.keys(model.schemas).length <= 1) {
+        return [];
+      }
+      var tableNameList = [];
+      refIds.forEach(function (refId) {
+        var ref = model.refs[refId];
+
+        // find the one relation in one - many, many - one, one - one relationship
+        var refOneIndex = ref.endpointIds.findIndex(function (endpointId) {
+          return model.endpoints[endpointId].relation === '1';
+        });
+        var refEndpointIndex = refOneIndex === -1 ? 0 : refOneIndex;
+        var refEndpointId = ref.endpointIds[refEndpointIndex];
+        var refEndpoint = model.endpoints[refEndpointId];
+        var refEndpointField = model.fields[refEndpoint.fieldIds[0]];
+        var refEndpointTable = model.tables[refEndpointField.tableId];
+        var refEndpointSchema = model.schemas[refEndpointTable.schemaId];
+
+        // refEndpointIndex could be 0 or 1, so use 1 - refEndpointIndex will take the remained index
+        var foreignEndpointId = ref.endpointIds[1 - refEndpointIndex];
+        var foreignEndpoint = model.endpoints[foreignEndpointId];
+        var foreignEndpointField = model.fields[foreignEndpoint.fieldIds[0]];
+        var foreignEndpointTable = model.tables[foreignEndpointField.tableId];
+        var foreignEndpointSchema = model.schemas[foreignEndpointTable.schemaId];
+
+        // reference in the same schema
+        if (refEndpointSchema.name === foreignEndpointSchema.name) {
+          tableNameList.push('');
+          return;
+        }
+        var refTableName = _this4.buildTableNameWithSchema(model, refEndpointSchema, refEndpointTable);
+        // refTableName is always needed to be grant
+        tableNameList.push(refTableName);
+
+        // one - many, many - one, one - one relationship
+        if (refOneIndex !== -1) {
+          return;
+        }
+        var foreignTableName = _this4.buildTableNameWithSchema(model, foreignEndpointSchema, foreignEndpointTable);
+        tableNameList.push(foreignTableName);
+      });
+      var tableToGrantList = tableNameList
+      // remove duplicate
+      .filter(function (table, index) {
+        return table && tableNameList.indexOf(table) === index;
+      })
+      // map into grant statement
+      .map(function (table) {
+        return "GRANT REFERENCES ON ".concat(table, " TO PUBLIC;\n");
+      });
+      return tableToGrantList;
+    }
+  }, {
+    key: "exportIndexes",
+    value: function exportIndexes(indexIds, model) {
+      var _this5 = this;
+      // exclude composite pk index
+      var indexArr = indexIds.filter(function (indexId) {
+        return !model.indexes[indexId].pk;
+      }).map(function (indexId) {
+        var index = model.indexes[indexId];
+        var table = model.tables[index.tableId];
+        var schema = model.schemas[table.schemaId];
+        var line = 'CREATE';
+        // ignore dbml index type: b-tree, hash
+        if (index.unique) {
+          line += ' UNIQUE';
+        }
+        line += ' INDEX';
+        if (index.name) {
+          line += " ".concat((0, _utils.escapeObjectName)(index.name, 'oracle'));
+        }
+        var tableName = _this5.buildTableNameWithSchema(model, schema, table);
+        line += " ON ".concat(tableName);
+        var columnArr = [];
+        index.columnIds.forEach(function (columnId) {
+          var column = model.indexColumns[columnId];
+          var columnStr = '';
+          if (column.type === 'expression') {
+            columnStr = "".concat(column.value);
+          } else {
+            columnStr = "\"".concat(column.value, "\"");
+          }
+          columnArr.push(columnStr);
+        });
+        var columnString = columnArr.join(', ');
+        line += " (".concat(columnString, ");\n");
+        return line;
+      });
+      return indexArr;
+    }
+  }, {
+    key: "exportComments",
+    value: function exportComments(comments, model) {
+      var _this6 = this;
+      var commentArr = comments.map(function (comment) {
+        var line = 'COMMENT ON';
+        var table = model.tables[comment.tableId];
+        var schema = model.schemas[table.schemaId];
+        var tableName = _this6.buildTableNameWithSchema(model, schema, table);
+        switch (comment.type) {
+          case 'table':
+            {
+              line += " TABLE ".concat(tableName, " IS '").concat(table.note.replace(/'/g, "''"), "'");
+              break;
+            }
+          case 'column':
+            {
+              var field = model.fields[comment.fieldId];
+              line += " COLUMN ".concat(tableName, ".").concat((0, _utils.escapeObjectName)(field.name, 'oracle'), " IS '").concat(field.note.replace(/'/g, "''"), "'");
+              break;
+            }
+          default:
+            break;
+        }
+        line += ';\n';
+        return line;
+      });
+      return commentArr;
+    }
+  }, {
+    key: "export",
+    value: function _export(model) {
+      var _this7 = this;
+      var database = model.database['1'];
+      var schemaToTableNameSetMap = this.buildSchemaToTableNameSetMap(model);
+      var statements = database.schemaIds.reduce(function (prevStatements, schemaId) {
+        var schema = model.schemas[schemaId];
+        var tableIds = schema.tableIds,
+          refIds = schema.refIds;
+        if ((0, _utils.shouldPrintSchema)(schema, model)) {
+          prevStatements.schemas.push(_this7.exportSchema(schema.name));
+        }
+        if (!_lodash["default"].isEmpty(tableIds)) {
+          var _prevStatements$table;
+          (_prevStatements$table = prevStatements.tables).push.apply(_prevStatements$table, _toConsumableArray(_this7.exportTables(tableIds, model)));
+        }
+        var indexIds = _lodash["default"].flatten(tableIds.map(function (tableId) {
+          return model.tables[tableId].indexIds;
+        }));
+        if (!_lodash["default"].isEmpty(indexIds)) {
+          var _prevStatements$index;
+          (_prevStatements$index = prevStatements.indexes).push.apply(_prevStatements$index, _toConsumableArray(_this7.exportIndexes(indexIds, model)));
+        }
+        var commentNodes = _lodash["default"].flatten(tableIds.map(function (tableId) {
+          var _model$tables$tableId = model.tables[tableId],
+            fieldIds = _model$tables$tableId.fieldIds,
+            note = _model$tables$tableId.note;
+          var fieldObjects = fieldIds.filter(function (fieldId) {
+            return model.fields[fieldId].note;
+          }).map(function (fieldId) {
+            return {
+              type: 'column',
+              fieldId: fieldId,
+              tableId: tableId
+            };
+          });
+          return note ? [{
+            type: 'table',
+            tableId: tableId
+          }].concat(fieldObjects) : fieldObjects;
+        }));
+        if (!_lodash["default"].isEmpty(commentNodes)) {
+          var _prevStatements$comme;
+          (_prevStatements$comme = prevStatements.comments).push.apply(_prevStatements$comme, _toConsumableArray(_this7.exportComments(commentNodes, model)));
+        }
+        if (!_lodash["default"].isEmpty(refIds)) {
+          var _prevStatements$table2, _prevStatements$refs, _prevStatements$refer;
+          var _this7$exportReferenc = _this7.exportReferencesAndNewTablesIfExists(refIds, model, schemaToTableNameSetMap),
+            refs = _this7$exportReferenc.refs,
+            manyToManyTables = _this7$exportReferenc.tables;
+          (_prevStatements$table2 = prevStatements.tables).push.apply(_prevStatements$table2, _toConsumableArray(manyToManyTables));
+          (_prevStatements$refs = prevStatements.refs).push.apply(_prevStatements$refs, _toConsumableArray(refs));
+          (_prevStatements$refer = prevStatements.referenceGrants).push.apply(_prevStatements$refer, _toConsumableArray(_this7.exportReferenceGrants(model, refIds)));
+        }
+        return prevStatements;
+      }, {
+        schemas: [],
+        tables: [],
+        indexes: [],
+        comments: [],
+        referenceGrants: [],
+        refs: []
+      });
+      var res = _lodash["default"].concat(statements.schemas, statements.tables, statements.indexes, statements.comments, statements.referenceGrants, statements.refs).join('\n');
+      return res;
+    }
+  }]);
+  return OracleExporter;
+}();
+var _default = OracleExporter;
+exports["default"] = _default;

package/lib/export/README.md

@@ -0,0 +1,32 @@
+# DBML Exporter
+
+## DBML vs Oracle Mapping
+
+Currently, our exporter supports Oracle version 19c syntax.
+
+| DBML | Oracle | Notes |
+|  ---  |  ---  |  ---  |
+| **Schema** | Schema - User |  |
+| **Table** | Table |  |
+|  `note`  | Table comment |  |
+| **Column** | Column |  |
+| `note` | Column comment |  |
+| `primary key or pk` | PRIMARY KEY constraint |  |
+| `null or not null` | NULL or NOT NULL constraint |  |
+| `unique` | UNIQUE constraint |  |
+| `default` | DEFAULT value |  |
+| `increment` | Identity column |  |
+| **Index** | Index |  |
+| `type` | Index type |  |
+| `name` | Index name |  |
+| `unique` | Unique index |  |
+| Index with an expression | Function-based index |  |
+| Composite index | Index on multiple columns |  |
+| **Relationship** | Foreign key |  |
+| `delete` | ON DELETE clause |  |
+| `update` | ❌ |  |
+| Many-to-many relationship | ❌ | Use junction table |
+| **Composite keys** |  |  |
+| Composite primary key | Composite primary key |  |
+| Composite foreign key | Composite foreign key |  |
+| **Enum** | ❌ | Use CHECK constraint |

package/lib/export/utils.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.buildJunctionFields1 = buildJunctionFields1;
 exports.buildJunctionFields2 = buildJunctionFields2;
 exports.buildNewTableName = buildNewTableName;
+exports.buildUniqueTableName = buildUniqueTableName;
+exports.escapeObjectName = escapeObjectName;
 exports.hasWhiteSpace = hasWhiteSpace;
 exports.shouldPrintSchema = shouldPrintSchema;
 var _config = require("../model_structure/config");
@@ -24,7 +26,7 @@ function buildJunctionFields1(fieldIds, model) {
 }
 function buildJunctionFields2(fieldIds, model, firstTableFieldsMap) {
   var fieldsMap = new Map();
-  fieldIds.map(function (fieldId) {
+  fieldIds.forEach(function (fieldId) {
     var fieldName = "".concat(model.tables[model.fields[fieldId].tableId].name, "_").concat(model.fields[fieldId].name);
     var count = 1;
     while (firstTableFieldsMap.has(fieldName)) {
@@ -44,4 +46,45 @@ function buildNewTableName(firstTable, secondTable, usedTableNames) {
   }
   usedTableNames.add(newTableName);
   return newTableName;
+}
+
+/**
+ *
+ * @param {string} schemaName
+ * @param {string} firstTableName
+ * @param {string} secondTableName
+ * @param {Map<string, Set>} schemaToTableNameSetMap
+ * @returns string
+ * @description This function is a clone version of the buildNewTableName, but without side effect - update the original usedTableNames
+ */
+function buildUniqueTableName(schemaName, firstTableName, secondTableName, schemaToTableNameSetMap) {
+  var newTableName = "".concat(firstTableName, "_").concat(secondTableName);
+  var count = 1;
+  var tableNameSet = schemaToTableNameSetMap.get(schemaName);
+  if (!tableNameSet) {
+    return newTableName;
+  }
+  while (tableNameSet.has(newTableName)) {
+    newTableName = "".concat(firstTableName, "_").concat(secondTableName, "(").concat(count, ")");
+    count += 1;
+  }
+  return newTableName;
+}
+function escapeObjectName(name, database) {
+  if (!name) {
+    return '';
+  }
+  var escapeSignature = '';
+  switch (database) {
+    case 'mysql':
+      escapeSignature = '`';
+      break;
+    case 'postgres':
+    case 'oracle':
+      escapeSignature = '"';
+      break;
+    default:
+      break;
+  }
+  return "".concat(escapeSignature).concat(name).concat(escapeSignature);
 }

package/lib/index.js

@@ -3,6 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "CompilerError", {
+  enumerable: true,
+  get: function get() {
+    return _error.CompilerError;
+  }
+});
 Object.defineProperty(exports, "ModelExporter", {
   enumerable: true,
   get: function get() {
@@ -29,6 +35,7 @@ Object.defineProperty(exports, "importer", {
 });
 var _ModelExporter = _interopRequireDefault(require("./export/ModelExporter"));
 var _Parser = _interopRequireDefault(require("./parse/Parser"));
+var _error = require("../lib/parse/error");
 var _import = _interopRequireDefault(require("./import"));
 var _export = _interopRequireDefault(require("./export"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

package/lib/model_structure/element.js

@@ -35,6 +35,7 @@ var ElementError = /*#__PURE__*/function (_Error) {
     _classCallCheck(this, ElementError);
     _this = _super.call(this, message);
     _this.location = location;
+    _this.error = 'error';
     return _this;
   }
   return _createClass(ElementError);

package/lib/model_structure/note.js

@@ -0,0 +1,72 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _element = _interopRequireDefault(require("./element"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+var Note = /*#__PURE__*/function (_Element) {
+  _inherits(Note, _Element);
+  var _super = _createSuper(Note);
+  function Note() {
+    var _this;
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      name = _ref.name,
+      content = _ref.content,
+      headerColor = _ref.headerColor,
+      token = _ref.token,
+      _ref$database = _ref.database,
+      database = _ref$database === void 0 ? {} : _ref$database;
+    _classCallCheck(this, Note);
+    _this = _super.call(this, token);
+    _this.name = name;
+    _this.content = content;
+    _this.headerColor = headerColor;
+    _this.database = database;
+    _this.dbState = _this.database.dbState;
+    _this.generateId();
+    return _this;
+  }
+  _createClass(Note, [{
+    key: "generateId",
+    value: function generateId() {
+      this.id = this.dbState.generateId('noteId');
+    }
+  }, {
+    key: "export",
+    value: function _export() {
+      return {
+        name: this.name,
+        content: this.content,
+        headerColor: this.headerColor
+      };
+    }
+  }, {
+    key: "normalize",
+    value: function normalize(model) {
+      model.notes = _objectSpread(_objectSpread({}, model.notes), {}, _defineProperty({}, this.id, _objectSpread({
+        id: this.id
+      }, this["export"]())));
+    }
+  }]);
+  return Note;
+}(_element["default"]);
+var _default = Note;
+exports["default"] = _default;

package/lib/parse/Parser.js

@@ -12,6 +12,7 @@ var _dbmlParser = _interopRequireDefault(require("./dbmlParser"));
 var _schemarbParser = _interopRequireDefault(require("./schemarbParser"));
 var _mssqlParser = _interopRequireDefault(require("./mssqlParser"));
 var _ASTGeneration = require("./ANTLR/ASTGeneration");
+var _error = require("./error");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
@@ -27,29 +28,28 @@ var Parser = /*#__PURE__*/function () {
   _createClass(Parser, [{
     key: "parse",
     value: function parse(str, format) {
-      var rawDatabase = {};
-      switch (format) {
-        case 'mysql':
-          rawDatabase = Parser.parseMySQLToJSONv2(str);
-          break;
-        case 'mysqlLegacy':
-          rawDatabase = Parser.parseMySQLToJSON(str);
-          break;
-        case 'postgres':
-          rawDatabase = Parser.parsePostgresToJSONv2(str);
-          break;
-        case 'postgresLegacy':
-          rawDatabase = Parser.parsePostgresToJSON(str);
-          break;
-        case 'dbml':
-          rawDatabase = Parser.parseDBMLToJSON(str);
-          break;
-        case 'dbmlv2':
-          {
-            this.DBMLCompiler.setSource(str);
-            var errors = this.DBMLCompiler.parse.errors();
-            if (errors.length > 0) {
-              throw errors.map(function (error) {
+      try {
+        var rawDatabase = {};
+        switch (format) {
+          case 'mysql':
+            rawDatabase = Parser.parseMySQLToJSONv2(str);
+            break;
+          case 'mysqlLegacy':
+            rawDatabase = Parser.parseMySQLToJSON(str);
+            break;
+          case 'postgres':
+            rawDatabase = Parser.parsePostgresToJSONv2(str);
+            break;
+          case 'postgresLegacy':
+            rawDatabase = Parser.parsePostgresToJSON(str);
+            break;
+          case 'dbml':
+            rawDatabase = Parser.parseDBMLToJSON(str);
+            break;
+          case 'dbmlv2':
+            {
+              this.DBMLCompiler.setSource(str);
+              var diags = this.DBMLCompiler.parse.errors().map(function (error) {
                 return {
                   message: error.diagnostic,
                   location: {
@@ -65,28 +65,31 @@ var Parser = /*#__PURE__*/function () {
                   code: error.code
                 };
               });
+              if (diags.length > 0) throw _error.CompilerError.create(diags);
             }
             rawDatabase = this.DBMLCompiler.parse.rawDb();
             break;
-          }
-        case 'schemarb':
-          rawDatabase = Parser.parseSchemaRbToJSON(str);
-          break;
-        case 'mssql':
-          rawDatabase = Parser.parseMSSQLToJSON(str);
-          break;
-        case 'json':
-          if (_typeof(str) === 'object') {
-            rawDatabase = str;
-          } else {
-            rawDatabase = JSON.parse(str);
-          }
-          break;
-        default:
-          break;
+          case 'schemarb':
+            rawDatabase = Parser.parseSchemaRbToJSON(str);
+            break;
+          case 'mssql':
+            rawDatabase = Parser.parseMSSQLToJSON(str);
+            break;
+          case 'json':
+            if (_typeof(str) === 'object') {
+              rawDatabase = str;
+            } else {
+              rawDatabase = JSON.parse(str);
+            }
+            break;
+          default:
+            break;
+        }
+        var schema = Parser.parseJSONToDatabase(rawDatabase);
+        return schema;
+      } catch (diags) {
+        throw _error.CompilerError.create(diags);
       }
-      var schema = Parser.parseJSONToDatabase(rawDatabase);
-      return schema;
     }
   }], [{
     key: "parseJSONToDatabase",

package/lib/parse/error.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CompilerError = void 0;
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var CompilerError = /*#__PURE__*/function () {
+  /**
+   * @param {import("../../types").CompilerDiagnostic[]} diags
+   */
+  function CompilerError(diags) {
+    _classCallCheck(this, CompilerError);
+    this.diags = diags;
+  }
+  _createClass(CompilerError, [{
+    key: "map",
+    value: function map(callback) {
+      return CompilerError.create(this.diags.map(callback));
+    }
+  }], [{
+    key: "create",
+    value: function create(nestedDiags) {
+      // eslint-disable-next-line no-use-before-define
+      return new CompilerError(flattenDiag(nestedDiags));
+    }
+  }]);
+  return CompilerError;
+}();
+exports.CompilerError = CompilerError;
+function flattenDiag(diag) {
+  if (Array.isArray(diag)) return diag.flatMap(flattenDiag);
+  if (diag instanceof CompilerError) return diag.diags;
+  return [diag];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbml/core",
-  "version": "3.3.0",
+  "version": "3.4.1-alpha.0",
   "description": "> TODO: description",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -32,7 +32,7 @@
     "prepublish": "npm run build"
   },
   "dependencies": {
-    "@dbml/parse": "^3.3.0",
+    "@dbml/parse": "^3.4.1-alpha.0",
     "antlr4": "^4.13.1",
     "lodash": "^4.17.15",
     "parsimmon": "^1.13.0",
@@ -59,5 +59,5 @@
       "\\.(?!json$)[^.]*$": "@glen/jest-raw-loader"
     }
   },
-  "gitHead": "4594bf6ee08c4bc73498f919673b12a4ecf06359"
+  "gitHead": "452294fcc48326294bf66a76daa418668d6ba8a9"
 }

package/types/export/ModelExporter.d.ts

@@ -1,5 +1,7 @@
 import Database, { NormalizedDatabase } from '../model_structure/database';
+
+export type ExportFormatOption = 'dbml' | 'mysql' | 'postgres' | 'json' | 'mssql' | 'oracle';
 declare class ModelExporter {
-    static export(model: Database | NormalizedDatabase, format: 'dbml' | 'mysql' | 'postgres' | 'json' | 'mssql', isNormalized?: boolean): string;
+    static export(model: Database | NormalizedDatabase, format: ExportFormatOption, isNormalized?: boolean): string;
 }
 export default ModelExporter;

package/types/export/index.d.ts

@@ -1,4 +1,6 @@
-declare function _export(str: string, format: 'dbml' | 'mysql' | 'postgres' | 'json' | 'mssql'): string;
+import { ExportFormatOption } from './ModelExporter';
+
+declare function _export(str: string, format: ExportFormatOption): string;
 declare const _default: {
     export: typeof _export;
 };

package/types/index.d.ts

@@ -3,3 +3,4 @@ import Parser from './parse/Parser';
 import importer from './import';
 import exporter from './export';
 export { importer, exporter, ModelExporter, Parser, };
+export { CompilerDiagnostic, CompilerError as CompilerDiagnostics, EditorPosition, ErrorCode, WarningLevel, } from './parse/error'

package/types/parse/error.d.ts

@@ -0,0 +1,28 @@
+export declare type WarningLevel =
+  | 'error'
+  | 'warning'
+  | 'info';
+
+export declare type ErrorCode = number;
+
+export declare interface EditorPosition {
+  line: number;
+  column: number;
+}
+
+export interface CompilerDiagnostic {
+  readonly message: Readonly<string>;
+  readonly filepath?: Readonly<string>;
+  readonly location: {
+      start: Readonly<EditorPosition>,
+      // in monaco, if an end position is not specified
+      // it consumes the word containing the start position
+      end?: Readonly<EditorPosition>,
+  };
+  readonly type?: Readonly<WarningLevel>;
+  readonly code?: Readonly<ErrorCode>; // the error code
+}
+
+export interface CompilerError {
+  readonly diags: CompilerDiagnostic[];
+}