@dbml/core 3.1.4 → 3.1.5-alpha.0

package/lib/model_structure/config.js

@@ -3,11 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.TABLE_GROUP = exports.TABLE = exports.REF = exports.ENUM = exports.DEFAULT_SCHEMA_NAME = void 0;
+exports.TABLE_GROUP = exports.TABLE = exports.REF = exports.NOTE = 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,6 +11,7 @@ var _ref2 = _interopRequireDefault(require("./ref"));
 var _enum2 = _interopRequireDefault(require("./enum"));
 var _tableGroup = _interopRequireDefault(require("./tableGroup"));
 var _table = _interopRequireDefault(require("./table"));
+var _note = _interopRequireDefault(require("./note"));
 var _element = _interopRequireDefault(require("./element"));
 var _config = require("./config");
 var _dbState = _interopRequireDefault(require("./dbState"));
@@ -41,6 +42,8 @@ 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,
@@ -57,16 +60,18 @@ 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;
@@ -76,13 +81,38 @@ 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 _note["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 _this2 = this;
+      var _this3 = this;
       rawSchemas.forEach(function (schema) {
-        _this2.pushSchema(new _schema["default"](_objectSpread(_objectSpread({}, schema), {}, {
-          database: _this2
+        _this3.pushSchema(new _schema["default"](_objectSpread(_objectSpread({}, schema), {}, {
+          database: _this3
         })));
       });
     }
@@ -104,16 +134,16 @@ var Database = /*#__PURE__*/function (_Element) {
   }, {
     key: "processSchemaElements",
     value: function processSchemaElements(elements, elementType) {
-      var _this3 = this;
+      var _this4 = this;
       var schema;
       elements.forEach(function (element) {
         if (element.schemaName) {
-          schema = _this3.findOrCreateSchema(element.schemaName);
+          schema = _this4.findOrCreateSchema(element.schemaName);
           if (element.schemaName === _config.DEFAULT_SCHEMA_NAME) {
             // this.hasDefaultSchema = true;
           }
         } else {
-          schema = _this3.findOrCreateSchema(_config.DEFAULT_SCHEMA_NAME);
+          schema = _this4.findOrCreateSchema(_config.DEFAULT_SCHEMA_NAME);
         }
         switch (elementType) {
           case _config.TABLE:
@@ -225,6 +255,9 @@ var Database = /*#__PURE__*/function (_Element) {
       return {
         schemas: this.schemas.map(function (s) {
           return s["export"]();
+        }),
+        notes: this.notes.map(function (n) {
+          return n["export"]();
         })
       };
     }
@@ -234,6 +267,9 @@ var Database = /*#__PURE__*/function (_Element) {
       return {
         schemaIds: this.schemas.map(function (s) {
           return s.id;
+        }),
+        noteIds: this.notes.map(function (n) {
+          return n.id;
         })
       };
     }
@@ -245,6 +281,7 @@ var Database = /*#__PURE__*/function (_Element) {
           id: this.id
         }, this.shallowExport()), this.exportChildIds())),
         schemas: {},
+        notes: {},
         refs: {},
         enums: {},
         tableGroups: {},
@@ -258,6 +295,9 @@ 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,6 +19,7 @@ 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,6 +129,11 @@ 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.4",
+  "version": "3.1.5-alpha.0",
   "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.4",
+    "@dbml/parse": "^3.1.5-alpha.0",
     "antlr4": "^4.13.1",
     "lodash": "^4.17.15",
     "parsimmon": "^1.13.0",
@@ -59,5 +59,5 @@
       "\\.(?!json$)[^.]*$": "@glen/jest-raw-loader"
     }
   },
-  "gitHead": "5d1db8fcffda24f8bae4476a72025215fb6335b4"
+  "gitHead": "21f760b3d70c53ca78c40720f07f99933862349e"
 }

package/types/model_structure/database.d.ts

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

package/types/model_structure/dbState.d.ts

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

package/types/model_structure/note.d.ts

@@ -0,0 +1,37 @@
+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 Note 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 NormalizedNote {
+    [id: number]: {
+        id: number;
+        name: string;
+        content: string;
+        headerColor: string;
+    };
+}
+export default Note;

package/types/model_structure/schema.d.ts

@@ -159,6 +159,7 @@ declare class Schema extends Element {
     };
     exportChildIds(): {
         tableIds: number[];
+        noteIds: number[];
         enumIds: number[];
         tableGroupIds: number[];
         refIds: number[];
@@ -180,6 +181,7 @@ 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,6 +9,10 @@ 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;