@dbml/core 2.4.1 → 2.4.3

package/lib/export/MysqlExporter.js

@@ -154,16 +154,45 @@ var MySQLExporter = /*#__PURE__*/function () {
       }).join(', ');
       return "(".concat(fieldNames, ")");
     }
+  }, {
+    key: "buildTableManyToMany",
+    value: function buildTableManyToMany(firstTableFieldsMap, secondTableFieldsMap, tableName, refEndpointSchema, model) {
+      var line = "CREATE TABLE ".concat((0, _utils.shouldPrintSchema)(refEndpointSchema, model) ? "`".concat(refEndpointSchema.name, "`.") : '', "`").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, ",\n");
+      });
+      secondTableFieldsMap.forEach(function (fieldType, fieldName) {
+        line += "  `".concat(fieldName, "` ").concat(fieldType, ",\n");
+      });
+      line += "  PRIMARY KEY (`".concat(key1s, "`, `").concat(key2s, "`)\n");
+      line += ');\n\n';
+      return line;
+    }
+  }, {
+    key: "buildForeignKeyManyToMany",
+    value: function buildForeignKeyManyToMany(fieldsMap, foreignEndpointFields, refEndpointTableName, foreignEndpointTableName, refEndpointSchema, foreignEndpointSchema, model) {
+      var refEndpointFields = _toConsumableArray(fieldsMap.keys()).join('`, `');
+
+      var line = "ALTER TABLE ".concat((0, _utils.shouldPrintSchema)(refEndpointSchema, model) ? "`".concat(refEndpointSchema.name, "`.") : '', "`").concat(refEndpointTableName, "` ADD FOREIGN KEY (`").concat(refEndpointFields, "`) REFERENCES ").concat((0, _utils.shouldPrintSchema)(foreignEndpointSchema, model) ? "`".concat(foreignEndpointSchema.name, "`.") : '', "`").concat(foreignEndpointTableName, "` ").concat(foreignEndpointFields, ";\n\n");
+      return line;
+    }
   }, {
     key: "exportRefs",
-    value: function exportRefs(refIds, model) {
+    value: function exportRefs(refIds, model, usedTableNames) {
       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 +209,33 @@ 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, refEndpointSchema, model);
+          line += _this.buildForeignKeyManyToMany(firstTableFieldsMap, refEndpointFieldName, newTableName, refEndpointTable.name, refEndpointSchema, refEndpointSchema, model);
+          line += _this.buildForeignKeyManyToMany(secondTableFieldsMap, foreignEndpointFieldName, newTableName, foreignEndpointTable.name, refEndpointSchema, foreignEndpointSchema, model);
+        } else {
+          line = "ALTER TABLE ".concat((0, _utils.shouldPrintSchema)(foreignEndpointSchema, model) ? "`".concat(foreignEndpointSchema.name, "`.") : '', "`").concat(foreignEndpointTable.name, "` ADD ");
 
-        if (ref.name) {
-          line += "CONSTRAINT `".concat(ref.name, "` ");
-        }
+          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);
+          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.onDelete) {
+            line += " ON DELETE ".concat(ref.onDelete.toUpperCase());
+          }
+
+          if (ref.onUpdate) {
+            line += " ON UPDATE ".concat(ref.onUpdate.toUpperCase());
+          }
 
-        if (ref.onUpdate) {
-          line += " ON UPDATE ".concat(ref.onUpdate.toUpperCase());
+          line += ';\n';
         }
 
-        line += ';\n';
         return line;
       });
       return strArr;
@@ -263,6 +302,9 @@ 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 statements = database.schemaIds.reduce(function (prevStatements, schemaId) {
         var schema = model.schemas[schemaId];
         var tableIds = schema.tableIds,
@@ -305,7 +347,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)));
         }
 
         return prevStatements;

package/lib/export/PostgresExporter.js

@@ -63,7 +63,8 @@ var PostgresExporter = /*#__PURE__*/function () {
         var line = '';
 
         if (field.increment) {
-          var typeSerial = field.type.type_name === 'bigint' ? 'BIGSERIAL' : 'SERIAL';
+          var typeSerial = 'SERIAL';
+          if (field.type.type_name.toLowerCase() === 'bigint') typeSerial = 'BIGSERIAL';else if (field.type.type_name.toLowerCase() === 'smallserial') typeSerial = 'SMALLSERIAL';
           line = "\"".concat(field.name, "\" ").concat(typeSerial);
         } else {
           var schemaName = '';
@@ -167,16 +168,45 @@ var PostgresExporter = /*#__PURE__*/function () {
       }).join(', ');
       return "(".concat(fieldNames, ")");
     }
