@dbml/core 2.3.1 → 2.4.2

package/lib/export/SqlServerExporter.js

@@ -141,7 +141,53 @@ var SqlServerExporter = /*#__PURE__*/function () {
         }).join(',\n'), "\n)\nGO\n");
         return tableStr;
       });
-      return tableStrs.length ? tableStrs.join('\n') : '';
+      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",
@@ -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,26 +225,46 @@ 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.name) {
+            line += "CONSTRAINT [".concat(ref.name, "] ");
+          }
 
-        if (ref.onUpdate) {
-          line += " ON UPDATE ".concat(ref.onUpdate.toUpperCase());
+          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.length ? strArr.join('\n') : '';
+      return strArr;
     }
   }, {
     key: "exportIndexes",
@@ -233,7 +301,7 @@ var SqlServerExporter = /*#__PURE__*/function () {
         line += '\nGO\n';
         return line;
       });
-      return indexArr.length ? indexArr.join('\n') : '';
+      return indexArr;
     }
   }, {
     key: "exportComments",
@@ -272,49 +340,48 @@ var SqlServerExporter = /*#__PURE__*/function () {
         line += 'GO\n';
         return line;
       });
-      return commentArr.length ? commentArr.join('\n') : '';
+      return commentArr;
     }
   }, {
     key: "export",
     value: function _export(model) {
-      var res = '';
-      var hasBlockAbove = false;
       var database = model.database['1'];
-      var indexIds = [];
-      var comments = [];
-      database.schemaIds.forEach(function (schemaId) {
+      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,
             refIds = schema.refIds;
 
         if ((0, _utils.shouldPrintSchema)(schema, model)) {
-          if (hasBlockAbove) res += '\n';
-          res += "CREATE SCHEMA [".concat(schema.name, "];\nGO\n");
-          hasBlockAbove = true;
+          prevStatements.schemas.push("CREATE SCHEMA [".concat(schema.name, "]\nGO\n"));
         }
 
         if (!_lodash["default"].isEmpty(tableIds)) {
-          if (hasBlockAbove) res += '\n';
-          res += SqlServerExporter.exportTables(tableIds, model);
-          hasBlockAbove = true;
+          var _prevStatements$table;
+
+          (_prevStatements$table = prevStatements.tables).push.apply(_prevStatements$table, _toConsumableArray(SqlServerExporter.exportTables(tableIds, model)));
         }
 
-        if (!_lodash["default"].isEmpty(refIds)) {
-          if (hasBlockAbove) res += '\n';
-          res += SqlServerExporter.exportRefs(refIds, model);
-          hasBlockAbove = true;
-        } /////////PUSH COMMENTS OF TABLE & COLUMN/////////
-        // console.log(JSON.stringify(tableIds, null, 2));
+        var indexIds = _lodash["default"].flatten(tableIds.map(function (tableId) {
+          return model.tables[tableId].indexIds;
+        }));
 
+        if (!_lodash["default"].isEmpty(indexIds)) {
+          var _prevStatements$index;
 
-        indexIds.push.apply(indexIds, _toConsumableArray(_lodash["default"].flatten(tableIds.map(function (tableId) {
-          return model.tables[tableId].indexIds;
-        }))));
-        comments.push.apply(comments, _toConsumableArray(_lodash["default"].flatten(tableIds.map(function (tableId) {
+          (_prevStatements$index = prevStatements.indexes).push.apply(_prevStatements$index, _toConsumableArray(SqlServerExporter.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 fieldObject = fieldIds.filter(function (fieldId) {
+          var fieldObjects = fieldIds.filter(function (fieldId) {
             return model.fields[fieldId].note;
           }).map(function (fieldId) {
             return {
@@ -326,21 +393,32 @@ var SqlServerExporter = /*#__PURE__*/function () {
           return note ? [{
             type: 'table',
             tableId: tableId
-          }].concat(fieldObject) : fieldObject;
-        }))));
-      });
+          }].concat(fieldObjects) : fieldObjects;
+        }));
 
-      if (!_lodash["default"].isEmpty(indexIds)) {
-        if (hasBlockAbove) res += '\n';
-        res += SqlServerExporter.exportIndexes(indexIds, model);
-        hasBlockAbove = true;
-      }
+        if (!_lodash["default"].isEmpty(commentNodes)) {
+          var _prevStatements$comme;
 
-      if (!_lodash["default"].isEmpty(comments)) {
-        if (hasBlockAbove) res += '\n';
-        res += SqlServerExporter.exportComments(comments, model);
-        hasBlockAbove = true;
-      }
+          (_prevStatements$comme = prevStatements.comments).push.apply(_prevStatements$comme, _toConsumableArray(SqlServerExporter.exportComments(commentNodes, model)));
+        }
+
+        if (!_lodash["default"].isEmpty(refIds)) {
+          var _prevStatements$refs;
+
+          (_prevStatements$refs = prevStatements.refs).push.apply(_prevStatements$refs, _toConsumableArray(SqlServerExporter.exportRefs(refIds, model, usedTableNames, usedIndexNames)));
+        }
+
+        return prevStatements;
+      }, {
+        schemas: [],
+        enums: [],
+        tables: [],
+        indexes: [],
+        comments: [],
+        refs: []
+      });
+
+      var res = _lodash["default"].concat(statements.schemas, statements.enums, statements.tables, statements.indexes, statements.comments, statements.refs).join('\n');
 
       return res;
     }

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/database.js

@@ -11,7 +11,7 @@ var _schema = _interopRequireDefault(require("./schema"));
 
 var _ref2 = _interopRequireDefault(require("./ref"));
 
-var _enum = _interopRequireDefault(require("./enum"));
+var _enum2 = _interopRequireDefault(require("./enum"));
 
 var _tableGroup = _interopRequireDefault(require("./tableGroup"));
 
@@ -72,7 +72,9 @@ var Database = /*#__PURE__*/function (_Element) {
         _ref$tableGroups = _ref.tableGroups,
         tableGroups = _ref$tableGroups === void 0 ? [] : _ref$tableGroups,
         _ref$project = _ref.project,
-        project = _ref$project === void 0 ? {} : _ref$project;
+        project = _ref$project === void 0 ? {} : _ref$project,
+        _ref$aliases = _ref.aliases,
+        aliases = _ref$aliases === void 0 ? [] : _ref$aliases;
 
     _classCallCheck(this, Database);
 
@@ -85,16 +87,17 @@ var Database = /*#__PURE__*/function (_Element) {
     _this.schemas = [];
     _this.note = project.note;
     _this.databaseType = project.database_type;
-    _this.name = project.name; // The process order is important. Do not change !
+    _this.name = project.name;
+    _this.aliases = aliases; // The process order is important. Do not change !
 
     _this.processSchemas(schemas);
 
+    _this.processSchemaElements(enums, _config.ENUM);
+
     _this.processSchemaElements(tables, _config.TABLE);
 
     _this.processSchemaElements(refs, _config.REF);
 
-    _this.processSchemaElements(enums, _config.ENUM);
-
     _this.processSchemaElements(tableGroups, _config.TABLE_GROUP);
 
     return _this;
@@ -141,8 +144,7 @@ var Database = /*#__PURE__*/function (_Element) {
         if (element.schemaName) {
           schema = _this3.findOrCreateSchema(element.schemaName);
 
-          if (element.schemaName === _config.DEFAULT_SCHEMA_NAME) {
-            _this3.hasDefaultSchema = true;
+          if (element.schemaName === _config.DEFAULT_SCHEMA_NAME) {// this.hasDefaultSchema = true;
           }
         } else {
           schema = _this3.findOrCreateSchema(_config.DEFAULT_SCHEMA_NAME);
@@ -156,7 +158,7 @@ var Database = /*#__PURE__*/function (_Element) {
             break;
 
           case _config.ENUM:
-            schema.pushEnum(new _enum["default"](_objectSpread(_objectSpread({}, element), {}, {
+            schema.pushEnum(new _enum2["default"](_objectSpread(_objectSpread({}, element), {}, {
               schema: schema
             })));
             break;
@@ -196,16 +198,55 @@ var Database = /*#__PURE__*/function (_Element) {
 
       return schema;
     }
+  }, {
+    key: "findTableAlias",
+    value: function findTableAlias(alias) {
+      var sym = this.aliases.find(function (a) {
+        return a.name === alias;
+      });
+      if (!sym || sym.kind !== 'table') return null;
+      var schemaName = sym.value.schemaName || _config.DEFAULT_SCHEMA_NAME;
+      var schema = this.schemas.find(function (s) {
+        return s.name === schemaName;
+      });
+      if (!schema) return null;
+      var tableName = sym.value.tableName;
+      var table = schema.tables.find(function (t) {
+        return t.name === tableName;
+      });
+      return table;
+    }
   }, {
     key: "findTable",
-    value: function findTable(rawTable) {
-      var schema = this.findOrCreateSchema(rawTable.schemaName || _config.DEFAULT_SCHEMA_NAME);
+    value: function findTable(schemaName, tableName) {
+      var table = null;
+
+      if (!schemaName) {
+        table = this.findTableAlias(tableName);
+        if (table) return table;
+      }
+
+      var schema = this.findOrCreateSchema(schemaName || _config.DEFAULT_SCHEMA_NAME);
 
       if (!schema) {
-        this.error("Schema ".concat(rawTable.schemaName || _config.DEFAULT_SCHEMA_NAME, " don't exist"));
+        this.error("Schema ".concat(schemaName || _config.DEFAULT_SCHEMA_NAME, " don't exist"));
       }
 
-      return schema.findTable(rawTable.name);
+      return schema.findTable(tableName);
+    }
+  }, {
+    key: "findEnum",
+    value: function findEnum(schemaName, name) {
+      var schema = this.schemas.find(function (s) {
+        return s.name === schemaName || s.alias === schemaName;
+      });
+      if (!schema) return null;
+
+      var _enum = schema.enums.find(function (e) {
+        return e.name === name;
+      });
+
+      return _enum;
     }
   }, {
     key: "export",

package/lib/model_structure/endpoint.js

@@ -72,10 +72,10 @@ var Endpoint = /*#__PURE__*/function (_Element) {
 
 
     var schema = ref.schema.database.findOrCreateSchema(schemaName || _config.DEFAULT_SCHEMA_NAME);
-    var table = schema.findTable(tableName);
+    var table = schema.database.findTable(schemaName, tableName);
 
     if (!table) {
-      _this.error("Can't find table ".concat((0, _utils.shouldPrintSchema)(schema) ? "\"".concat(schema.name, "\".") : '', "\"").concat(tableName, "\""));
+      _this.error("Can't find table ".concat((0, _utils.shouldPrintSchemaName)(schemaName) ? "\"".concat(schemaName, "\".") : '', "\"").concat(tableName, "\""));
     }
 
     _this.setFields(fieldNames, table);

package/lib/model_structure/field.js

@@ -7,6 +7,8 @@ exports["default"] = void 0;
 
 var _element = _interopRequireDefault(require("./element"));
 
+var _config = require("./config");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
 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); }
@@ -70,7 +72,7 @@ var Field = /*#__PURE__*/function (_Element) {
       _this.error('Field must have a type');
     }
 
-    _this.name = name; // type : { type_name, value }
+    _this.name = name; // type : { type_name, value, schemaName }
 
     _this.type = type;
     _this.unique = unique;
@@ -85,6 +87,8 @@ var Field = /*#__PURE__*/function (_Element) {
 
     _this.generateId();
 
+    _this.bindType();
+
     return _this;
   }
 
@@ -93,6 +97,32 @@ var Field = /*#__PURE__*/function (_Element) {
     value: function generateId() {
       this.id = this.dbState.generateId('fieldId');
     }
+  }, {
+    key: "bindType",
+    value: function bindType() {
+      var typeName = this.type.type_name;
+      var typeSchemaName = this.type.schemaName || _config.DEFAULT_SCHEMA_NAME;
+
+      if (this.type.schemaName) {
+        var _enum = this.table.schema.database.findEnum(typeSchemaName, typeName);
+
+        if (!_enum) {
+          this.error("Cannot find type ".concat(typeSchemaName, " in schema ").concat(typeSchemaName));
+          return;
+        }
+
+        this._enum = _enum;
+
+        _enum.pushField(this);
+      } else {
+        var _enum2 = this.table.schema.database.findEnum(typeSchemaName, typeName);
+
+        if (!_enum2) return;
+        this._enum = _enum2;
+
+        _enum2.pushField(this);
+      }
+    }
   }, {
     key: "pushEndpoint",
     value: function pushEndpoint(endpoint) {

package/lib/model_structure/ref.js

@@ -100,8 +100,7 @@ var Ref = /*#__PURE__*/function (_Element) {
           ref: _this2
         })));
 
-        if (endpoint.schemaName === _config.DEFAULT_SCHEMA_NAME) {
-          _this2.database.hasDefaultSchema = true;
+        if (endpoint.schemaName === _config.DEFAULT_SCHEMA_NAME) {// this.schema.database.hasDefaultSchema = true;
         }
       });
 

package/lib/model_structure/schema.js

@@ -88,10 +88,10 @@ var Schema = /*#__PURE__*/function (_Element) {
 
     _this.generateId();
 
-    _this.processTables(tables);
-
     _this.processEnums(enums);
 
+    _this.processTables(tables);
+
     _this.processRefs(refs);
 
     _this.processTableGroups(tableGroups);
@@ -134,7 +134,7 @@ var Schema = /*#__PURE__*/function (_Element) {
     key: "findTable",
     value: function findTable(tableName) {
       return this.tables.find(function (t) {
-        return t.name === tableName || t.alias === tableName;
+        return t.name === tableName;
       });
     }
   }, {
@@ -153,7 +153,6 @@ var Schema = /*#__PURE__*/function (_Element) {
     value: function pushEnum(_enum) {
       this.checkEnum(_enum);
       this.enums.push(_enum);
-      this.bindEnumToField(_enum);
     }
   }, {
     key: "checkEnum",
@@ -164,21 +163,6 @@ var Schema = /*#__PURE__*/function (_Element) {
         _enum.error("Enum ".concat((0, _utils.shouldPrintSchema)(this) ? "\"".concat(this.name, "\".") : '', "\"").concat(_enum.name, "\" existed"));
       }
     }
-  }, {
-    key: "bindEnumToField",
-    value: function bindEnumToField(_enum) {
-      this.database.schemas.forEach(function (schema) {
-        schema.tables.forEach(function (table) {
-          table.fields.forEach(function (field) {
-            if (_enum.name === field.type.type_name && (field.type.schemaName || _config.DEFAULT_SCHEMA_NAME) === schema.name) {
-              field._enum = _enum;
-
-              _enum.pushField(field);
-            }
-          });
-        });
-      });
-    }
   }, {
     key: "processRefs",
     value: function processRefs(rawRefs) {

package/lib/model_structure/tableGroup.js

@@ -80,7 +80,7 @@ var TableGroup = /*#__PURE__*/function (_Element) {
       var _this2 = this;
 
       rawTables.forEach(function (rawTable) {
-        var table = _this2.schema.database.findTable(rawTable);
+        var table = _this2.schema.database.findTable(rawTable.schemaName, rawTable.name);
 
         if (!table) {
           _this2.error("Table ".concat(rawTable.schemaName ? "\"".concat(rawTable.schemaName, "\".") : '').concat(rawTable.name, " don't exist"));

package/lib/model_structure/utils.js

@@ -4,9 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.shouldPrintSchema = shouldPrintSchema;
+exports.shouldPrintSchemaName = shouldPrintSchemaName;
 
 var _config = require("./config");
 
 function shouldPrintSchema(schema) {
   return schema.name !== _config.DEFAULT_SCHEMA_NAME || schema.name === _config.DEFAULT_SCHEMA_NAME && schema.database.hasDefaultSchema;
+}
+
+function shouldPrintSchemaName(schemaName) {
+  return schemaName !== _config.DEFAULT_SCHEMA_NAME;
 }