@dbml/core 2.4.1 → 2.4.2

package/lib/export/MysqlExporter.js

@@ -154,16 +154,64 @@ var MySQLExporter = /*#__PURE__*/function () {
       }).join(', ');
       return "(".concat(fieldNames, ")");
     }
+  }, {
+    key: "buildTableManyToMany",
+    value: function buildTableManyToMany(firstTableFieldsMap, secondTableFieldsMap, tableName) {
+      var line = "CREATE TABLE `".concat(tableName, "` (\n");
+
+      var key1s = _toConsumableArray(firstTableFieldsMap.keys()).join('`, `');
+
+      var key2s = _toConsumableArray(secondTableFieldsMap.keys()).join('`, `');
+
+      firstTableFieldsMap.forEach(function (fieldType, fieldName) {
+        line += "  `".concat(fieldName, "` ").concat(fieldType, " NOT NULL,\n");
+      });
+      secondTableFieldsMap.forEach(function (fieldType, fieldName) {
+        line += "  `".concat(fieldName, "` ").concat(fieldType, " NOT NULL,\n");
+      });
+      line += "  PRIMARY KEY (`".concat(key1s, "`, `").concat(key2s, "`)\n");
+      line += ');\n\n';
+      return line;
+    }
+  }, {
+    key: "buildForeignKeyManyToMany",
+    value: function buildForeignKeyManyToMany(fieldsMap, foreignEndpointFields, refEndpointTableName, foreignEndpointTableName, schema, model) {
+      var refEndpointFields = _toConsumableArray(fieldsMap.keys()).join('`, `');
+
+      var line = "ALTER TABLE `".concat(refEndpointTableName, "` ADD FOREIGN KEY (`").concat(refEndpointFields, "`) REFERENCES ").concat((0, _utils.shouldPrintSchema)(schema, model) ? "`".concat(schema.name, "`.") : '', "`").concat(foreignEndpointTableName, "` ").concat(foreignEndpointFields, ";\n\n");
+      return line;
+    }
+  }, {
+    key: "buildIndexManytoMany",
+    value: function buildIndexManytoMany(fieldsMap, newTableName, tableRefName, usedIndexNames) {
+      var newIndexName = "".concat(newTableName, "_").concat(tableRefName);
+      var count = 1;
+
+      while (usedIndexNames.has(newIndexName)) {
+        newIndexName = "".concat(newTableName, "_").concat(tableRefName, "(").concat(count, ")");
+        count += 1;
+      }
+
+      usedIndexNames.add(newIndexName);
+
+      var indexFields = _toConsumableArray(fieldsMap.keys()).join('`, `');
+
+      var line = "CREATE INDEX `idx_".concat(newIndexName, "` ON `").concat(newTableName, "` (");
+      line += "`".concat(indexFields, "`);\n\n");
+      return line;
+    }
   }, {
     key: "exportRefs",
-    value: function exportRefs(refIds, model) {
+    value: function exportRefs(refIds, model, usedTableNames, usedIndexNames) {
       var _this = this;
 
       var strArr = refIds.map(function (refId) {
+        var line = '';
         var ref = model.refs[refId];
-        var refEndpointIndex = ref.endpointIds.findIndex(function (endpointId) {
+        var refOneIndex = ref.endpointIds.findIndex(function (endpointId) {
           return model.endpoints[endpointId].relation === '1';
         });
+        var refEndpointIndex = refOneIndex === -1 ? 0 : refOneIndex;
         var foreignEndpointId = ref.endpointIds[1 - refEndpointIndex];
         var refEndpointId = ref.endpointIds[refEndpointIndex];
         var foreignEndpoint = model.endpoints[foreignEndpointId];
@@ -180,23 +228,42 @@ var MySQLExporter = /*#__PURE__*/function () {
 
         var foreignEndpointFieldName = _this.buildFieldName(foreignEndpoint.fieldIds, model, 'mysql');
 
-        var line = "ALTER TABLE ".concat((0, _utils.shouldPrintSchema)(foreignEndpointSchema, model) ? "`".concat(foreignEndpointSchema.name, "`.") : '', "`").concat(foreignEndpointTable.name, "` ADD ");
+        if (refOneIndex === -1) {
+          var firstTableFieldsMap = (0, _utils.buildJunctionFields1)(refEndpoint.fieldIds, model);
+          var secondTableFieldsMap = (0, _utils.buildJunctionFields2)(foreignEndpoint.fieldIds, model, firstTableFieldsMap);
+          var newTableName = (0, _utils.buildNewTableName)(refEndpointTable.name, foreignEndpointTable.name, usedTableNames);
+          line += _this.buildTableManyToMany(firstTableFieldsMap, secondTableFieldsMap, newTableName);
 
-        if (ref.name) {
-          line += "CONSTRAINT `".concat(ref.name, "` ");
-        }
+          if (firstTableFieldsMap.size > 1) {
+            line += _this.buildIndexManytoMany(firstTableFieldsMap, newTableName, refEndpointTable.name, usedIndexNames);
+          }
 
-        line += "FOREIGN KEY ".concat(foreignEndpointFieldName, " REFERENCES ").concat((0, _utils.shouldPrintSchema)(refEndpointSchema, model) ? "`".concat(refEndpointSchema.name, "`.") : '', "`").concat(refEndpointTable.name, "` ").concat(refEndpointFieldName);
+          if (secondTableFieldsMap.size > 1) {
+            line += _this.buildIndexManytoMany(secondTableFieldsMap, newTableName, foreignEndpointTable.name, usedIndexNames);
+          }
 
-        if (ref.onDelete) {
-          line += " ON DELETE ".concat(ref.onDelete.toUpperCase());
-        }
+          line += _this.buildForeignKeyManyToMany(firstTableFieldsMap, refEndpointFieldName, newTableName, refEndpointTable.name, refEndpointSchema, model);
+          line += _this.buildForeignKeyManyToMany(secondTableFieldsMap, foreignEndpointFieldName, newTableName, foreignEndpointTable.name, foreignEndpointSchema, model);
+        } else {
+          line = "ALTER TABLE ".concat((0, _utils.shouldPrintSchema)(foreignEndpointSchema, model) ? "`".concat(foreignEndpointSchema.name, "`.") : '', "`").concat(foreignEndpointTable.name, "` ADD ");
 
-        if (ref.onUpdate) {
-          line += " ON UPDATE ".concat(ref.onUpdate.toUpperCase());
+          if (ref.name) {
+            line += "CONSTRAINT `".concat(ref.name, "` ");
+          }
+
+          line += "FOREIGN KEY ".concat(foreignEndpointFieldName, " REFERENCES ").concat((0, _utils.shouldPrintSchema)(refEndpointSchema, model) ? "`".concat(refEndpointSchema.name, "`.") : '', "`").concat(refEndpointTable.name, "` ").concat(refEndpointFieldName);
+
+          if (ref.onDelete) {
+            line += " ON DELETE ".concat(ref.onDelete.toUpperCase());
+          }
+
+          if (ref.onUpdate) {
+            line += " ON UPDATE ".concat(ref.onUpdate.toUpperCase());
+          }
+
+          line += ';\n';
         }
 
-        line += ';\n';
         return line;
       });
       return strArr;
@@ -263,6 +330,12 @@ var MySQLExporter = /*#__PURE__*/function () {
     key: "export",
     value: function _export(model) {
       var database = model.database['1'];
+      var usedTableNames = new Set(Object.values(model.tables).map(function (table) {
+        return table.name;
+      }));
+      var usedIndexNames = new Set(Object.values(model.indexes).map(function (index) {
+        return index.name;
+      }));
       var statements = database.schemaIds.reduce(function (prevStatements, schemaId) {
         var schema = model.schemas[schemaId];
         var tableIds = schema.tableIds,
@@ -305,7 +378,7 @@ var MySQLExporter = /*#__PURE__*/function () {
         if (!_lodash["default"].isEmpty(refIds)) {
           var _prevStatements$refs;
 
-          (_prevStatements$refs = prevStatements.refs).push.apply(_prevStatements$refs, _toConsumableArray(MySQLExporter.exportRefs(refIds, model)));
+          (_prevStatements$refs = prevStatements.refs).push.apply(_prevStatements$refs, _toConsumableArray(MySQLExporter.exportRefs(refIds, model, usedTableNames, usedIndexNames)));
         }
 
         return prevStatements;

package/lib/export/PostgresExporter.js

@@ -167,16 +167,64 @@ var PostgresExporter = /*#__PURE__*/function () {
       }).join(', ');
       return "(".concat(fieldNames, ")");
     }
+  }, {
+    key: "buildTableManyToMany",
+    value: function buildTableManyToMany(firstTableFieldsMap, secondTableFieldsMap, tableName) {
+      var line = "CREATE TABLE \"".concat(tableName, "\" (\n");
+
+      var key1s = _toConsumableArray(firstTableFieldsMap.keys()).join('", "');
+
+      var key2s = _toConsumableArray(secondTableFieldsMap.keys()).join('", "');
+
+      firstTableFieldsMap.forEach(function (fieldType, fieldName) {
+        line += "  \"".concat(fieldName, "\" ").concat(fieldType, " NOT NULL,\n");
+      });
+      secondTableFieldsMap.forEach(function (fieldType, fieldName) {
+        line += "  \"".concat(fieldName, "\" ").concat(fieldType, " NOT NULL,\n");
+      });
+      line += "  PRIMARY KEY (\"".concat(key1s, "\", \"").concat(key2s, "\")\n");
+      line += ');\n\n';
+      return line;
+    }
+  }, {
+    key: "buildForeignKeyManyToMany",
+    value: function buildForeignKeyManyToMany(fieldsMap, foreignEndpointFields, refEndpointTableName, foreignEndpointTableName, schema, model) {
+      var refEndpointFields = _toConsumableArray(fieldsMap.keys()).join('", "');
+
+      var line = "ALTER TABLE \"".concat(refEndpointTableName, "\" ADD FOREIGN KEY (\"").concat(refEndpointFields, "\") REFERENCES ").concat((0, _utils.shouldPrintSchema)(schema, model) ? "\"".concat(schema.name, "\".") : '', "\"").concat(foreignEndpointTableName, "\" ").concat(foreignEndpointFields, ";\n\n");
+      return line;
+    }
+  }, {
+    key: "buildIndexManytoMany",
+    value: function buildIndexManytoMany(fieldsMap, newTableName, tableRefName, usedIndexNames) {
+      var newIndexName = "".concat(newTableName, "_").concat(tableRefName);
+      var count = 1;
+
+      while (usedIndexNames.has(newIndexName)) {
+        newIndexName = "".concat(newTableName, "_").concat(tableRefName, "(").concat(count, ")");
+        count += 1;
+      }
+
+      usedIndexNames.add(newIndexName);
+
+      var indexFields = _toConsumableArray(fieldsMap.keys()).join('", "');
+
+      var line = "CREATE INDEX \"idx_".concat(newIndexName, "\" ON \"").concat(newTableName, "\" (");
+      line += "\"".concat(indexFields, "\");\n\n");
+      return line;
+    }
   }, {
     key: "exportRefs",
-    value: function exportRefs(refIds, model) {
+    value: function exportRefs(refIds, model, usedTableNames, usedIndexNames) {
       var _this = this;
 
       var strArr = refIds.map(function (refId) {
+        var line = '';
         var ref = model.refs[refId];
-        var refEndpointIndex = ref.endpointIds.findIndex(function (endpointId) {
+        var refOneIndex = ref.endpointIds.findIndex(function (endpointId) {
           return model.endpoints[endpointId].relation === '1';
         });
+        var refEndpointIndex = refOneIndex === -1 ? 0 : refOneIndex;
         var foreignEndpointId = ref.endpointIds[1 - refEndpointIndex];
         var refEndpointId = ref.endpointIds[refEndpointIndex];
         var foreignEndpoint = model.endpoints[foreignEndpointId];
@@ -193,23 +241,43 @@ var PostgresExporter = /*#__PURE__*/function () {
 
         var foreignEndpointFieldName = _this.buildFieldName(foreignEndpoint.fieldIds, model, 'postgres');
 
-        var line = "ALTER TABLE ".concat((0, _utils.shouldPrintSchema)(foreignEndpointSchema, model) ? "\"".concat(foreignEndpointSchema.name, "\".") : '', "\"").concat(foreignEndpointTable.name, "\" ADD ");
+        if (refOneIndex === -1) {
+          // 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.buildNewTableName)(refEndpointTable.name, foreignEndpointTable.name, usedTableNames);
+          line += _this.buildTableManyToMany(firstTableFieldsMap, secondTableFieldsMap, newTableName);
 
-        if (ref.name) {
-          line += "CONSTRAINT \"".concat(ref.name, "\" ");
-        }
+          if (firstTableFieldsMap.size > 1) {
+            line += _this.buildIndexManytoMany(firstTableFieldsMap, newTableName, refEndpointTable.name, usedIndexNames);
+          }
 
-        line += "FOREIGN KEY ".concat(foreignEndpointFieldName, " REFERENCES ").concat((0, _utils.shouldPrintSchema)(refEndpointSchema, model) ? "\"".concat(refEndpointSchema.name, "\".") : '', "\"").concat(refEndpointTable.name, "\" ").concat(refEndpointFieldName);
+          if (secondTableFieldsMap.size > 1) {
+            line += _this.buildIndexManytoMany(secondTableFieldsMap, newTableName, foreignEndpointTable.name, usedIndexNames);
+          }
 
-        if (ref.onDelete) {
-          line += " ON DELETE ".concat(ref.onDelete.toUpperCase());
-        }
+          line += _this.buildForeignKeyManyToMany(firstTableFieldsMap, refEndpointFieldName, newTableName, refEndpointTable.name, refEndpointSchema, model);
+          line += _this.buildForeignKeyManyToMany(secondTableFieldsMap, foreignEndpointFieldName, newTableName, foreignEndpointTable.name, foreignEndpointSchema, model);
+        } else {
+          line = "ALTER TABLE ".concat((0, _utils.shouldPrintSchema)(foreignEndpointSchema, model) ? "\"".concat(foreignEndpointSchema.name, "\".") : '', "\"").concat(foreignEndpointTable.name, "\" ADD ");
 
-        if (ref.onUpdate) {
-          line += " ON UPDATE ".concat(ref.onUpdate.toUpperCase());
+          if (ref.name) {
+            line += "CONSTRAINT \"".concat(ref.name, "\" ");
+          }
+
+          line += "FOREIGN KEY ".concat(foreignEndpointFieldName, " REFERENCES ").concat((0, _utils.shouldPrintSchema)(refEndpointSchema, model) ? "\"".concat(refEndpointSchema.name, "\".") : '', "\"").concat(refEndpointTable.name, "\" ").concat(refEndpointFieldName);
+
+          if (ref.onDelete) {
+            line += " ON DELETE ".concat(ref.onDelete.toUpperCase());
+          }
+
+          if (ref.onUpdate) {
+            line += " ON UPDATE ".concat(ref.onUpdate.toUpperCase());
+          }
+
+          line += ';\n';
         }
 
-        line += ';\n';
         return line;
       });
       return strArr;
@@ -297,6 +365,12 @@ var PostgresExporter = /*#__PURE__*/function () {
     key: "export",
     value: function _export(model) {
       var database = model.database['1'];
+      var usedTableNames = new Set(Object.values(model.tables).map(function (table) {
+        return table.name;
+      }));
+      var usedIndexNames = new Set(Object.values(model.indexes).map(function (index) {
+        return index.name;
+      }));
       var statements = database.schemaIds.reduce(function (prevStatements, schemaId) {
         var schema = model.schemas[schemaId];
         var tableIds = schema.tableIds,
@@ -357,7 +431,7 @@ var PostgresExporter = /*#__PURE__*/function () {
         if (!_lodash["default"].isEmpty(refIds)) {
           var _prevStatements$refs;
 
-          (_prevStatements$refs = prevStatements.refs).push.apply(_prevStatements$refs, _toConsumableArray(PostgresExporter.exportRefs(refIds, model)));
+          (_prevStatements$refs = prevStatements.refs).push.apply(_prevStatements$refs, _toConsumableArray(PostgresExporter.exportRefs(refIds, model, usedTableNames, usedIndexNames)));
         }
 
         return prevStatements;

package/lib/export/SqlServerExporter.js

@@ -143,6 +143,52 @@ var SqlServerExporter = /*#__PURE__*/function () {
       });
       return tableStrs;
     }
+  }, {
+    key: "buildTableManyToMany",
+    value: function buildTableManyToMany(firstTableFieldsMap, secondTableFieldsMap, tableName) {
+      var line = "CREATE TABLE [".concat(tableName, "] (\n");
+
+      var key1s = _toConsumableArray(firstTableFieldsMap.keys()).join('], [');
+
+      var key2s = _toConsumableArray(secondTableFieldsMap.keys()).join('], [');
+
+      firstTableFieldsMap.forEach(function (fieldType, fieldName) {
+        line += "  [".concat(fieldName, "] ").concat(fieldType, " NOT NULL,\n");
+      });
+      secondTableFieldsMap.forEach(function (fieldType, fieldName) {
+        line += "  [".concat(fieldName, "] ").concat(fieldType, " NOT NULL,\n");
+      });
+      line += "  PRIMARY KEY ([".concat(key1s, "], [").concat(key2s, "])\n");
+      line += ');\nGO\n\n';
+      return line;
+    }
+  }, {
+    key: "buildForeignKeyManyToMany",
+    value: function buildForeignKeyManyToMany(fieldsMap, foreignEndpointFields, refEndpointTableName, foreignEndpointTableName, schema, model) {
+      var refEndpointFields = _toConsumableArray(fieldsMap.keys()).join('], [');
+
+      var line = "ALTER TABLE [".concat(refEndpointTableName, "] ADD FOREIGN KEY ([").concat(refEndpointFields, "]) REFERENCES ").concat((0, _utils.shouldPrintSchema)(schema, model) ? "[".concat(schema.name, "].") : '', "[").concat(foreignEndpointTableName, "] ").concat(foreignEndpointFields, ";\nGO\n\n");
+      return line;
+    }
+  }, {
+    key: "buildIndexManytoMany",
+    value: function buildIndexManytoMany(fieldsMap, newTableName, tableRefName, usedIndexNames) {
+      var newIndexName = "".concat(newTableName, "_").concat(tableRefName);
+      var count = 1;
+
+      while (usedIndexNames.has(newIndexName)) {
+        newIndexName = "".concat(newTableName, "_").concat(tableRefName, "(").concat(count, ")");
+        count += 1;
+      }
+
+      usedIndexNames.add(newIndexName);
+
+      var indexFields = _toConsumableArray(fieldsMap.keys()).join('", "');
+
+      var line = "CREATE INDEX [idx_".concat(newIndexName, "] ON [").concat(newTableName, "] (");
+      line += "\"".concat(indexFields, "\");\nGO\n\n");
+      return line;
+    }
   }, {
     key: "buildFieldName",
     value: function buildFieldName(fieldIds, model) {
@@ -153,14 +199,16 @@ var SqlServerExporter = /*#__PURE__*/function () {
     }
   }, {
     key: "exportRefs",
-    value: function exportRefs(refIds, model) {
+    value: function exportRefs(refIds, model, usedTableNames, usedIndexNames) {
       var _this = this;
 
       var strArr = refIds.map(function (refId) {
+        var line = '';
         var ref = model.refs[refId];
-        var refEndpointIndex = ref.endpointIds.findIndex(function (endpointId) {
+        var refOneIndex = ref.endpointIds.findIndex(function (endpointId) {
           return model.endpoints[endpointId].relation === '1';
         });
+        var refEndpointIndex = refOneIndex === -1 ? 0 : refOneIndex;
         var foreignEndpointId = ref.endpointIds[1 - refEndpointIndex];
         var refEndpointId = ref.endpointIds[refEndpointIndex];
         var foreignEndpoint = model.endpoints[foreignEndpointId];
@@ -177,23 +225,43 @@ var SqlServerExporter = /*#__PURE__*/function () {
 
         var foreignEndpointFieldName = _this.buildFieldName(foreignEndpoint.fieldIds, model, 'mssql');
 
-        var line = "ALTER TABLE ".concat((0, _utils.shouldPrintSchema)(foreignEndpointSchema, model) ? "[".concat(foreignEndpointSchema.name, "].") : '', "[").concat(foreignEndpointTable.name, "] ADD ");
+        if (refOneIndex === -1) {
+          // 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.buildNewTableName)(refEndpointTable.name, foreignEndpointTable.name, usedTableNames);
+          line += _this.buildTableManyToMany(firstTableFieldsMap, secondTableFieldsMap, newTableName);
 
-        if (ref.name) {
-          line += "CONSTRAINT [".concat(ref.name, "] ");
-        }
+          if (firstTableFieldsMap.size > 1) {
+            line += _this.buildIndexManytoMany(firstTableFieldsMap, newTableName, refEndpointTable.name, usedIndexNames);
+          }
 
-        line += "FOREIGN KEY ".concat(foreignEndpointFieldName, " REFERENCES ").concat((0, _utils.shouldPrintSchema)(refEndpointSchema, model) ? "[".concat(refEndpointSchema.name, "].") : '', "[").concat(refEndpointTable.name, "] ").concat(refEndpointFieldName);
+          if (secondTableFieldsMap.size > 1) {
+            line += _this.buildIndexManytoMany(secondTableFieldsMap, newTableName, foreignEndpointTable.name, usedIndexNames);
+          }
 
-        if (ref.onDelete) {
-          line += " ON DELETE ".concat(ref.onDelete.toUpperCase());
-        }
+          line += _this.buildForeignKeyManyToMany(firstTableFieldsMap, refEndpointFieldName, newTableName, refEndpointTable.name, refEndpointSchema, model);
+          line += _this.buildForeignKeyManyToMany(secondTableFieldsMap, foreignEndpointFieldName, newTableName, foreignEndpointTable.name, foreignEndpointSchema, model);
+        } else {
+          line = "ALTER TABLE ".concat((0, _utils.shouldPrintSchema)(foreignEndpointSchema, model) ? "[".concat(foreignEndpointSchema.name, "].") : '', "[").concat(foreignEndpointTable.name, "] ADD ");
 
-        if (ref.onUpdate) {
-          line += " ON UPDATE ".concat(ref.onUpdate.toUpperCase());
+          if (ref.name) {
+            line += "CONSTRAINT [".concat(ref.name, "] ");
+          }
+
+          line += "FOREIGN KEY ".concat(foreignEndpointFieldName, " REFERENCES ").concat((0, _utils.shouldPrintSchema)(refEndpointSchema, model) ? "[".concat(refEndpointSchema.name, "].") : '', "[").concat(refEndpointTable.name, "] ").concat(refEndpointFieldName);
+
+          if (ref.onDelete) {
+            line += " ON DELETE ".concat(ref.onDelete.toUpperCase());
+          }
+
+          if (ref.onUpdate) {
+            line += " ON UPDATE ".concat(ref.onUpdate.toUpperCase());
+          }
+
+          line += '\nGO\n';
         }
 
-        line += '\nGO\n';
         return line;
       });
       return strArr;
@@ -278,6 +346,12 @@ var SqlServerExporter = /*#__PURE__*/function () {
     key: "export",
     value: function _export(model) {
       var database = model.database['1'];
+      var usedTableNames = new Set(Object.values(model.tables).map(function (table) {
+        return table.name;
+      }));
+      var usedIndexNames = new Set(Object.values(model.indexes).map(function (index) {
+        return index.name;
+      }));
       var statements = database.schemaIds.reduce(function (prevStatements, schemaId) {
         var schema = model.schemas[schemaId];
         var tableIds = schema.tableIds,
@@ -331,7 +405,7 @@ var SqlServerExporter = /*#__PURE__*/function () {
         if (!_lodash["default"].isEmpty(refIds)) {
           var _prevStatements$refs;
 
-          (_prevStatements$refs = prevStatements.refs).push.apply(_prevStatements$refs, _toConsumableArray(SqlServerExporter.exportRefs(refIds, model)));
+          (_prevStatements$refs = prevStatements.refs).push.apply(_prevStatements$refs, _toConsumableArray(SqlServerExporter.exportRefs(refIds, model, usedTableNames, usedIndexNames)));
         }
 
         return prevStatements;

package/lib/export/utils.js

@@ -5,6 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.hasWhiteSpace = hasWhiteSpace;
 exports.shouldPrintSchema = shouldPrintSchema;
+exports.buildJunctionFields1 = buildJunctionFields1;
+exports.buildJunctionFields2 = buildJunctionFields2;
+exports.buildNewTableName = buildNewTableName;
 
 var _config = require("../model_structure/config");
 
@@ -14,4 +17,41 @@ function hasWhiteSpace(s) {
 
 function shouldPrintSchema(schema, model) {
   return schema.name !== _config.DEFAULT_SCHEMA_NAME || schema.name === _config.DEFAULT_SCHEMA_NAME && model.database['1'].hasDefaultSchema;
+}
+
+function buildJunctionFields1(fieldIds, model) {
+  var fieldsMap = new Map();
+  fieldIds.map(function (fieldId) {
+    return fieldsMap.set("".concat(model.tables[model.fields[fieldId].tableId].name, "_").concat(model.fields[fieldId].name), model.fields[fieldId].type.type_name);
+  });
+  return fieldsMap;
+}
+
+function buildJunctionFields2(fieldIds, model, firstTableFieldsMap) {
+  var fieldsMap = new Map();
+  fieldIds.map(function (fieldId) {
+    var fieldName = "".concat(model.tables[model.fields[fieldId].tableId].name, "_").concat(model.fields[fieldId].name);
+    var count = 1;
+
+    while (firstTableFieldsMap.has(fieldName)) {
+      fieldName = "".concat(model.tables[model.fields[fieldId].tableId].name, "_").concat(model.fields[fieldId].name, "(").concat(count, ")");
+      count += 1;
+    }
+
+    fieldsMap.set(fieldName, model.fields[fieldId].type.type_name);
+  });
+  return fieldsMap;
+}
+
+function buildNewTableName(firstTable, secondTable, usedTableNames) {
+  var newTableName = "".concat(firstTable, "_").concat(secondTable);
+  var count = 1;
+
+  while (usedTableNames.has(newTableName)) {
+    newTableName = "".concat(firstTable, "_").concat(secondTable, "(").concat(count, ")");
+    count += 1;
+  }
+
+  usedTableNames.add(newTableName);
+  return newTableName;
 }

package/lib/parse/dbml/parser.pegjs

@@ -9,6 +9,12 @@
     project: {},
   };
   let projectCnt = 0;
+  function getRelations(operator) {
+    if(operator === '<>') return ['*','*'];
+    if(operator === '>') return ['*','1'];
+    if(operator === '<') return ['1','*'];
+    if(operator === '-') return ['1','1'];
+  }
 }
 
 rules
@@ -173,19 +179,20 @@ ref_short
 
 ref_body
   = field1:field_identifier sp+ relation:relation sp+ field2:field_identifier sp* ref_settings:RefSettings? {
+    const rel = getRelations(relation);
     const endpoints = [
       {
         schemaName: field1.schemaName,
         tableName: field1.tableName,
         fieldNames: field1.fieldNames,
-        relation: relation === ">" ? "*" : "1",
+        relation: rel[0],
         token: location()
       },
       {
         schemaName: field2.schemaName,
         tableName: field2.tableName,
         fieldNames: field2.fieldNames,
-        relation: relation === "<" ? "*" : "1",
+        relation: rel[1],
         token: location()
       }
     ];
@@ -243,19 +250,20 @@ TableSyntax
 
       fields.forEach((field) => {
         (field.inline_refs || []).forEach((iref) => {
+          const rel = getRelations(iref.relation);
           const endpoints = [
           {
             schemaName: iref.schemaName,
             tableName: iref.tableName,
             fieldNames: iref.fieldNames,
-            relation: iref.relation === "<" ? "*" : "1",
+            relation: rel[1],
             token: iref.token
           },
           {
             schemaName: schemaName,
             tableName: name,
             fieldNames: [field.name],
-            relation: iref.relation === ">" ? "*" : "1",
+            relation: rel[0],
             token: iref.token
           }];
 
@@ -611,7 +619,7 @@ set_null "set null" = "set null"i
 set_default "set default" = "set default"i
 
 // Commonly used tokens
-relation ">, - or <" = [>\-<]
+relation "<>, >, - or <" = '<>' / '>' / '<' / '-'
 name "valid name"
   = c:(character+) { return c.join("") }
   / quote c:[^\"\n]+ quote { return c.join("") }