+  }, {
+    key: "buildTableManyToMany",
+    value: function buildTableManyToMany(firstTableFieldsMap, secondTableFieldsMap, tableName, refEndpointSchema, model) {
+      var line = "CREATE TABLE ".concat((0, _utils.shouldPrintSchema)(refEndpointSchema, model) ? "\"".concat(refEndpointSchema.name, "\".") : '', "\"").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, ",\n");
+      });
+      secondTableFieldsMap.forEach(function (fieldType, fieldName) {
+        line += "  \"".concat(fieldName, "\" ").concat(fieldType, ",\n");
+      });
+      line += "  PRIMARY KEY (\"".concat(key1s, "\", \"").concat(key2s, "\")\n");
+      line += ');\n\n';
+      return line;
+    }
+  }, {
+    key: "buildForeignKeyManyToMany",
+    value: function buildForeignKeyManyToMany(fieldsMap, foreignEndpointFields, refEndpointTableName, foreignEndpointTableName, refEndpointSchema, foreignEndpointSchema, model) {
+      var refEndpointFields = _toConsumableArray(fieldsMap.keys()).join('", "');
+
+      var line = "ALTER TABLE ".concat((0, _utils.shouldPrintSchema)(refEndpointSchema, model) ? "\"".concat(refEndpointSchema.name, "\".") : '', "\"").concat(refEndpointTableName, "\" ADD FOREIGN KEY (\"").concat(refEndpointFields, "\") REFERENCES ").concat((0, _utils.shouldPrintSchema)(foreignEndpointSchema, model) ? "\"".concat(foreignEndpointSchema.name, "\".") : '', "\"").concat(foreignEndpointTableName, "\" ").concat(foreignEndpointFields, ";\n\n");
+      return line;
+    }
   }, {
     key: "exportRefs",
-    value: function exportRefs(refIds, model) {
+    value: function exportRefs(refIds, model, usedTableNames) {
       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 +223,34 @@ 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, refEndpointSchema, model);
+          line += _this.buildForeignKeyManyToMany(firstTableFieldsMap, refEndpointFieldName, newTableName, refEndpointTable.name, refEndpointSchema, refEndpointSchema, model);
+          line += _this.buildForeignKeyManyToMany(secondTableFieldsMap, foreignEndpointFieldName, newTableName, foreignEndpointTable.name, refEndpointSchema, foreignEndpointSchema, model);
+        } else {
+          line = "ALTER TABLE ".concat((0, _utils.shouldPrintSchema)(foreignEndpointSchema, model) ? "\"".concat(foreignEndpointSchema.name, "\".") : '', "\"").concat(foreignEndpointTable.name, "\" ADD ");
 
-        if (ref.name) {
-          line += "CONSTRAINT \"".concat(ref.name, "\" ");
-        }
+          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);
+          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.onDelete) {
+            line += " ON DELETE ".concat(ref.onDelete.toUpperCase());
+          }
+
+          if (ref.onUpdate) {
+            line += " ON UPDATE ".concat(ref.onUpdate.toUpperCase());
+          }
 
-        if (ref.onUpdate) {
-          line += " ON UPDATE ".concat(ref.onUpdate.toUpperCase());
+          line += ';\n';
         }
 
-        line += ';\n';
         return line;
       });
       return strArr;
@@ -297,6 +338,9 @@ 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 statements = database.schemaIds.reduce(function (prevStatements, schemaId) {
         var schema = model.schemas[schemaId];
         var tableIds = schema.tableIds,
@@ -357,7 +401,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)));
         }
 
         return prevStatements;

package/lib/export/SqlServerExporter.js

@@ -143,6 +143,33 @@ var SqlServerExporter = /*#__PURE__*/function () {
       });
       return tableStrs;
     }
