@dbml/core 3.1.8-alpha.0 → 3.1.8

package/lib/model_structure/config.js

@@ -3,13 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.TABLE_GROUP = exports.TABLE = exports.REF = exports.NOTE = exports.ENUM = exports.DEFAULT_SCHEMA_NAME = void 0;
+exports.TABLE_GROUP = exports.TABLE = exports.REF = exports.ENUM = exports.DEFAULT_SCHEMA_NAME = void 0;
 var DEFAULT_SCHEMA_NAME = 'public';
 exports.DEFAULT_SCHEMA_NAME = DEFAULT_SCHEMA_NAME;
 var TABLE = 'table';
 exports.TABLE = TABLE;
-var NOTE = 'note';
-exports.NOTE = NOTE;
 var ENUM = 'enum';
 exports.ENUM = ENUM;
 var REF = 'ref';

package/lib/model_structure/database.js

@@ -11,7 +11,6 @@ var _ref2 = _interopRequireDefault(require("./ref"));
 var _enum2 = _interopRequireDefault(require("./enum"));
 var _tableGroup = _interopRequireDefault(require("./tableGroup"));
 var _table = _interopRequireDefault(require("./table"));
-var _stickyNote = _interopRequireDefault(require("./stickyNote"));
 var _element = _interopRequireDefault(require("./element"));
 var _config = require("./config");
 var _dbState = _interopRequireDefault(require("./dbState"));
