@dbml/core 2.2.0 → 2.4.0

package/lib/parse/postgresql/Base_rules.pegjs

@@ -1,8 +1,27 @@
 // Base rules:
 // collumn_name, table_name
 column_name "valid column name" = identifier
-table_name "valid table name"
-  = ((identifier _ "." _)*)? name:identifier { return name }
+
+path_name = names:(identifier _ "." _)* {
+  let dbName = null;
+  let schemaName = null;
+  if (names && names.length > 0) {
+    if (names.length === 1) schemaName = names[0][0];
+    else {
+      dbName = names[0][0];
+      schemaName = names[1][0];
+    }
+  }
+  return { dbName, schemaName }
+}
+
+table_name "valid table name" = pathName:path_name name:identifier {
+  return { ...pathName, name }
+}
+
+enum_name "valid enum name" = pathName:path_name? name:identifier {
+  return { ...pathName, name }
+}
 
 // string constant
 string_constant "string" = "'" c:char_inside_single_quote+ "'" {
@@ -32,36 +51,43 @@ digits = d:digit+ { return d.join('') }
 digit = [0-9]
 
 // type
-data_type "VALID TYPE" = c1:"CHARACTER"i _ c2:"VARYING"i _ args:("("expression")")? {
+data_type "VALID TYPE" = c1:"CHARACTER"i _ c2:"VARYING"i _ args:("("expression")")? dimensions:(array_extension)? {
   let c = `${c1} ${c2}`;
   c = args ? c + '(' + args[1] + ')' : c;
   return {
-    type_name: c,
+    type_name: c + (dimensions ? dimensions.map((dimension) => '[' + dimension + ']').join('') : ''),
     args: args ? args[1] : null
   }
 }
-/ "timestamp"i _ number:("(" _ numeric_constant _ ")" _)? (("without"i/"with"i) _ "time"i _ "zone"i)? {
+/ "timestamp"i _ number:("(" _ numeric_constant _ ")" _)? (("without"i/"with"i) _ "time"i _ "zone"i)? dimensions:(array_extension)? {
   const args = number ? number[2] : null;
   return {
-    type_name: args !== null ? `timestamp(${args})`: `timestamp`,
+    type_name: (args !== null ? `timestamp(${args})`: `timestamp`) + (dimensions ? dimensions.map((dimension) => '[' + dimension + ']').join('') : ''),
     args
   }
 }
-/ "time"i _ number:("(" _ numeric_constant _ ")" _)? (("without"i/"with"i) _ "time"i _ "zone"i)? {
+/ "time"i _ number:("(" _ numeric_constant _ ")" _)? (("without"i/"with"i) _ "time"i _ "zone"i)? dimensions:(array_extension)? {
   const args = number ? number[2] : null;
   return {
-    type_name: args !== null ? `time(${args})`: `time`,
+    type_name: (args !== null ? `time(${args})`: `time`) + (dimensions ? dimensions.map((dimension) => '[' + dimension + ']').join('') : ''),
     args
   }
 }
-/ c:type_name { return c }
+/ c:type_name dimensions:(array_extension)? {
+	  const args = c.args;
+    return {
+      type_name: c.type_name + (dimensions ? dimensions.map((dimension) => '[' + dimension + ']').join('') : ''),
+      schemaName: c.schemaName,
+      args
+    };
+	}
 / double_quote c:[^\"\n]+ double_quote { 
   return { 
     type_name: c.join(""),
     args: null
   } 
 }
-type_name = c:(character)+ _ args:("(" expression ")")? {
+type_name = pathName:path_name? c:(character)+ _ args:("(" expression ")")? {
 	let type_name = c.join("");
 	args = args ? args[1] : null;
 	if (type_name.toLowerCase() !== 'enum') {
@@ -69,10 +95,19 @@ type_name = c:(character)+ _ args:("(" expression ")")? {
 	}
 
 	return {
+    ...pathName,
 		type_name,
 		args
 	}
 }
+//https://www.postgresql.org/docs/13/arrays.html
+array_extension = _ "array"i  singledimenson:(_ "[" _ expression _ "]")? {
+    return [singledimenson ? singledimenson[3] : ''];
+	} 
+	/ _ multidimenson:("[" _ expression _ "]")+ {
+    // this will parse into Array(Array('[', _ , expression , _ ']'))
+    return multidimenson.map((dimension) => dimension[2]);
+  }
 
 // Default
 default_expr = val:string_constant { return { value: val, type: 'string' }}

package/lib/parse/postgresql/Commands/Alter_table/Alter_table.pegjs

@@ -11,7 +11,8 @@ alter_table_action = _ ALTER __ TABLE (__ IF_EXISTS)? (__ ONLY)? __ name:table_n
 			switch(type.toLowerCase()) {
 				case "fk":
 					t_value.forEach(({ endpoints }) => {
-						endpoints[0].tableName = name
+						endpoints[0].tableName = name.name;
+						endpoints[0].schemaName = name.schemaName;
 					})
 			}
 		})

package/lib/parse/postgresql/Commands/Create_table/Create_table_normal.pegjs

@@ -7,7 +7,7 @@ create_table_normal =
 	(__ ON __ COMMIT __ (PRESERVE __ ROWS/ DELETE __ ROWS/ DROP))?
 	(__ TABLESPACE __ tablespace_name:identifier)?
 	_ semicolon _ {
-		const table = { name: table_name, fields: [], indexes: [] }
+		const table = { name: table_name.name, schemaName: table_name.schemaName, fields: [], indexes: [] }
 		// process table_properties
 		table_properties.forEach(({ table_property_name, value }) => {
 			switch(table_property_name.toLowerCase()) {
@@ -156,7 +156,8 @@ column_constraint = (CONSTRAINT __ constraint_name:identifier __)?
 				type: "fk",
 				value: {
 					endpoint: {
-						tableName: reftable,
+						tableName: reftable.name,
+            schemaName: reftable.schemaName,
 						fieldNames: refcolumn ? [refcolumn] : null,
 						relation: "1"
 					},
@@ -192,7 +193,8 @@ table_constraint = (CONSTRAINT __ constraint_name:identifier __)?
 						relation: "*",
 					},
 					{
-						tableName: reftable,
+						tableName: reftable.name,
+            schemaName: reftable.schemaName,
 						fieldNames: refcolumn,// ? refcolumn[key] : null,
 						relation: "1",
 					},

package/lib/parse/postgresql/Commands/Create_table/Create_table_of.pegjs

@@ -6,7 +6,7 @@ create_table_of =
 	(__ ON __ COMMIT __ (PRESERVE __ ROWS/ DELETE __ ROWS/ DROP))?
 	(__ TABLESPACE __ tablespace_name:identifier)?
 	_ semicolon _ {
-		const table = { name: table_name, type: type_name}
+		const table = { name: table_name.name, schemaName: table_name.schemaName, type: type_name}
 		return {
 			syntax_name: "create_table_of",
 			value: table

package/lib/parse/postgresql/Commands/Create_table/Create_table_partition_of.pegjs

@@ -7,7 +7,7 @@ create_table_partition_of =
 	(__ ON __ COMMIT __ (PRESERVE __ ROWS/ DELETE __ ROWS/ DROP))?
 	(__ TABLESPACE __ tablespace_name:identifier)?
 	_ semicolon _ {
-		const table = { name: table_name, parent_table: parent_table}
+		const table = { name: table_name.name, schemaName: table_name.schemaName, parent_table: parent_table}
 		return {
 			syntax_name: "create_table_partition_of",
 			value: table

package/lib/parse/postgresql/Commands/Create_type/Create_type_enum.pegjs

@@ -1,12 +1,12 @@
 create_type_enum = 
-	_ CREATE __ TYPE __ name:identifier __ AS __ ENUM _
+	_ CREATE __ TYPE __ enumName:enum_name __ AS __ ENUM _
 	"(" _ labels:labels _ ")" 
 	_ semicolon _ {
 		const values = labels.map(name => ({ name }))
 		return {
 			syntax_name: "create_type_enum",
 			value: {
-				name,
+				...enumName,
 				values,
 			}
 		}

package/lib/parse/postgresql/InitializerUtils.pegjs

@@ -14,4 +14,14 @@
     });
     return arrAfterTrim.join(', ');
   }
+
+  // TODO: support configurable default schema name other than 'public'
+  const findTable = (schemaName, tableName) => {
+    const realSchemaName = schemaName || 'public';
+    const table = tables.find(table => {
+      const targetSchemaName = table.schemaName || 'public';
+      return targetSchemaName === realSchemaName && table.name === tableName;
+    });
+    return table;
+  };
 }

package/lib/parse/postgresql/parser.pegjs

@@ -23,6 +23,7 @@ parser = commands:command* {
 										endpoints: [
 											{
 												tableName: table.name,
+												schemaName: table.schemaName,
 												fieldNames: [field.name],
 												relation: "*",
 											},
@@ -70,7 +71,7 @@ parser = commands:command* {
 			case "create_index":
 				const { table_name } = value;
 				delete value.table_name; // remove table_name from column
-				const table_index = tables.find(table => table.name === table_name);
+        const table_index = findTable(table_name.schemaName, table_name.name);
 				if (table_index.indexes) {
 					table_index.indexes.push(value);
 				} else {

package/lib/parse/schemarbParser.js

@@ -7,7 +7,7 @@
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
@@ -2738,13 +2738,13 @@ function peg$parse(input, options) {
       }
 
       if (currentProp.onDelete) {
-        refProp = _objectSpread({}, refProp, {
+        refProp = _objectSpread(_objectSpread({}, refProp), {}, {
           onDelete: currentProp.onDelete
         });
       }
 
       if (currentProp.onUpdate) {
-        refProp = _objectSpread({}, refProp, {
+        refProp = _objectSpread(_objectSpread({}, refProp), {}, {
           onUpdate: currentProp.onUpdate
         });
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbml/core",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "> TODO: description",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -15,8 +15,10 @@
     "test": "__tests__"
   },
   "files": [
-    "lib"
+    "lib",
+    "types"
   ],
+  "types": "./types/index.d.ts",
   "main": "lib/index.js",
   "publishConfig": {
     "access": "public"
@@ -54,5 +56,5 @@
       "\\.(?!json$)[^.]*$": "jest-raw-loader"
     }
   },
-  "gitHead": "3b7c1dfdf2b67db569b32a57ec4873e54c8612a9"
+  "gitHead": "bbc1d589c6dcefce089bd6007a24cad2808a3818"
 }

package/types/export/ModelExporter.d.ts

@@ -0,0 +1,5 @@
+import Database, { NormalizedDatabase } from '../model_structure/database';
+declare class ModelExporter {
+    static export(model: Database | NormalizedDatabase, format: 'dbml' | 'mysql' | 'postgres' | 'json' | 'mssql', isNormalized?: boolean): string;
+}
+export default ModelExporter;

package/types/export/index.d.ts

@@ -0,0 +1,5 @@
+declare function _export(str: string, format: 'dbml' | 'mysql' | 'postgres' | 'json' | 'mssql'): string;
+declare const _default: {
+    export: typeof _export;
+};
+export default _default;

package/types/import/index.d.ts

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

package/types/index.d.ts

@@ -0,0 +1,5 @@
+import ModelExporter from './export/ModelExporter';
+import Parser from './parse/Parser';
+import importer from './import';
+import exporter from './export';
+export { importer, exporter, ModelExporter, Parser, };

package/types/model_structure/database.d.ts

@@ -0,0 +1,195 @@
+import Schema, { NormalizedSchema, RawSchema } from './schema';
+import Ref, { NormalizedRef } from './ref';
+import Enum, { NormalizedEnum } from './enum';
+import TableGroup, { NormalizedTableGroup } from './tableGroup';
+import Table, { NormalizedTable } from './table';
+import Element from './element';
+import DbState from './dbState';
+import { NormalizedEndpoint } from './endpoint';
+import { NormalizedEnumValue } from './enumValue';
+import { NormalizedField } from './field';
+import { NormalizedIndexColumn } from './indexColumn';
+import { NormalizedIndex } from './indexes';
+export interface Project {
+    note: string;
+    database_type: string;
+    name: string;
+}
+export interface RawDatabase {
+    schemas: Schema[];
+    tables: Table[];
+    enums: Enum[];
+    refs: Ref[];
+    tableGroups: TableGroup[];
+    project: Project;
+}
+declare class Database extends Element {
+    dbState: DbState;
+    hasDefaultSchema: boolean;
+    schemas: Schema[];
+    note: string;
+    databaseType: string;
+    name: string;
+    id: number;
+    constructor({ schemas, tables, enums, refs, tableGroups, project }: RawDatabase);
+    generateId(): void;
+    processSchemas(rawSchemas: RawSchema[]): void;
+    pushSchema(schema: Schema): void;
+    checkSchema(schema: Schema): void;
+    processSchemaElements(elements: Schema[] | Table[] | Enum[] | TableGroup[] | Ref[], elementType: any): void;
+    findOrCreateSchema(schemaName: string): Schema;
+    findTable(rawTable: any): Table;
+    export(): {
+        schemas: {
+            tables: {
+                fields: {
+                    name: string;
+                    type: any;
+                    unique: boolean;
+                    pk: boolean;
+                    not_null: boolean;
+                    note: string;
+                    dbdefault: any;
+                    increment: boolean;
+                }[];
+                indexes: {
+                    columns: {
+                        type: any;
+                        value: any;
+                    }[];
+                    name: string;
+                    type: any;
+                    unique: boolean;
+                    pk: string;
+                    note: string;
+                }[];
+                name: string;
+                alias: string;
+                note: string;
+                headerColor: string;
+            }[];
+            enums: {
+                values: {
+                    name: string;
+                    note: string;
+                }[];
+                name: string;
+                note: string;
+            }[];
+            tableGroups: {
+                tables: {
+                    tableName: string;
+                    schemaName: string;
+                }[];
+                name: string;
+            }[];
+            refs: {
+                endpoints: {
+                    schemaName: string;
+                    tableName: string;
+                    fieldNames: string[];
+                    relation: any;
+                }[];
+                name: string;
+                onDelete: any;
+                onUpdate: any;
+            }[];
+            name: string;
+            note: string;
+            alias: string;
+        }[];
+    };
+    shallowExport(): {
+        hasDefaultSchema: boolean;
+        note: string;
+        databaseType: string;
+        name: string;
+    };
+    exportChild(): {
+        schemas: {
+            tables: {
+                fields: {
+                    name: string;
+                    type: any;
+                    unique: boolean;
+                    pk: boolean;
+                    not_null: boolean;
+                    note: string;
+                    dbdefault: any;
+                    increment: boolean;
+                }[];
+                indexes: {
+                    columns: {
+                        type: any;
+                        value: any;
+                    }[];
+                    name: string;
+                    type: any;
+                    unique: boolean;
+                    pk: string;
+                    note: string;
+                }[];
+                name: string;
+                alias: string;
+                note: string;
+                headerColor: string;
+            }[];
+            enums: {
+                values: {
+                    name: string;
+                    note: string;
+                }[];
+                name: string;
+                note: string;
+            }[];
+            tableGroups: {
+                tables: {
+                    tableName: string;
+                    schemaName: string;
+                }[];
+                name: string;
+            }[];
+            refs: {
+                endpoints: {
+                    schemaName: string;
+                    tableName: string;
+                    fieldNames: string[];
+                    relation: any;
+                }[];
+                name: string;
+                onDelete: any;
+                onUpdate: any;
+            }[];
+            name: string;
+            note: string;
+            alias: string;
+        }[];
+    };
+    exportChildIds(): {
+        schemaIds: number[];
+    };
+    normalize(): NormalizedDatabase;
+}
+export interface NormalizedDatabase {
+    database: {
+        [_id: number]: {
+            id: number;
+            hasDefaultSchema: boolean;
+            note: string;
+            databaseType: string;
+            name: string;
+            schemaIds: number[];
+        };
+    };
+    schemas: NormalizedSchema;
+    refs: NormalizedRef;
+    enums: NormalizedEnum;
+    tableGroups: NormalizedTableGroup;
+    tables: NormalizedTable;
+    endpoints: NormalizedEndpoint;
+    enumValues: NormalizedEnumValue;
+    indexes: NormalizedIndex;
+    indexColumns: NormalizedIndexColumn;
+    fields: NormalizedField;
+}
+export default Database;

package/types/model_structure/dbState.d.ts

@@ -0,0 +1,14 @@
+export default class DbState {
+    dbId: number;
+    schemaId: number;
+    enumId: number;
+    tableGroupId: number;
+    refId: number;
+    tableId: number;
+    enumValueId: number;
+    endpointId: number;
+    indexId: number;
+    fieldId: number;
+    indexColumnId: number;
+    generateId(el: string): any;
+}

package/types/model_structure/element.d.ts

@@ -0,0 +1,21 @@
+export interface Token {
+    end: {
+        column: number;
+        line: number;
+        offset: number;
+    };
+    start: {
+        column: number;
+        line: number;
+        offset: number;
+    };
+}
+declare class Element {
+    token: Token;
+    id: number;
+    selection: string;
+    constructor(token: Token);
+    bind(selection: any): void;
+    error(message: string): void;
+}
+export default Element;

package/types/model_structure/endpoint.d.ts

@@ -0,0 +1,55 @@
+import Element from './element';
+import Field from './field';
+import Ref from './ref';
+import DbState from './dbState';
+import { NormalizedDatabase } from './database';
+declare class Endpoint extends Element {
+    relation: any;
+    schemaName: string;
+    tableName: string;
+    fieldNames: string[];
+    fields: Field[];
+    ref: Ref;
+    dbState: DbState;
+    constructor({ tableName, schemaName, fieldNames, relation, token, ref }: {
+        tableName: any;
+        schemaName: any;
+        fieldNames: any;
+        relation: any;
+        token: any;
+        ref: any;
+    });
+    generateId(): void;
+    equals(endpoint: any): boolean;
+    compareFields(endpoint: any): boolean;
+    export(): {
+        schemaName: string;
+        tableName: string;
+        fieldNames: string[];
+        relation: any;
+    };
+    exportParentIds(): {
+        refId: number;
+        fieldIds: number[];
+    };
+    shallowExport(): {
+        schemaName: string;
+        tableName: string;
+        fieldNames: string[];
+        relation: any;
+    };
+    setFields(fieldNames: any, table: any): void;
+    normalize(model: NormalizedDatabase): void;
+}
+export interface NormalizedEndpoint {
+    [_id: number]: {
+        id: number;
+        schemaName: string;
+        tableName: string;
+        fieldNames: string[];
+        relation: any;
+        refId: number;
+        fieldIds: number[];
+    };
+}
+export default Endpoint;

package/types/model_structure/enum.d.ts

@@ -0,0 +1,67 @@
+import { NormalizedDatabase } from './database';
+import DbState from './dbState';
+import Element, { Token } from './element';
+import EnumValue from './enumValue';
+import Field from './field';
+import Schema from './schema';
+interface RawEnum {
+    name: string;
+    token: Token;
+    values: EnumValue[];
+    note: string;
+    schema: Schema;
+}
+declare class Enum extends Element {
+    name: string;
+    token: Token;
+    values: EnumValue[];
+    note: string;
+    schema: Schema;
+    fields: Field[];
+    dbState: DbState;
+    id: number;
+    constructor({ name, token, values, note, schema }: RawEnum);
+    generateId(): void;
+    processValues(rawValues: any): void;
+    pushValue(value: any): void;
+    checkValue(value: any): void;
+    pushField(field: any): void;
+    checkField(field: any): void;
+    export(): {
+        values: {
+            name: string;
+            note: string;
+        }[];
+        name: string;
+        note: string;
+    };
+    exportChild(): {
+        values: {
+            name: string;
+            note: string;
+        }[];
+    };
+    exportChildIds(): {
+        valueIds: number[];
+        fieldIds: number[];
+    };
+    exportParentIds(): {
+        schemaId: number;
+    };
+    shallowExport(): {
+        name: string;
+        note: string;
+    };
+    normalize(model: NormalizedDatabase): void;
+}
+export interface NormalizedEnum {
+    [_id: number]: {
+        id: number;
+        name: string;
+        note: string;
+        valueIds: number[];
+        fieldIds: number[];
+        schemaId: number;
+    };
+}
+export default Enum;