@dbml/core 3.15.0-alpha.0 → 5.0.0-alpha.0

package/lib/parse/schemarb/parser.pegjs

@@ -25,16 +25,16 @@
   function addCheckConstraintToTable(tableName, expression, name) {
     const table = data.tables.find(t => t.name === tableName);
     if (!table) {
-      error("Table " + tableName + " not found");
+      error("Table ${tableName} not found");
     }
-    if (!table.constraints) {
-      table.constraints = [];
+    if (!table.checks) {
+      table.checks = [];
     }
-    const constraint = { expression };
+    const check = { expression };
     if (name) {
-      constraint.name = name;
+      check.name = name;
     }
-    table.constraints.push(constraint);
+    table.checks.push(check);
   }
 
   function addPrimaryKey(fields = [], props = []) {
@@ -284,8 +284,8 @@ rule = tableData:create_table_syntax {
 
 add_check_constraint_syntax
   = sp* add_check_constraint sp* tableName:(symbol / name) "," sp* expression:name props:check_constraint_props* {
-    const constraintName = props.find(p => p.name)?.name;
-    addCheckConstraintToTable(tableName, expression, constraintName);
+    const checkName = props.find(p => p.name)?.name;
+    addCheckConstraintToTable(tableName, expression, checkName);
   }
 
 add_foreign_key_syntax
@@ -319,8 +319,8 @@ create_table_syntax
       fields: addPrimaryKey(body.fields),
       // index: _.union(...body.index)
     })
-    if (body.constraints && body.constraints.length > 0) {
-      table.constraints = body.constraints;
+    if (body.checks && body.checks.length > 0) {
+      table.checks = body.checks;
     }
     return {
       table,
@@ -333,7 +333,7 @@ table_body = fields:field* {
       fields: fields.filter(field => field.isField).map(field => field.field),
       index: fields.filter(field => field.isIndex).map(field => field.index),
       references: fields.filter(field => field.isReferences).map(field => field.reference),
-      constraints: fields.filter(field => field.isConstraint).map(field => field.constraint),
+      checks: fields.filter(field => field.isCheck).map(field => field.check),
     });
   }
 
@@ -342,7 +342,7 @@ field = whitespace* field:table_field_syntax whatever* endline { return field }
 table_field_syntax
   = field_index_syntax
   / reference: field_reference_syntax { return ({ reference, isReferences: true })}
-  / constraint: field_check_constraint_syntax { return ({ constraint, isConstraint: true })}
+  / check: field_check_constraint_syntax { return ({ check, isCheck: true })}
   / field:field_type_syntax { return ({ field, isField: true }) }
 
 field_index_syntax = index sp+ whateters
@@ -350,13 +350,13 @@ field_reference_syntax = references sp+ reference:reference_value {
     return reference;
   }
 field_check_constraint_syntax = check_constraint sp+ expression:name props:check_constraint_props* {
-    const constraint = { expression };
+    const check = { expression };
     for (let i = 0; i < props.length; i++) {
       if (props[i].name) {
-        constraint.name = props[i].name;
+        check.name = props[i].name;
       }
     }
-    return constraint;
+    return check;
   }
 field_type_syntax = type:field_type sp+ name:name {
     return ({

package/lib/parse/schemarbParser.js

@@ -129,10 +129,10 @@ function peg$parse(input, options) {
     peg$c4 = peg$literalExpectation(",", false),
     peg$c5 = function peg$c5(tableName, expression, props) {
       var _props$find;
-      var constraintName = (_props$find = props.find(function (p) {
+      var checkName = (_props$find = props.find(function (p) {
         return p.name;
       })) === null || _props$find === void 0 ? void 0 : _props$find.name;
-      addCheckConstraintToTable(tableName, expression, constraintName);
+      addCheckConstraintToTable(tableName, expression, checkName);
     },
     peg$c6 = function peg$c6(fromTable, toTable, props) {
       var foreign = refactorForeign(createForeign(fromTable, toTable, props));
@@ -168,8 +168,8 @@ function peg$parse(input, options) {
         fields: addPrimaryKey(body.fields)
         // index: _.union(...body.index)
       };
-      if (body.constraints && body.constraints.length > 0) {
-        table.constraints = body.constraints;
+      if (body.checks && body.checks.length > 0) {
+        table.checks = body.checks;
       }
       return {
         table: table,
@@ -193,10 +193,10 @@ function peg$parse(input, options) {
         }).map(function (field) {
           return field.reference;
         }),
-        constraints: fields.filter(function (field) {
-          return field.isConstraint;
+        checks: fields.filter(function (field) {
+          return field.isCheck;
         }).map(function (field) {
-          return field.constraint;
+          return field.check;
         })
       };
     },
@@ -209,10 +209,10 @@ function peg$parse(input, options) {
         isReferences: true
       };
     },
-    peg$c16 = function peg$c16(constraint) {
+    peg$c16 = function peg$c16(check) {
       return {
-        constraint: constraint,
-        isConstraint: true
+        check: check,
+        isCheck: true
       };
     },
     peg$c17 = function peg$c17(field) {
@@ -225,15 +225,15 @@ function peg$parse(input, options) {
       return reference;
     },
     peg$c19 = function peg$c19(expression, props) {
-      var constraint = {
+      var check = {
         expression: expression
       };
       for (var i = 0; i < props.length; i++) {
         if (props[i].name) {
-          constraint.name = props[i].name;
+          check.name = props[i].name;
         }
       }
-      return constraint;
+      return check;
     },
     peg$c20 = function peg$c20(type, name) {
       return {
@@ -2464,18 +2464,18 @@ function peg$parse(input, options) {
       return t.name === tableName;
     });
     if (!table) {
-      error("Table " + tableName + " not found");
+      error("Table ${tableName} not found");
     }
-    if (!table.constraints) {
-      table.constraints = [];
+    if (!table.checks) {
+      table.checks = [];
     }
-    var constraint = {
+    var check = {
       expression: expression
     };
     if (name) {
-      constraint.name = name;
+      check.name = name;
     }
-    table.constraints.push(constraint);
+    table.checks.push(check);
   }
   function addPrimaryKey() {
     var fields = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbml/core",
-  "version": "3.15.0-alpha.0",
+  "version": "5.0.0-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.15.0-alpha.0",
+    "@dbml/parse": "^5.0.0-alpha.0",
     "antlr4": "^4.13.1",
     "lodash": "^4.17.15",
     "parsimmon": "^1.13.0",
@@ -62,7 +62,7 @@
       "^lodash-es$": "lodash"
     }
   },
-  "gitHead": "b8718ceac53a179f91856011a03b360c9c40854c",
+  "gitHead": "630548187910efa893579e80ab07f447df1ef61e",
   "engines": {
     "node": ">=16"
   }

package/types/model_structure/{constraint.d.ts → check.d.ts}

@@ -4,27 +4,27 @@ import Field from './field';
 import Table from './table';
 import TablePartial from './tablePartial';
 
-interface RawConstraint {
+interface RawCheck {
     token: Token;
     name: string;
-    expression: any;
+    expression: string;
     table: Table;
     column?: Field | null;
     injectedPartial?: TablePartial | null;
 }
 
-declare class Constraint extends Element {
+declare class Check extends Element {
     name: string;
-    expression: any;
+    expression: string;
     table: Table;
     column: Field | null;
     injectedPartial: TablePartial | null;
 
-    constructor({ token, name, expression, table, column, injectedPartial }: RawConstraint);
+    constructor({ token, name, expression, table, column, injectedPartial }: RawCheck);
     generateId(): void;
     export(): {
         name: string;
-        expression: any;
+        expression: string;
     };
     exportParentIds(): {
         tableId: number;
@@ -33,20 +33,20 @@ declare class Constraint extends Element {
     };
     shallowExport(): {
         name: string;
-        expression: any;
+        expression: string;
     };
     normalize(model: NormalizedDatabase): void;
 }
 
-export interface NormalizedConstraint {
+export interface NormalizedCheck {
     [_id: number]: {
         id: number;
         name: string;
-        expression: any;
+        expression: string;
         tableId: number;
         columnId: number | null;
         injectedPartialId: number | null;
     };
 }
 
-export default Constraint;
+export default Check;

package/types/model_structure/database.d.ts

@@ -11,7 +11,7 @@ import { NormalizedEnumValue } from './enumValue';
 import { NormalizedField } from './field';
 import { NormalizedIndexColumn } from './indexColumn';
 import { NormalizedIndex } from './indexes';
-import { NormalizedConstraint } from './constraint';
+import { NormalizedCheck } from './check';
 import TablePartial, { NormalizedTablePartial } from './tablePartial';
 export interface Project {
     note: RawNote;
@@ -300,7 +300,7 @@ export interface NormalizedDatabase {
     enumValues: NormalizedEnumValue;
     indexes: NormalizedIndex;
     indexColumns: NormalizedIndexColumn;
-    constraints: NormalizedConstraint;
+    checks: NormalizedCheck;
     fields: NormalizedField;
     records: NormalizedRecords;
     tablePartials: NormalizedTablePartial;

package/types/model_structure/dbState.d.ts

@@ -8,6 +8,7 @@ export default class DbState {
     noteId: number;
     enumValueId: number;
     endpointId: number;
+    checkId: number;
     indexId: number;
     fieldId: number;
     indexColumnId: number;

package/types/model_structure/field.d.ts

@@ -5,7 +5,7 @@ import Endpoint from './endpoint';
 import Enum from './enum';
 import Table from './table';
 import TablePartial from './tablePartial';
-import Constraint from './constraint';
+import Check from './check';
 interface RawField {
     name: string;
     type: any;
@@ -16,7 +16,7 @@ interface RawField {
     note: RawNote;
     dbdefault: any;
     increment: boolean;
-    constraints?: any[];
+    checks?: any[];
     table: Table;
 }
 declare class Field extends Element {
@@ -30,16 +30,16 @@ declare class Field extends Element {
     noteToken: Token;
     dbdefault: any;
     increment: boolean;
-    constraints: Constraint[];
+    checks: Check[];
     table: Table;
     endpoints: Endpoint[];
     _enum: Enum;
     injectedPartial?: TablePartial;
     injectedToken: Token;
-    constructor({ name, type, unique, pk, token, not_null, note, dbdefault, increment, constraints, table }: RawField);
+    constructor({ name, type, unique, pk, token, not_null, note, dbdefault, increment, checks, table }: RawField);
     generateId(): void;
     pushEndpoint(endpoint: any): void;
-    processConstraints(constraints: any[]): void;
+    processChecks(checks: any[]): void;
     export(): {
         name: string;
         type: any;
@@ -68,7 +68,7 @@ declare class Field extends Element {
         dbdefault: any;
         increment: boolean;
         injectedPartialId?: number;
-        constraintIds: number[];
+        checkIds: number[];
     };
     normalize(model: NormalizedDatabase): void;
 }
@@ -87,7 +87,7 @@ export interface NormalizedField {
         endpointIds: number[];
         enumId: number;
         injectedPartialId?: number;
-        constraintIds: number[];
+        checkIds: number[];
     };
 }
 export default Field;

package/types/model_structure/table.d.ts

@@ -1,7 +1,7 @@
 import Element, { RawNote, Token } from './element';
 import Field from './field';
 import Index from './indexes';
-import Constraint from './constraint';
+import Check from './check';
 import Schema from './schema';
 import DbState from './dbState';
 import TableGroup from './tableGroup';
@@ -14,7 +14,7 @@ interface RawTable {
     note: RawNote;
     fields: Field[];
     indexes: Index[];
-    constraints?: any[];
+    checks?: any[];
     schema: Schema;
     token: Token;
     headerColor: string;
@@ -28,7 +28,7 @@ declare class Table extends Element {
     noteToken: Token;
     fields: Field[];
     indexes: Index[];
-    constraints: Constraint[];
+    checks: Check[];
     schema: Schema;
     headerColor: string;
     dbState: DbState;
@@ -36,7 +36,7 @@ declare class Table extends Element {
     group: TableGroup;
     partials: TablePartial[];
 
-    constructor({ name, alias, note, fields, indexes, constraints, schema, token, headerColor }: RawTable);
+    constructor({ name, alias, note, fields, indexes, checks, schema, token, headerColor }: RawTable);
     generateId(): void;
     processFields(rawFields: any): void;
     pushField(field: any): void;
@@ -44,8 +44,8 @@ declare class Table extends Element {
     processIndexes(rawIndexes: any): void;
     pushIndex(index: any): void;
     checkIndex(index: any): void;
-    processConstraints(constraints: any[]): void;
-    pushConstraint(constraint: any): void;
+    processChecks(checks: any[]): void;
+    pushCheck(check: any): void;
     findField(fieldName: any): Field;
     checkSameId(table: any): boolean;
     processPartials(): void;
@@ -103,7 +103,7 @@ declare class Table extends Element {
     exportChildIds(): {
         fieldIds: number[];
         indexIds: number[];
-        constraintIds: number[];
+        checkIds: number[];
     };
     exportParentIds(): {
         schemaId: number;
@@ -128,7 +128,7 @@ export interface NormalizedTable {
         headerColor: string;
         fieldIds: number[];
         indexIds: number[];
-        constraintIds: number[];
+        checkIds: number[];
         schemaId: number;
         groupId: number;
         partials: TablePartial[];

package/types/model_structure/tablePartial.d.ts

@@ -1,7 +1,7 @@
 import Element, { RawNote, Token } from './element';
 import Field from './field';
 import Index from './indexes';
-import Constraint from './constraint';
+import Check from './check';
 import DbState from './dbState';
 import { NormalizedDatabase } from './database';
 
@@ -10,7 +10,7 @@ interface RawTablePartial {
     note: RawNote;
     fields: Field[];
     indexes: Index[];
-    constraints?: any[];
+    checks?: any[];
     token: Token;
     headerColor: string;
     dbState: DbState;
@@ -22,12 +22,12 @@ declare class TablePartial extends Element {
     noteToken: Token;
     fields: Field[];
     indexes: Index[];
-    constraints: Constraint[];
+    checks: Check[];
     headerColor: string;
     dbState: DbState;
     id: number;
 
-    constructor({ name, note, fields, indexes, constraints, token, headerColor, dbState }: RawTablePartial);
+    constructor({ name, note, fields, indexes, checks, token, headerColor, dbState }: RawTablePartial);
     generateId(): void;
     export(): {
         name: string;