@dbml/core 3.6.1 → 3.7.0

package/lib/model_structure/table.js

@@ -183,9 +183,9 @@ var Table = /*#__PURE__*/function (_Element) {
   }, {
     key: "normalize",
     value: function normalize(model) {
-      model.tables = _objectSpread(_objectSpread({}, model.tables), {}, _defineProperty({}, this.id, _objectSpread(_objectSpread(_objectSpread({
+      model.tables[this.id] = _objectSpread(_objectSpread(_objectSpread({
         id: this.id
-      }, this.shallowExport()), this.exportChildIds()), this.exportParentIds())));
+      }, this.shallowExport()), this.exportChildIds()), this.exportParentIds());
       this.fields.forEach(function (field) {
         return field.normalize(model);
       });

package/lib/model_structure/tableGroup.js

@@ -123,9 +123,9 @@ var TableGroup = /*#__PURE__*/function (_Element) {
   }, {
     key: "normalize",
     value: function normalize(model) {
-      model.tableGroups = _objectSpread(_objectSpread({}, model.tableGroups), {}, _defineProperty({}, this.id, _objectSpread(_objectSpread(_objectSpread({
+      model.tableGroups[this.id] = _objectSpread(_objectSpread(_objectSpread({
         id: this.id
-      }, this.shallowExport()), this.exportChildIds()), this.exportParentIds())));
+      }, this.shallowExport()), this.exportChildIds()), this.exportParentIds());
     }
   }]);
   return TableGroup;

package/lib/parse/ANTLR/ASTGeneration/AST.js

@@ -10,6 +10,7 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 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); }
+/* eslint-disable camelcase */
 /* eslint-disable max-classes-per-file */
 var Index = /*#__PURE__*/function () {
   /**

package/lib/parse/ANTLR/ASTGeneration/snowflake/SnowflakeASTGen.js

@@ -711,7 +711,7 @@ var SnowflakeASTGen = /*#__PURE__*/function (_SnowflakeParserVisit) {
     key: "visitLiteral",
     value: function visitLiteral(ctx) {
       if (ctx.STRING()) return {
-        value: (0, _helpers.getOriginalText)(ctx),
+        value: sanitizeComment(ctx),
         type: 'string'
       };
       if (ctx.DECIMAL() || ctx.REAL || ctx.FLOAT) return {

package/lib/parse/DatabaseGenerator.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateDatabase = void 0;
+var _database = _interopRequireDefault(require("../model_structure/database"));
+var _AST = require("./ANTLR/ASTGeneration/AST");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var parseJSONToDatabase = function parseJSONToDatabase(rawDatabase) {
+  return new _database["default"](rawDatabase);
+};
+var createRefs = function createRefs(rawRefs) {
+  return rawRefs.map(function (rawRef) {
+    var name = rawRef.name,
+      endpoints = rawRef.endpoints,
+      onDelete = rawRef.onDelete,
+      onUpdate = rawRef.onUpdate;
+    var eps = endpoints.map(function (ep) {
+      return new _AST.Endpoint(ep);
+    });
+    return new _AST.Ref({
+      name: name,
+      endpoints: eps,
+      onDelete: onDelete,
+      onUpdate: onUpdate
+    }).toJSON();
+  });
+};
+var createEnums = function createEnums(rawEnums) {
+  return rawEnums.map(function (rawEnum) {
+    var name = rawEnum.name,
+      schemaName = rawEnum.schemaName,
+      values = rawEnum.values;
+    return new _AST.Enum({
+      name: name,
+      schemaName: schemaName,
+      values: values
+    });
+  });
+};
+var createFields = function createFields(rawFields, fieldsConstraints) {
+  return rawFields.map(function (field) {
+    var constraints = fieldsConstraints[field.name] || {};
+    var f = new _AST.Field({
+      name: field.name,
+      type: field.type,
+      dbdefault: field.dbdefault,
+      not_null: field.not_null,
+      increment: field.increment,
+      pk: constraints.pk,
+      unique: constraints.unique,
+      note: field.note
+    });
+    return f;
+  });
+};
+var createIndexes = function createIndexes(rawIndexes) {
+  return rawIndexes.map(function (rawIndex) {
+    var name = rawIndex.name,
+      unique = rawIndex.unique,
+      primary = rawIndex.primary,
+      type = rawIndex.type,
+      columns = rawIndex.columns;
+    var index = new _AST.Index({
+      name: name,
+      unique: unique,
+      pk: primary,
+      type: type,
+      columns: columns
+    });
+    return index;
+  });
+};
+var createTables = function createTables(rawTables, rawFields, rawIndexes, tableConstraints) {
+  return rawTables.map(function (rawTable) {
+    var name = rawTable.name,
+      schemaName = rawTable.schemaName,
+      note = rawTable.note;
+    var key = schemaName ? "".concat(schemaName, ".").concat(name) : "".concat(name);
+    var constraints = tableConstraints[key] || {};
+    var fields = createFields(rawFields[key], constraints);
+    var indexes = createIndexes(rawIndexes[key] || []);
+    return new _AST.Table({
+      name: name,
+      schemaName: schemaName,
+      fields: fields,
+      indexes: indexes,
+      note: note
+    });
+  });
+};
+var generateDatabase = function generateDatabase(schemaJson) {
+  var rawTables = schemaJson.tables,
+    rawFields = schemaJson.fields,
+    rawIndexes = schemaJson.indexes,
+    rawRefs = schemaJson.refs,
+    rawEnums = schemaJson.enums,
+    tableConstraints = schemaJson.tableConstraints;
+  try {
+    var tables = createTables(rawTables, rawFields, rawIndexes, tableConstraints);
+    var enums = createEnums(rawEnums);
+    var refs = createRefs(rawRefs);
+    var rawDatabase = {
+      schemas: [],
+      tables: tables,
+      refs: refs,
+      enums: enums,
+      tableGroups: [],
+      aliases: [],
+      project: {}
+    };
+    return parseJSONToDatabase(rawDatabase);
+  } catch (err) {
+    throw new Error(err);
+  }
+};
+exports.generateDatabase = generateDatabase;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbml/core",
-  "version": "3.6.1",
+  "version": "3.7.0",
   "description": "> TODO: description",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -32,10 +32,14 @@
     "prepublish": "npm run build"
   },
   "dependencies": {
-    "@dbml/parse": "^3.6.1",
+    "@dbml/parse": "^3.7.0",
+    "@tediousjs/connection-string": "^0.5.0",
     "antlr4": "^4.13.1",
     "lodash": "^4.17.15",
+    "mssql": "^11.0.1",
+    "mysql2": "^3.11.0",
     "parsimmon": "^1.13.0",
+    "pg": "^8.12.0",
     "pluralize": "^8.0.0"
   },
   "devDependencies": {
@@ -59,5 +63,5 @@
       "\\.(?!json$)[^.]*$": "@glen/jest-raw-loader"
     }
   },
-  "gitHead": "2d7bc464a2e56cbe1555347c3292456cc2ddc4f7"
+  "gitHead": "3222baa4bf45b9ff74711a63d376505cf4bd9ac0"
 }

package/types/import/index.d.ts

@@ -1,5 +1,7 @@
 declare function _import(str: string, format: 'dbml' | 'mysql' | 'postgres' | 'json' | 'mssql' | 'postgresLegacy'): string;
+declare async function generateDbml(connection: any, format: 'mysql' | 'postgres' | 'mssql'): string;
 declare const _default: {
     import: typeof _import;
+    generateDbml: typeof generateDbml;
 };
 export default _default;