+  }, {
+    key: "buildTableManyToMany",
+    value: function buildTableManyToMany(firstTableFieldsMap, secondTableFieldsMap, tableName, refEndpointSchema, model) {
+      var line = "CREATE TABLE ".concat((0, _utils.shouldPrintSchema)(refEndpointSchema, model) ? "[".concat(refEndpointSchema.name, "].") : '', "[").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, ",\n");
+      });
+      secondTableFieldsMap.forEach(function (fieldType, fieldName) {
+        line += "  [".concat(fieldName, "] ").concat(fieldType, ",\n");
+      });
+      line += "  PRIMARY KEY ([".concat(key1s, "], [").concat(key2s, "])\n");
+      line += ');\nGO\n\n';
+      return line;
+    }
+  }, {
+    key: "buildForeignKeyManyToMany",
+    value: function buildForeignKeyManyToMany(fieldsMap, foreignEndpointFields, refEndpointTableName, foreignEndpointTableName, refEndpointSchema, foreignEndpointSchema, model) {
+      var refEndpointFields = _toConsumableArray(fieldsMap.keys()).join('], [');
+
+      var line = "ALTER TABLE ".concat((0, _utils.shouldPrintSchema)(refEndpointSchema, model) ? "[".concat(refEndpointSchema.name, "].") : '', "[").concat(refEndpointTableName, "] ADD FOREIGN KEY ([").concat(refEndpointFields, "]) REFERENCES ").concat((0, _utils.shouldPrintSchema)(foreignEndpointSchema, model) ? "[".concat(foreignEndpointSchema.name, "].") : '', "[").concat(foreignEndpointTableName, "] ").concat(foreignEndpointFields, ";\nGO\n\n");
+      return line;
+    }
   }, {
     key: "buildFieldName",
     value: function buildFieldName(fieldIds, model) {
@@ -153,14 +180,16 @@ var SqlServerExporter = /*#__PURE__*/function () {
     }
   }, {
     key: "exportRefs",
-    value: function exportRefs(refIds, model) {
+    value: function exportRefs(refIds, model, usedTableNames) {
       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 +206,34 @@ 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, refEndpointSchema, model);
+          line += _this.buildForeignKeyManyToMany(firstTableFieldsMap, refEndpointFieldName, newTableName, refEndpointTable.name, refEndpointSchema, refEndpointSchema, model);
+          line += _this.buildForeignKeyManyToMany(secondTableFieldsMap, foreignEndpointFieldName, newTableName, foreignEndpointTable.name, refEndpointSchema, foreignEndpointSchema, model);
+        } else {
+          line = "ALTER TABLE ".concat((0, _utils.shouldPrintSchema)(foreignEndpointSchema, model) ? "[".concat(foreignEndpointSchema.name, "].") : '', "[").concat(foreignEndpointTable.name, "] ADD ");
 
-        if (ref.name) {
-          line += "CONSTRAINT [".concat(ref.name, "] ");
-        }
+          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);
+          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.onDelete) {
+            line += " ON DELETE ".concat(ref.onDelete.toUpperCase());
+          }
+
+          if (ref.onUpdate) {
+            line += " ON UPDATE ".concat(ref.onUpdate.toUpperCase());
+          }
 
-        if (ref.onUpdate) {
-          line += " ON UPDATE ".concat(ref.onUpdate.toUpperCase());
+          line += '\nGO\n';
         }
 
-        line += '\nGO\n';
         return line;
       });
       return strArr;
@@ -278,6 +318,9 @@ 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 statements = database.schemaIds.reduce(function (prevStatements, schemaId) {
         var schema = model.schemas[schemaId];
         var tableIds = schema.tableIds,
@@ -331,7 +374,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)));
         }
 
         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/model_structure/endpoint.js

@@ -15,6 +15,18 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "d
 
 function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _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" && 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; }
+
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
@@ -140,11 +152,35 @@ var Endpoint = /*#__PURE__*/function (_Element) {
     value: function setFields(fieldNames, table) {
       var _this2 = this;
 
-      fieldNames.forEach(function (fieldName) {
+      var newFieldNames = fieldNames && fieldNames.length ? _toConsumableArray(fieldNames) : [];
+
+      if (!newFieldNames.length) {
+        var fieldHasPK = table.fields.find(function (field) {
+          return field.pk;
+        });
+
+        if (fieldHasPK) {
+          newFieldNames.push(fieldHasPK.name);
+        } else {
+          var indexHasPK = table.indexes.find(function (index) {
+            return index.pk;
+          });
+
+          if (indexHasPK) {
+            newFieldNames = indexHasPK.columns.map(function (column) {
+              return column.value;
+            });
+          } else {
+            this.error("Can't find primary or composite key in table ".concat((0, _utils.shouldPrintSchema)(table.schema) ? "\"".concat(table.schema.name, "\".") : '', "\"").concat(table.name, "\""));
+          }
+        }
+      }
+
+      newFieldNames.forEach(function (fieldName) {
         var field = table.findField(fieldName);
 
         if (!field) {
-          _this2.error("Can't find field ".concat((0, _utils.shouldPrintSchema)(table.schema) ? "\"".concat(table.schema.name, "\".") : '', "\"").concat(fieldName, "\" in table \"").concat(_this2.tableName, "\""));
+          _this2.error("Can't find field ".concat((0, _utils.shouldPrintSchema)(table.schema) ? "\"".concat(table.schema.name, "\".") : '', "\"").concat(fieldName, "\" in table \"").concat(table.name, "\""));
         }
 
         _this2.fields.push(field);

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("") }