@@ -42,8 +41,6 @@ var Database = /*#__PURE__*/function (_Element) {
       schemas = _ref$schemas === void 0 ? [] : _ref$schemas,
       _ref$tables = _ref.tables,
       tables = _ref$tables === void 0 ? [] : _ref$tables,
-      _ref$notes = _ref.notes,
-      notes = _ref$notes === void 0 ? [] : _ref$notes,
       _ref$enums = _ref.enums,
       enums = _ref$enums === void 0 ? [] : _ref$enums,
       _ref$refs = _ref.refs,
@@ -60,18 +57,16 @@ var Database = /*#__PURE__*/function (_Element) {
     _this.generateId();
     _this.hasDefaultSchema = false;
     _this.schemas = [];
-    _this.notes = [];
     _this.note = project.note ? (0, _lodash.get)(project, 'note.value', project.note) : null;
     _this.noteToken = project.note ? (0, _lodash.get)(project, 'note.token', project.noteToken) : null;
     _this.databaseType = project.database_type;
     _this.name = project.name;
     _this.aliases = aliases;
-    _this.processNotes(notes);
+
     // The process order is important. Do not change !
     _this.processSchemas(schemas);
     _this.processSchemaElements(enums, _config.ENUM);
     _this.processSchemaElements(tables, _config.TABLE);
-    _this.processSchemaElements(notes, _config.NOTE);
     _this.processSchemaElements(refs, _config.REF);
     _this.processSchemaElements(tableGroups, _config.TABLE_GROUP);
     return _this;
@@ -81,38 +76,13 @@ var Database = /*#__PURE__*/function (_Element) {
     value: function generateId() {
       this.id = this.dbState.generateId('dbId');
     }
-  }, {
-    key: "processNotes",
-    value: function processNotes(rawNotes) {
-      var _this2 = this;
-      rawNotes.forEach(function (note) {
-        _this2.pushNote(new _stickyNote["default"](_objectSpread(_objectSpread({}, note), {}, {
-          database: _this2
-        })));
-      });
-    }
-  }, {
-    key: "pushNote",
-    value: function pushNote(note) {
-      this.checkNote(note);
-      this.notes.push(note);
-    }
-  }, {
-    key: "checkNote",
-    value: function checkNote(note) {
-      if (this.notes.some(function (n) {
-        return n.name === note.name;
-      })) {
-        note.error("Notes ".concat(note.name, " existed"));
-      }
-    }
   }, {
     key: "processSchemas",
     value: function processSchemas(rawSchemas) {
-      var _this3 = this;
+      var _this2 = this;
       rawSchemas.forEach(function (schema) {
-        _this3.pushSchema(new _schema["default"](_objectSpread(_objectSpread({}, schema), {}, {
-          database: _this3
+        _this2.pushSchema(new _schema["default"](_objectSpread(_objectSpread({}, schema), {}, {
+          database: _this2
         })));
       });
     }
@@ -134,16 +104,16 @@ var Database = /*#__PURE__*/function (_Element) {
   }, {
     key: "processSchemaElements",
     value: function processSchemaElements(elements, elementType) {
-      var _this4 = this;
+      var _this3 = this;
       var schema;
       elements.forEach(function (element) {
         if (element.schemaName) {
-          schema = _this4.findOrCreateSchema(element.schemaName);
+          schema = _this3.findOrCreateSchema(element.schemaName);
           if (element.schemaName === _config.DEFAULT_SCHEMA_NAME) {
             // this.hasDefaultSchema = true;
           }
         } else {
-          schema = _this4.findOrCreateSchema(_config.DEFAULT_SCHEMA_NAME);
+          schema = _this3.findOrCreateSchema(_config.DEFAULT_SCHEMA_NAME);
         }
         switch (elementType) {
           case _config.TABLE:
@@ -255,9 +225,6 @@ var Database = /*#__PURE__*/function (_Element) {
       return {
         schemas: this.schemas.map(function (s) {
           return s["export"]();
-        }),
-        notes: this.notes.map(function (n) {
-          return n["export"]();
         })
       };
     }
@@ -267,9 +234,6 @@ var Database = /*#__PURE__*/function (_Element) {
       return {
         schemaIds: this.schemas.map(function (s) {
           return s.id;
-        }),
-        noteIds: this.notes.map(function (n) {
-          return n.id;
         })
       };
     }
@@ -281,7 +245,6 @@ var Database = /*#__PURE__*/function (_Element) {
           id: this.id
         }, this.shallowExport()), this.exportChildIds())),
         schemas: {},
-        notes: {},
         refs: {},
         enums: {},
         tableGroups: {},
@@ -295,9 +258,6 @@ var Database = /*#__PURE__*/function (_Element) {
       this.schemas.forEach(function (schema) {
         return schema.normalize(normalizedModel);
       });
-      this.notes.forEach(function (note) {
-        return note.normalize(normalizedModel);
-      });
       return normalizedModel;
     }
   }]);

package/lib/model_structure/dbState.js

@@ -19,7 +19,6 @@ var DbState = /*#__PURE__*/function () {
     this.tableGroupId = 1;
     this.refId = 1;
     this.tableId = 1;
-    this.noteId = 1;
     this.enumValueId = 1;
     this.endpointId = 1;
     this.indexId = 1;

package/lib/parse/Parser.js

@@ -129,11 +129,6 @@ var Parser = /*#__PURE__*/function () {
     value: function parseMSSQLToJSON(str) {
       return _mssqlParser["default"].parseWithPegError(str);
     }
-  }, {
-    key: "parse",
-    value: function parse(str, format) {
-      return new Parser().parse(str, format);
-    }
   }]);
   return Parser;
 }();

package/package.json

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

package/types/model_structure/database.d.ts

@@ -3,7 +3,6 @@ import Ref, { NormalizedRef } from './ref';
 import Enum, { NormalizedEnum } from './enum';
 import TableGroup, { NormalizedTableGroup } from './tableGroup';
 import Table, { NormalizedTable } from './table';
-import StickyNote, { NormalizedStickyNote } from './stickyNote';
 import Element, { RawNote, Token } from './element';
 import DbState from './dbState';
 import { NormalizedEndpoint } from './endpoint';
@@ -19,7 +18,6 @@ export interface Project {
 export interface RawDatabase {
     schemas: Schema[];
     tables: Table[];
-    notes: StickyNote[];
     enums: Enum[];
     refs: Ref[];
     tableGroups: TableGroup[];
@@ -29,7 +27,6 @@ declare class Database extends Element {
     dbState: DbState;
     hasDefaultSchema: boolean;
     schemas: Schema[];
-    notes: StickyNote[];
     note: string;
     noteToken: Token;
     databaseType: string;
@@ -102,12 +99,6 @@ declare class Database extends Element {
             note: string;
             alias: string;
         }[];
-        notes: {
-            id: number;
-            name: string;
-            content: string;
-            headerColor: string;
-        }[];
     };
     shallowExport(): {
         hasDefaultSchema: boolean;
@@ -174,16 +165,9 @@ declare class Database extends Element {
             note: string;
             alias: string;
         }[];
-        notes: {
-            id: number;
-            name: string;
-            content: string;
-            headerColor: string;
-        }[];
     };
     exportChildIds(): {
         schemaIds: number[];
-        noteIds: number[];
     };
     normalize(): NormalizedDatabase;
 }
@@ -196,11 +180,9 @@ export interface NormalizedDatabase {
             databaseType: string;
             name: string;
             schemaIds: number[];
-            noteIds: number[];
         };
     };
     schemas: NormalizedSchema;
-    notes: NormalizedStickyNote;
     refs: NormalizedRef;
     enums: NormalizedEnum;
     tableGroups: NormalizedTableGroup;

package/types/model_structure/dbState.d.ts

@@ -5,7 +5,6 @@ export default class DbState {
     tableGroupId: number;
     refId: number;
     tableId: number;
-    noteId: number;
     enumValueId: number;
     endpointId: number;
     indexId: number;

package/types/model_structure/schema.d.ts

@@ -159,7 +159,6 @@ declare class Schema extends Element {
     };
     exportChildIds(): {
         tableIds: number[];
-        noteIds: number[];
         enumIds: number[];
         tableGroupIds: number[];
         refIds: number[];
@@ -181,7 +180,6 @@ export interface NormalizedSchema {
         note: string;
         alias: string;
         tableIds: number[];
-        noteIds: number[];
         enumIds: number[];
         tableGroupIds: number[];
         refIds: number[];

package/types/parse/Parser.d.ts

@@ -1,7 +1,7 @@
 import { Compiler } from '@dbml/parse';
 import Database, { RawDatabase } from '../model_structure/database';
 declare class Parser {
-    constructor(DBMLCompiler?: Compiler);
+    constructor(DBMLCompiler: Compiler?);
     static parseJSONToDatabase(rawDatabase: RawDatabase): Database;
     static parseMySQLToJSON(str: string): RawDatabase;
     static parsePostgresToJSON(str: string): RawDatabase;
@@ -9,10 +9,6 @@ declare class Parser {
     static parseDBMLToJSON(str: string): RawDatabase;
     static parseSchemaRbToJSON(str: string): RawDatabase;
     static parseMSSQLToJSON(str: string): RawDatabase;
-    /**
-     * Should use parse() instance method instead of this static method whenever possible
-     */
-    static parse(str: string, format: 'mysql' | 'postgres' | 'dbml' | 'dbmlv2' | 'schemarb' | 'mssql' | 'json'): Database;
     parse(str: string, format: 'mysql' | 'postgres' | 'dbml' | 'dbmlv2' | 'schemarb' | 'mssql' | 'json'): Database;
 }
 export default Parser;

package/lib/model_structure/stickyNote.js

@@ -1,72 +0,0 @@
-"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 StickyNote = /*#__PURE__*/function (_Element) {
-  _inherits(StickyNote, _Element);
-  var _super = _createSuper(StickyNote);
-  function StickyNote() {
-    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, StickyNote);
-    _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(StickyNote, [{
-    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 StickyNote;
-}(_element["default"]);
-var _default = StickyNote;
-exports["default"] = _default;

package/types/model_structure/stickyNote.d.ts

@@ -1,37 +0,0 @@
-import Element, { Token } from './element';
-import Database from './database';
-import DbState from './dbState';
-import { NormalizedDatabase } from './database';
-interface RawStickyNote {
-    name: string;
-    content: string;
-    database: Database;
-    token: Token;
-    headerColor: string;
-}
-declare class StickyNote extends Element {
-    name: string;
-    content: string;
-    noteToken: Token;
-    headerColor: string;
-    database: Database;
-    dbState: DbState;
-    id: number;
-    constructor({ name, content, token, headerColor, database }: RawStickyNote);
-    generateId(): void;
-    export(): {
-        name: string;
-        content: string;
-        headerColor: string;
-    };
-    normalize(model: NormalizedDatabase): void;
-}
-export interface NormalizedStickyNote {
-    [id: number]: {
-        id: number;
-        name: string;
-        content: string;
-        headerColor: string;
-    };
-}
-export default StickyNote;